Display names for reads

Sg312 · Sg312 · commit f261cfee3323 · 2026-06-02T13:24:31.000-07:00
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.test.ts b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.test.ts
@@ -23,6 +23,14 @@ function subagentToolCall(
   }
 }
 
+function mainText(content: string): ContentBlock {
+  return { type: 'text', content, timestamp: 1 }
+}
+
+function mainToolCall(id: string, name: string): ContentBlock {
+  return { type: 'tool_call', toolCall: { id, name, status: 'success' }, timestamp: 1 }
+}
+
 describe('parseBlocks span-identity tree', () => {
   it('nests a deploy subagent inside the workflow subagent that spawned it', () => {
     const blocks: ContentBlock[] = [
@@ -101,6 +109,61 @@ describe('parseBlocks span-identity tree', () => {
     expect(segments[0].items.some((item) => item.type === 'tool')).toBe(true)
   })
 
+  it('interleaves mothership tools with main text instead of clustering them at the top', () => {
+    const blocks: ContentBlock[] = [
+      mainText('Let me search.'),
+      mainToolCall('t1', 'grep'),
+      subagentStart('research', 'S1', 'main'),
+      { type: 'subagent_text', content: 'looking', spanId: 'S1', timestamp: 2 },
+      { type: 'subagent_end', spanId: 'S1', parentSpanId: 'main', timestamp: 3 },
+      mainText('Found it, now finding files.'),
+      mainToolCall('t2', 'glob'),
+    ]
+
+    const segments = parseBlocks(blocks)
+
+    // Order is preserved chronologically: the second mothership tool stays below
+    // the research subagent and the trailing text rather than jumping back up
+    // into the first group.
+    const shape = segments.map((s) => (s.type === 'agent_group' ? s.agentName : s.type))
+    expect(shape).toEqual(['text', 'mothership', 'research', 'text', 'mothership'])
+
+    // The two mothership tools land in two distinct groups, one each.
+    const mothershipGroups = segments.filter(
+      (s) => s.type === 'agent_group' && s.agentName === 'mothership'
+    )
+    expect(mothershipGroups).toHaveLength(2)
+    const [first, second] = mothershipGroups
+    if (first.type !== 'agent_group' || second.type !== 'agent_group') {
+      throw new Error('expected mothership groups')
+    }
+    expect(first.items).toHaveLength(1)
+    expect(second.items).toHaveLength(1)
+    expect(first.items[0].type === 'tool' && first.items[0].data.toolName).toBe('grep')
+    expect(second.items[0].type === 'tool' && second.items[0].data.toolName).toBe('glob')
+  })
+
+  it('absorbs the dispatch tool of a nested file subagent from its parent span group', () => {
+    const blocks: ContentBlock[] = [
+      subagentStart('workflow', 'S1', 'main'),
+      subagentToolCall('t1', 'workspace_file', 'S1', 'workflow'),
+      { type: 'subagent', content: 'file', spanId: 'S2', parentSpanId: 'S1', timestamp: 2 },
+      { type: 'subagent_text', content: 'writing', spanId: 'S2', timestamp: 3 },
+    ]
+
+    const segments = parseBlocks(blocks)
+    expect(segments).toHaveLength(1)
+    const workflow = segments[0]
+    if (workflow.type !== 'agent_group') throw new Error('expected workflow group')
+
+    // The workspace_file dispatch tool is absorbed (not shown as a sibling tool);
+    // only the nested file subagent remains under workflow.
+    expect(workflow.items.some((item) => item.type === 'tool')).toBe(false)
+    const nested = workflow.items.find((item) => item.type === 'agent_group')
+    if (!nested || nested.type !== 'agent_group') throw new Error('expected nested file group')
+    expect(nested.group.agentName).toBe('file')
+  })
+
   it('falls back to legacy flat grouping when blocks have no span identity', () => {
     const blocks: ContentBlock[] = [
       { type: 'subagent', content: 'workflow', parentToolCallId: 'tc-1', timestamp: 1 },
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx
@@ -184,14 +184,39 @@ function appendTextItem(group: AgentGroupSegment, content: string): void {
 function parseBlocksWithSpanTree(blocks: ContentBlock[]): MessageSegment[] {
   const segments: MessageSegment[] = []
   const groupsBySpanId = new Map<string, AgentGroupSegment>()
-  let mothership: AgentGroupSegment | null = null
 
+  const tailMothershipGroup = (): AgentGroupSegment | null => {
+    const last = segments[segments.length - 1]
+    return last?.type === 'agent_group' && last.agentName === 'mothership' ? last : null
+  }
+
+  // Top-level (mothership) tool calls render in a collapsible group. Reuse that
+  // group only while it is still the most recent segment so consecutive tools
+  // stay together; once any other segment (main text, a spawned subagent,
+  // thinking, etc.) breaks the run, the next tool opens a fresh group below it
+  // instead of jumping back up into the original one. This keeps the mothership's
+  // tools and prose interleaved in the order they actually happened.
   const ensureMothership = (): AgentGroupSegment => {
-    if (!mothership) {
-      mothership = createAgentGroupSegment('mothership', 'mothership', segments.length)
-      segments.push(mothership)
+    const existing = tailMothershipGroup()
+    if (existing) return existing
+    const group = createAgentGroupSegment('mothership', 'mothership', segments.length)
+    segments.push(group)
+    return group
+  }
+
+  // When a subagent spawns, drop the dispatch tool that triggered it (e.g.
+  // workspace_file -> file) from whichever container it landed in so it does not
+  // render as a separate entry beside the agent group.
+  const absorbDispatchTool = (toolName: string, parentSpanId: string | undefined): void => {
+    const container =
+      parentSpanId && parentSpanId !== SPAN_ROOT
+        ? groupsBySpanId.get(parentSpanId)
+        : tailMothershipGroup()
+    if (!container) return
+    const last = container.items[container.items.length - 1]
+    if (last?.type === 'tool' && last.data.toolName === toolName) {
+      container.items.pop()
     }
-    return mothership
   }
 
   const attachSpanGroup = (group: AgentGroupSegment, parentSpanId: string | undefined): void => {
@@ -283,14 +308,9 @@ function parseBlocksWithSpanTree(blocks: ContentBlock[]): MessageSegment[] {
     if (block.type === 'subagent') {
       if (!block.content || !block.spanId) continue
       // Absorb a trailing dispatch tool (e.g. workspace_file -> file) so it does
-      // not render as a separate Mothership entry alongside the agent group.
+      // not render as a separate entry alongside the agent group.
       const dispatchToolName = SUBAGENT_DISPATCH_TOOLS[block.content]
-      if (dispatchToolName && mothership) {
-        const last = mothership.items[mothership.items.length - 1]
-        if (last?.type === 'tool' && last.data.toolName === dispatchToolName) {
-          mothership.items.pop()
-        }
-      }
+      if (dispatchToolName) absorbDispatchTool(dispatchToolName, block.parentSpanId)
       const g = ensureSpanGroup(block.content, block.spanId, block.parentSpanId, i)
       // Show the working/delegating spinner from span open until the agent
       // emits its first content or tool (or ends). The legacy path derived this
diff --git a/apps/sim/lib/copilot/tools/client/store-utils.test.ts b/apps/sim/lib/copilot/tools/client/store-utils.test.ts
@@ -37,6 +37,63 @@ describe('resolveToolDisplay', () => {
     ).toBe('Read RET XYZ')
   })
 
+  it('decodes percent-encoded VFS path segments for display', () => {
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.executing, {
+        path: 'files/My%20Report.txt',
+      })?.text
+    ).toBe('Reading My Report.txt')
+
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
+        path: 'workflows/My%20Workflow/meta.json',
+      })?.text
+    ).toBe('Read My Workflow')
+
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.executing, {
+        path: 'files/caf%C3%A9.txt',
+      })?.text
+    ).toBe('Reading café.txt')
+
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
+        path: 'files/Quarterly%20Report.docx/content',
+      })?.text
+    ).toBe('Read Quarterly Report.docx')
+  })
+
+  it('shows only the file name for file reads, dropping the folder path and content qualifier', () => {
+    // Bare file leaf inside a folder → just the file name (with extension).
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
+        path: 'files/Skills/Skill%20%E2%80%94%20PostHog%20Analytics.md',
+      })?.text
+    ).toBe('Read Skill — PostHog Analytics.md')
+
+    // Explicit content facet → no "the content of", folder dropped too.
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
+        path: 'files/Skills/Skill%20%E2%80%94%20PostHog%20Analytics.md/content',
+      })?.text
+    ).toBe('Read Skill — PostHog Analytics.md')
+
+    // Non-content facets keep their descriptive label but still show only the name.
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.executing, {
+        path: 'files/Reports/brief.docx/meta.json',
+      })?.text
+    ).toBe('Reading metadata for brief.docx')
+  })
+
+  it('falls back to the raw segment when it is not valid percent-encoding', () => {
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.executing, {
+        path: 'files/100%done.txt',
+      })?.text
+    ).toBe('Reading 100%done.txt')
+  })
+
   it('formats special workspace file reads as natural language', () => {
     expect(
       resolveToolDisplay(ReadTool.id, ClientToolCallState.error, {
@@ -48,7 +105,7 @@ describe('resolveToolDisplay', () => {
       resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
         path: 'files/Reports/brief.docx/content',
       })?.text
-    ).toBe('Read the content of Reports/brief.docx')
+    ).toBe('Read brief.docx')
 
     expect(
       resolveToolDisplay(ReadTool.id, ClientToolCallState.executing, {
diff --git a/apps/sim/lib/copilot/tools/client/store-utils.ts b/apps/sim/lib/copilot/tools/client/store-utils.ts
@@ -5,6 +5,7 @@ import { Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
 import { VFS_DIR_TO_RESOURCE } from '@/lib/copilot/resources/types'
 import { isToolHiddenInUi } from '@/lib/copilot/tools/client/hidden-tools'
 import { ClientToolCallState } from '@/lib/copilot/tools/client/tool-call-state'
+import { decodeVfsSegment } from '@/lib/copilot/vfs/path-utils'
 
 /** Respond tools are internal handoff tools shown with a friendly generic label. */
 const HIDDEN_TOOL_SUFFIX = '_respond'
@@ -80,13 +81,28 @@ function formatReadingLabel(target: string | undefined, state: ClientToolCallSta
   }
 }
 
+/**
+ * VFS paths store each segment percent-encoded (see {@link encodeVfsSegment}), so
+ * a read on "My Report.txt" arrives as "files/My%20Report.txt". Decode for
+ * display so the user sees the real file name. Falls back to the raw segment when
+ * it is not valid encoding (e.g. a literal "%" that was never encoded).
+ */
+function decodeVfsSegmentSafe(segment: string): string {
+  try {
+    return decodeVfsSegment(segment)
+  } catch {
+    return segment
+  }
+}
+
 function describeReadTarget(path: string | undefined): string | undefined {
   if (!path) return undefined
 
   const segments = path
     .split('/')
     .map((segment) => segment.trim())
     .filter(Boolean)
+    .map(decodeVfsSegmentSafe)
 
   if (segments.length === 0) return undefined
 
@@ -107,25 +123,30 @@ function describeReadTarget(path: string | undefined): string | undefined {
   return stripExtension(resourceName)
 }
 
-const FILE_SPECIAL_READ_TARGET_PREFIXES: Record<string, string> = {
-  content: 'the content of',
+// A workspace file is addressed as a directory of facets in the VFS
+// (files/{...path}/{name}/{facet}). `content` is the default facet — reading a
+// file means reading its content — so it carries no qualifier, matching a bare
+// `files/{...path}/{name}` read. The remaining facets are genuinely distinct, so
+// they keep a descriptive label.
+const FILE_FACET_LABELS: Record<string, string> = {
+  content: '',
   'meta.json': 'metadata for',
   style: 'style details for',
   'compiled-check': 'the final file check for',
 }
 
 function describeFileReadTarget(segments: string[]): string {
   const lastSegment = segments[segments.length - 1] || ''
-  const specialPrefix = FILE_SPECIAL_READ_TARGET_PREFIXES[lastSegment]
-  if (specialPrefix) {
-    return `${specialPrefix} ${describeSpecialFilePathSubject(segments)}`
+  const facetLabel = FILE_FACET_LABELS[lastSegment]
+  // Treat the suffix as a facet only when a real file name precedes it; otherwise
+  // the leaf is the file itself (e.g. a file literally named "content").
+  if (facetLabel !== undefined && segments.length > 2) {
+    const fileName = segments[segments.length - 2]
+    return facetLabel ? `${facetLabel} ${fileName}` : fileName
   }
-
-  return segments.slice(1).join('/') || lastSegment
-}
-
-function describeSpecialFilePathSubject(segments: string[]): string {
-  return segments.slice(1, -1).join('/') || 'this file'
+  // Show just the file name, not the folder path — these are glanceable status
+  // lines, and the other resource types already render the leaf only.
+  return lastSegment
 }
 
 function getLeafResourceSegment(segments: string[]): string {
