fix

Author: icecrasher321

apps/sim/lib/copilot/request/lifecycle/run.test.ts

@@ -331,6 +331,63 @@ describe('runCopilotLifecycle', () => {
     })
   })
 
+  it('projects large tool catalogs at the tool-definition boundary', async () => {
+    const registry = new ResolvedSecretTraceRegistry([
+      { name: 'TOKEN', plaintext: 'catalog-secret', encryptedValue: 'ciphertext' },
+    ])
+    const toolCount = 4_000
+    const propertiesPerTool = 8
+    // These definitions are individually small, but flattening their semantic fields into one
+    // synthetic projection value creates 108,001 traversal nodes and crosses the per-value budget.
+    const integrationTools = Array.from({ length: toolCount }, (_, toolIndex) => {
+      const properties = Object.fromEntries(
+        Array.from({ length: propertiesPerTool }, (_, propertyIndex) => [
+          `field_${propertyIndex}`,
+          {
+            type: 'string',
+            description: `Field ${propertyIndex} for tool ${toolIndex}`,
+          },
+        ])
+      )
+
+      return {
+        name: `tool_${toolIndex}`,
+        description: `Tool ${toolIndex} uses catalog-secret`,
+        input_schema: {
+          type: 'object',
+          properties,
+          required: Object.keys(properties),
+        },
+      }
+    })
+    let capturedRequestBody = ''
+    mockRunStreamLoop.mockImplementationOnce(async (_url: string, request: RequestInit) => {
+      capturedRequestBody = String(request.body)
+    })
+
+    const result = await runCopilotLifecycle(
+      {
+        message: 'Use the integration catalog',
+        messageId: 'stream-large-tool-catalog',
+        integrationTools,
+      },
+      {
+        userId: 'user-1',
+        workspaceId: 'ws-1',
+        executionContext: { userId: 'user-1', workflowId: '', workspaceId: 'ws-1' },
+        resolvedSecretTraceRegistry: registry,
+      }
+    )
+
+    expect(result.success).toBe(true)
+    expect(mockRunStreamLoop).toHaveBeenCalledOnce()
+    const sent = JSON.parse(capturedRequestBody)
+    expect(sent.integrationTools).toHaveLength(integrationTools.length)
+    expect(sent.integrationTools[0].description).toBe('Tool 0 uses {{TOKEN}}')
+    expect(sent.integrationTools.at(-1).name).toBe(`tool_${toolCount - 1}`)
+    expect(capturedRequestBody).not.toContain('catalog-secret')
+  })
+
   it('projects selected JSON and attachment fields exactly once when plaintext overlaps its alias', async () => {
     const registry = new ResolvedSecretTraceRegistry([
       { name: 'TOKEN', plaintext: 'TOKEN', encryptedValue: 'ciphertext' },

apps/sim/lib/copilot/request/lifecycle/run.ts

@@ -38,10 +38,7 @@ import {
   COPILOT_VFS_ROUTING_KEYS,
   isCopilotModelTextKey,
 } from '@/lib/copilot/model-visible-content'
-import {
-  collectModelVisibleSchemaContent,
-  getModelVisibleSchemaAction,
-} from '@/lib/copilot/model-visible-schema'
+import { getModelVisibleSchemaAction } from '@/lib/copilot/model-visible-schema'
 import { getAutoAllowedTools } from '@/lib/copilot/persistence/tool-permission/auto-allow'
 import { createStreamingContext } from '@/lib/copilot/request/context/request-context'
 import { buildToolCallSummaries } from '@/lib/copilot/request/context/result'
@@ -332,9 +329,9 @@ function schemaContentAction(
 }
 
 const toolContentSelector: SelectedContentSelector = (path, key, value) => {
-  if (path.length === 1 && key === 'description') return 'project'
-  if (path.length === 1 && key === 'name') return 'verify'
-  if (path.length === 1 && TOOL_SCHEMA_KEYS.has(key)) return 'traverse'
+  if (path.length === 0 && key === 'description') return 'project'
+  if (path.length === 0 && key === 'name') return 'verify'
+  if (path.length === 0 && TOOL_SCHEMA_KEYS.has(key)) return 'traverse'
 
   const schemaRootIndex = path.findIndex((segment) => TOOL_SCHEMA_KEYS.has(segment))
   if (schemaRootIndex >= 0) {
@@ -402,31 +399,27 @@ const desktopContentSelector: SelectedContentSelector = (_path, key, value) => {
   return value !== null && typeof value === 'object' ? 'traverse' : 'preserve'
 }
 
-function isModelSafeToolPayload(
-  candidate: unknown,
+function projectModelSafeToolPayloads(
+  value: unknown,
   registry: ResolvedSecretTraceRegistry
-): boolean {
-  if (!isPlainRecord(candidate) || typeof candidate.name !== 'string') return false
-  if (!isResolvedSecretModelContentUnchanged(candidate.name, registry)) return false
+): unknown[] {
+  if (!Array.isArray(value)) throw new CopilotModelContentProjectionError()
 
-  try {
-    for (const schemaKey of TOOL_SCHEMA_KEYS) {
-      if (!Object.hasOwn(candidate, schemaKey)) continue
-      const guardedValues = collectModelVisibleSchemaContent(candidate[schemaKey]).guardedValues
-      if (!isResolvedSecretModelContentUnchanged(guardedValues, registry)) return false
+  const projected: unknown[] = []
+  for (const candidate of value) {
+    if (!isPlainRecord(candidate) || typeof candidate.name !== 'string') continue
+
+    try {
+      projected.push(projectStructuredContent(candidate, registry, toolContentSelector, 'record'))
+    } catch {
+      // Tool definitions are independent protocol entities. Reject an unsafe definition without
+      // turning the entire catalog into one synthetic projection value or failing safe siblings.
     }
-    return true
-  } catch {
-    return false
   }
-}
 
-function filterModelSafeToolPayloads(
-  value: unknown,
-  registry: ResolvedSecretTraceRegistry
-): unknown[] {
-  if (!Array.isArray(value)) throw new CopilotModelContentProjectionError()
-  return value.filter((candidate) => isModelSafeToolPayload(candidate, registry))
+  // Projection completeness is a request-level invariant, even when every candidate was rejected.
+  projectModelContent([], registry)
+  return projected
 }
 
 function hasModelSafeRoutingFields(
@@ -645,12 +638,7 @@ function projectInitialCopilotPayload(
   }
   for (const key of TOOL_PAYLOAD_KEYS) {
     if (Object.hasOwn(payload, key)) {
-      projectedPayload[key] = projectStructuredContent(
-        filterModelSafeToolPayloads(payload[key], registry),
-        registry,
-        toolContentSelector,
-        'array'
-      )
+      projectedPayload[key] = projectModelSafeToolPayloads(payload[key], registry)
     }
   }
   if (Object.hasOwn(payload, 'responseFormat')) {