fix(thinking): show thinking during subagents

Author: Sg312

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

@@ -4,7 +4,7 @@
 import { describe, expect, it } from 'vitest'
 import type { ContentBlock } from '../../types'
 import {
-  assistantMessageHasRunningWork,
+  assistantMessageHasVisibleExecutingTool,
   parseBlocks,
   shouldShowTrailingThinking,
   shouldSmoothTextSegment,
@@ -14,10 +14,6 @@ function subagentStart(name: string, spanId: string, parentSpanId: string): Cont
   return { type: 'subagent', content: name, spanId, parentSpanId, timestamp: 1 }
 }
 
-function subagentEnd(spanId: string): ContentBlock {
-  return { type: 'subagent_end', spanId, timestamp: 2 }
-}
-
 function subagentToolCall(
   id: string,
   name: string,
@@ -489,41 +485,46 @@ describe('parseBlocks legacy — thinking between top-level tools', () => {
   })
 })
 
-describe('assistantMessageHasRunningWork', () => {
-  it('reads an open subagent lane as running work', () => {
-    expect(assistantMessageHasRunningWork([subagentStart('workflow', 'S1', 'main')])).toBe(true)
-  })
-
-  it('reads a lane closed by its paired subagent_end (live path) as settled', () => {
-    const blocks: ContentBlock[] = [subagentStart('workflow', 'S1', 'main'), subagentEnd('S1')]
-    expect(assistantMessageHasRunningWork(blocks)).toBe(false)
-  })
-
-  it('reads a lane closed by a stamped endedAt (persisted path) as settled', () => {
-    const closed: ContentBlock = { ...subagentStart('workflow', 'S1', 'main'), endedAt: 5 }
-    expect(assistantMessageHasRunningWork([closed])).toBe(false)
+describe('assistantMessageHasVisibleExecutingTool', () => {
+  it('does not treat an open subagent lane as an executing tool row', () => {
+    expect(assistantMessageHasVisibleExecutingTool([subagentStart('workflow', 'S1', 'main')])).toBe(
+      false
+    )
   })
 
-  it('keeps an executing tool as running work after every lane closed', () => {
+  it('keeps a visible executing tool as active work', () => {
     const blocks: ContentBlock[] = [
       subagentStart('workflow', 'S1', 'main'),
-      subagentEnd('S1'),
       {
         type: 'tool_call',
-        toolCall: { id: 't1', name: 'grep', status: 'executing' },
+        toolCall: { id: 't1', name: 'grep', status: 'executing', calledBy: 'workflow' },
+        spanId: 'S1',
         timestamp: 3,
       },
     ]
-    expect(assistantMessageHasRunningWork(blocks)).toBe(true)
+    expect(assistantMessageHasVisibleExecutingTool(blocks)).toBe(true)
   })
 
-  it('tracks parallel lanes independently — one still-open lane keeps the turn running', () => {
+  it('does not let open parallel lanes suppress the single turn-level indicator', () => {
     const blocks: ContentBlock[] = [
       subagentStart('workflow', 'S1', 'main'),
       subagentStart('search', 'S2', 'main'),
-      subagentEnd('S1'),
     ]
-    expect(assistantMessageHasRunningWork(blocks)).toBe(true)
-    expect(assistantMessageHasRunningWork([...blocks, subagentEnd('S2')])).toBe(false)
+    expect(assistantMessageHasVisibleExecutingTool(blocks)).toBe(false)
+  })
+
+  it('ignores the executing dispatch tool represented by its subagent lane', () => {
+    const blocks: ContentBlock[] = [
+      {
+        type: 'tool_call',
+        toolCall: { id: 'dispatch-1', name: 'workspace_file', status: 'executing' },
+        timestamp: 1,
+      },
+      {
+        ...subagentStart('file', 'S1', 'main'),
+        parentToolCallId: 'dispatch-1',
+      },
+    ]
+    expect(assistantMessageHasVisibleExecutingTool(blocks)).toBe(false)
   })
 })

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

@@ -761,27 +761,23 @@ export function assistantMessageHasRenderableContent(
   return segments.length > 0
 }
 
-/**
- * True while any wire-declared work in the turn is still running: a tool row
- * still `executing`, or a subagent lane that has not closed. A lane closes via
- * its paired `subagent_end` block (live serializer) or a stamped `endedAt`
- * (Sim-backend persistence / turn-terminal sweep). The live path never stamps
- * `endedAt` on `subagent` blocks, so checking `endedAt` alone reads every
- * finished subagent as still running for the rest of the turn — permanently
- * suppressing the between-steps thinking indicator after the first delegation.
- */
-export function assistantMessageHasRunningWork(blocks: ContentBlock[]): boolean {
-  const closedSpanIds = new Set<string>()
+/** 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_end' && block.spanId) closedSpanIds.add(block.spanId)
+    if (block.type === 'subagent' && block.parentToolCallId) {
+      subagentDispatchCallIds.add(block.parentToolCallId)
+    }
   }
-  return blocks.some(
-    (block) =>
-      block.toolCall?.status === 'executing' ||
-      (block.type === 'subagent' &&
-        block.endedAt === undefined &&
-        !(block.spanId && closedSpanIds.has(block.spanId)))
-  )
+
+  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 shouldSmoothTextSegment({
@@ -897,7 +893,7 @@ function MessageContentInner({
   // not suppress the turn-level indicator: once its latest visible chunk has
   // settled, the loader can bridge the wait until that lane (or a parallel
   // sibling) emits again.
-  const hasExecutingTool = blocks.some((b) => b.toolCall?.status === 'executing')
+  const hasExecutingTool = assistantMessageHasVisibleExecutingTool(blocks)
   const showTrailingThinking = shouldShowTrailingThinking({
     isStreaming: phase === 'streaming',
     isStreamIdle,