fix(netsuite): complete generated integration docs

Author: Bill Leoutsakos

apps/docs/content/docs/en/integrations/netsuite.mdx

@@ -663,7 +663,7 @@ Return ONLY the comma-separated sublist IDs - no explanations, no extra text.`,
     data: {
       type: 'json',
       description:
-        'NetSuite payload: account-specific record fields, collection items and paging fields, metadata, or async task data',
+        'NetSuite payload: account-specific records, collections, field-keyed select options with paging, metadata, or async task data',
     },
     location: { type: 'string', description: 'Created resource or async job location' },
     jobId: { type: 'string', description: 'Async job ID parsed from the Location header' },

apps/sim/blocks/blocks/netsuite.ts

@@ -3,6 +3,7 @@ import {
   buildQuery,
   buildRecordPath,
   createNetSuiteTool,
+  NETSUITE_SELECT_OPTIONS_OUTPUTS,
   OPTIONAL_JSON_BODY_PARAM,
   optionalTrim,
   PAGINATION_PARAMS,
@@ -54,4 +55,5 @@ export const netsuiteGetSelectOptionsTool = createNetSuiteTool<NetSuiteGetSelect
       body: params.body ?? {},
     }
   },
+  outputs: NETSUITE_SELECT_OPTIONS_OUTPUTS,
 })

apps/sim/tools/generated/tool-outputs.ts

@@ -650,6 +650,16 @@ describe('NetSuite operation contracts', () => {
         },
       },
     })
+    expect(netsuiteGetSelectOptionsTool.outputs?.data).toMatchObject({
+      type: 'json',
+      description: expect.stringContaining('_selectOptions'),
+      properties: {
+        links: { type: 'array' },
+      },
+    })
+    for (const pagingField of ['items', 'count', 'offset', 'hasMore', 'totalResults']) {
+      expect(netsuiteGetSelectOptionsTool.outputs?.data?.description).toContain(pagingField)
+    }
   })
 
   it('lists async tasks and requires a task ID for the documented task-status endpoint', async () => {

apps/sim/tools/netsuite/get_select_options.ts

@@ -179,6 +179,19 @@ export const NETSUITE_COLLECTION_OUTPUTS = {
   },
 } as const satisfies Record<string, ToolOutputProperty>
 
+export const NETSUITE_SELECT_OPTIONS_OUTPUTS = {
+  ...NETSUITE_OUTPUTS,
+  data: {
+    type: 'json',
+    description:
+      'Select-options response keyed by requested field ID; each dynamic field contains an _selectOptions object with links, items, count, offset, hasMore, and totalResults',
+    nullable: true,
+    properties: {
+      links: NETSUITE_LINKS_OUTPUT,
+    },
+  },
+} as const satisfies Record<string, ToolOutputProperty>
+
 export const NETSUITE_ACTION_OUTPUTS = {
   ...NETSUITE_OUTPUTS,
   data: {

apps/sim/tools/netsuite/netsuite.test.ts

@@ -300,13 +300,43 @@ async function loadTriggerRegistry(): Promise<Record<string, RegistryTrigger>> {
   return module.TRIGGER_REGISTRY as Record<string, RegistryTrigger>
 }
 
+interface GeneratedToolParam {
+  type?: string
+  required?: boolean
+  description?: string
+}
+
+interface GeneratedToolMetadataEntry {
+  name?: string
+  description?: string
+  params?: Record<string, GeneratedToolParam>
+}
+
+/** Serializable tool metadata generated from the executable registry and checked by CI. */
+let generatedToolMetadata: Record<string, GeneratedToolMetadataEntry> | null = null
+
+async function loadGeneratedToolMetadata(): Promise<Record<string, GeneratedToolMetadataEntry>> {
+  if (generatedToolMetadata) return generatedToolMetadata
+  const module = await import(path.join(rootDir, 'apps/sim/tools/generated/tool-metadata.ts'))
+  generatedToolMetadata = module.default as Record<string, GeneratedToolMetadataEntry>
+  return generatedToolMetadata
+}
+
+let generatedToolOutputs: Record<string, Record<string, any>> | null = null
+
+async function loadGeneratedToolOutputs(): Promise<Record<string, Record<string, any>>> {
+  if (generatedToolOutputs) return generatedToolOutputs
+  const module = await import(path.join(rootDir, 'apps/sim/tools/generated/tool-outputs.ts'))
+  generatedToolOutputs = module.default as Record<string, Record<string, any>>
+  return generatedToolOutputs
+}
+
 /** Human-facing tool names, keyed by tool id. Kept in sync with the registry by CI. */
 let toolDisplayNames: Map<string, string> | null = null
 
 async function loadToolDisplayNames(): Promise<Map<string, string>> {
   if (toolDisplayNames) return toolDisplayNames
-  const module = await import(path.join(rootDir, 'apps/sim/tools/generated/tool-metadata.ts'))
-  const metadata = module.default as Record<string, { name?: string }>
+  const metadata = await loadGeneratedToolMetadata()
   toolDisplayNames = new Map(
     Object.entries(metadata).flatMap(([id, entry]) =>
       entry?.name ? [[id, entry.name] as const] : []
@@ -2011,7 +2041,7 @@ function extractOutputsFromToolContent(content: string, toolPrefix: string): Rec
  * Returns null when the tool declares its own config, which is the common case.
  */
 function resolveFactorySource(fileContent: string, toolFilePath: string, rootDir: string): string {
-  const factoryCall = fileContent.match(/=\s*(create\w+)\s*\(\s*\{/)
+  const factoryCall = fileContent.match(/=\s*(create\w+)(?:\s*<[^>]+>)?\s*\(\s*\{/)
   if (!factoryCall) return ''
 
   const factoryName = factoryCall[1]
@@ -2919,11 +2949,48 @@ async function getToolInfo(toolName: string): Promise<{
       return null
     }
 
-    return extractToolInfo(
-      toolName,
-      toolFileContent,
-      resolveFactorySource(toolFileContent, foundFile, rootDir)
-    )
+    const factorySource = resolveFactorySource(toolFileContent, foundFile, rootDir)
+    const extractedInfo = extractToolInfo(toolName, toolFileContent, factorySource)
+
+    const delegatesParams = /\.\.\.options\.params\b/.test(factorySource)
+    const delegatesOutputs = /\boptions\.outputs\b/.test(factorySource)
+    if (!factorySource || (!delegatesParams && !delegatesOutputs)) return extractedInfo
+
+    // Factory-built tools often compose params and outputs through imported constants and
+    // spreads. The source parser intentionally stays lightweight, so fall back to the
+    // executable registry's generated metadata when it exposes fields the parser missed.
+    const [metadata, outputs] = await Promise.all([
+      loadGeneratedToolMetadata(),
+      loadGeneratedToolOutputs(),
+    ])
+    const generatedEntry = metadata[toolName]
+    if (!generatedEntry) return extractedInfo
+
+    const generatedParams = Object.entries(generatedEntry.params ?? {})
+      .filter(([name]) => name !== 'accessToken' && name !== 'params' && name !== 'tools')
+      .map(([name, param]) => ({
+        name,
+        type: typeof param.type === 'string' ? param.type : 'string',
+        required: param.required === true,
+        description: param.description ?? 'No description',
+      }))
+    const extractedParams = extractedInfo?.params ?? []
+    const extractedOutputs = extractedInfo?.outputs ?? {}
+    const generatedOutputs = outputs[toolName] ?? {}
+
+    return {
+      description:
+        extractedInfo?.description ?? generatedEntry.description ?? 'No description available',
+      params:
+        delegatesParams && generatedParams.length > extractedParams.length
+          ? generatedParams
+          : extractedParams,
+      outputs:
+        delegatesOutputs &&
+        Object.keys(generatedOutputs).length > Object.keys(extractedOutputs).length
+          ? generatedOutputs
+          : extractedOutputs,
+    }
   } catch (error) {
     console.error(`Error getting info for tool ${toolName}:`, error)
     return null