otherwise-cli 0.1.0

package/src/agent/index.js

@@ -0,0 +1,1066 @@
+import { streamInference, hasRequiredApiKey } from '../inference/index.js';
+import { executeTool } from './tools.js';
+import { 
+  buildAgentSystemPrompt, 
+  cleanResponseText,
+  validateToolCall,
+  VALID_TOOL_NAMES,
+} from './prompt.js';
+import { randomUUID } from 'crypto';
+import { isOllamaReasoningModel } from '../inference/ollama.js';
+
+const MAX_TOOL_ITERATIONS = 25;
+
+// Agent logging helper - respects SILENT_MODE
+const agentLog = (...args) => {
+  if (process.env.SILENT_MODE !== 'true') {
+    console.log(...args);
+  }
+};
+
+// Web-related tools that should be skipped when web search was already done
+const WEB_TOOLS = ['web_search', 'fetch_url'];
+
+// Threshold for warning about too many edits to the same file
+const EDIT_WARNING_THRESHOLD = 3;
+
+/**
+ * Serialize a tool call object to XML format
+ * @param {{ name: string, args: object }} toolCall - The tool call to serialize
+ * @returns {string} - XML string representation
+ */
+function serializeToolCallToXml(toolCall) {
+  let xml = `<name>${toolCall.name}</name>\n`;
+  
+  for (const [key, value] of Object.entries(toolCall.args || {})) {
+    // Convert value to string representation
+    let strValue;
+    if (typeof value === 'boolean') {
+      strValue = value ? 'true' : 'false';
+    } else if (typeof value === 'number') {
+      strValue = String(value);
+    } else if (value === null || value === undefined) {
+      continue; // Skip null/undefined values
+    } else {
+      strValue = String(value);
+    }
+    xml += `<${key}>${strValue}</${key}>\n`;
+  }
+  
+  return xml.trimEnd();
+}
+
+/**
+ * Try to repair malformed JSON for edit_file/write_file tools
+ * @deprecated JSON format is no longer used - keeping for backwards compatibility only
+ * @param {string} jsonText - The malformed JSON text
+ * @returns {object|null} - Parsed object or null if repair failed
+ */
+function tryRepairToolCallJson(jsonText) {
+  // Extract tool name first
+  const nameMatch = jsonText.match(/"name"\s*:\s*"([^"]+)"/);
+  if (!nameMatch) return null;
+  
+  const toolName = nameMatch[1];
+  
+  // Only attempt repair for tools that have string content parameters
+  if (!['edit_file', 'write_file'].includes(toolName)) {
+    return null;
+  }
+  
+  agentLog('[Agent] Attempting JSON repair for:', toolName);
+  
+  // Extract path (should be properly quoted)
+  const pathMatch = jsonText.match(/"path"\s*:\s*"([^"]+)"/);
+  if (!pathMatch) {
+    agentLog('[Agent] JSON repair failed: could not extract path');
+    return null;
+  }
+  const path = pathMatch[1];
+  
+  if (toolName === 'write_file') {
+    // For write_file, extract content
+    // Pattern: "content": followed by content until end of args
+    const contentStart = jsonText.indexOf('"content"');
+    if (contentStart === -1) return null;
+    
+    // Find the colon after "content"
+    const colonIdx = jsonText.indexOf(':', contentStart);
+    if (colonIdx === -1) return null;
+    
+    // Content starts after the colon (skip whitespace and optional quote)
+    let contentBegin = colonIdx + 1;
+    while (contentBegin < jsonText.length && /\s/.test(jsonText[contentBegin])) {
+      contentBegin++;
+    }
+    
+    // Check if properly quoted
+    const isQuoted = jsonText[contentBegin] === '"';
+    if (isQuoted) {
+      // Already quoted - let normal JSON.parse handle it
+      return null;
+    }
+    
+    // Extract raw content until closing braces
+    // Find the last }} or } that closes the args
+    let depth = 0;
+    let contentEnd = jsonText.length;
+    for (let i = jsonText.length - 1; i >= contentBegin; i--) {
+      if (jsonText[i] === '}') {
+        depth++;
+        if (depth === 2) { // Found the closing of args and outer object
+          contentEnd = i;
+          break;
+        }
+      }
+    }
+    
+    const rawContent = jsonText.substring(contentBegin, contentEnd).trim();
+    
+    agentLog('[Agent] JSON repair: extracted write_file content, length:', rawContent.length);
+    
+    return {
+      name: toolName,
+      args: { path, content: rawContent }
+    };
+  }
+  
+  if (toolName === 'edit_file') {
+    // For edit_file, extract old_string and new_string
+    // This is trickier because we have two unquoted strings
+    
+    const oldStringStart = jsonText.indexOf('"old_string"');
+    const newStringStart = jsonText.indexOf('"new_string"');
+    
+    if (oldStringStart === -1 || newStringStart === -1) {
+      agentLog('[Agent] JSON repair failed: could not find old_string/new_string markers');
+      return null;
+    }
+    
+    // Find colons after each marker
+    const oldColonIdx = jsonText.indexOf(':', oldStringStart);
+    const newColonIdx = jsonText.indexOf(':', newStringStart);
+    
+    if (oldColonIdx === -1 || newColonIdx === -1) return null;
+    
+    // Determine order (old_string usually comes first)
+    let oldStringContent, newStringContent;
+    
+    if (oldStringStart < newStringStart) {
+      // old_string comes first
+      // old_string content is between old colon and "new_string"
+      let oldBegin = oldColonIdx + 1;
+      while (oldBegin < newStringStart && /\s/.test(jsonText[oldBegin])) oldBegin++;
+      
+      // Skip opening quote if present
+      if (jsonText[oldBegin] === '"') oldBegin++;
+      
+      // Find end - look for "new_string" or ", "new_string"
+      let oldEnd = newStringStart;
+      // Walk back to find the actual end (before comma/whitespace)
+      while (oldEnd > oldBegin && /[\s,"]/.test(jsonText[oldEnd - 1])) oldEnd--;
+      
+      oldStringContent = jsonText.substring(oldBegin, oldEnd);
+      
+      // new_string content is from new colon to end
+      let newBegin = newColonIdx + 1;
+      while (newBegin < jsonText.length && /\s/.test(jsonText[newBegin])) newBegin++;
+      if (jsonText[newBegin] === '"') newBegin++;
+      
+      // Find end - closing braces
+      let depth = 0;
+      let newEnd = jsonText.length;
+      for (let i = jsonText.length - 1; i >= newBegin; i--) {
+        if (jsonText[i] === '}') {
+          depth++;
+          if (depth === 2) {
+            newEnd = i;
+            break;
+          }
+        }
+      }
+      // Remove trailing quote if present
+      while (newEnd > newBegin && /[\s}"]/.test(jsonText[newEnd - 1])) newEnd--;
+      
+      newStringContent = jsonText.substring(newBegin, newEnd);
+    } else {
+      // new_string comes first (unusual but handle it)
+      agentLog('[Agent] JSON repair: unusual order (new_string before old_string)');
+      return null; // Too complex to handle reliably
+    }
+    
+    // Check for replace_all parameter
+    const replaceAllMatch = jsonText.match(/"replace_all"\s*:\s*(true|false)/);
+    const replaceAll = replaceAllMatch ? replaceAllMatch[1] === 'true' : false;
+    
+    agentLog('[Agent] JSON repair: extracted edit_file content');
+    agentLog('[Agent] JSON repair: old_string length:', oldStringContent.length);
+    agentLog('[Agent] JSON repair: new_string length:', newStringContent.length);
+    
+    return {
+      name: toolName,
+      args: { 
+        path, 
+        old_string: oldStringContent, 
+        new_string: newStringContent,
+        ...(replaceAll && { replace_all: replaceAll })
+      }
+    };
+  }
+  
+  return null;
+}
+
+/**
+ * Parse XML tool call format
+ * Format: <tool_call><name>tool</name><param1>value1</param1>...</tool_call>
+ * Or with CDATA: <tool_call><name>tool</name><content><![CDATA[...]]></content></tool_call>
+ * @param {string} xmlText - The XML content between <tool_call> tags
+ * @returns {object|null} - Parsed tool call object or null
+ */
+function parseXmlToolCall(xmlText) {
+  // Check if this looks like XML format (has <name> tag, not {"name":)
+  if (!xmlText.includes('<name>') || xmlText.trim().startsWith('{')) {
+    return null; // Not XML format
+  }
+  
+  agentLog('[Agent] Parsing XML-format tool call');
+  
+  // Extract tool name
+  const nameMatch = xmlText.match(/<name>\s*([\s\S]*?)\s*<\/name>/);
+  if (!nameMatch) {
+    agentLog('[Agent] XML parse failed: no <name> tag found');
+    return null;
+  }
+  
+  const toolName = nameMatch[1].trim();
+  const args = {};
+  
+  // Extract all other XML tags as parameters
+  // Support both regular content and CDATA sections
+  const paramPattern = /<(\w+)>(?:<!\[CDATA\[([\s\S]*?)\]\]>|([\s\S]*?))<\/\1>/g;
+  
+  let match;
+  while ((match = paramPattern.exec(xmlText)) !== null) {
+    const paramName = match[1];
+    if (paramName === 'name') continue; // Skip the name tag
+    
+    // CDATA content is in match[2], regular content in match[3]
+    const value = match[2] !== undefined ? match[2] : match[3];
+    
+    // Try to parse as boolean or number if appropriate
+    const trimmedValue = value.trim();
+    if (trimmedValue === 'true') {
+      args[paramName] = true;
+    } else if (trimmedValue === 'false') {
+      args[paramName] = false;
+    } else if (/^-?\d+$/.test(trimmedValue)) {
+      args[paramName] = parseInt(trimmedValue, 10);
+    } else if (/^-?\d+\.\d+$/.test(trimmedValue)) {
+      args[paramName] = parseFloat(trimmedValue);
+    } else {
+      // Keep as string - preserve the exact content (including whitespace for code)
+      args[paramName] = value;
+    }
+  }
+  
+  agentLog('[Agent] XML parse success:', toolName, 'with', Object.keys(args).length, 'args');
+  
+  return { name: toolName, args };
+}
+
+/**
+ * Parse a single tool call from text (finds first complete tool_call block)
+ * Returns { toolCall, beforeText, afterText, parseError? } or null if no complete tool call found
+ * Uses XML format: <tool_call><name>tool_name</name><parameter_name>value</parameter_name></tool_call>
+ * Example: <tool_call><name>web_search</name><query>weather in Miami</query></tool_call>
+ */
+function parseFirstToolCall(text) {
+  const startTag = '<tool_call>';
+  const endTag = '</tool_call>';
+  
+  // CRITICAL FIX: Normalize malformed closing tags (missing >) before parsing
+  // The LLM sometimes outputs </tool_call without the closing >
+  let normalizedText = text.replace(/<\/tool_call([^>])/g, '</tool_call>$1');
+  
+  const startIdx = normalizedText.indexOf(startTag);
+  if (startIdx === -1) return null;
+  
+  const endIdx = normalizedText.indexOf(endTag, startIdx);
+  if (endIdx === -1) return null; // Incomplete tool call
+  
+  const beforeText = normalizedText.substring(0, startIdx);
+  const toolCallContent = normalizedText.substring(startIdx + startTag.length, endIdx).trim();
+  const afterText = normalizedText.substring(endIdx + endTag.length);
+  
+  // Parse XML format: <name>tool_name</name><parameter_name>value</parameter_name>
+  const xmlParsed = parseXmlToolCall(toolCallContent);
+  if (xmlParsed) {
+    return {
+      toolCall: xmlParsed,
+      beforeText,
+      afterText,
+    };
+  }
+  
+  // XML parsing failed - log error for debugging
+  console.error('[Agent] Failed to parse tool call XML');
+  console.error('[Agent] Tool call content:', toolCallContent.substring(0, 200));
+  
+  // Try to extract tool name for debugging
+  const nameMatch = toolCallContent.match(/<name>\s*([\s\S]*?)\s*<\/name>/);
+  if (nameMatch) {
+    console.error('[Agent] Tool name found:', nameMatch[1]);
+  }
+  
+  // Return error info so we can notify the user
+  return {
+    toolCall: null,
+    beforeText,
+    afterText,
+    parseError: {
+      message: 'Failed to parse XML tool call',
+      toolName: nameMatch ? nameMatch[1] : 'unknown',
+      contentPreview: toolCallContent.substring(0, 300),
+    },
+  };
+}
+
+/**
+ * Check if text contains a partial (incomplete) tool call at the end
+ * This now also detects partial opening tags like <tool, <tool_, <tool_c, etc.
+ */
+function hasPartialToolCall(text) {
+  // First check for complete opening tag without closing tag
+  const startTag = '<tool_call>';
+  const endTag = '</tool_call>';
+  
+  const startIdx = text.lastIndexOf(startTag);
+  if (startIdx !== -1) {
+    const endIdx = text.indexOf(endTag, startIdx);
+    if (endIdx === -1) return true; // Has start but no end = partial
+  }
+  
+  // Also check for partial opening tags at the end of the text
+  // This catches cases like "Hello<tool" before it becomes "Hello<tool_call>"
+  const partialTags = ['<tool_call', '<tool_cal', '<tool_ca', '<tool_c', '<tool_', '<tool', '<too', '<to', '<t'];
+  for (const partial of partialTags) {
+    if (text.endsWith(partial)) {
+      return true;
+    }
+  }
+  
+  // Also check if text ends with just '<' which could be start of a tag
+  if (text.endsWith('<')) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Get safe text to yield (everything before any partial tool call tag)
+ * CRITICAL: Must check for <tool_call> ANYWHERE in text, not just at last '<'
+ */
+function getSafeTextLength(text) {
+  // CRITICAL FIX: First check if there's ANY <tool_call> tag in the text
+  // This catches complete tool_call blocks that shouldn't be yielded
+  const toolCallStart = text.indexOf('<tool_call>');
+  if (toolCallStart !== -1) {
+    // Found a tool_call opening tag - don't yield any content from here onward
+    // The parseFirstToolCall function will handle this once the closing tag arrives
+    return toolCallStart;
+  }
+  
+  // Now check the last '<' for partial tags
+  const lastLt = text.lastIndexOf('<');
+  if (lastLt === -1) return text.length;
+  
+  // Check if this '<' starts a partial tool_call tag
+  const afterLt = text.substring(lastLt);
+  
+  // Check if it could be a partial OPENING tool_call tag
+  if ('<tool_call>'.startsWith(afterLt)) {
+    // Potential partial tag - yield up to the <
+    return lastLt;
+  }
+  
+  // CRITICAL FIX: Also check for incomplete CLOSING tags
+  // The LLM might output </tool_call without the final > yet
+  // We need to wait for the > before yielding
+  if (afterLt.startsWith('</tool_call') && !afterLt.startsWith('</tool_call>')) {
+    // Incomplete closing tag (missing >) - yield up to the <
+    return lastLt;
+  }
+  
+  // Check if it could be a partial closing tag (</t, </to, </too, etc.)
+  // BUT only for tool_call, not general HTML tags!
+  if ('</tool_call>'.startsWith(afterLt) && afterLt.length >= 3) {
+    // Only treat as partial tool_call if it's at least </t (3 chars)
+    // This prevents false positives on HTML tags like </td>, </tr>
+    // Potential partial closing tag - yield up to the <
+    return lastLt;
+  }
+  
+  // Not a tool tag, safe to yield everything
+  return text.length;
+}
+
+/**
+ * Run the agent with inline tool execution
+ * Tools are executed one at a time, inline with text generation
+ * @param {string} userMessage - The user's message
+ * @param {Array} history - Previous messages in the conversation
+ * @param {object} config - Configuration with API keys, model, etc.
+ * @param {object} options - Additional options
+ * @param {boolean} options.skipWebTools - Skip web-related tools
+ * @yields {object} - Chunks to stream to client
+ */
+export async function* runAgent(userMessage, history, config, options = {}) {
+  const model = config.model || 'claude-sonnet-4-20250514';
+  const { skipWebTools = false, snapshotFn = null, shellUndoFn = null, ragDocuments = [], images: currentTurnImages = [] } = options;
+  
+  // Check for API key
+  if (!hasRequiredApiKey(model, config)) {
+    yield { type: 'error', message: `No API key configured for model ${model}. Run: otherwise config` };
+    return;
+  }
+  
+  // Check if this is an Ollama reasoning model (like gpt-oss) that needs CoT preservation
+  const isOllamaReasoning = model.startsWith('ollama:') && isOllamaReasoningModel(model.replace('ollama:', ''));
+
+  // Build system prompt (with RAG documents if any were detected)
+  let systemPrompt = buildAgentSystemPrompt(config, { ragDocuments });
+  if (skipWebTools) {
+    systemPrompt += '\n\nIMPORTANT: Web search has already been performed and the results are included in the user\'s message. Do NOT use web_search or fetch_url tools - the information you need is already provided.';
+  }
+  
+  // Log if RAG documents are being used
+  if (ragDocuments.length > 0) {
+    agentLog('[Agent] RAG documents enabled:', ragDocuments.map(d => d.name).join(', '));
+  }
+  
+  // Build messages array (include images on current user message for vision models)
+  const currentUserMessage = currentTurnImages?.length
+    ? { role: 'user', content: userMessage, images: currentTurnImages }
+    : { role: 'user', content: userMessage };
+  let messages = [
+    ...history,
+    currentUserMessage,
+  ];
+
+  const maxIterations = skipWebTools ? 3 : MAX_TOOL_ITERATIONS;
+  let iterationCount = 0;
+  let totalToolCalls = 0;
+  
+  // Full response text for building conversation history
+  let fullResponseText = '';
+  
+  // Track thinking/reasoning content for models like gpt-oss that need CoT
+  let thinkingContent = '';
+  
+  // Track recovery attempts to prevent infinite loops
+  let recoveryAttempts = 0;
+  const MAX_RECOVERY_ATTEMPTS = 2;
+  
+  // Track edit_file calls by path to detect "many small edits" anti-pattern
+  const editFileCountByPath = new Map();
+  
+  // STREAMING DEDUPLICATION: Track current streaming tool state
+  // This prevents flooding the frontend with duplicate tool_streaming events
+  let currentStreamingTool = null; // { id, name, lastEmittedLength, lastEmittedTime }
+  
+  // Agent loop
+  while (iterationCount < maxIterations) {
+    iterationCount++;
+    
+    // Buffer for detecting tool calls mid-stream
+    let buffer = '';
+    let textYielded = ''; // Track what we've already sent to client
+    let executedToolInline = false; // Track if we broke due to tool execution
+    
+    // Stream from the model
+    try {
+      for await (const chunk of streamInference(model, messages, systemPrompt, config)) {
+        if (chunk.type === 'text') {
+          buffer += chunk.content;
+          
+          // Only parse when we have a complete tool_call block (avoids heavy parse on every chunk)
+          const toolParse =
+            config.disableTools || !buffer.includes('</tool_call>')
+              ? null
+              : parseFirstToolCall(buffer);
+          
+          if (toolParse) {
+            const { toolCall, beforeText, afterText, parseError, wasRepaired } = toolParse;
+            
+            // Yield any text before the tool call that we haven't sent yet
+            const newTextBefore = beforeText.substring(textYielded.length);
+            if (newTextBefore) {
+              yield { type: 'text', content: newTextBefore };
+              fullResponseText += newTextBefore;
+            }
+            
+            // Handle parse error - notify user and skip this tool call
+            if (parseError || !toolCall) {
+              console.error('[Agent] Tool call parsing failed completely');
+              
+              // Yield error to frontend so user knows what happened
+              yield { 
+                type: 'tool_parse_error', 
+                name: parseError?.toolName || 'unknown',
+                error: `Failed to parse tool call: ${parseError?.message || 'Unknown error'}`,
+                hint: 'The AI generated a malformed tool call. Try rephrasing your request or using a different model.',
+                preview: parseError?.contentPreview?.substring(0, 150) || '',
+              };
+              
+              // Add error to messages so AI knows something went wrong
+              const errorMessage = `[SYSTEM ERROR] Your previous tool call for "${parseError?.toolName || 'unknown'}" could not be parsed. The tool was NOT executed. Please try again using the correct XML format. Example for web_search: <tool_call><name>web_search</name><query>your search query</query></tool_call>`;
+              
+              messages.push({ role: 'assistant', content: fullResponseText });
+              messages.push({ role: 'user', content: errorMessage });
+              
+              // Reset and continue to let the AI try again
+              buffer = afterText;
+              textYielded = '';
+              fullResponseText = '';
+              executedToolInline = true;
+              break;
+            }
+            
+            // Log if repair was needed (successful)
+            if (wasRepaired) {
+              agentLog('[Agent] Tool call was repaired from malformed format');
+              yield { 
+                type: 'warning', 
+                message: `Note: Repaired malformed tool call for ${toolCall.name}.`
+              };
+            }
+            
+            // Validate before execute/emit - only emit tool_start with valid, sanitized args
+            const validation = validateToolCall({ name: toolCall.name, args: toolCall.args });
+            if (!validation.valid) {
+              console.error('[Agent] Tool call validation failed:', validation.error);
+              yield {
+                type: 'tool_parse_error',
+                name: toolCall.name,
+                error: `Invalid tool call: ${validation.error}`,
+                hint: 'The tool name or arguments are invalid. Check the tool format.',
+                preview: '',
+              };
+              messages.push({ role: 'assistant', content: fullResponseText });
+              messages.push({ role: 'user', content: `[SYSTEM ERROR] Tool "${toolCall.name}" rejected: ${validation.error}. Please use a valid tool and format.` });
+              buffer = afterText;
+              textYielded = '';
+              fullResponseText = '';
+              executedToolInline = true;
+              break;
+            }
+            const sanitizedToolCall = { name: validation.sanitized.name, args: validation.sanitized.args };
+            
+            // Skip web tools if already searched - but provide feedback to the AI
+            if (skipWebTools && WEB_TOOLS.includes(sanitizedToolCall.name)) {
+              agentLog('[Agent] Skipping web tool (search already done):', sanitizedToolCall.name);
+              
+              // Generate a fake tool result so the AI knows what happened
+              const callId = randomUUID();
+              const skipResult = sanitizedToolCall.name === 'web_search' 
+                ? 'Web search was already performed. The search results are included in the user message above. Please use that information to answer.'
+                : 'URL fetching is not needed. The relevant content was already fetched and included in the user message above. Please use that information.';
+              
+              yield { type: 'tool_start', name: sanitizedToolCall.name, args: sanitizedToolCall.args, callId };
+              yield { type: 'tool_result', name: sanitizedToolCall.name, result: skipResult, callId };
+              
+              // Add to messages so the AI sees the result
+              const assistantContent = fullResponseText + `<tool_call>\n${serializeToolCallToXml(sanitizedToolCall)}\n</tool_call>`;
+              messages.push({ role: 'assistant', content: assistantContent });
+              messages.push({ role: 'user', content: `Tool result for ${sanitizedToolCall.name}:\n${skipResult}` });
+              
+              buffer = afterText;
+              textYielded = '';
+              fullResponseText = '';
+              executedToolInline = true;
+              break; // Re-prompt the model with the skip message
+            }
+            
+            // Execute the tool INLINE (using validated/sanitized tool call)
+            totalToolCalls++;
+            const callId = randomUUID(); // Unique ID for correlating start/result
+            console.log(`[Agent] Executing tool inline: ${sanitizedToolCall.name} (${callId}) [${totalToolCalls}/${maxIterations}]`);
+            
+            // Clear streaming tool state since we're now executing
+            currentStreamingTool = null;
+            
+            // Warn the AI when approaching tool limit
+            const remainingTools = maxIterations - iterationCount;
+            if (remainingTools <= 3) {
+              yield { 
+                type: 'warning', 
+                message: `Warning: Only ${remainingTools} tool calls remaining. Please wrap up soon.` 
+              };
+            }
+            
+            yield { type: 'tool_start', name: sanitizedToolCall.name, args: sanitizedToolCall.args, callId };
+            
+            let toolResult;
+            let toolError = null;
+            
+            try {
+              toolResult = await executeTool(sanitizedToolCall.name, sanitizedToolCall.args, config, snapshotFn, shellUndoFn, callId);
+              yield { type: 'tool_result', name: sanitizedToolCall.name, result: toolResult, callId };
+            } catch (err) {
+              toolError = `Error: ${err.message}`;
+              yield { type: 'tool_error', name: sanitizedToolCall.name, error: toolError, callId };
+              toolResult = toolError;
+            }
+            
+            // Add the assistant's text (up to and including tool call) and tool result to messages
+            // For Ollama reasoning models (like gpt-oss), include thinking content as context
+            let assistantContent = fullResponseText + `<tool_call>\n${serializeToolCallToXml(sanitizedToolCall)}\n</tool_call>`;
+            if (isOllamaReasoning && thinkingContent) {
+              // Include thinking content as a prefix so the model maintains context
+              assistantContent = `<thinking>${thinkingContent}</thinking>\n${assistantContent}`;
+            }
+            messages.push({ role: 'assistant', content: assistantContent });
+            
+            // Track edit_file calls by path to detect "many small edits" anti-pattern
+            if (sanitizedToolCall.name === 'edit_file' && sanitizedToolCall.args?.path) {
+              const editPath = sanitizedToolCall.args.path;
+              const count = (editFileCountByPath.get(editPath) || 0) + 1;
+              editFileCountByPath.set(editPath, count);
+            }
+            
+            // Build tool result message with optional warning about tool limit
+            let toolResultMessage = `[Tool "${sanitizedToolCall.name}" returned]:\n${toolResult}`;
+            
+            // Warn if making many small edits to the same file
+            if (sanitizedToolCall.name === 'edit_file' && sanitizedToolCall.args?.path) {
+              const editCount = editFileCountByPath.get(sanitizedToolCall.args.path) || 0;
+              if (editCount >= EDIT_WARNING_THRESHOLD) {
+                toolResultMessage += `\n\n⚠️ EFFICIENCY WARNING: You've made ${editCount} edit_file calls to this file. Instead of many small edits, use LARGER CHUNKS - include 30-100 lines in old_string and make ALL changes to that section at once. This is faster and won't hit the tool limit.`;
+              }
+            }
+            
+            // Warn the AI if approaching limit so it can wrap up gracefully
+            const toolsRemaining = maxIterations - iterationCount;
+            if (toolsRemaining <= 5) {
+              toolResultMessage += `\n\n⚠️ WARNING: You have ${toolsRemaining} tool calls remaining. Please finish your current task soon.`;
+            }
+            
+            messages.push({ 
+              role: 'user', 
+              content: toolResultMessage 
+            });
+            
+            // Reset for continuation - the model will continue from here
+            buffer = '';
+            textYielded = '';
+            fullResponseText = ''; // Reset since we're starting a new turn
+            thinkingContent = ''; // Reset thinking for next iteration
+            executedToolInline = true; // Mark that we need to continue the loop
+            
+            // Break out of the streaming loop to get a fresh response
+            break;
+          }
+          
+          // No complete tool call yet - yield safe text
+          // Use getSafeTextLength to determine how much we can safely yield
+          // This prevents partial tags like "<tool" from being sent to the client
+          const safeLength = getSafeTextLength(buffer);
+          const safeText = buffer.substring(textYielded.length, safeLength);
+          
+          if (safeText) {
+            yield { type: 'text', content: safeText };
+            fullResponseText += safeText;
+            textYielded = buffer.substring(0, safeLength);
+          }
+          
+          // Check if we're buffering a partial tool call and emit streaming update
+          // This lets the frontend show the tool call UI while it's being written
+          const toolCallStart = buffer.indexOf('<tool_call>');
+          if (toolCallStart !== -1) {
+            const partialToolContent = buffer.substring(toolCallStart + '<tool_call>'.length).trim();
+            
+            // Try to extract tool name from XML format
+            const nameMatch = partialToolContent.match(/<name>\s*([\s\S]*?)\s*<\/name>/);
+            
+            // Only emit tool_streaming once we have a complete, valid tool name (avoids malformed streaming)
+            if (nameMatch) {
+              const partialToolName = nameMatch[1].trim();
+              if (!partialToolName || !VALID_TOOL_NAMES.includes(partialToolName)) {
+                // Incomplete or invalid name (e.g. "read_fi" or garbage) - don't emit yet
+                currentStreamingTool = null;
+              } else {
+              // Extract what we can from the partial XML
+              let partialArgs = {};
+              
+              // Helper to extract XML tag content (handles partial/streaming tags)
+              const extractXmlContent = (xmlText, tagName) => {
+                // Try complete tag first
+                const completeMatch = xmlText.match(new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`));
+                if (completeMatch) {
+                  return completeMatch[1];
+                }
+                
+                // Try partial tag (opened but not closed yet)
+                const openTagMatch = xmlText.match(new RegExp(`<${tagName}>([\\s\\S]*)$`));
+                if (openTagMatch) {
+                  return openTagMatch[1];
+                }
+                
+                return null;
+              };
+              
+              // Extract path - handle both complete and partial
+              const pathContent = extractXmlContent(partialToolContent, 'path');
+              if (pathContent) partialArgs.path = pathContent;
+              
+              // Extract query
+              const queryContent = extractXmlContent(partialToolContent, 'query');
+              if (queryContent) partialArgs.query = queryContent;
+              
+              // Extract command
+              const commandContent = extractXmlContent(partialToolContent, 'command');
+              if (commandContent) partialArgs.command = commandContent;
+              
+              // Extract streaming content based on tool type
+              let streamingContent = null;
+              
+              // For write_file: stream the content parameter
+              if (partialToolName === 'write_file') {
+                const content = extractXmlContent(partialToolContent, 'content');
+                if (content) {
+                  streamingContent = content;
+                  const lineCount = (content.match(/\n/g) || []).length + 1;
+                  partialArgs._streamingLines = lineCount;
+                  partialArgs._streamingChars = content.length;
+                }
+              }
+              
+              // For edit_file: stream old_string and new_string
+              if (partialToolName === 'edit_file') {
+                const oldString = extractXmlContent(partialToolContent, 'old_string');
+                const newString = extractXmlContent(partialToolContent, 'new_string');
+                
+                if (oldString || newString) {
+                  partialArgs._streamingOldString = oldString || '';
+                  partialArgs._streamingNewString = newString || '';
+                  // Create a preview diff-like content
+                  streamingContent = `--- ${partialArgs.path || 'file'}\n+++ ${partialArgs.path || 'file'}\n`;
+                  if (oldString) {
+                    streamingContent += oldString.split('\n').map(l => `- ${l}`).join('\n') + '\n';
+                  }
+                  if (newString) {
+                    streamingContent += newString.split('\n').map(l => `+ ${l}`).join('\n');
+                  }
+                  partialArgs._streamingLines = (streamingContent.match(/\n/g) || []).length + 1;
+                  partialArgs._streamingChars = (oldString?.length || 0) + (newString?.length || 0);
+                }
+              }
+              
+              // For search_files: stream the query
+              if (partialToolName === 'search_files') {
+                const queryContent = extractXmlContent(partialToolContent, 'query');
+                if (queryContent) {
+                  partialArgs._streamingQuery = queryContent;
+                  streamingContent = `Searching for: "${queryContent}"`;
+                }
+              }
+              
+              // For read_file: just show path info
+              if (partialToolName === 'read_file') {
+                if (partialArgs.path) {
+                  streamingContent = `Reading: ${partialArgs.path}`;
+                }
+              }
+              
+              // For execute_command/shell: stream the command being typed
+              if (partialToolName === 'execute_command' || partialToolName === 'shell' || partialToolName === 'run_command') {
+                const command = extractXmlContent(partialToolContent, 'command');
+                if (command) {
+                  partialArgs.command = command;
+                  streamingContent = command;
+                  partialArgs._streamingChars = command.length;
+                }
+              }
+              
+              // DEDUPLICATION FIX: Only emit tool_streaming when there's meaningful change
+              // This prevents flooding the frontend with hundreds of identical events
+              const contentLength = streamingContent?.length || partialToolContent.length;
+              const now = Date.now();
+              
+              // Check if this is a NEW tool or if we should emit an update
+              const isNewTool = !currentStreamingTool || currentStreamingTool.name !== partialToolName;
+              const shouldEmit = isNewTool ||
+                // Emit every ~300 chars of content change (reduces event volume)
+                (contentLength - (currentStreamingTool?.lastEmittedLength || 0)) >= 300 ||
+                // Or every 200ms for progress feedback
+                (now - (currentStreamingTool?.lastEmittedTime || 0)) >= 200;
+              
+              if (shouldEmit) {
+                // Generate stable ID for this tool call (persists across all streaming events)
+                const streamingId = isNewTool 
+                  ? `streaming-${partialToolName}-${now}` 
+                  : currentStreamingTool.id;
+                
+                // Update tracking state
+                currentStreamingTool = {
+                  id: streamingId,
+                  name: partialToolName,
+                  lastEmittedLength: contentLength,
+                  lastEmittedTime: now,
+                };
+                
+                // Sanitize partial args: drop values that look truncated (contain '<' = unclosed tag)
+                const sanitizedPartialArgs = {};
+                for (const [k, v] of Object.entries(partialArgs)) {
+                  if (typeof v === 'string' && v.includes('<')) continue; // Truncated/invalid
+                  sanitizedPartialArgs[k] = v;
+                }
+                // Emit with stable ID so frontend can match/update existing entry
+                yield { 
+                  type: 'tool_streaming', 
+                  streamingId, // CRITICAL: Stable ID for deduplication
+                  name: partialToolName, 
+                  args: sanitizedPartialArgs,
+                  streamingContent,
+                  bufferLength: partialToolContent.length,
+                  status: streamingContent ? 'streaming' : 'preparing',
+                };
+              }
+            }
+            }
+          } else {
+            // No tool call in buffer - clear streaming state
+            currentStreamingTool = null;
+          }
+          
+        } else if (chunk.type === 'thinking') {
+          // Track thinking content for models like gpt-oss that need CoT preservation
+          thinkingContent += chunk.content;
+          yield chunk;
+        } else if (chunk.type === 'thinking_only') {
+          // Ollama reasoning model produced thinking but no response
+          // This is handled after the streaming loop via the recovery mechanism
+          agentLog('[Agent] Received thinking_only marker - will attempt recovery if tools were called');
+        } else if (chunk.type === 'image' || chunk.type === 'image_url') {
+          // Pass through image chunks directly from image generation models
+          yield chunk;
+        } else if (chunk.type === 'usage') {
+          // Pass through usage stats from inference providers
+          yield chunk;
+        }
+      }
+      
+      // If we executed a tool inline, continue to next iteration for the model to respond
+      if (executedToolInline) {
+        agentLog('[Agent] Tool executed inline, continuing to next iteration...');
+        continue;
+      }
+      
+      // After streaming completes, check if there's a remaining tool call (skip during recovery)
+      const remainingTool = config.disableTools ? null : parseFirstToolCall(buffer);
+      if (remainingTool) {
+        const { toolCall, beforeText, parseError } = remainingTool;
+        
+        // Yield any remaining text before tool call
+        const newTextBefore = beforeText.substring(textYielded.length);
+        if (newTextBefore) {
+          yield { type: 'text', content: newTextBefore };
+          fullResponseText += newTextBefore;
+        }
+        
+        if (parseError || !toolCall) {
+          yield {
+            type: 'tool_parse_error',
+            name: parseError?.toolName || 'unknown',
+            error: `Failed to parse tool call: ${parseError?.message || 'Unknown error'}`,
+            hint: 'The AI generated a malformed tool call at end of stream.',
+            preview: parseError?.contentPreview?.substring(0, 150) || '',
+          };
+          buffer = remainingTool.afterText || '';
+          textYielded = '';
+          continue;
+        }
+        
+        const postValidation = validateToolCall({ name: toolCall.name, args: toolCall.args });
+        if (!postValidation.valid) {
+          yield {
+            type: 'tool_parse_error',
+            name: toolCall.name,
+            error: `Invalid tool call: ${postValidation.error}`,
+            hint: 'Tool name or arguments invalid.',
+            preview: '',
+          };
+          buffer = remainingTool.afterText || '';
+          textYielded = '';
+          continue;
+        }
+        const finalSanitized = { name: postValidation.sanitized.name, args: postValidation.sanitized.args };
+        
+        // Skip web tools if needed - but provide feedback to the AI
+        if (skipWebTools && WEB_TOOLS.includes(finalSanitized.name)) {
+          agentLog('[Agent] Skipping web tool (post-stream):', finalSanitized.name);
+          
+          const skipCallId = randomUUID();
+          const skipResult = finalSanitized.name === 'web_search' 
+            ? 'Web search was already performed. The search results are included in the user message above. Please use that information to answer.'
+            : 'URL fetching is not needed. The relevant content was already fetched and included in the user message above. Please use that information.';
+          
+          yield { type: 'tool_start', name: finalSanitized.name, args: finalSanitized.args, callId: skipCallId };
+          yield { type: 'tool_result', name: finalSanitized.name, result: skipResult, callId: skipCallId };
+          
+          const assistantContent = fullResponseText + `<tool_call>\n${serializeToolCallToXml(finalSanitized)}\n</tool_call>`;
+          messages.push({ role: 'assistant', content: assistantContent });
+          messages.push({ role: 'user', content: `Tool result for ${finalSanitized.name}:\n${skipResult}` });
+          
+          fullResponseText = '';
+          continue;
+        }
+        
+        // Execute the tool (validated/sanitized)
+        totalToolCalls++;
+        const finalCallId = randomUUID();
+        console.log(`[Agent] Executing final tool: ${finalSanitized.name} (${finalCallId})`);
+        
+        yield { type: 'tool_start', name: finalSanitized.name, args: finalSanitized.args, callId: finalCallId };
+        
+        let toolResult;
+        try {
+          toolResult = await executeTool(finalSanitized.name, finalSanitized.args, config, snapshotFn, shellUndoFn, finalCallId);
+          yield { type: 'tool_result', name: finalSanitized.name, result: toolResult, callId: finalCallId };
+        } catch (err) {
+          toolResult = `Error: ${err.message}`;
+          yield { type: 'tool_error', name: finalSanitized.name, error: toolResult, callId: finalCallId };
+        }
+        
+        let assistantMsgContent = fullResponseText + `<tool_call>\n${serializeToolCallToXml(finalSanitized)}\n</tool_call>`;
+        if (isOllamaReasoning && thinkingContent) {
+          assistantMsgContent = `<thinking>${thinkingContent}</thinking>\n${assistantMsgContent}`;
+        }
+        messages.push({ role: 'assistant', content: assistantMsgContent });
+        messages.push({ 
+          role: 'user', 
+          content: `[Tool "${finalSanitized.name}" returned]:\n${toolResult}` 
+        });
+        
+        fullResponseText = '';
+        thinkingContent = '';
+        continue;
+      }
+      
+      // No more tool calls - yield any remaining buffered text
+      const remainingText = buffer.substring(textYielded.length);
+      if (remainingText) {
+        // Clean out any tool call tags (both complete and incomplete)
+        let cleanRemaining = remainingText;
+        
+        // CRITICAL FIX: Normalize malformed closing tags (missing >) before processing
+        // The LLM sometimes outputs </tool_call without the closing >
+        cleanRemaining = cleanRemaining.replace(/<\/tool_call([^>])/g, '</tool_call>$1');
+        
+        // CRITICAL FIX: Strip ALL complete tool_call blocks too
+        // This is a safeguard for cases where parseFirstToolCall fails to parse the XML
+        // (e.g., malformed XML, unexpected format, etc.)
+        // We should NEVER yield tool_call XML as text - it confuses the frontend
+        cleanRemaining = cleanRemaining.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, '');
+        
+        // Check if there's an incomplete tool call (opening without closing)
+        const lastToolStart = cleanRemaining.lastIndexOf('<tool_call>');
+        if (lastToolStart !== -1) {
+          const afterStart = cleanRemaining.substring(lastToolStart);
+          if (!afterStart.includes('</tool_call>')) {
+            // Incomplete tool call - remove from opening tag to end
+            cleanRemaining = cleanRemaining.substring(0, lastToolStart);
+          }
+        }
+        
+        // Also clean partial opening tags at the very end
+        cleanRemaining = cleanRemaining.replace(/<tool_call$/g, '')
+          .replace(/<tool_cal$/g, '')
+          .replace(/<tool_ca$/g, '')
+          .replace(/<tool_c$/g, '')
+          .replace(/<tool_$/g, '')
+          .replace(/<tool$/g, '')
+          .replace(/<too$/g, '')
+          .replace(/<to$/g, '')
+          .replace(/<t$/g, '')
+          .replace(/<$/g, '');
+        
+        if (cleanRemaining) {
+          yield { type: 'text', content: cleanRemaining };
+          fullResponseText += cleanRemaining;
+        }
+      }
+      
+      // RECOVERY: If model produced no text response after using tools, nudge it to answer.
+      // Common with Ollama models that get stuck in a tool-calling loop or produce only thinking.
+      // Disable tools during recovery so the model is forced to produce a text response.
+      if (!fullResponseText.trim() && totalToolCalls > 0 && recoveryAttempts < MAX_RECOVERY_ATTEMPTS) {
+        recoveryAttempts++;
+        console.log(`[Agent] Model produced no response after ${totalToolCalls} tool call(s) - recovery attempt ${recoveryAttempts}/${MAX_RECOVERY_ATTEMPTS}`);
+        
+        messages.push({ 
+          role: 'user', 
+          content: 'Based on the tool results above, please provide your answer now. Do not use any tools. Respond directly with the information you have.' 
+        });
+        
+        thinkingContent = '';
+        config.disableTools = true;
+        continue;
+      }
+      
+      // Restore tools after recovery (whether it succeeded or not)
+      if (recoveryAttempts > 0) {
+        config.disableTools = false;
+      }
+      
+      if (!fullResponseText.trim() && totalToolCalls > 0 && recoveryAttempts >= MAX_RECOVERY_ATTEMPTS) {
+        console.warn('[Agent] Recovery failed - model did not produce a response after multiple attempts');
+        yield { 
+          type: 'text', 
+          content: '\n\n*The model gathered information but could not formulate a response. Try asking your question again or use a different model.*\n' 
+        };
+      }
+      
+      // No tool calls found in this iteration - we're done (title is set by frontend via backend)
+      return;
+      
+    } catch (err) {
+      yield { type: 'error', message: `Inference error: ${err.message}` };
+      return;
+    }
+  }
+
+  // Max iterations reached
+  yield { 
+    type: 'warning', 
+    message: `Reached maximum tool iterations (${maxIterations}). Stopping.` 
+  };
+}
+
+/**
+ * Run agent for a scheduled task
+ */
+export async function runScheduledTask(taskDescription, config) {
+  const messages = [];
+  const prompt = `Execute the following scheduled task:\n\n${taskDescription}\n\nComplete this task and report the results.`;
+  
+  let fullResponse = '';
+  
+  for await (const chunk of runAgent(prompt, messages, config, {})) {
+    if (chunk.type === 'text') {
+      fullResponse += chunk.content;
+    }
+    if (chunk.type === 'tool_start') {
+      console.log(`[Scheduled Task] Executing: ${chunk.name}`);
+    }
+    if (chunk.type === 'tool_result') {
+      console.log(`[Scheduled Task] Result: ${chunk.result?.slice(0, 100)}...`);
+    }
+  }
+  
+  return cleanResponseText(fullResponse);
+}
+
+export default { runAgent, runScheduledTask };