Implement xml tool call parsing and execution

Author: jahooma

.agents/editor/editor.ts

@@ -103,44 +103,19 @@ More style notes:
 
 Write out your complete implementation now, formatting all changes as tool calls as shown above.`,
 
-    handleSteps: function* ({ agentState: initialAgentState }) {
+    handleSteps: function* ({ agentState: initialAgentState, logger }) {
       const initialMessageHistoryLength =
         initialAgentState.messageHistory.length
       const { agentState } = yield 'STEP'
       const { messageHistory } = agentState
 
       const newMessages = messageHistory.slice(initialMessageHistoryLength)
-      const assistantText = newMessages
-        .filter((message) => message.role === 'assistant')
-        .flatMap((message) => message.content)
-        .filter((content) => content.type === 'text')
-        .map((content) => content.text)
-        .join('\n')
-
-      // Extract tool calls from the assistant text
-      const toolCallsText = extractToolCallsOnly(assistantText)
-
-      const { agentState: postAssistantTextAgentState } = yield {
-        type: 'STEP_TEXT',
-        text: toolCallsText,
-      } as StepText
-
-      const postAssistantTextMessageHistory =
-        postAssistantTextAgentState.messageHistory.slice(
-          initialMessageHistoryLength,
-        )
-      const toolResults = postAssistantTextMessageHistory
-        .filter((message) => message.role === 'tool')
-        .flatMap((message) => message.content)
-        .filter((content) => content.type === 'json')
-        .map((content) => content.value)
 
       yield {
         toolName: 'set_output',
         input: {
           output: {
-            message: toolCallsText,
-            toolResults,
+            messages: newMessages,
           },
         },
         includeToolCall: false,

cli/src/components/tools/registry.ts

@@ -37,6 +37,9 @@ const toolComponentRegistry = new Map<ToolName, ToolComponent>([
   [SuggestFollowupsComponent.toolName, SuggestFollowupsComponent],
   [WriteFileComponent.toolName, WriteFileComponent],
   [TaskCompleteComponent.toolName, TaskCompleteComponent],
+  // Propose tools reuse the same rendering as their base counterparts
+  ['propose_str_replace', StrReplaceComponent],
+  ['propose_write_file', WriteFileComponent],
 ])
 
 /**

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

@@ -22,7 +22,6 @@ import {
 } from './spawn-agent-matcher'
 import {
   destinationFromChunkEvent,
-  destinationFromTextEvent,
   processTextChunk,
 } from './stream-chunk-processor'
 
@@ -162,40 +161,6 @@ const updateStreamingAgents = (
   })
 }
 
-const handleTextEvent = (state: EventHandlerState, event: PrintModeText) => {
-  if (!event.text) {
-    return
-  }
-
-  ensureStreaming(state)
-
-  const destination = destinationFromTextEvent(event)
-  const text = event.text
-
-  if (destination.type === 'agent') {
-    const previous =
-      state.streaming.streamRefs.state.agentStreamAccumulators.get(
-        destination.agentId,
-      ) ?? ''
-    state.streaming.streamRefs.setters.setAgentAccumulator(
-      destination.agentId,
-      previous + text,
-    )
-    state.message.updater.updateAiMessageBlocks((blocks) =>
-      processTextChunk(blocks, destination, text),
-    )
-    return
-  }
-
-  if (state.streaming.streamRefs.state.rootStreamSeen) {
-    return
-  }
-
-  state.streaming.streamRefs.setters.appendRootStreamBuffer(text)
-  state.streaming.streamRefs.setters.setRootStreamSeen(true)
-  appendRootChunk(state, { type: destination.textType, text })
-}
-
 const handleSubagentStart = (
   state: EventHandlerState,
   event: PrintModeSubagentStart,
@@ -483,16 +448,6 @@ export const createStreamChunkHandler =
       return
     }
 
-    const previous =
-      state.streaming.streamRefs.state.agentStreamAccumulators.get(
-        destination.agentId,
-      ) ?? ''
-
-    state.streaming.streamRefs.setters.setAgentAccumulator(
-      destination.agentId,
-      previous + text,
-    )
-
     state.message.updater.updateAiMessageBlocks((blocks) =>
       processTextChunk(blocks, destination, text),
     )

common/src/tools/constants.ts

@@ -61,6 +61,8 @@ export const publishedTools = [
   'glob',
   'list_directory',
   'lookup_agent_info',
+  'propose_str_replace',
+  'propose_write_file',
   'read_docs',
   'read_files',
   'read_subtree',

packages/agent-runtime/src/tool-stream-parser.ts

@@ -1,5 +1,11 @@
 import { AnalyticsEvent } from '@codebuff/common/constants/analytics-events'
 
+import {
+  createStreamParserState,
+  parseStreamChunk,
+} from './util/stream-xml-parser'
+
+import type { StreamParserState } from './util/stream-xml-parser'
 import type { Model } from '@codebuff/common/old-constants'
 import type { TrackEventFn } from '@codebuff/common/types/contracts/analytics'
 import type { StreamChunk } from '@codebuff/common/types/contracts/llm'
@@ -31,6 +37,11 @@ export async function* processStreamWithTools(params: {
     agentName?: string
   }
   trackEvent: TrackEventFn
+  executeXmlToolCall: (params: {
+    toolCallId: string
+    toolName: string
+    input: Record<string, unknown>
+  }) => Promise<void>
 }): AsyncGenerator<StreamChunk, string | null> {
   const {
     stream,
@@ -41,11 +52,15 @@ export async function* processStreamWithTools(params: {
     logger,
     loggerOptions,
     trackEvent,
+    executeXmlToolCall,
   } = params
   let streamCompleted = false
   let buffer = ''
   let autocompleted = false
 
+  // State for parsing XML tool calls from text stream
+  const xmlParserState: StreamParserState = createStreamParserState()
+
   function processToolCallObject(params: {
     toolName: string
     input: any
@@ -83,17 +98,48 @@ export async function* processStreamWithTools(params: {
     buffer = ''
   }
 
-  function* processChunk(
+  async function* processChunk(
     chunk: StreamChunk | undefined,
-  ): Generator<StreamChunk> {
+  ): AsyncGenerator<StreamChunk> {
     if (chunk === undefined) {
       flush()
       streamCompleted = true
       return
     }
 
     if (chunk.type === 'text') {
-      buffer += chunk.text
+      // Parse XML tool calls from the text stream
+      const { filteredText, toolCalls } = parseStreamChunk(
+        chunk.text,
+        xmlParserState,
+      )
+
+      if (filteredText) {
+        buffer += filteredText
+        yield {
+          type: 'text',
+          text: filteredText,
+        }
+      }
+
+      // Flush buffer before yielding tool calls so text event is sent first
+      if (toolCalls.length > 0) {
+        flush()
+      }
+
+      // Then process and yield any XML tool calls found
+      for (const toolCall of toolCalls) {
+        const toolCallId = `xml-${crypto.randomUUID().slice(0, 8)}`
+
+        // Execute the tool immediately if callback provided, pausing the stream
+        // The callback handles emitting tool_call and tool_result events
+        await executeXmlToolCall({
+          toolCallId,
+          toolName: toolCall.toolName,
+          input: toolCall.input,
+        })
+      }
+      return
     } else {
       flush()
     }

packages/agent-runtime/src/tools/stream-parser.ts

@@ -64,7 +64,11 @@ export async function processStream(
   > &
     ParamsExcluding<
       typeof processStreamWithTools,
-      'processors' | 'defaultProcessor' | 'onError' | 'loggerOptions'
+      | 'processors'
+      | 'defaultProcessor'
+      | 'onError'
+      | 'loggerOptions'
+      | 'executeXmlToolCall'
     >,
 ) {
   const {
@@ -246,6 +250,26 @@ export async function processStream(
       }
       return onResponseChunk(chunk)
     },
+    // Execute XML-parsed tool calls immediately during streaming
+    executeXmlToolCall: async ({ toolName, input }) => {
+      if (signal.aborted) {
+        return
+      }
+
+      // Cast input to the expected type - the XML parser produces Record<string, unknown>
+      // but the callbacks expect Record<string, string>. The actual values are strings.
+      const inputAsStrings = input as Record<string, string>
+
+      // Use the appropriate callback based on whether it's a native or custom tool
+      const isNativeTool = toolNames.includes(toolName as ToolName)
+      if (isNativeTool) {
+        const callback = toolCallback(toolName as ToolName)
+        await callback.onTagEnd(toolName, inputAsStrings)
+      } else {
+        const callback = customToolCallback(toolName)
+        await callback.onTagEnd(toolName, inputAsStrings)
+      }
+    },
   })
 
   let messageId: string | null = null