Remove tool truncation limits

Author: Sg312

apps/sim/lib/copilot/constants.ts

@@ -50,6 +50,20 @@ export const COPILOT_STATS_API_PATH = '/api/copilot/stats'
 /** Maximum entries in the in-memory SSE tool-event dedup cache. */
 export const STREAM_BUFFER_MAX_DEDUP_ENTRIES = 1_000
 
+// ---------------------------------------------------------------------------
+// Tool result size limits
+// ---------------------------------------------------------------------------
+
+/** Approximate max inline tool-result budget before artifact/error handling takes over. */
+export const TOOL_RESULT_MAX_INLINE_TOKENS = 50_000
+
+/** Rough chars-per-token estimate used when only serialized text length is available. */
+export const TOOL_RESULT_ESTIMATED_CHARS_PER_TOKEN = 4
+
+/** Approximate max inline tool-result size in characters. */
+export const TOOL_RESULT_MAX_INLINE_CHARS =
+  TOOL_RESULT_MAX_INLINE_TOKENS * TOOL_RESULT_ESTIMATED_CHARS_PER_TOKEN
+
 // ---------------------------------------------------------------------------
 // Copilot modes
 // ---------------------------------------------------------------------------

apps/sim/lib/copilot/tools/client/tool-display-registry.ts

