api: move wire types and parsing to api module

Move FunctionCall, FunctionCallDelta, ToolCall, ToolCallDelta from
tools/mod.rs to api/types.rs — these are API wire format, not tool
definitions. Re-export from tools for existing callers.

Move parsing.rs to api/parsing.rs — leaked tool call parsing is API
plumbing.

Co-Authored-By: Proof of Concept <poc@bcachefs.org>

src/agent/api/mod.rs

@@ -6,6 +6,7 @@
 // Diagnostics: anomalies always logged to debug panel.
 // Set POC_DEBUG=1 for verbose per-turn logging.
 
+pub mod parsing;
 pub mod types;
 mod openai;
 
@@ -17,7 +18,8 @@ use std::time::{Duration, Instant};
 
 use tokio::sync::mpsc;
 
-use crate::agent::tools::{self as agent_tools, ToolCall, FunctionCall};
+use crate::agent::tools::{self as agent_tools};
+use types::{ToolCall, FunctionCall};
 use crate::user::ui_channel::{UiMessage, UiSender};
 
 /// A JoinHandle that aborts its task when dropped.
@@ -488,9 +490,9 @@ pub fn build_response_message(
     }
 
     // Check for leaked tool calls in content text.
-    let leaked = crate::agent::parsing::parse_leaked_tool_calls(&content);
+    let leaked = parsing::parse_leaked_tool_calls(&content);
     if !leaked.is_empty() {
-        let cleaned = crate::agent::parsing::strip_leaked_artifacts(&content);
+        let cleaned = parsing::strip_leaked_artifacts(&content);
         return Message {
             role: Role::Assistant,
             content: if cleaned.trim().is_empty() { None }

src/agent/api/parsing.rs

@@ -0,0 +1,209 @@
+// parsing.rs — Tool call parsing for leaked/streamed XML
+//
+// When models stream tool calls as XML text (Qwen-style <tool_call>
+// blocks) rather than structured tool_calls, this module extracts
+// them from the response text.
+//
+// Handles two wire formats:
+//   - Qwen XML: <function=name><parameter=key>value</parameter></function>
+//   - JSON: {"name": "...", "arguments": {...}}
+//
+// Also handles streaming artifacts: whitespace inside XML tags from
+// token boundaries, </think> tags, etc.
+
+use super::types::{ToolCall, FunctionCall};
+
+/// Parse leaked tool calls from response text.
+/// Looks for `<tool_call>...</tool_call>` blocks and tries both
+/// XML and JSON formats for the body.
+/// Parse a single tool call body (content between `<tool_call>` and `</tool_call>`).
+pub fn parse_tool_call_body(body: &str) -> Option<ToolCall> {
+    let normalized = normalize_xml_tags(body);
+    let body = normalized.trim();
+    let mut counter = 0u32;
+    parse_xml_tool_call(body, &mut counter)
+        .or_else(|| parse_json_tool_call(body, &mut counter))
+}
+
+pub fn parse_leaked_tool_calls(text: &str) -> Vec<ToolCall> {
+    // Normalize whitespace inside XML tags: "<\nfunction\n=\nbash\n>" → "<function=bash>"
+    // This handles streaming tokenizers that split tags across tokens.
+    let normalized = normalize_xml_tags(text);
+    let text = &normalized;
+
+    let mut calls = Vec::new();
+    let mut search_from = 0;
+    let mut call_counter: u32 = 0;
+
+    while let Some(start) = text[search_from..].find("<tool_call>") {
+        let abs_start = search_from + start;
+        let after_tag = abs_start + "<tool_call>".len();
+
+        let end = match text[after_tag..].find("</tool_call>") {
+            Some(pos) => after_tag + pos,
+            None => break,
+        };
+
+        let body = text[after_tag..end].trim();
+        search_from = end + "</tool_call>".len();
+
+        // Try XML format first, then JSON
+        if let Some(call) = parse_xml_tool_call(body, &mut call_counter) {
+            calls.push(call);
+        } else if let Some(call) = parse_json_tool_call(body, &mut call_counter) {
+            calls.push(call);
+        }
+    }
+
+    calls
+}
+
+/// Normalize whitespace inside XML-like tags for streaming tokenizers.
+/// Collapses whitespace between `<` and `>` so that `<\nfunction\n=\nbash\n>`
+/// becomes `<function=bash>`, and `</\nparameter\n>` becomes `</parameter>`.
+/// Leaves content between tags untouched.
+fn normalize_xml_tags(text: &str) -> String {
+    let mut result = String::with_capacity(text.len());
+    let mut chars = text.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if ch == '<' {
+            let mut tag = String::from('<');
+            for inner in chars.by_ref() {
+                if inner == '>' {
+                    tag.push('>');
+                    break;
+                } else if inner.is_whitespace() {
+                    // Skip whitespace inside tags
+                } else {
+                    tag.push(inner);
+                }
+            }
+            result.push_str(&tag);
+        } else {
+            result.push(ch);
+        }
+    }
+    result
+}
+
+/// Parse a Qwen-style `<tag=value>body</tag>` pseudo-XML element.
+/// Returns `(value, body, rest)` on success.
+fn parse_qwen_tag<'a>(s: &'a str, tag: &str) -> Option<(&'a str, &'a str, &'a str)> {
+    let open = format!("<{}=", tag);
+    let close = format!("</{}>", tag);
+
+    let start = s.find(&open)? + open.len();
+    let name_end = start + s[start..].find('>')?;
+    let body_start = name_end + 1;
+    let body_end = body_start + s[body_start..].find(&close)?;
+
+    Some((
+        s[start..name_end].trim(),
+        s[body_start..body_end].trim(),
+        &s[body_end + close.len()..],
+    ))
+}
+
+/// Parse Qwen's XML tool call format.
+fn parse_xml_tool_call(body: &str, counter: &mut u32) -> Option<ToolCall> {
+    let (func_name, func_body, _) = parse_qwen_tag(body, "function")?;
+    let func_name = func_name.to_string();
+
+    let mut args = serde_json::Map::new();
+    let mut rest = func_body;
+    while let Some((key, val, remainder)) = parse_qwen_tag(rest, "parameter") {
+        args.insert(key.to_string(), serde_json::Value::String(val.to_string()));
+        rest = remainder;
+    }
+
+    *counter += 1;
+    Some(ToolCall {
+        id: format!("leaked_{}", counter),
+        call_type: "function".to_string(),
+        function: FunctionCall {
+            name: func_name,
+            arguments: serde_json::to_string(&args).unwrap_or_default(),
+        },
+    })
+}
+
+/// Parse JSON tool call format (some models emit this).
+fn parse_json_tool_call(body: &str, counter: &mut u32) -> Option<ToolCall> {
+    let v: serde_json::Value = serde_json::from_str(body).ok()?;
+    let name = v["name"].as_str()?;
+    let arguments = &v["arguments"];
+
+    *counter += 1;
+    Some(ToolCall {
+        id: format!("leaked_{}", counter),
+        call_type: "function".to_string(),
+        function: FunctionCall {
+            name: name.to_string(),
+            arguments: serde_json::to_string(arguments).unwrap_or_default(),
+        },
+    })
+}
+
+/// Strip tool call XML and thinking tokens from text so the conversation
+/// history stays clean. Removes `<tool_call>...</tool_call>` blocks and
+/// `</think>` tags (thinking content before them is kept — it's useful context).
+pub fn strip_leaked_artifacts(text: &str) -> String {
+    let normalized = normalize_xml_tags(text);
+    let mut result = normalized.clone();
+
+    // Remove <tool_call>...</tool_call> blocks
+    while let Some(start) = result.find("<tool_call>") {
+        if let Some(end_pos) = result[start..].find("</tool_call>") {
+            let end = start + end_pos + "</tool_call>".len();
+            result = format!("{}{}", &result[..start], &result[end..]);
+        } else {
+            break;
+        }
+    }
+
+    // Remove </think> tags (but keep the thinking text before them)
+    result = result.replace("</think>", "");
+
+    result.trim().to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_leaked_tool_call_clean() {
+        let text = "thinking\n</think>\n<tool_call>\n<function=bash>\n<parameter=command>poc-memory used core-personality</parameter>\n</function>\n</tool_call>";
+        let calls = parse_leaked_tool_calls(text);
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].function.name, "bash");
+        let args: serde_json::Value = serde_json::from_str(&calls[0].function.arguments).unwrap();
+        assert_eq!(args["command"], "poc-memory used core-personality");
+    }
+
+    #[test]
+    fn test_leaked_tool_call_streamed_whitespace() {
+        // Streaming tokenizer splits XML tags across tokens with newlines
+        let text = "<tool_call>\n<\nfunction\n=\nbash\n>\n<\nparameter\n=\ncommand\n>pwd</\nparameter\n>\n</\nfunction\n>\n</tool_call>";
+        let calls = parse_leaked_tool_calls(text);
+        assert_eq!(calls.len(), 1, "should parse streamed format");
+        assert_eq!(calls[0].function.name, "bash");
+        let args: serde_json::Value = serde_json::from_str(&calls[0].function.arguments).unwrap();
+        assert_eq!(args["command"], "pwd");
+    }
+
+    #[test]
+    fn test_normalize_preserves_content() {
+        let text = "<function=bash>\n<parameter=command>echo hello world</parameter>\n</function>";
+        let normalized = normalize_xml_tags(text);
+        // Newlines between tags are not inside tags, so preserved
+        assert_eq!(normalized, "<function=bash>\n<parameter=command>echo hello world</parameter>\n</function>");
+    }
+
+    #[test]
+    fn test_normalize_strips_tag_internal_whitespace() {
+        let text = "<\nfunction\n=\nbash\n>";
+        let normalized = normalize_xml_tags(text);
+        assert_eq!(normalized, "<function=bash>");
+    }
+}

src/agent/api/types.rs

@@ -9,7 +9,38 @@
 use chrono::Utc;
 use serde::{Deserialize, Serialize};
 
-use crate::agent::tools::{ToolCall, ToolCallDelta};
+/// Function call within a tool call — name + JSON arguments.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FunctionCall {
+    pub name: String,
+    pub arguments: String,
+}
+
+/// Partial function call within a streaming delta.
+#[derive(Debug, Deserialize)]
+pub struct FunctionCallDelta {
+    pub name: Option<String>,
+    pub arguments: Option<String>,
+}
+
+/// A tool call requested by the model.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolCall {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub call_type: String,
+    pub function: FunctionCall,
+}
+
+/// A partial tool call within a streaming delta.
+#[derive(Debug, Deserialize)]
+pub struct ToolCallDelta {
+    pub index: usize,
+    pub id: Option<String>,
+    #[serde(rename = "type")]
+    pub call_type: Option<String>,
+    pub function: Option<FunctionCallDelta>,
+}
 
 /// Message content — either plain text or an array of content parts
 /// (for multimodal messages with images). Serializes as a JSON string