Name the target resource in the remaining tool titles

Table tools keep their operands nested under args and identify the table by
id, so their rows said 'Adding rows' with no hint where: enrichment now lifts
the nested args and resolves tableId against the cached workspace table list,
giving 'Adding rows to Runtimes', 'Adding column status in Runtimes',
'Reading views of Runtimes'.

Also: a block-schema read names the block instead of the file ('Loading
Slack', 'Loading Google Sheets tips'); browser type/insert show the text they
send, middle-ellipsized; downloads name the file; library-docs searches name
the library and query; knowledge-base searches include the query; generated
media names its output file; and diff_workflows, list_deployment_versions,
and publish_custom_block joined the workflow-name enrichment set.

Author: Sg312

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers.ts

@@ -29,8 +29,10 @@ import {
 } from '@/lib/copilot/generated/tool-catalog-v1'
 import { extractStreamingStringArgument } from '@/lib/copilot/tools/streaming-args'
 import { getToolDisplayTitle, mvDisplayVerb } from '@/lib/copilot/tools/tool-display'
+import { getQueryClient } from '@/app/_shell/providers/get-query-client'
 import type { ContentBlock } from '@/app/workspace/[workspaceId]/home/types'
 import { ToolCallStatus } from '@/app/workspace/[workspaceId]/home/types'
+import { tableKeys } from '@/hooks/queries/utils/table-keys'
 import { getWorkflowById } from '@/hooks/queries/utils/workflow-cache'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
@@ -123,6 +125,33 @@ function resolveTargetWorkflowName(args: Record<string, unknown> | undefined): s
   return resolveWorkflowNameForDisplay(args?.workflowId ?? registry.hydration.workflowId)
 }
 
