fix(chat): replace activity across message segments

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group-view.tsx

@@ -12,9 +12,9 @@ import {
 import { ChevronDown, cn, Expandable, ExpandableContent, OverflowText } from '@sim/emcn'
 import { ShimmerText } from '@/components/ui'
 import { isBrowserAgentAvailable } from '@/lib/browser-agent/transport'
-import { Terminal as TerminalTool } from '@/lib/copilot/generated/tool-catalog-v1'
 import { RETIRED_BROWSER_REQUEST_TAKEOVER_ID } from '@/lib/copilot/tools/retired-tools'
 import { renderInlineMarkdown } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/inline-markdown'
+import { getVisibleMainAgentItems } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/main-agent-activity'
 import type { ToolCallItemProps } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item'
 import {
   getAgentIcon,
@@ -208,27 +208,7 @@ export function AgentGroupView({
     setManualExpanded(!expanded)
   }
 
-  let latestTool: AgentGroupItem | undefined
-  if (isMainAgent) {
-    for (let index = items.length - 1; index >= 0; index--) {
-      if (items[index].type === 'tool') {
-        latestTool = items[index]
-        break
-      }
-    }
-  }
-  /** Keep blocking controls visible even when a newer tool replaces the activity text. */
-  const visibleItems = isMainAgent
-    ? items.filter(
-        (item) =>
-          item.type !== 'tool' ||
-          item === latestTool ||
-          item.data.status === ToolCallStatus.awaiting_approval ||
-          (item.data.status === ToolCallStatus.executing &&
-            item.data.toolName === TerminalTool.id &&
-            item.data.params?.operation === 'handoff')
-      )
-    : items
+  const visibleItems = isMainAgent ? getVisibleMainAgentItems(items) : items
   const activity = (
     <div className={cn('flex min-w-0 flex-col gap-1.5', !isMainAgent && 'py-0.5 pl-6')}>
       {visibleItems.map((item, idx) => {

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/main-agent-activity.ts

@@ -0,0 +1,26 @@
+import { Terminal as TerminalTool } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { AgentGroupItem } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group-view'
+import { ToolCallStatus } from '@/app/workspace/[workspaceId]/home/types'
+
+export function getLatestToolId(items: AgentGroupItem[]): string | undefined {
+  for (let index = items.length - 1; index >= 0; index--) {
+    const item = items[index]
+    if (item.type === 'tool') return item.data.id
+  }
+}
+
+/** Keep blocking controls visible even when a newer tool replaces the activity text. */
+export function getVisibleMainAgentItems(
+  items: AgentGroupItem[],
+  latestToolId = getLatestToolId(items)
+): AgentGroupItem[] {
+  return items.filter(
+    (item) =>
+      item.type !== 'tool' ||
+      item.data.id === latestToolId ||
+      item.data.status === ToolCallStatus.awaiting_approval ||
+      (item.data.status === ToolCallStatus.executing &&
+        item.data.toolName === TerminalTool.id &&
+        item.data.params?.operation === 'handoff')
+  )
+}

apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.test.ts

@@ -335,7 +335,7 @@ 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', () => {
+  it('replaces earlier main activity across prose and subagents while preserving stream order', () => {
     const blocks: ContentBlock[] = [
       mainText('Let me search.'),
       mainToolCall('t1', 'grep'),
@@ -348,25 +348,19 @@ describe('parseBlocks span-identity tree', () => {
 
     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'])
+    expect(shape).toEqual(['text', '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(mothershipGroups).toHaveLength(1)
+    const [latest] = mothershipGroups
+    if (latest.type !== 'agent_group') {
+      throw new Error('expected mothership group')
     }
-    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')
+    expect(latest.items).toHaveLength(1)
+    expect(latest.items[0].type === 'tool' && latest.items[0].data.id).toBe('t2')
   })
 
   it('absorbs the dispatch tool of a nested file subagent from its parent span group', () => {
@@ -721,7 +715,7 @@ describe('narration text seams', () => {
 })
 
 describe('parseBlocks legacy — thinking between top-level tools', () => {
-  it('keeps consecutive mothership tools in one group across intervening thinking', () => {
+  it('shows only the latest main tool across intervening thinking', () => {
     const blocks: ContentBlock[] = [
       { type: 'thinking', content: 'planning the search', timestamp: 1 },
       mainToolCall('t1', 'grep'),
@@ -734,18 +728,20 @@ describe('parseBlocks legacy — thinking between top-level tools', () => {
     expect(groups).toHaveLength(1)
     if (groups[0].type !== 'agent_group') throw new Error('expected group')
     expect(groups[0].agentName).toBe('mothership')
-    expect(groups[0].items).toHaveLength(3)
+    expect(groups[0].items).toHaveLength(1)
+    expect(groups[0].items[0].type === 'tool' && groups[0].items[0].data.id).toBe('t3')
   })
 
-  it('still splits the mothership run on real main text', () => {
+  it('replaces earlier main tools across prose without leaving an empty activity segment', () => {
     const blocks: ContentBlock[] = [
       mainToolCall('t1', 'grep'),
       mainText('Here is what I found so far.'),
       mainToolCall('t2', 'read'),
     ]
     const segments = parseBlocks(blocks)
     const groups = segments.filter((s) => s.type === 'agent_group')
-    expect(groups).toHaveLength(2)
+    expect(groups).toHaveLength(1)
+    expect(segments.map((segment) => segment.type)).toEqual(['text', 'agent_group'])
   })
 
   it('does not let main thinking affect subagent lane grouping', () => {
@@ -787,10 +783,28 @@ describe('parseBlocks legacy — thinking between top-level tools', () => {
 })
 
 describe('assistantMessageHasVisibleExecutingTool', () => {
+  it.each([undefined, 'main'])('ignores a replaced running tool with spanId=%s', (spanId) => {
+    const blocks: ContentBlock[] = [
+      {
+        type: 'tool_call',
+        toolCall: { id: 'older', name: 'grep', status: 'executing' },
+        spanId,
+        timestamp: 1,
+      },
+      mainText('Reading the result.'),
+      mainToolCall('latest', 'read'),
+    ]
+    const segments = parseBlocks(blocks)
+    expect(segments.map((segment) => segment.type)).toEqual(['text', 'agent_group'])
+    expect(assistantMessageHasVisibleExecutingTool(segments)).toBe(false)
+  })
+
   it('does not treat an open subagent lane as an executing tool row', () => {
-    expect(assistantMessageHasVisibleExecutingTool([subagentStart('workflow', 'S1', 'main')])).toBe(
-      false
-    )
+    expect(
+      assistantMessageHasVisibleExecutingTool(
+        parseBlocks([subagentStart('workflow', 'S1', 'main')])
+      )
+    ).toBe(false)
   })
 
   it('keeps a visible executing tool as active work', () => {
@@ -803,15 +817,15 @@ describe('assistantMessageHasVisibleExecutingTool', () => {
         timestamp: 3,
       },
     ]
-    expect(assistantMessageHasVisibleExecutingTool(blocks)).toBe(true)
+    expect(assistantMessageHasVisibleExecutingTool(parseBlocks(blocks))).toBe(true)
   })
 
   it('does not let open parallel lanes suppress the single turn-level indicator', () => {
     const blocks: ContentBlock[] = [
       subagentStart('workflow', 'S1', 'main'),
       subagentStart('search', 'S2', 'main'),
     ]
-    expect(assistantMessageHasVisibleExecutingTool(blocks)).toBe(false)
+    expect(assistantMessageHasVisibleExecutingTool(parseBlocks(blocks))).toBe(false)
   })
 
   it('ignores the executing dispatch tool represented by its subagent lane', () => {
@@ -826,10 +840,68 @@ describe('assistantMessageHasVisibleExecutingTool', () => {
         parentToolCallId: 'dispatch-1',
       },
     ]
-    expect(assistantMessageHasVisibleExecutingTool(blocks)).toBe(false)
+    expect(assistantMessageHasVisibleExecutingTool(parseBlocks(blocks))).toBe(false)
   })
 })
 
+describe('parseBlocks main activity controls', () => {
+  it.each([undefined, 'main'])(
+    'retains blocking controls across prose and completion with spanId=%s',
+    (spanId) => {
+      const blocks: ContentBlock[] = [
+        {
+          type: 'tool_call',
+          toolCall: { id: 'permission', name: 'read', status: 'awaiting_approval' },
+          spanId,
+          timestamp: 1,
+        },
+        mainText('A permission decision is pending.'),
+        {
+          type: 'tool_call',
+          toolCall: {
+            id: 'handoff',
+            name: 'terminal',
+            status: 'executing',
+            params: { operation: 'handoff' },
+          },
+          timestamp: 2,
+        },
+        mainToolCall('older', 'grep'),
+        mainText('Checking another source.'),
+        {
+          type: 'tool_call',
+          toolCall: { id: 'latest', name: 'read', status: 'executing' },
+          timestamp: 3,
+        },
+      ]
+
+      const visibleTools = (content: ContentBlock[]) =>
+        parseBlocks(content).flatMap((segment) =>
+          segment.type === 'agent_group'
+            ? segment.items.flatMap((item) => (item.type === 'tool' ? [item.data] : []))
+            : []
+        )
+
+      expect(visibleTools(blocks).map((tool) => tool.id)).toEqual([
+        'permission',
+        'handoff',
+        'latest',
+      ])
+      const completed = blocks.map((block) =>
+        block.toolCall?.id === 'latest'
+          ? { ...block, toolCall: { ...block.toolCall, status: 'success' as const } }
+          : block
+      )
+      expect(visibleTools(completed).map((tool) => tool.id)).toEqual([
+        'permission',
+        'handoff',
+        'latest',
+      ])
+      expect(visibleTools(completed).at(-1)?.status).toBe('success')
+    }
+  )
+})
+
 describe('deriveThinkingLabel', () => {
   it('maps the most recent block to an activity phrase', () => {
     expect(deriveThinkingLabel([])).toBe('Thinking…')

apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx

@@ -21,6 +21,10 @@ import {
   humanizeToolName,
 } from '@/lib/copilot/tools/tool-display'
 import { useChatSurface } from '@/app/workspace/[workspaceId]/home/components/chat-surface-context'
+import {
+  getLatestToolId,
+  getVisibleMainAgentItems,
+} from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/main-agent-activity'
 import type { CredentialSubmissionPayload } from '@/app/workspace/[workspaceId]/home/components/message-content/components/special-tags'
 import { collectMessageSources } from '@/app/workspace/[workspaceId]/home/components/message-content/message-sources'
 import { resolveMessageCitations } from '@/app/workspace/[workspaceId]/home/components/message-content/resolve-citations'
@@ -490,18 +494,30 @@ function parseBlocksWithSpanTree(blocks: ContentBlock[]): MessageSegment[] {
  * Groups content blocks into agent-scoped segments.
  * Dispatch tool_calls (name matches a subagent key, no calledBy) are absorbed
  * into the agent header. Inner tool_calls are nested underneath their agent.
- * Orphan tool_calls (no calledBy, not a dispatch) group under "Sim".
+ * Main-agent tool calls share one latest activity status across all segments.
  *
  * New backends stamp every subagent block with deterministic span identity; in
  * that case {@link parseBlocksWithSpanTree} builds a real nested tree. The
  * legacy flat heuristics below are retained for transcripts persisted before
  * span identity existed.
  */
 export function parseBlocks(blocks: ContentBlock[]): MessageSegment[] {
-  if (blocks.some((block) => Boolean(block.spanId))) {
-    return parseBlocksWithSpanTree(blocks)
+  const segments = blocks.some((block) => Boolean(block.spanId))
+    ? parseBlocksWithSpanTree(blocks)
+    : parseBlocksLegacy(blocks)
+  let latestToolId: string | undefined
+  for (let index = segments.length - 1; index >= 0; index--) {
+    const segment = segments[index]
+    if (segment.type !== 'agent_group' || segment.agentName !== 'mothership') continue
+    latestToolId = getLatestToolId(segment.items)
+    if (latestToolId !== undefined) break
   }
-  return parseBlocksLegacy(blocks)
+
+  return segments.flatMap<MessageSegment>((segment) => {
+    if (segment.type !== 'agent_group' || segment.agentName !== 'mothership') return [segment]
+    const items = getVisibleMainAgentItems(segment.items, latestToolId)
+    return items.length > 0 ? [{ ...segment, items }] : []
+  })
 }
 
 function joinRenderableText(parts: string[]): string {
@@ -760,22 +776,17 @@ export function assistantMessageHasRenderableContent(
 }
 
 /** True when the transcript is already rendering an executing tool row. */
-export function assistantMessageHasVisibleExecutingTool(blocks: ContentBlock[]): boolean {
-  const subagentDispatchCallIds = new Set<string>()
-  for (const block of blocks) {
-    if (block.type === 'subagent' && block.parentToolCallId) {
-      subagentDispatchCallIds.add(block.parentToolCallId)
-    }
-  }
-
-  return blocks.some((block) => {
-    const toolCall = block.toolCall
-    if (!toolCall || toolCall.status !== 'executing') return false
-    if (isHiddenToolCall(toolCall.name)) return false
-    if (toolCall.name === ReadTool.id && isToolResultRead(toolCall.params)) return false
-    if (SUBAGENT_KEYS.has(toolCall.name)) return false
-    return !subagentDispatchCallIds.has(toolCall.id)
-  })
+export function assistantMessageHasVisibleExecutingTool(segments: MessageSegment[]): boolean {
+  const hasExecutingTool = (items: AgentGroupItem[]): boolean =>
+    items.some((item) =>
+      item.type === 'tool'
+        ? item.data.status === 'executing'
+        : item.type === 'agent_group' && hasExecutingTool(item.group.items)
+    )
+
+  return segments.some(
+    (segment) => segment.type === 'agent_group' && hasExecutingTool(segment.items)
+  )
 }
 
 export function shouldSmoothTextSegment({
@@ -960,7 +971,7 @@ function MessageContentInner({
   // A mid-stream special tag renders nothing until complete, so its bytes are a
   // wait, not output — the shimmer bridges it without the quiet-period delay.
   const thinkingLabel = deriveThinkingLabel(blocks)
-  const hasExecutingTool = assistantMessageHasVisibleExecutingTool(blocks)
+  const hasExecutingTool = assistantMessageHasVisibleExecutingTool(segments)
   const showShimmer =
     thinkingExpanded &&
     thinkingLabel !== null &&