fix(subagents): lanes

Author: Sg312

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

@@ -266,3 +266,47 @@ describe('shouldSmoothTextSegment', () => {
     )
   })
 })
+
+describe('parseBlocks legacy — thinking between top-level tools', () => {
+  it('keeps consecutive mothership tools in one group across intervening thinking', () => {
+    const blocks: ContentBlock[] = [
+      { type: 'thinking', content: 'planning the search', timestamp: 1 },
+      mainToolCall('t1', 'grep'),
+      { type: 'thinking', content: 'now read the workflow', timestamp: 1 },
+      mainToolCall('t2', 'read'),
+      mainToolCall('t3', 'read'),
+    ]
+    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].agentName).toBe('mothership')
+    expect(groups[0].items).toHaveLength(3)
+  })
+
+  it('still splits the mothership run on real main text', () => {
+    const blocks: ContentBlock[] = [
+      mainToolCall('t1', 'grep'),
+      mainText('Here is what I found so far.'),
+      mainToolCall('t2', 'read'),
+    ]
+    const segments = parseBlocks(blocks)
+    const groups = segments.filter((s) => s.type === 'agent_group')
+    expect(groups).toHaveLength(2)
+  })
+
+  it('still breaks subagent lanes on main thinking', () => {
+    const blocks: ContentBlock[] = [
+      { type: 'subagent', content: 'workflow', parentToolCallId: 'd1', timestamp: 1 },
+      { type: 'subagent_text', content: 'working', parentToolCallId: 'd1', timestamp: 1 },
+      { type: 'thinking', content: 'main reasoning', timestamp: 1 },
+      { type: 'subagent_text', content: 'later chunk with no lane tag', timestamp: 1 },
+    ]
+    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')
+    // The untagged chunk after thinking must NOT merge into the flushed lane.
+    expect(groups[0].items).toHaveLength(1)
+  })
+})

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

@@ -502,10 +502,20 @@ function parseBlocksLegacy(blocks: ContentBlock[]): MessageSegment[] {
     }
 
     if (block.type === 'thinking') {
-      // Main-agent thinking is not rendered, but it still breaks open subagent
-      // lanes so later chunks don't merge across it (display-only omission).
+      // Main-agent thinking is not rendered. It still breaks open SUBAGENT
+      // lanes so later chunks don't merge across them, but it must not
+      // fracture the top-level (mothership) tool run: models stream reasoning
+      // between consecutive tool rounds (Anthropic thinking, OpenAI per-round
+      // summaries), and splitting on it renders back-to-back top-level tools
+      // as separate groups. Thinking is also stripped at persistence, so a
+      // live split would disagree with the reloaded transcript. Every other
+      // segment kind still breaks the run via its own branch.
       if (!block.content?.trim()) continue
+      const mothershipKey = groupKey('mothership', undefined)
+      const mothership = groupsByKey.get(mothershipKey)
+      if (mothership) groupsByKey.delete(mothershipKey)
       flushLanes()
+      if (mothership) groupsByKey.set(mothershipKey, mothership)
       continue
     }
 

apps/sim/lib/copilot/chat/persisted-message.ts

@@ -269,7 +269,17 @@ export function buildPersistedAssistantMessage(
   }
 
   if (result.contentBlocks.length > 0) {
-    message.contentBlocks = mergeAndRedactPersistedBlocks(result.contentBlocks.map(mapContentBlock))
+    // Reasoning is display-transient and never rendered, so it is never
+    // persisted either: storing it bloats whale chats and lets the persisted
+    // turn diverge from the streamed one (the refresh-vs-switch mismatch).
+    // This is the single write-side choke point for assistant blocks, so the
+    // guarantee holds for every terminal path (complete, cancelled, error).
+    const withoutThinking = result.contentBlocks.filter(
+      (block) => block.type !== 'thinking' && block.type !== 'subagent_thinking'
+    )
+    if (withoutThinking.length > 0) {
+      message.contentBlocks = mergeAndRedactPersistedBlocks(withoutThinking.map(mapContentBlock))
+    }
   }
 
   return message