+/**
+ * Table name for a nested `args.tableId`. Tables reach the client through
+ * React Query rather than a Zustand store, so the cached workspace list is
+ * the synchronous source a title can read; an uncached id simply stays
+ * unnamed rather than blocking the row.
+ */
+function resolveTableNameForDisplay(tableId: unknown): string | undefined {
+  const id = stringParam(tableId)
+  if (!id) return undefined
+  const cache = getQueryClient().getQueryCache()
+  for (const query of cache.findAll({ queryKey: tableKeys.lists() })) {
+    const data = query.state.data
+    const tables = Array.isArray(data)
+      ? data
+      : isRecordLike(data) && Array.isArray((data as { tables?: unknown }).tables)
+        ? ((data as { tables: unknown[] }).tables as unknown[])
+        : []
+    for (const table of tables) {
+      if (!isRecordLike(table)) continue
+      if (stringParam(table.id) !== id) continue
+      const name = stringParam(table.name)
+      if (name) return name
+    }
+  }
+  return undefined
+}
+
 function resolveBlockNameForDisplay(blockId: unknown): string | undefined {
   const id = stringParam(blockId)
   if (!id) return undefined
@@ -191,8 +220,20 @@ export function resolveIntegrationToolDisplayTitle(tool: {
  * the current workflow), so their titles can only name the workflow once the
  * client resolves the id against the workflow registry.
  */
+const TABLE_SCOPED_TOOL_IDS = new Set<string>([
+  'table_automations',
+  'table_columns',
+  'table_enrichments',
+  'table_manage',
+  'table_rows',
+  'table_views',
+])
+
 const WORKFLOW_SCOPED_TOOL_IDS = new Set<string>([
   'deploy_as_api',
+  'diff_workflows',
+  'list_deployment_versions',
+  'publish_custom_block',
   'deploy_as_chat',
   'deploy_as_mcp',
   'get_block_outputs',
@@ -250,6 +291,22 @@ export function resolveToolDisplayTitle(name: string, args?: Record<string, unkn
   // defaulting to the current workflow. Resolve the name here and hand it to
   // the shared resolver as `workflowName`, which every workflow title already
   // reads, so deployments, reads, and block work all say WHICH workflow.
+  // Table tools keep their operands nested under `args`, and identify the
+  // table by id — so the shared resolver sees neither the column being added
+  // nor which table it belongs to. Lift both here.
+  if (TABLE_SCOPED_TOOL_IDS.has(name)) {
+    const nested = isRecordLike(args?.args) ? (args?.args as Record<string, unknown>) : undefined
+    const tableName =
+      stringParam(args?.tableName) ?? resolveTableNameForDisplay(nested?.tableId ?? args?.tableId)
+    if (nested || tableName) {
+      return getToolDisplayTitle(name, {
+        ...args,
+        ...(nested ?? {}),
+        ...(tableName ? { tableName } : {}),
+      })
+    }
+  }
+
   if (WORKFLOW_SCOPED_TOOL_IDS.has(name) && !stringParam(args?.workflowName)) {
     const workflowName = resolveTargetWorkflowName(args)
     // Block-scoped tools carry a blockId for the same reason; resolve it too,

apps/sim/lib/copilot/tools/tool-display.test.ts

@@ -700,3 +700,53 @@ describe('terminal-title projection is idempotent', () => {
     )
   })
 })
+
+describe('resource-naming titles', () => {
+  it('names the table a row/column operation targets', () => {
+    expect(getToolDisplayTitle('table_rows', { operation: 'insert', tableName: 'Runtimes' })).toBe(
+      'Adding rows to Runtimes'
+    )
+    expect(
+      getToolDisplayTitle('table_columns', {
+        operation: 'add',
+        columnName: 'status',
+        tableName: 'Runtimes',
+      })
+    ).toBe('Adding column status in Runtimes')
+    expect(getToolDisplayTitle('table_views', { operation: 'list', tableName: 'Runtimes' })).toBe(
+      'Reading views of Runtimes'
+    )
+  })
+
+  it('falls back cleanly when the table is unnamed', () => {
+    expect(getToolDisplayTitle('table_rows', { operation: 'update' })).toBe('Updating rows')
+  })
+
+  it('names the block behind a block-schema read', () => {
+    expect(getToolDisplayTitle('read', { path: 'components/blocks/slack_v2.json' })).toBe(
+      'Loading Slack'
+    )
+    expect(
+      getToolDisplayTitle('read', { path: 'components/blocks/google_sheets_v2/README.md' })
+    ).toBe('Loading Google Sheets tips')
+  })
+
+  it('shows the text a browser type/insert call sends', () => {
+    expect(getToolDisplayTitle('browser_type', { text: 'hello there' })).toBe(
+      'Typing "hello there"'
+    )
+    expect(getToolDisplayTitle('browser_insert_text', {})).toBe('Inserting text')
+  })
+
+  it('names downloads, docs searches, and generated files', () => {
+    expect(getToolDisplayTitle('download_file', { fileName: 'report.csv' })).toBe(
+      'Downloading report.csv'
+    )
+    expect(
+      getToolDisplayTitle('search_library_docs', { library_name: 'React', query: 'useEffect' })
+    ).toBe('Searching React docs for useEffect')
+    expect(getToolDisplayTitle('generate_image', { path: 'files/hero.png' })).toBe(
+      'Generating hero.png'
+    )
+  })
+})

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

@@ -84,41 +84,47 @@ function stringOrNumberArg(args: ToolArgs, key: string): string {
  */
 function splitTableTitle(name: string, args: ToolArgs): string {
   const op = stringArg(args, 'operation')
-  const target = firstStringArg(args, 'name', 'columnName', 'viewName', 'tableName', 'title')
+  const target = firstStringArg(args, 'columnName', 'viewName', 'name', 'title')
   const suffix = target ? ` ${target}` : ''
+  // "in Runtimes" / "of Runtimes" — enrichment resolves the nested tableId.
+  const table = stringArg(args, 'tableName')
+  const inTable = table ? ` in ${table}` : ''
+  const ofTable = table ? ` of ${table}` : ''
   switch (name) {
     case 'table_manage':
-      if (op === 'create') return `Creating table${suffix}`
-      if (op === 'delete') return `Deleting table${suffix}`
-      if (op === 'read' || op === 'get' || op === 'list') return 'Reading table'
-      return 'Updating table'
+      if (op === 'create') return `Creating table${suffix || (table ? ` ${table}` : '')}`
+      if (op === 'delete') return `Deleting table${table ? ` ${table}` : suffix}`
+      if (op === 'read' || op === 'get' || op === 'list')
+        return `Reading${table ? ` ${table}` : ' table'}`
+      return `Updating${table ? ` ${table}` : ' table'}`
     case 'table_rows':
-      if (op === 'insert' || op === 'add' || op === 'create') return 'Adding rows'
-      if (op === 'update') return 'Updating rows'
-      if (op === 'delete') return 'Deleting rows'
-      if (op === 'read' || op === 'list' || op === 'query') return 'Reading rows'
-      return 'Editing rows'
+      if (op === 'insert' || op === 'add' || op === 'create')
+        return `Adding rows${inTable ? ` to ${table}` : ''}`
+      if (op === 'update') return `Updating rows${inTable}`
+      if (op === 'delete') return `Deleting rows${inTable}`
+      if (op === 'read' || op === 'list' || op === 'query') return `Reading rows${ofTable}`
+      return `Editing rows${ofTable}`
     case 'table_columns':
-      if (op === 'add' || op === 'create') return `Adding column${suffix}`
-      if (op === 'update') return `Updating column${suffix}`
-      if (op === 'delete') return `Deleting column${suffix}`
-      if (op === 'read' || op === 'list') return 'Reading columns'
-      return 'Editing columns'
+      if (op === 'add' || op === 'create') return `Adding column${suffix}${inTable}`
+      if (op === 'update') return `Updating column${suffix}${inTable}`
+      if (op === 'delete') return `Deleting column${suffix}${inTable}`
+      if (op === 'read' || op === 'list') return `Reading columns${ofTable}`
+      return `Editing columns${ofTable}`
     case 'table_automations':
-      if (op === 'read' || op === 'list') return 'Reading automations'
-      if (op === 'delete') return 'Removing automation'
-      return 'Wiring automation'
+      if (op === 'read' || op === 'list') return `Reading automations${ofTable}`
+      if (op === 'delete') return `Removing automation${inTable}`
+      return `Wiring automation${inTable}`
     case 'table_enrichments':
-      if (op === 'read' || op === 'list') return 'Reading enrichments'
-      if (op === 'delete') return 'Removing enrichment'
-      return 'Configuring enrichment'
+      if (op === 'read' || op === 'list') return `Reading enrichments${ofTable}`
+      if (op === 'delete') return `Removing enrichment${inTable}`
+      return `Configuring enrichment${suffix}${inTable}`
     case 'table_views':
-      if (op === 'create') return `Creating view${suffix}`
-      if (op === 'delete') return `Deleting view${suffix}`
-      if (op === 'read' || op === 'list') return 'Reading views'
-      return 'Editing views'
+      if (op === 'create') return `Creating view${suffix}${inTable}`
+      if (op === 'delete') return `Deleting view${suffix}${inTable}`
+      if (op === 'read' || op === 'list') return `Reading views${ofTable}`
+      return `Editing views${ofTable}`
     default:
-      return 'Updating table'
+      return `Updating${table ? ` ${table}` : ' table'}`
   }
 }
 
@@ -165,6 +171,29 @@ function displayUrl(raw: string): string {
   }
 }
 
+/**
+ * Human name for a block type id: strip the version suffix and title-case the
+ * snake_case stem (`slack_v2` -> `Slack`, `google_sheets_v2` -> `Google Sheets`).
+ */
+export function blockDisplayName(blockType: string): string {
+  const stem = stripVersionSuffix(blockType.trim())
+  if (!stem) return blockType
+  return stem
+    .split('_')
+    .filter(Boolean)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ')
+}
+
+/** Ellipsizes the middle so both ends of a value stay recognizable. */
+function truncateMiddle(value: string, maxChars: number): string {
+  const text = value.replace(/\s+/g, ' ').trim()
+  if (text.length <= maxChars) return text
+  const head = Math.ceil((maxChars - 1) / 2)
+  const tail = Math.floor((maxChars - 1) / 2)
+  return `${text.slice(0, head)}…${text.slice(text.length - tail)}`
+}
+
 function isWorkflowArtifactPath(path: string, filename: string): boolean {
   const trimmed = path.trim()
   return trimmed.startsWith('workflows/') && trimmed.endsWith(`/${filename}`)
@@ -305,12 +334,12 @@ function queryUserTableTitle(args: ToolArgs): string {
 }
 
 function searchKnowledgeBaseTitle(args: ToolArgs): string {
-  const titles: Record<string, string> = {
-    get: 'Reading knowledge base',
-    query: 'Searching knowledge base',
-    list_tags: 'Listing knowledge base tags',
-  }
-  return titles[stringArg(args, 'operation')] ?? 'Searching knowledge base'
+  const query = stringArg(args, 'query')
+  const operation = stringArg(args, 'operation')
+  if (operation === 'get') return 'Reading knowledge base'
+  if (operation === 'list_tags') return 'Listing knowledge base tags'
+  // A search row is far more useful with the question it asked.
+  return query ? `Searching knowledge base for ${query}` : 'Searching knowledge base'
 }
 
 function manageSandboxTitle(args: ToolArgs): string {
@@ -524,9 +553,7 @@ const TOOL_TITLES: Record<string, string> = {
   manage_knowledge_base: 'Managing knowledge base',
   search_knowledge_base: 'Searching knowledge base',
   open_resource: 'Opening resource',
-  generate_image: 'Generating image',
-  generate_video: 'Generating video',
-  generate_audio: 'Generating audio',
+
   ffmpeg: 'Processing media',
   get_deployment_status: 'Checking deployment status',
   create_empty_file: 'Creating file',
@@ -538,7 +565,7 @@ const TOOL_TITLES: Record<string, string> = {
   publish_custom_block: 'Publishing custom block',
   deploy_as_mcp: 'Deploying as MCP tool',
   diff_workflows: 'Comparing workflows',
-  download_file: 'Downloading file',
+
   run_function: 'Running code',
   generate_api_key: 'Generating API key',
   // Retired in favor of the account/ and organization/ VFS namespaces. Kept so
@@ -589,8 +616,7 @@ const TOOL_TITLES: Record<string, string> = {
   browser_screenshot: 'Taking screenshot',
   browser_click: 'Clicking element',
   browser_click_at: 'Clicking point',
-  browser_type: 'Typing text',
-  browser_insert_text: 'Inserting text',
+
   browser_drag: 'Dragging element',
   browser_select_option: 'Selecting option',
   browser_hover: 'Hovering element',
@@ -996,6 +1022,40 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
       const text = stringArg(args, 'text')
       return text ? `Waiting for "${text}"` : 'Waiting for page'
     }
+    case 'generate_image':
+    case 'generate_video':
+    case 'generate_audio': {
+      const kind =
+        name === 'generate_image' ? 'image' : name === 'generate_video' ? 'video' : 'audio'
+      const target =
+        firstStringArg(args, 'toolTitle', 'title') ||
+        (stringArg(args, 'path') ? pathLeaf(stringArg(args, 'path')) : '')
+      return target ? `Generating ${target}` : `Generating ${kind}`
+    }
+    case 'download_file': {
+      const target =
+        firstStringArg(args, 'fileName', 'toolTitle', 'title') ||
+        (stringArg(args, 'path') ? pathLeaf(stringArg(args, 'path')) : '') ||
+        (stringArg(args, 'url') ? displayUrl(stringArg(args, 'url')) : '')
+      return target ? `Downloading ${target}` : 'Downloading file'
+    }
+    case 'search_library_docs': {
+      const library = firstStringArg(args, 'library_name', 'libraryName', 'library')
+      const query = stringArg(args, 'query')
+      if (library && query) return `Searching ${library} docs for ${query}`
+      if (library) return `Searching ${library} docs`
+      return query ? `Searching library docs for ${query}` : 'Searching library docs'
+    }
+    case 'run_code': {
+      const title = stringArg(args, 'title')
+      return title || 'Running code'
+    }
+    case 'browser_type':
+    case 'browser_insert_text': {
+      const verb = name === 'browser_type' ? 'Typing' : 'Inserting'
+      const text = stringArg(args, 'text')
+      return text ? `${verb} "${truncateMiddle(text, 32)}"` : `${verb} text`
+    }
     case 'browser_press_key': {
       const key = stringArg(args, 'key')
       return key ? `Pressing ${key}` : 'Pressing key'
@@ -1161,6 +1221,12 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
       }
       // Workflow artifacts name BOTH the workflow and which part, so five
       // reads in a row differentiate instead of all saying the same thing.
+      // A block schema read is the model looking up how a block works; name
+      // the block, not the file. The row's icon is chosen from the same id.
+      const blockSchema = path.match(/^components\/blocks\/([^/]+)\.json$/)
+      if (blockSchema) return `Loading ${blockDisplayName(decodePathSegment(blockSchema[1]))}`
+      const blockTips = path.match(/^components\/blocks\/([^/]+)\/README\.md$/)
+      if (blockTips) return `Loading ${blockDisplayName(decodePathSegment(blockTips[1]))} tips`
       const workflowArtifact = path.match(/^workflows\/([^/]+)\/([^/]+)$/)
       if (workflowArtifact) {
         const part =