@@ -11,7 +11,6 @@ import {
   FolderPlus,
   GitBranch,
   Globe,
-  Globe2,
   Grid2x2,
   Grid2x2Check,
   Grid2x2X,
@@ -960,71 +959,6 @@ const META_list_workspace_mcp_servers: ToolMetadata = {
   interrupt: undefined,
 }
 
-const META_make_api_request: ToolMetadata = {
-  displayNames: {
-    [ClientToolCallState.generating]: { text: 'Preparing API request', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Review API request', icon: Globe2 },
-    [ClientToolCallState.executing]: { text: 'Executing API request', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Completed API request', icon: Globe2 },
-    [ClientToolCallState.error]: { text: 'Failed to execute API request', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped API request', icon: MinusCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted API request', icon: XCircle },
-  },
-  interrupt: {
-    accept: { text: 'Execute', icon: Globe2 },
-    reject: { text: 'Skip', icon: MinusCircle },
-  },
-  uiConfig: {
-    interrupt: {
-      accept: { text: 'Execute', icon: Globe2 },
-      reject: { text: 'Skip', icon: MinusCircle },
-      showAllowOnce: true,
-      showAllowAlways: true,
-    },
-    paramsTable: {
-      columns: [
-        { key: 'method', label: 'Method', width: '26%', editable: true, mono: true },
-        { key: 'url', label: 'Endpoint', width: '74%', editable: true, mono: true },
-      ],
-      extractRows: (params: Record<string, any>): Array<[string, ...any[]]> => {
-        return [['request', (params.method || 'GET').toUpperCase(), params.url || '']]
-      },
-    },
-  },
-  getDynamicText: (params, state) => {
-    if (params?.url && typeof params.url === 'string') {
-      const method = params.method || 'GET'
-      let url = params.url
-
-      // Extract domain from URL for cleaner display
-      try {
-        const urlObj = new URL(url)
-        url = urlObj.hostname + urlObj.pathname
-      } catch {
-        // Use URL as-is if parsing fails
-      }
-
-      switch (state) {
-        case ClientToolCallState.success:
-          return `${method} ${url} complete`
-        case ClientToolCallState.executing:
-          return `${method} ${url}`
-        case ClientToolCallState.generating:
-          return `Preparing ${method} ${url}`
-        case ClientToolCallState.pending:
-          return `Review ${method} ${url}`
-        case ClientToolCallState.error:
-          return `Failed ${method} ${url}`
-        case ClientToolCallState.rejected:
-          return `Skipped ${method} ${url}`
-        case ClientToolCallState.aborted:
-          return `Aborted ${method} ${url}`
-      }
-    }
-    return undefined
-  },
-}
-
 const META_manage_custom_tool: ToolMetadata = {
   displayNames: {
     [ClientToolCallState.generating]: {
@@ -2327,7 +2261,6 @@ const TOOL_METADATA_BY_ID: Record<string, ToolMetadata> = {
   list_folders: META_list_folders,
   list_user_workspaces: META_list_user_workspaces,
   list_workspace_mcp_servers: META_list_workspace_mcp_servers,
-  make_api_request: META_make_api_request,
   manage_custom_tool: META_manage_custom_tool,
   manage_mcp_tool: META_manage_mcp_tool,
   manage_skill: META_manage_skill,

apps/sim/lib/copilot/tools/handlers/vfs.test.ts

@@ -0,0 +1,89 @@
+/**
+ * @vitest-environment node
+ */
+
+import { loggerMock } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { getOrMaterializeVFS } = vi.hoisted(() => ({
+  getOrMaterializeVFS: vi.fn(),
+}))
+
+const { readChatUpload } = vi.hoisted(() => ({
+  readChatUpload: vi.fn(),
+}))
+
+vi.mock('@sim/logger', () => loggerMock)
+vi.mock('@/lib/copilot/vfs', () => ({
+  getOrMaterializeVFS,
+}))
+vi.mock('./upload-file-reader', () => ({
+  readChatUpload,
+  listChatUploads: vi.fn(),
+}))
+
+import { executeVfsGrep, executeVfsRead } from './vfs'
+
+function makeVfs() {
+  return {
+    grep: vi.fn(),
+    read: vi.fn(),
+    readFileContent: vi.fn(),
+    suggestSimilar: vi.fn().mockReturnValue([]),
+  }
+}
+
+describe('vfs handlers oversize policy', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('fails oversized grep results with narrowing guidance', async () => {
+    const vfs = makeVfs()
+    vfs.grep.mockReturnValue([
+      { path: 'files/a.txt', line: 1, content: 'a'.repeat(60_000) },
+      { path: 'files/b.txt', line: 2, content: 'b'.repeat(60_000) },
+    ])
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsGrep(
+      { pattern: 'foo', output_mode: 'content' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('smaller grep')
+  })
+
+  it('fails oversized read results with grep guidance', async () => {
+    const vfs = makeVfs()
+    vfs.read.mockReturnValue({ content: 'a'.repeat(100_001), totalLines: 1 })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/big.txt' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Use grep')
+  })
+
+  it('fails file-backed oversized read placeholders with grep guidance', async () => {
+    const vfs = makeVfs()
+    vfs.read.mockReturnValue(null)
+    vfs.readFileContent.mockResolvedValue({
+      content: '[File too large to display inline: big.txt (6000000 bytes, limit 5242880)]',
+      totalLines: 1,
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/big.txt' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Use grep')
+  })
+})

apps/sim/lib/copilot/tools/handlers/vfs.ts

@@ -1,10 +1,26 @@
 import { createLogger } from '@sim/logger'
+import { TOOL_RESULT_MAX_INLINE_CHARS } from '@/lib/copilot/constants'
 import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { getOrMaterializeVFS } from '@/lib/copilot/vfs'
 import { listChatUploads, readChatUpload } from './upload-file-reader'
 
 const logger = createLogger('VfsTools')
 
+function serializedResultSize(value: unknown): number {
+  try {
+    return JSON.stringify(value).length
+  } catch {
+    return String(value).length
+  }
+}
+
+function isOversizedReadPlaceholder(content: string): boolean {
+  return (
+    content.startsWith('[File too large to display inline:') ||
+    content.startsWith('[Image too large:')
+  )
+}
+
 export async function executeVfsGrep(
   params: Record<string, unknown>,
   context: ExecutionContext
@@ -36,8 +52,16 @@ export async function executeVfsGrep(
       : typeof result === 'object'
         ? Object.keys(result).length
         : 0
+    const output = { [key]: result }
+    if (serializedResultSize(output) > TOOL_RESULT_MAX_INLINE_CHARS) {
+      return {
+        success: false,
+        error:
+          'Grep result too large to return inline. Use a smaller grep by narrowing the pattern/path, reducing context, or lowering maxResults.',
+      }
+    }
     logger.debug('vfs_grep result', { pattern, path: params.path, outputMode, matchCount })
-    return { success: true, output: { [key]: result } }
+    return { success: true, output }
   } catch (err) {
     logger.error('vfs_grep failed', {
       pattern,
@@ -106,6 +130,16 @@ export async function executeVfsRead(
       const filename = path.slice('uploads/'.length)
       const uploadResult = await readChatUpload(filename, context.chatId)
       if (uploadResult) {
+        if (
+          isOversizedReadPlaceholder(uploadResult.content) ||
+          serializedResultSize(uploadResult) > TOOL_RESULT_MAX_INLINE_CHARS
+        ) {
+          return {
+            success: false,
+            error:
+              'Read result too large to return inline. Use grep on this path instead of reading it directly, or retry read with offset/limit.',
+          }
+        }
         logger.debug('vfs_read resolved chat upload', { path, totalLines: uploadResult.totalLines })
         return { success: true, output: uploadResult }
       }
@@ -124,6 +158,16 @@ export async function executeVfsRead(
     if (!result) {
       const fileContent = await vfs.readFileContent(path)
       if (fileContent) {
+        if (
+          isOversizedReadPlaceholder(fileContent.content) ||
+          serializedResultSize(fileContent) > TOOL_RESULT_MAX_INLINE_CHARS
+        ) {
+          return {
+            success: false,
+            error:
+              'Read result too large to return inline. Use grep on this path instead of reading it directly, or retry read with offset/limit.',
+          }
+        }
         logger.debug('vfs_read resolved workspace file', {
           path,
           totalLines: fileContent.totalLines,
@@ -142,6 +186,16 @@ export async function executeVfsRead(
           : ' Use glob to discover available paths.'
       return { success: false, error: `File not found: ${path}.${hint}` }
     }
+    if (
+      isOversizedReadPlaceholder(result.content) ||
+      serializedResultSize(result) > TOOL_RESULT_MAX_INLINE_CHARS
+    ) {
+      return {
+        success: false,
+        error:
+          'Read result too large to return inline. Use grep on this path instead of reading it directly, or retry read with offset/limit.',
+      }
+    }
     logger.debug('vfs_read result', { path, totalLines: result.totalLines })
     return {
       success: true,