fix(stream): show thinking text

Author: Sg312

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

@@ -22,6 +22,7 @@ export interface NestedAgentGroup {
 
 export type AgentGroupItem =
   | { type: 'text'; content: string }
+  | { type: 'thinking'; content: string }
   | { type: 'tool'; data: ToolCallData }
   | { type: 'agent_group'; group: NestedAgentGroup }
 
@@ -150,6 +151,16 @@ export function AgentGroup({
                       </div>
                     )
                   }
+                  if (item.type === 'thinking') {
+                    return (
+                      <span
+                        key={`thinking-${idx}`}
+                        className='pl-6 text-[13px] text-[var(--text-secondary)] italic leading-[18px] opacity-50'
+                      >
+                        {item.content.trim()}
+                      </span>
+                    )
+                  }
                   return (
                     <span
                       key={`text-${idx}`}

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

@@ -231,6 +231,69 @@ describe('parseBlocks span-identity tree', () => {
     expect(nested.group.agentName).toBe('file')
   })
 
+  it('renders subagent thinking as a muted thinking item and keeps the delegating spinner', () => {
+    const blocks: ContentBlock[] = [
+      subagentStart('workflow', 'S1', 'main'),
+      {
+        type: 'subagent_thinking',
+        content: 'reasoning about the fix',
+        spanId: 'S1',
+        subagent: 'workflow',
+        timestamp: 2,
+      },
+    ]
+
+    const segments = parseBlocks(blocks)
+    expect(segments).toHaveLength(1)
+    if (segments[0].type !== 'agent_group') throw new Error('expected workflow group')
+    // Thinking renders in the lane…
+    expect(segments[0].items).toEqual([{ type: 'thinking', content: 'reasoning about the fix' }])
+    // …but does not clear the delegating spinner (no real output yet).
+    expect(segments[0].isDelegating).toBe(true)
+  })
+
+  it('creates the lane on demand when thinking arrives before its subagent start', () => {
+    const blocks: ContentBlock[] = [
+      {
+        type: 'subagent_thinking',
+        content: 'early reasoning',
+        spanId: 'S1',
+        parentSpanId: 'main',
+        subagent: 'workflow',
+        timestamp: 1,
+      },
+      subagentStart('workflow', 'S1', 'main'),
+    ]
+
+    const segments = parseBlocks(blocks)
+    const group = segments.find((s) => s.type === 'agent_group')
+    if (!group || group.type !== 'agent_group') throw new Error('expected workflow group')
+    expect(group.agentName).toBe('workflow')
+    expect(group.items).toEqual([{ type: 'thinking', content: 'early reasoning' }])
+  })
+
+  it('orders thinking before the lane text that follows it', () => {
+    const blocks: ContentBlock[] = [
+      subagentStart('workflow', 'S1', 'main'),
+      {
+        type: 'subagent_thinking',
+        content: 'planning',
+        spanId: 'S1',
+        subagent: 'workflow',
+        timestamp: 2,
+      },
+      { type: 'subagent_text', content: 'done', spanId: 'S1', subagent: 'workflow', timestamp: 3 },
+    ]
+
+    const segments = parseBlocks(blocks)
+    if (segments[0].type !== 'agent_group') throw new Error('expected workflow group')
+    expect(segments[0].items).toEqual([
+      { type: 'thinking', content: 'planning' },
+      { type: 'text', content: 'done' },
+    ])
+    expect(segments[0].isDelegating).toBe(false)
+  })
+
   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 },
@@ -309,4 +372,25 @@ describe('parseBlocks legacy — thinking between top-level tools', () => {
     // The untagged chunk after thinking must NOT merge into the flushed lane.
     expect(groups[0].items).toHaveLength(1)
   })
+
+  it('renders subagent thinking inside the legacy lane', () => {
+    const blocks: ContentBlock[] = [
+      { type: 'subagent', content: 'workflow', parentToolCallId: 'd1', timestamp: 1 },
+      {
+        type: 'subagent_thinking',
+        content: 'legacy reasoning',
+        parentToolCallId: 'd1',
+        timestamp: 2,
+      },
+      { type: 'subagent_text', content: 'output', parentToolCallId: 'd1', timestamp: 3 },
+    ]
+    const segments = parseBlocks(blocks)
+    const groups = segments.filter((s) => s.type === 'agent_group')
+    expect(groups).toHaveLength(1)
+    if (groups[0].type !== 'agent_group') throw new Error('expected group')
+    expect(groups[0].items).toEqual([
+      { type: 'thinking', content: 'legacy reasoning' },
+      { type: 'text', content: 'output' },
+    ])
+  })
 })

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

