feat(subagents): add support for parallel subagents

Author: Sg312

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

@@ -94,6 +94,56 @@ describe('parseBlocks span-identity tree', () => {
     expect(withContent[0].isDelegating).toBe(false)
   })
 
+  it('keeps two concurrently-open subagent lanes separate with interleaved text', () => {
+    const blocks: ContentBlock[] = [
+      subagentStart('research', 'A', 'main'),
+      subagentStart('research', 'B', 'main'),
+      { type: 'subagent_text', content: 'A1 ', spanId: 'A', subagent: 'research', timestamp: 2 },
+      { type: 'subagent_text', content: 'B1 ', spanId: 'B', subagent: 'research', timestamp: 2 },
+      { type: 'subagent_text', content: 'A2', spanId: 'A', subagent: 'research', timestamp: 3 },
+    ]
+
+    const segments = parseBlocks(blocks)
+    const groups = segments.filter((s) => s.type === 'agent_group')
+    expect(groups).toHaveLength(2)
+
+    const textOf = (g: (typeof groups)[number]): string => {
+      if (g.type !== 'agent_group') return ''
+      return g.items
+        .filter((i) => i.type === 'text')
+        .map((i) => (i.type === 'text' ? i.content : ''))
+        .join('')
+    }
+    // Group A (spanId A) created first, group B second. Interleaved chunks stay
+    // in their own lane and in order — no cross-contamination.
+    expect(textOf(groups[0])).toBe('A1 A2')
+    expect(textOf(groups[1])).toBe('B1 ')
+  })
+
+  it('renders a persisted subagent lane as closed when only endedAt is set (no subagent_end)', () => {
+    // The Sim backend stamps endedAt on the subagent block but does not emit a
+    // separate subagent_end block; a reloaded transcript must still show the
+    // lane closed (no stuck delegating spinner).
+    const blocks: ContentBlock[] = [
+      {
+        type: 'subagent',
+        content: 'research',
+        spanId: 'S1',
+        parentSpanId: 'main',
+        timestamp: 1,
+        endedAt: 5,
+      },
+      { type: 'subagent_text', content: 'done', spanId: 'S1', subagent: 'research', timestamp: 2 },
+    ]
+
+    const segments = parseBlocks(blocks)
+    const group = segments.find((s) => s.type === 'agent_group')
+    expect(group).toBeDefined()
+    if (!group || group.type !== 'agent_group') throw new Error('expected research group')
+    expect(group.isOpen).toBe(false)
+    expect(group.isDelegating).toBe(false)
+  })
+
   it('prunes an empty nested subagent that started and ended without output', () => {
     const blocks: ContentBlock[] = [
       subagentStart('workflow', 'S1', 'main'),

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

@@ -315,6 +315,16 @@ function parseBlocksWithSpanTree(blocks: ContentBlock[]): MessageSegment[] {
       const dispatchToolName = SUBAGENT_DISPATCH_TOOLS[block.content]
       if (dispatchToolName) absorbDispatchTool(dispatchToolName, block.parentSpanId)
       const g = ensureSpanGroup(block.content, block.spanId, block.parentSpanId, i)
+      if (block.endedAt !== undefined) {
+        // Persisted backend path: the lane was stamped closed (endedAt) without
+        // a separate subagent_end block (the Sim backend stamps endedAt only;
+        // only the live browser path pushes subagent_end). Honor endedAt so a
+        // reloaded transcript shows the subagent closed instead of a stuck
+        // delegating spinner.
+        g.isOpen = false
+        g.isDelegating = false
+        continue
+      }
       // Show the working/delegating spinner from span open until the agent
       // 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

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-span-event.ts

@@ -106,11 +106,12 @@ export function handleSpanEvent(
         deps.setActiveResourceId(lastFileResource.id)
       }
     }
-    if (
-      !parentToolCallId ||
-      parentToolCallId === state.activeSubagentParentToolCallId ||
-      name === state.activeSubagent
-    ) {
+    // Clear the legacy single pointer only when THIS ending lane is the active
+    // one (matched by parent tool call id, or an unscoped end). Never clear by
+    // agent name alone — a concurrent same-name subagent that is still open must
+    // not be torn down by a sibling's end. Per-lane state lives in the
+    // subagentBySpanId / subagentByParentToolCallId maps cleared above.
+    if (!parentToolCallId || parentToolCallId === state.activeSubagentParentToolCallId) {
       state.activeSubagent = undefined
       state.activeSubagentParentToolCallId = undefined
     }

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-context.test.ts

@@ -223,15 +223,52 @@ describe('createStreamLoopContext', () => {
       expect(Number.isFinite(ms)).toBe(true)
     })
 
-    it('resolveScopedSubagent prefers agentId, then spanId, then parentToolCallId, then active', () => {
+    it('stampBlockEnd never closes a subagent header (prevents concurrent-lane flicker)', () => {
+      const ctx = createStreamLoopContext(makeStreamLoopDeps())
+
+      // A subagent header must stay open when a generic block boundary fires
+      // (e.g. the next sibling subagent starts, or this lane's first content
+      // arrives). endedAt is set only by the real span-end handler.
+      const header: ContentBlock = { type: 'subagent', content: 'research', spanId: 's1' }
+      ctx.ops.stampBlockEnd(header)
+      expect(header.endedAt).toBeUndefined()
+
+      // Other block types still get their endedAt stamped as before.
+      const text: ContentBlock = { type: 'text', content: 'hi' }
+      ctx.ops.stampBlockEnd(text)
+      expect(text.endedAt).toBeTypeOf('number')
+    })
+
+    it('resolveScopedSubagent prefers agentId, then spanId, then parentToolCallId (scope-only, no active fallback)', () => {
       const ctx = createStreamLoopContext(makeStreamLoopDeps())
       ctx.state.subagentBySpanId.set('s1', 'spanAgent')
       ctx.state.subagentByParentToolCallId.set('p1', 'parentAgent')
       ctx.state.activeSubagent = 'activeAgent'
       expect(ctx.ops.resolveScopedSubagent('explicit', 'p1', 's1')).toBe('explicit')
       expect(ctx.ops.resolveScopedSubagent(undefined, 'p1', 's1')).toBe('spanAgent')
       expect(ctx.ops.resolveScopedSubagent(undefined, 'p1', undefined)).toBe('parentAgent')
-      expect(ctx.ops.resolveScopedSubagent(undefined, undefined, undefined)).toBe('activeAgent')
+      // No scope match → undefined (the legacy activeSubagent fallback was
+      // removed so a concurrent sibling can never be mis-attributed).
+      expect(ctx.ops.resolveScopedSubagent(undefined, undefined, undefined)).toBeUndefined()
+    })
+
+    it('rebuilds every open subagent lane on reconnect, skipping closed ones', () => {
+      const blocks: ContentBlock[] = [
+        { type: 'subagent', content: 'research', spanId: 'span-a', parentToolCallId: 'tc-a' },
+        { type: 'subagent', content: 'deploy', spanId: 'span-b', parentToolCallId: 'tc-b' },
+        // span-b closed via marker; span-a stays open.
+        { type: 'subagent_end', spanId: 'span-b', parentToolCallId: 'tc-b' },
+      ]
+      const ctx = createStreamLoopContext(
+        makeStreamLoopDeps({
+          options: { preserveExistingState: true },
+          streamingBlocksRef: ref<ContentBlock[]>(blocks),
+        })
+      )
+      expect(ctx.state.subagentBySpanId.get('span-a')).toBe('research')
+      expect(ctx.state.subagentBySpanId.has('span-b')).toBe(false)
+      expect(ctx.state.subagentByParentToolCallId.get('tc-a')).toBe('research')
+      expect(ctx.state.subagentByParentToolCallId.has('tc-b')).toBe(false)
     })
 
     it('buildInlineErrorTag includes the message, code and provider', () => {

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-context.ts

@@ -218,20 +218,31 @@ export function createStreamLoopContext(deps: StreamLoopDeps): StreamLoopContext
         if (tc.params) state.toolArgsMap.set(tc.id, tc.params)
       }
     }
+    // Rebuild ALL open subagent lanes (not just the most recent one) so that a
+    // reconnect mid-flight with multiple concurrent subagents rehydrates every
+    // lane. A lane is closed when its `subagent` start block has an endedAt OR a
+    // matching `subagent_end` marker exists (the live path stamps endedAt and
+    // pushes subagent_end; the persisted backend path stamps endedAt only).
+    const endedSpanIds = new Set<string>()
+    const endedParents = new Set<string>()
     for (const block of state.blocks) {
-      if (block.type === 'subagent' && block.spanId && block.content) {
-        state.subagentBySpanId.set(block.spanId, block.content)
+      if (block.type === 'subagent_end') {
+        if (block.spanId) endedSpanIds.add(block.spanId)
+        if (block.parentToolCallId) endedParents.add(block.parentToolCallId)
       }
     }
-    for (let i = state.blocks.length - 1; i >= 0; i--) {
-      if (state.blocks[i].type === 'subagent' && state.blocks[i].content) {
-        state.activeSubagent = state.blocks[i].content
-        state.activeSubagentParentToolCallId = state.blocks[i].parentToolCallId
-        break
-      }
-      if (state.blocks[i].type === 'subagent_end') {
-        break
+    for (const block of state.blocks) {
+      if (block.type !== 'subagent' || !block.content || block.endedAt !== undefined) continue
+      if (block.spanId && endedSpanIds.has(block.spanId)) continue
+      if (block.parentToolCallId && endedParents.has(block.parentToolCallId)) continue
+      if (block.spanId) state.subagentBySpanId.set(block.spanId, block.content)
+      if (block.parentToolCallId) {
+        state.subagentByParentToolCallId.set(block.parentToolCallId, block.content)
       }
+      // Keep a best-effort single pointer for legacy (no-spanId) dedup only;
+      // routing no longer depends on it.
+      state.activeSubagent = block.content
+      state.activeSubagentParentToolCallId = block.parentToolCallId
     }
   } else if (!isStale()) {
     deps.streamingContentRef.current = ''
@@ -247,7 +258,15 @@ export function createStreamLoopContext(deps: StreamLoopDeps): StreamLoopContext
   }
 
   const stampBlockEnd = (block: ContentBlock | undefined, ts?: string) => {
-    if (block && block.endedAt === undefined) block.endedAt = toEventMs(ts)
+    // Never stamp a subagent header here. Its endedAt is the renderer's
+    // "group closed" signal (parseBlocksWithSpanTree), set explicitly only when
+    // the subagent's span actually ends (the span-end handler and the backend
+    // both set it directly). Stamping it as a generic block boundary — when the
+    // next sibling subagent starts, or when this lane's first content arrives —
+    // would close + prune concurrent subagents mid-stream, making them all flash
+    // in, vanish to one, then reappear one-by-one as content trickles in.
+    if (!block || block.type === 'subagent') return
+    if (block.endedAt === undefined) block.endedAt = toEventMs(ts)
   }
 
   const ensureTextBlock = (
@@ -306,6 +325,12 @@ export function createStreamLoopContext(deps: StreamLoopDeps): StreamLoopContext
     parentToolCallId: string | undefined,
     spanId?: string
   ): string | undefined => {
+    // Scope-only: resolve by the event's own identity. The legacy
+    // `state.activeSubagent` fallback was removed — with concurrent subagents it
+    // points at whichever started most recently and would mis-attribute an
+    // interleaved event from a different lane. Well-formed subagent events carry
+    // agentId (and spanId), so this resolves deterministically; anything else is
+    // treated as main-lane rather than guessed.
     if (agentId) return agentId
     if (spanId) {
       const scoped = state.subagentBySpanId.get(spanId)
@@ -315,20 +340,18 @@ export function createStreamLoopContext(deps: StreamLoopDeps): StreamLoopContext
       const scoped = state.subagentByParentToolCallId.get(parentToolCallId)
       if (scoped) return scoped
     }
-    return state.activeSubagent
+    return undefined
   }
 
   const resolveParentForSubagentBlock = (
     subagent: string | undefined,
     scopedParent: string | undefined
   ): string | undefined => {
+    // Scope-only: a subagent block's parent comes from the event's own scope.
+    // The previous "first parent whose name matches" scan was ambiguous when two
+    // concurrent subagents share an agent name, so it was removed.
     if (!subagent) return undefined
-    if (scopedParent) return scopedParent
-    if (state.activeSubagent === subagent) return state.activeSubagentParentToolCallId
-    for (const [parent, name] of state.subagentByParentToolCallId) {
-      if (name === subagent) return parent
-    }
-    return undefined
+    return scopedParent
   }
 
   const flush = () => {

apps/sim/lib/copilot/chat/effective-transcript.ts

@@ -119,6 +119,9 @@ function buildLiveAssistantMessage(params: {
   let requestId: string | undefined
   let lastTimestamp: string | undefined
 
+  // Scope-only resolution (mirrors the live browser stream loop): with
+  // concurrent subagents the legacy activeSubagent fallback / name-match scan
+  // would mis-attribute interleaved replayed events to the wrong lane.
   const resolveScopedSubagent = (
     agentId: string | undefined,
     parentToolCallId: string | undefined,
@@ -133,20 +136,15 @@ function buildLiveAssistantMessage(params: {
       const scoped = subagentByParentToolCallId.get(parentToolCallId)
       if (scoped) return scoped
     }
-    return activeSubagent
+    return undefined
   }
 
   const resolveParentForSubagentBlock = (
     subagent: string | undefined,
     scopedParent: string | undefined
   ): string | undefined => {
     if (!subagent) return undefined
-    if (scopedParent) return scopedParent
-    if (activeSubagent === subagent) return activeSubagentParentToolCallId
-    for (const [parent, name] of subagentByParentToolCallId) {
-      if (name === subagent) return parent
-    }
-    return undefined
+    return scopedParent
   }
 
   const ensureToolBlock = (input: {
@@ -364,11 +362,10 @@ function buildLiveAssistantMessage(params: {
           if (parentToolCallId) {
             subagentByParentToolCallId.delete(parentToolCallId)
           }
-          if (
-            !parentToolCallId ||
-            parentToolCallId === activeSubagentParentToolCallId ||
-            name === activeSubagent
-          ) {
+          // Clear the legacy pointer only for THIS lane (by parent tool call id)
+          // or an unscoped end — never by agent name, which would tear down a
+          // concurrent same-name sibling that is still open.
+          if (!parentToolCallId || parentToolCallId === activeSubagentParentToolCallId) {
             activeSubagent = undefined
             activeSubagentParentToolCallId = undefined
           }

apps/sim/lib/copilot/generated/mothership-stream-v1-schema.ts

@@ -50,6 +50,9 @@ export const MOTHERSHIP_STREAM_V1_SCHEMA: JsonSchema = {
     MothershipStreamV1CheckpointPauseFrame: {
       additionalProperties: false,
       properties: {
+        checkpointId: {
+          type: 'string',
+        },
         parentToolCallId: {
           type: 'string',
         },

apps/sim/lib/copilot/generated/mothership-stream-v1.ts

@@ -319,6 +319,7 @@ export interface MothershipStreamV1CheckpointPausePayload {
   runId: string
 }
 export interface MothershipStreamV1CheckpointPauseFrame {
+  checkpointId?: string
   parentToolCallId: string
   parentToolName: string
   pendingToolIds: string[]

apps/sim/lib/copilot/request/context/request-context.ts

@@ -18,7 +18,7 @@ export function createStreamingContext(overrides?: Partial<StreamingContext>): S
     toolCalls: new Map(),
     pendingToolPromises: new Map(),
     currentThinkingBlock: null,
-    currentSubagentThinkingBlock: null,
+    subagentThinkingBlocks: new Map(),
     isInThinkingBlock: false,
     subAgentParentToolCallId: undefined,
     subAgentParentStack: [],
@@ -28,7 +28,7 @@ export function createStreamingContext(overrides?: Partial<StreamingContext>): S
     streamComplete: false,
     wasAborted: false,
     errors: [],
-    activeFileIntent: null,
+    activeFileIntents: new Map(),
     trace: new TraceCollector(),
     ...overrides,
   }

apps/sim/lib/copilot/request/context/result.test.ts

@@ -23,6 +23,7 @@ function makeContext(): StreamingContext {
     pendingToolPromises: new Map(),
     awaitingAsyncContinuation: undefined,
     currentThinkingBlock: null,
+    subagentThinkingBlocks: new Map(),
     isInThinkingBlock: false,
     subAgentParentToolCallId: undefined,
     subAgentParentStack: [],