fix(subagents): subagent resume should join on existing subagent text…

… block
simstudioai · Sg312 · Apr 4, 2026 · Mar 25, 2026 · Mar 25, 2026 · Mar 25, 2026
commit e3f8663feb1c4937fe0475f6138ae999d93198e3
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
@@ -531,6 +531,7 @@ export function useChat(
       const toolArgsMap = new Map<string, Record<string, unknown>>()
       const clientExecutionStarted = new Set<string>()
       let activeSubagent: string | undefined
+      let activeSubagentParentToolCallId: string | undefined
       let activeCompactionId: string | undefined
       let runningText = ''
       let lastContentSource: 'main' | 'subagent' | null = null
@@ -1095,23 +1096,42 @@ export function useChat(
                   break
                 }
                 const spanEvent = typeof payload.event === 'string' ? payload.event : ''
+                const spanData = asPayloadRecord(payload.data)
+                const parentToolCallId =
+                  typeof parsed.scope?.parentToolCallId === 'string'
+                    ? parsed.scope.parentToolCallId
+                    : typeof spanData?.tool_call_id === 'string'
+                      ? spanData.tool_call_id
+                      : undefined
+                const isPendingPause = spanData?.pending === true
                 const name =
                   typeof payload.agent === 'string'
                     ? payload.agent
                     : typeof parsed.scope?.agentId === 'string'
                       ? parsed.scope.agentId
                       : undefined
                 if (spanEvent === MothershipStreamV1SpanLifecycleEvent.start && name) {
+                  const isSameActiveSubagent =
+                    activeSubagent === name &&
+                    activeSubagentParentToolCallId &&
+                    parentToolCallId === activeSubagentParentToolCallId
                   activeSubagent = name
-                  blocks.push({ type: 'subagent', content: name })
+                  activeSubagentParentToolCallId = parentToolCallId
+                  if (!isSameActiveSubagent) {
+                    blocks.push({ type: 'subagent', content: name })
+                  }
                   if (name === FileWrite.id) {
                     const emptyFile = { fileName: '', content: '' }
                     streamingFileRef.current = emptyFile
                     setStreamingFile(emptyFile)
                   }
                   flush()
                 } else if (spanEvent === MothershipStreamV1SpanLifecycleEvent.end) {
+                  if (isPendingPause) {
+                    break
+                  }
                   activeSubagent = undefined
+                  activeSubagentParentToolCallId = undefined
                   blocks.push({ type: 'subagent_end' })
                   flush()
                 }

diff --git a/apps/sim/lib/copilot/request/go/stream.ts b/apps/sim/lib/copilot/request/go/stream.ts
@@ -160,14 +160,26 @@ export async function runStreamLoop(
           (spanData?.tool_call_id as string | undefined)
         const subagentName = streamEvent.payload.agent as string | undefined
         const spanEvent = streamEvent.payload.event as string | undefined
+        const isPendingPause = spanData?.pending === true
         if (spanEvent === MothershipStreamV1SpanLifecycleEvent.start) {
+          const lastParent = context.subAgentParentStack[context.subAgentParentStack.length - 1]
+          const lastBlock = context.contentBlocks[context.contentBlocks.length - 1]
           if (toolCallId) {
-            context.subAgentParentStack.push(toolCallId)
+            if (lastParent !== toolCallId) {
+              context.subAgentParentStack.push(toolCallId)
+            }
             context.subAgentParentToolCallId = toolCallId
-            context.subAgentContent[toolCallId] = ''
-            context.subAgentToolCalls[toolCallId] = []
+            context.subAgentContent[toolCallId] ??= ''
+            context.subAgentToolCalls[toolCallId] ??= []
           }
-          if (subagentName) {
+          if (
+            subagentName &&
+            !(
+              lastParent === toolCallId &&
+              lastBlock?.type === 'subagent' &&
+              lastBlock.content === subagentName
+            )
+          ) {
             context.contentBlocks.push({
               type: 'subagent',
               content: subagentName,
@@ -177,6 +189,9 @@ export async function runStreamLoop(
           continue
         }
         if (spanEvent === MothershipStreamV1SpanLifecycleEvent.end) {
+          if (isPendingPause) {
+            continue
+          }
           if (context.subAgentParentStack.length > 0) {
             context.subAgentParentStack.pop()
           } else {

diff --git a/apps/sim/lib/copilot/request/handlers/handlers.test.ts b/apps/sim/lib/copilot/request/handlers/handlers.test.ts
@@ -40,6 +40,7 @@ vi.mock('@/lib/copilot/async-runs/repository', async () => {
 
 import {
   MothershipStreamV1EventType,
+  MothershipStreamV1TextChannel,
   MothershipStreamV1ToolExecutor,
   MothershipStreamV1ToolMode,
   MothershipStreamV1ToolOutcome,
@@ -186,6 +187,66 @@ describe('sse-handlers tool lifecycle', () => {
     })
   })
 
+  it('routes subagent text using the event scope parent tool call id', async () => {
+    context.subAgentParentToolCallId = 'wrong-parent'
+    context.subAgentContent['parent-1'] = ''
+
+    await subAgentHandlers.text(
+      {
+        type: MothershipStreamV1EventType.text,
+        scope: { lane: 'subagent', parentToolCallId: 'parent-1', agentId: 'deploy' },
+        payload: {
+          channel: MothershipStreamV1TextChannel.assistant,
+          text: 'hello from deploy',
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    expect(context.subAgentContent['parent-1']).toBe('hello from deploy')
+    expect(context.contentBlocks.at(-1)).toEqual(
+      expect.objectContaining({
+        type: 'subagent_text',
+        content: 'hello from deploy',
+      })
+    )
+  })
+
+  it('routes subagent tool calls using the event scope parent tool call id', async () => {
+    executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
+    context.subAgentParentToolCallId = 'wrong-parent'
+    context.toolCalls.set('parent-1', {
+      id: 'parent-1',
+      name: 'deploy',
+      status: 'pending',
+      startTime: Date.now(),
+    })
+
+    await subAgentHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        scope: { lane: 'subagent', parentToolCallId: 'parent-1', agentId: 'deploy' },
+        payload: {
+          toolCallId: 'sub-tool-scope-1',
+          toolName: 'read',
+          arguments: { path: 'workflow.json' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(context.subAgentToolCalls['parent-1']?.[0]?.id).toBe('sub-tool-scope-1')
+  })
+
   it('skips duplicate tool_call after result', async () => {
     executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
 

diff --git a/apps/sim/lib/copilot/request/handlers/index.ts b/apps/sim/lib/copilot/request/handlers/index.ts
@@ -33,8 +33,9 @@ export const subAgentHandlers: Record<string, StreamHandler> = {
 export function handleSubagentRouting(event: StreamEvent, context: StreamingContext): boolean {
   if (event.scope?.lane !== 'subagent') return false
 
-  // Prefer the wire-level parentToolCallId when present; fall back to the stack.
-  if (event.scope?.parentToolCallId && !context.subAgentParentToolCallId) {
+  // Keep the latest scoped parent on hand for legacy callers, but subagent
+  // handlers should prefer the event-local scope for correctness.
+  if (event.scope?.parentToolCallId) {
     context.subAgentParentToolCallId = event.scope.parentToolCallId
   }
 

diff --git a/apps/sim/lib/copilot/request/handlers/text.ts b/apps/sim/lib/copilot/request/handlers/text.ts
@@ -4,14 +4,14 @@ import {
 } from '@/lib/copilot/generated/mothership-stream-v1'
 import { getEventData } from '@/lib/copilot/request/sse-utils'
 import type { StreamHandler, ToolScope } from './types'
-import { addContentBlock } from './types'
+import { addContentBlock, getScopedParentToolCallId } from './types'
 
 export function handleTextEvent(scope: ToolScope): StreamHandler {
   return (event, context) => {
     const d = getEventData(event)
 
     if (scope === 'subagent') {
-      const parentToolCallId = context.subAgentParentToolCallId
+      const parentToolCallId = getScopedParentToolCallId(event, context)
       if (!parentToolCallId || d?.channel !== MothershipStreamV1TextChannel.assistant) return
       const chunk = d?.text as string | undefined
       if (!chunk) return

diff --git a/apps/sim/lib/copilot/request/handlers/tool.ts b/apps/sim/lib/copilot/request/handlers/tool.ts
@@ -30,6 +30,7 @@ import {
   emitSyntheticToolResult,
   ensureTerminalToolCallState,
   getEventUI,
+  getScopedParentToolCallId,
   handleClientCompletion,
   inferToolSuccess,
   registerPendingToolPromise,
@@ -54,7 +55,7 @@ export async function handleToolEvent(
   scope: ToolScope
 ): Promise<void> {
   const isSubagent = scope === 'subagent'
-  const parentToolCallId = isSubagent ? context.subAgentParentToolCallId : undefined
+  const parentToolCallId = isSubagent ? getScopedParentToolCallId(event, context) : undefined
 
   if (isSubagent && !parentToolCallId) return
 

diff --git a/apps/sim/lib/copilot/request/handlers/types.ts b/apps/sim/lib/copilot/request/handlers/types.ts
@@ -38,6 +38,13 @@ export function addContentBlock(
   })
 }
 
+export function getScopedParentToolCallId(
+  event: StreamEvent,
+  context: StreamingContext
+): string | undefined {
+  return event.scope?.parentToolCallId || context.subAgentParentToolCallId
+}
+
 export function registerPendingToolPromise(
   context: StreamingContext,
   toolCallId: string,