Refactor streaming architecture to fix agent content attribution

Implemented robust tool XML filtering and agent content routing to resolve
issues with nested agent streaming where output was being lost, duplicated,
or incorrectly attributed.

Key improvements:
- SDK: Rewrote tool XML filtering with proper state machines and partial tag
  matching to handle streaming text at buffer boundaries without data loss
- Backend: Modified spawn-agents to route text chunks through sendSubagentChunk
  and forward print mode events with agent IDs for proper attribution
- CLI: Enhanced agent content tracking with duplicate detection, proper content
  field synchronization, and comprehensive logging for debugging
- Dev: Simplified development workflow by running CLI directly via bun
- Cleanup: Removed duplicate ToolName export from SDK

The new architecture ensures streaming content flows correctly through the
agent hierarchy, preventing edge cases where tool XML tags could corrupt
output or cause content to be misattributed to the wrong agent.

🤖 Generated with Codebuff
Co-Authored-By: Codebuff <noreply@codebuff.com>

Author: brandonkachen

backend/src/tools/handlers/tool/spawn-agents.ts

@@ -147,20 +147,22 @@ export const handleSpawnAgents = ((
             isOnlyChild: agents.length === 1,
             parentSystemPrompt,
             onResponseChunk: (chunk: string | PrintModeEvent) => {
-              if (agents.length === 1) {
-                writeToClient(chunk)
-              }
-              if (typeof chunk !== 'string') {
+              if (typeof chunk === 'string') {
+                sendSubagentChunk({
+                  userInputId,
+                  agentId: subAgentState.agentId,
+                  agentType,
+                  chunk,
+                  prompt,
+                })
                 return
               }
-              // Send subagent streaming chunks to client
-              sendSubagentChunk({
-                userInputId,
+
+              const eventWithAgent = {
+                ...chunk,
                 agentId: subAgentState.agentId,
-                agentType,
-                chunk,
-                prompt,
-              })
+              }
+              writeToClient(eventWithAgent)
             },
           })
           return { ...result, agentType, agentName: agentTemplate.displayName }

cli/src/hooks/use-send-message.ts

@@ -157,6 +157,15 @@ export const useSendMessage = ({
           | { type: 'text'; content: string }
           | Extract<ContentBlock, { type: 'tool' }>,
       ) => {
+        const preview =
+          update.type === 'text'
+            ? update.content.slice(0, 120)
+            : JSON.stringify({ toolName: update.toolName }).slice(0, 120)
+        logger.info('updateAgentContent invoked', {
+          agentId,
+          updateType: update.type,
+          preview,
+        })
         setMessages((prev) =>
           prev.map((msg) => {
             if (msg.id === aiMessageId && msg.blocks) {
@@ -168,18 +177,48 @@ export const useSendMessage = ({
                   if (update.type === 'text' && update.content) {
                     const lastBlock = agentBlocks[agentBlocks.length - 1]
                     if (lastBlock && lastBlock.type === 'text') {
+                      if (update.content && lastBlock.content.endsWith(update.content)) {
+                        logger.info('Skipping duplicate agent text append', {
+                          agentId,
+                          preview,
+                        })
+                        return block
+                      }
                       const updatedLastBlock: ContentBlock = {
                         ...lastBlock,
                         content: lastBlock.content + update.content,
                       }
+                      const updatedContent =
+                        (block.content ?? '') + update.content
+                      logger.info('Agent block text appended', {
+                        agentId,
+                        appendedLength: update.content.length,
+                        totalLength: updatedContent.length,
+                      })
                       return {
                         ...block,
+                        content: updatedContent,
                         blocks: [...agentBlocks.slice(0, -1), updatedLastBlock],
                       }
                     } else {
-                      return { ...block, blocks: [...agentBlocks, update] }
+                      const updatedContent =
+                        (block.content ?? '') + update.content
+                      logger.info('Agent block text started', {
+                        agentId,
+                        appendedLength: update.content.length,
+                        totalLength: updatedContent.length,
+                      })
+                      return {
+                        ...block,
+                        content: updatedContent,
+                        blocks: [...agentBlocks, update],
+                      }
                     }
                   } else if (update.type === 'tool') {
+                    logger.info('Agent block tool appended', {
+                      agentId,
+                      toolName: update.toolName,
+                    })
                     return { ...block, blocks: [...agentBlocks, update] }
                   }
                 }
@@ -348,35 +387,29 @@ export const useSendMessage = ({
                 '',
               )
 
+              if (text.includes('<codebuff_tool_call>')) {
+                logger.warn('Tool XML detected in text event post-filter', {
+                  agentId: event.agentId ?? 'root',
+                  textPreview: text.slice(0, 80),
+                })
+              }
+
               if (!text) return
 
-              if (event.agentId) {
-                logger.info('setMessages: text event with agentId', {
-                  agentId: event.agentId,
-                  textPreview: text.slice(0, 100),
-                })
-                setMessages((prev) =>
-                  prev.map((msg) => {
-                    if (msg.id === aiMessageId && msg.blocks) {
-                      const blocks = msg.blocks.map((block) => {
-                        if (
-                          block.type === 'agent' &&
-                          block.agentId === event.agentId
-                        ) {
-                          return { ...block, content: block.content + text }
-                        }
-                        return block
-                      })
-                      return { ...msg, blocks }
-                    }
-                    return msg
-                  }),
-                )
-                return
-              } else {
-                logger.info('setMessages: text event without agentId', {
-                  textPreview: text.slice(0, 100),
-                })
+            if (event.agentId) {
+              logger.info('setMessages: text event with agentId', {
+                agentId: event.agentId,
+                textPreview: text.slice(0, 100),
+              })
+              updateAgentContent(event.agentId, {
+                type: 'text',
+                content: text,
+              })
+              return
+            } else {
+              logger.info('setMessages: text event without agentId', {
+                textPreview: text.slice(0, 100),
+              })
                 setMessages((prev) =>
                   prev.map((msg) => {
                     if (msg.id !== aiMessageId) {

sdk/src/index.ts

@@ -3,7 +3,6 @@ export type * from '../../common/src/types/messages/codebuff-message'
 export type * from '../../common/src/types/messages/data-content'
 export type * from '../../common/src/types/print-mode'
 export type * from './run'
-export { type ToolName } from '../../common/src/tools/constants'
 // Agent type exports
 export type { AgentDefinition } from '../../common/src/templates/initial-agents-dir/types/agent-definition'