Fix web researcher subagent output not displaying in CLI

Root causes:
1. extractSpawnAgentResultContent didn't handle lastMessage output mode
   where value is an array of Message objects
2. After subagent_start replaced temp agent IDs with real IDs,
   handleSpawnAgentsResult couldn't match blocks to apply results

Changes:
- Add spawnToolCallId and spawnIndex fields to AgentContentBlock
- Add extractTextFromMessageContent helper to extract text from messages
- Update extractSpawnAgentResultContent to handle lastMessage output mode
- Update createAgentBlock to accept spawnToolCallId and spawnIndex
- Refactor updateSpawnAgentBlocks to match by spawnToolCallId/spawnIndex
- Preserve streamed content for agents like commander that stream output
- Add test cases for lastMessage output handling

Author: jahooma

cli/src/types/chat.ts

@@ -48,6 +48,10 @@ export type AgentContentBlock = {
   params?: Record<string, any>
   isCollapsed?: boolean
   userOpened?: boolean
+  /** The spawn_agents tool call ID that created this block, used to match results */
+  spawnToolCallId?: string
+  /** The index within the spawn_agents call, used to match the correct result */
+  spawnIndex?: number
 }
 export type AgentListContentBlock = {
   type: 'agent-list'

cli/src/utils/__tests__/message-block-helpers.test.ts

@@ -261,6 +261,76 @@ describe('extractSpawnAgentResultContent', () => {
     const result = extractSpawnAgentResultContent(undefined)
     expect(result.hasError).toBe(false)
   })
+
+  test('extracts text from lastMessage output mode with Message array', () => {
+    // This is the format returned by agents with outputMode: 'last_message'
+    const result = extractSpawnAgentResultContent({
+      type: 'lastMessage',
+      value: [
+        {
+          role: 'assistant',
+          content: [
+            { type: 'text', text: 'Here are the research findings:' },
+            { type: 'text', text: ' Important information found.' },
+          ],
+        },
+      ],
+    })
+    expect(result).toEqual({
+      content: 'Here are the research findings: Important information found.',
+      hasError: false,
+    })
+  })
+
+  test('extracts text from multiple assistant messages in lastMessage output', () => {
+    const result = extractSpawnAgentResultContent({
+      type: 'lastMessage',
+      value: [
+        {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'First message' }],
+        },
+        {
+          role: 'tool',
+          content: [{ type: 'json', value: {} }],
+        },
+        {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Second message' }],
+        },
+      ],
+    })
+    expect(result).toEqual({
+      content: 'First message\nSecond message',
+      hasError: false,
+    })
+  })
+
+  test('handles lastMessage with empty content array', () => {
+    const result = extractSpawnAgentResultContent({
+      type: 'lastMessage',
+      value: [
+        {
+          role: 'assistant',
+          content: [],
+        },
+      ],
+    })
+    expect(result).toEqual({ content: '', hasError: false })
+  })
+
+  test('handles lastMessage with no assistant messages', () => {
+    const result = extractSpawnAgentResultContent({
+      type: 'lastMessage',
+      value: [
+        {
+          role: 'tool',
+          content: [{ type: 'json', value: {} }],
+        },
+      ],
+    })
+    expect(result).toEqual({ content: '', hasError: false })
+  })
 })
 
 describe('appendInterruptionNotice', () => {

cli/src/utils/__tests__/sdk-event-handlers.test.ts

@@ -182,7 +182,12 @@ describe('sdk-event-handlers', () => {
   test('handles spawn_agents tool results and clears streaming agents', () => {
     const { ctx, getMessages, getStreamingAgents } = createTestContext()
     ctx.message.updater.addBlock(
-      createAgentBlock({ agentId: 'tool-1-0', agentType: 'temp' }),
+      createAgentBlock({
+        agentId: 'tool-1-0',
+        agentType: 'temp',
+        spawnToolCallId: 'tool-1',
+        spawnIndex: 0,
+      }),
     )
     ctx.streaming.setStreamingAgents(() => new Set(['tool-1-0']))
 

cli/src/utils/message-block-helpers.ts

@@ -1,4 +1,4 @@
-import { has, isEqual } from 'lodash'
+import { isEqual } from 'lodash'
 
 import { formatToolOutput } from './codebuff-client'
 import { shouldCollapseByDefault } from './constants'
@@ -120,69 +120,79 @@ export interface SpawnAgentResultContent {
   hasError: boolean
 }
 
+/**
+ * Extracts text content from a Message object's content array.
+ * Handles assistant messages with TextPart content.
+ */
+const extractTextFromMessageContent = (content: unknown): string => {
+  if (!Array.isArray(content)) {
+    return ''
+  }
+  return content
+    .filter((part: any) => part?.type === 'text' && typeof part?.text === 'string')
+    .map((part: any) => part.text)
+    .join('')
+}
+
 /**
  * Extracts displayable content from a spawn_agents result value.
  * Handles various nested structures that can come back from agent spawns.
  */
 export const extractSpawnAgentResultContent = (
   resultValue: unknown,
 ): SpawnAgentResultContent => {
+  // Handle null/undefined
+  if (!resultValue) {
+    return { content: '', hasError: false }
+  }
+
+  // Handle direct string
   if (typeof resultValue === 'string') {
     return { content: resultValue, hasError: false }
   }
 
-  if (resultValue && typeof resultValue === 'object') {
-    const nestedValue = (resultValue as any).value
-
-    if (typeof nestedValue === 'string') {
-      return { content: nestedValue, hasError: false }
-    }
-
-    if (nestedValue && typeof nestedValue === 'object') {
-      if (has(nestedValue, 'errorMessage') && (nestedValue as any).errorMessage) {
-        return {
-          content: String((nestedValue as any).errorMessage),
-          hasError: true,
-        }
-      }
+  if (typeof resultValue !== 'object') {
+    return { content: '', hasError: false }
+  }
 
-      if (has(nestedValue, 'message') && (nestedValue as any).message) {
-        return { content: String((nestedValue as any).message), hasError: false }
-      }
-    }
+  const obj = resultValue as Record<string, unknown>
 
-    if (
-      typeof resultValue === 'object' &&
-      Object.keys(resultValue as Record<string, unknown>).length === 0
-    ) {
-      return { content: '', hasError: false }
-    }
+  // Handle empty object
+  if (Object.keys(obj).length === 0) {
+    return { content: '', hasError: false }
+  }
 
-    // Handle error messages from failed agent spawns
-    if (has(resultValue, 'errorMessage') && (resultValue as any).errorMessage) {
-      return {
-        content: String((resultValue as any).errorMessage),
-        hasError: true,
-      }
-    }
+  // Handle error messages (check both top-level and nested)
+  if (obj.errorMessage) {
+    return { content: String(obj.errorMessage), hasError: true }
+  }
+  if ((obj.value as any)?.errorMessage) {
+    return { content: String((obj.value as any).errorMessage), hasError: true }
+  }
 
-    // Handle nested value structure like { type: "lastMessage", value: "..." }
-    if (
-      has(resultValue, 'value') &&
-      (resultValue as any).value &&
-      typeof (resultValue as any).value === 'string'
-    ) {
-      return { content: (resultValue as any).value, hasError: false }
-    }
+  // Handle lastMessage output mode: { type: "lastMessage", value: [Message array] }
+  // This is common for agents like researcher-web
+  if (obj.type === 'lastMessage' && Array.isArray(obj.value)) {
+    const messages = obj.value as Array<{ role?: string; content?: unknown }>
+    const textContent = messages
+      .filter((msg) => msg?.role === 'assistant')
+      .map((msg) => extractTextFromMessageContent(msg?.content))
+      .filter(Boolean)
+      .join('\n')
+    return { content: textContent, hasError: false }
+  }
 
-    // Handle message field
-    if (has(resultValue, 'message') && (resultValue as any).message) {
-      return { content: (resultValue as any).message, hasError: false }
-    }
+  // Handle nested string value: { value: "..." }
+  if (typeof obj.value === 'string') {
+    return { content: obj.value, hasError: false }
   }
 
-  if (!resultValue) {
-    return { content: '', hasError: false }
+  // Handle message field (top-level or nested)
+  if (obj.message) {
+    return { content: String(obj.message), hasError: false }
+  }
+  if ((obj.value as any)?.message) {
+    return { content: String((obj.value as any).message), hasError: false }
   }
 
   // Fallback to formatted output
@@ -224,6 +234,10 @@ export interface CreateAgentBlockOptions {
   agentType: string
   prompt?: string
   params?: Record<string, unknown>
+  /** The spawn_agents tool call ID that created this block */
+  spawnToolCallId?: string
+  /** The index within the spawn_agents call */
+  spawnIndex?: number
 }
 
 /**
@@ -232,7 +246,7 @@ export interface CreateAgentBlockOptions {
 export const createAgentBlock = (
   options: CreateAgentBlockOptions,
 ): AgentContentBlock => {
-  const { agentId, agentType, prompt, params } = options
+  const { agentId, agentType, prompt, params, spawnToolCallId, spawnIndex } = options
   return {
     type: 'agent',
     agentId,
@@ -243,6 +257,8 @@ export const createAgentBlock = (
     blocks: [] as ContentBlock[],
     initialPrompt: prompt || '',
     ...(params && { params }),
+    ...(spawnToolCallId && { spawnToolCallId }),
+    ...(spawnIndex !== undefined && { spawnIndex }),
     ...(shouldCollapseByDefault(agentType || '') && { isCollapsed: true }),
   }
 }

cli/src/utils/sdk-event-handlers.ts

@@ -1,4 +1,3 @@
-import { has } from 'lodash'
 import { match } from 'ts-pattern'
 
 import {
@@ -275,12 +274,15 @@ const handleSpawnAgentsToolCall = (
 
   state.message.updater.updateAiMessageBlocks((blocks) => {
     const newAgentBlocks: ContentBlock[] = agents
-      .filter((agent: any) => !shouldHideAgent(agent.agent_type || ''))
-      .map((agent: any, index: number) =>
+      .map((agent: any, originalIndex: number) => ({ agent, originalIndex }))
+      .filter(({ agent }) => !shouldHideAgent(agent.agent_type || ''))
+      .map(({ agent, originalIndex }) =>
         createAgentBlock({
-          agentId: `${event.toolCallId}-${index}`,
+          agentId: `${event.toolCallId}-${originalIndex}`,
           agentType: agent.agent_type || '',
           prompt: agent.prompt,
+          spawnToolCallId: event.toolCallId,
+          spawnIndex: originalIndex,
         }),
       )
 
@@ -334,42 +336,56 @@ const handleToolCall = (state: EventHandlerState, event: PrintModeToolCall) => {
   updateStreamingAgents(state, { add: event.toolCallId })
 }
 
-const handleSpawnAgentsResult = (
-  state: EventHandlerState,
+/**
+ * Recursively finds and updates agent blocks that match a spawn_agents tool call.
+ */
+const updateSpawnAgentBlocks = (
+  blocks: ContentBlock[],
   toolCallId: string,
   results: any[],
-) => {
-  // Replace placeholder spawn agent blocks with their final text/status output.
-  state.message.updater.updateAiMessageBlocks((blocks) =>
-    blocks.map((block) => {
-      if (
-        block.type === 'agent' &&
-        block.agentId.startsWith(toolCallId) &&
-        block.blocks
-      ) {
-        const agentIndex = Number.parseInt(
-          block.agentId.split('-').pop() || '0',
-          10,
-        )
-        const result = results[agentIndex]
-
-        if (has(result, 'value') && result.value) {
-          const { content, hasError } = extractSpawnAgentResultContent(
-            result.value,
-          )
-          const resultTextBlock: ContentBlock = {
-            type: 'text',
-            content,
-          }
+): ContentBlock[] => {
+  return blocks.map((block) => {
+    if (block.type !== 'agent') {
+      return block
+    }
+
+    if (block.spawnToolCallId === toolCallId && block.spawnIndex !== undefined && block.blocks) {
+      const result = results[block.spawnIndex]
+
+      if (result?.value) {
+        const { content, hasError } = extractSpawnAgentResultContent(result.value)
+        // Preserve streamed content (agents like commander stream their output)
+        const hasStreamedContent = block.blocks.length > 0
+        if (hasError || content || hasStreamedContent) {
           return {
             ...block,
-            blocks: [resultTextBlock],
+            blocks: hasStreamedContent ? block.blocks : [{ type: 'text', content } as ContentBlock],
             status: hasError ? ('failed' as const) : ('complete' as const),
           }
         }
       }
-      return block
-    }),
+    }
+
+    // Recursively process nested agent blocks
+    if (block.blocks?.length) {
+      const updatedNestedBlocks = updateSpawnAgentBlocks(block.blocks, toolCallId, results)
+      if (updatedNestedBlocks !== block.blocks) {
+        return { ...block, blocks: updatedNestedBlocks }
+      }
+    }
+
+    return block
+  })
+}
+
+const handleSpawnAgentsResult = (
+  state: EventHandlerState,
+  toolCallId: string,
+  results: any[],
+) => {
+  // Replace placeholder spawn agent blocks with their final text/status output.
+  state.message.updater.updateAiMessageBlocks((blocks) =>
+    updateSpawnAgentBlocks(blocks, toolCallId, results),
   )
 
   results.forEach((_, index: number) => {
@@ -390,9 +406,8 @@ const handleToolResult = (
     }),
   )
 
-  const firstOutputValue = has(event.output?.[0], 'value')
-    ? event.output?.[0]?.value
-    : undefined
+  const firstOutput = event.output?.[0]
+  const firstOutputValue = firstOutput && 'value' in firstOutput ? firstOutput.value : undefined
   const isSpawnAgentsResult =
     Array.isArray(firstOutputValue) &&
     firstOutputValue.some((v: any) => v?.agentName || v?.agentType)