@@ -138,6 +138,15 @@ function appendTextItem(group: AgentGroupSegment, content: string): void {
   }
 }
 
+function appendThinkingItem(group: AgentGroupSegment, content: string): void {
+  const lastItem = group.items[group.items.length - 1]
+  if (lastItem?.type === 'thinking') {
+    lastItem.content += content
+  } else {
+    group.items.push({ type: 'thinking', content })
+  }
+}
+
 /**
  * Deterministic span-identity grouping. Every subagent-scoped block carries the
  * stable `spanId` of the run that produced it and a `parentSpanId` linking it to
@@ -244,12 +253,26 @@ function parseBlocksWithSpanTree(blocks: ContentBlock[]): MessageSegment[] {
   for (let i = 0; i < blocks.length; i++) {
     const block = blocks[i]
 
-    // Thinking is never rendered — a display-only omission; the reasoning is
-    // still reduced and persisted upstream. This covers subagent lanes too:
-    // reasoning-summary models (OpenAI effort-style) stream a summary on every
-    // tool round, which would otherwise fill the agent card with reasoning
-    // prose. The lane keeps its delegating spinner until real output arrives.
-    if (block.type === 'thinking' || block.type === 'subagent_thinking') continue
+    // Main-agent thinking is not rendered — a display-only omission; the
+    // reasoning is still reduced upstream (and stripped at persistence).
+    if (block.type === 'thinking') continue
+
+    // Subagent thinking renders in the lane as muted reasoning prose so a long
+    // thinking round (extended thinking after a tool result can run for
+    // minutes) reads as visible progress instead of a hung spinner. It does
+    // NOT clear isDelegating: the header spinner keeps signaling activity
+    // until real output or a tool arrives.
+    if (block.type === 'subagent_thinking') {
+      if (!block.content?.trim() || !block.spanId) continue
+      let g = groupsBySpanId.get(block.spanId)
+      // Out-of-order safety: see subagent_text branch below.
+      if (!g && block.subagent) {
+        g = ensureSpanGroup(block.subagent, block.spanId, block.parentSpanId)
+      }
+      if (!g) continue
+      appendThinkingItem(g, block.content)
+      continue
+    }
 
     if (block.type === 'subagent_text') {
       if (!block.content || !block.spanId) continue
@@ -303,7 +326,7 @@ function parseBlocksWithSpanTree(blocks: ContentBlock[]): MessageSegment[] {
       // emits its first content or tool (or ends). The legacy path derived this
       // from the dispatch tool_call, which the span path absorbs, so we set it
       // here. It is cleared in the subagent_text, scoped text, tool_call, and
-      // subagent_end branches (thinking is skipped, so it keeps the spinner).
+      // subagent_end branches (thinking renders but keeps the spinner).
       g.isDelegating = true
       g.isOpen = true
       continue
@@ -482,10 +505,20 @@ function parseBlocksLegacy(blocks: ContentBlock[]): MessageSegment[] {
   for (let i = 0; i < blocks.length; i++) {
     const block = blocks[i]
 
-    // Subagent thinking is never rendered (same display-only omission as the
-    // span-tree parser): reasoning-summary models stream a summary every tool
-    // round and would flood the lane with reasoning prose.
-    if (block.type === 'subagent_thinking') continue
+    // Subagent thinking renders in the lane as muted reasoning prose (same
+    // rationale as the span-tree parser); it keeps the delegating spinner.
+    if (block.type === 'subagent_thinking') {
+      if (!block.content?.trim()) continue
+      const g = findGroupForSubagentChunk(block.parentToolCallId)
+      if (!g) continue
+      const lastItem = g.items[g.items.length - 1]
+      if (lastItem?.type === 'thinking') {
+        lastItem.content += block.content
+      } else {
+        g.items.push({ type: 'thinking', content: block.content })
+      }
+      continue
+    }
 
     if (block.type === 'subagent_text') {
       if (!block.content) continue