@probelabs/probe 0.6.0-rc104 → 0.6.0-rc105

package/build/agent/index.js

@@ -30083,20 +30083,15 @@ var init_index = __esm({
   }
 });
 
-// src/agent/tools.js
-import { randomUUID as randomUUID2 } from "crypto";
-function createTools(configOptions) {
-  return {
-    searchTool: searchTool(configOptions),
-    queryTool: queryTool(configOptions),
-    extractTool: extractTool(configOptions),
-    delegateTool: delegateTool(configOptions)
-  };
+// src/agent/xmlParsingUtils.js
+function removeThinkingTags(xmlString) {
+  return xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
 }
-function parseXmlToolCallWithThinking(xmlString, validTools) {
+function extractThinkingContent(xmlString) {
   const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
-  const thinkingContent = thinkingMatch ? thinkingMatch[1].trim() : null;
-  let cleanedXmlString = xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
+  return thinkingMatch ? thinkingMatch[1].trim() : null;
+}
+function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
   const attemptCompletePatterns = [
     // Standard shorthand with optional whitespace
     /^<attempt_complete>\s*$/,
@@ -30126,12 +30121,7 @@ function parseXmlToolCallWithThinking(xmlString, validTools) {
       params: { result: "__PREVIOUS_RESPONSE__" }
     };
   }
-  const parsedTool = parseXmlToolCall(cleanedXmlString, validTools);
-  if (process.env.DEBUG === "1" && thinkingContent) {
-    console.log(`[DEBUG] AI Thinking Process:
-${thinkingContent}`);
-  }
-  return parsedTool;
+  return null;
 }
 function hasOtherToolTags(xmlString, validTools = []) {
   const defaultTools = ["search", "query", "extract", "listFiles", "searchFiles", "implement", "attempt_completion"];
@@ -30143,11 +30133,49 @@ function hasOtherToolTags(xmlString, validTools = []) {
   }
   return false;
 }
+function processXmlWithThinkingAndRecovery(xmlString, validTools = []) {
+  const thinkingContent = extractThinkingContent(xmlString);
+  const cleanedXmlString = removeThinkingTags(xmlString);
+  const recoveryResult = checkAttemptCompleteRecovery(cleanedXmlString, validTools);
+  if (process.env.DEBUG === "1" && thinkingContent) {
+    console.log(`[DEBUG] AI Thinking Process:
+${thinkingContent}`);
+  }
+  return {
+    cleanedXmlString,
+    thinkingContent,
+    recoveryResult
+  };
+}
+var init_xmlParsingUtils = __esm({
+  "src/agent/xmlParsingUtils.js"() {
+    "use strict";
+  }
+});
+
+// src/agent/tools.js
+import { randomUUID as randomUUID2 } from "crypto";
+function createTools(configOptions) {
+  return {
+    searchTool: searchTool(configOptions),
+    queryTool: queryTool(configOptions),
+    extractTool: extractTool(configOptions),
+    delegateTool: delegateTool(configOptions)
+  };
+}
+function parseXmlToolCallWithThinking(xmlString, validTools) {
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+  return parseXmlToolCall(cleanedXmlString, validTools);
+}
 var implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition;
 var init_tools2 = __esm({
   "src/agent/tools.js"() {
     "use strict";
     init_index();
+    init_xmlParsingUtils();
     implementToolDefinition = `
 ## implement
 Description: Implement a given task. Can modify files. Can be used ONLY if task explicitly stated that something requires modification or implementation.
@@ -32151,11 +32179,9 @@ function parseXmlMcpToolCall(xmlString, mcpToolNames = []) {
   return null;
 }
 function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
-  for (const toolName of nativeTools) {
-    const nativeResult = parseNativeXmlTool(xmlString, toolName);
-    if (nativeResult) {
-      return { ...nativeResult, type: "native" };
-    }
+  const nativeResult = parseNativeXmlToolWithThinking(xmlString, nativeTools);
+  if (nativeResult) {
+    return { ...nativeResult, type: "native" };
   }
   if (mcpBridge) {
     const mcpResult = parseXmlMcpToolCall(xmlString, mcpBridge.getToolNames());
@@ -32165,6 +32191,19 @@ function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
   }
   return null;
 }
+function parseNativeXmlToolWithThinking(xmlString, validTools) {
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+  for (const toolName of validTools) {
+    const result = parseNativeXmlTool(cleanedXmlString, toolName);
+    if (result) {
+      return result;
+    }
+  }
+  return null;
+}
 function parseNativeXmlTool(xmlString, toolName) {
   const openTag = `<${toolName}>`;
   const closeTag = `</${toolName}>`;
@@ -32194,6 +32233,7 @@ var init_xmlBridge = __esm({
     "use strict";
     init_client2();
     init_config();
+    init_xmlParsingUtils();
     MCPXmlBridge = class {
       constructor(options = {}) {
         this.debug = options.debug || false;

package/build/agent/mcp/xmlBridge.js

@@ -5,6 +5,7 @@
 
 import { MCPClientManager } from './client.js';
 import { loadMCPConfiguration } from './config.js';
+import { processXmlWithThinkingAndRecovery } from '../xmlParsingUtils.js';
 
 /**
  * Convert MCP tool to XML definition format
@@ -254,18 +255,18 @@ export class MCPXmlBridge {
 
 /**
  * Enhanced XML parser that handles both native and MCP tools
+ * Uses the exact same logic as CLI/SDK mode to ensure consistency
  * @param {string} xmlString - XML string to parse
  * @param {Array<string>} nativeTools - List of native tool names
  * @param {MCPXmlBridge} mcpBridge - MCP bridge instance
  * @returns {Object|null} Parsed tool call
  */
 export function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
-  // First try native tools with standard XML parsing
-  for (const toolName of nativeTools) {
-    const nativeResult = parseNativeXmlTool(xmlString, toolName);
-    if (nativeResult) {
-      return { ...nativeResult, type: 'native' };
-    }
+  // First try native tools with the same logic as CLI/SDK mode
+  // This includes thinking tag removal and attempt_complete recovery logic
+  const nativeResult = parseNativeXmlToolWithThinking(xmlString, nativeTools);
+  if (nativeResult) {
+    return { ...nativeResult, type: 'native' };
   }
 
   // Then try MCP tools if bridge is available
@@ -279,6 +280,33 @@ export function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge =
   return null;
 }
 
+/**
+ * Parse native XML tools using the same logic as CLI/SDK mode
+ * Now uses shared utilities instead of duplicating code
+ * @param {string} xmlString - XML string to parse
+ * @param {Array<string>} validTools - List of valid tool names
+ * @returns {Object|null} Parsed tool call
+ */
+function parseNativeXmlToolWithThinking(xmlString, validTools) {
+  // Use the shared processing logic
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  
+  // If recovery found an attempt_complete pattern, return it
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+
+  // Use the original parseNativeXmlTool function to parse the cleaned XML string
+  for (const toolName of validTools) {
+    const result = parseNativeXmlTool(cleanedXmlString, toolName);
+    if (result) {
+      return result;
+    }
+  }
+
+  return null;
+}
+
 /**
  * Parse native XML tool (existing format)
  * @param {string} xmlString - XML string

package/build/agent/tools.js

@@ -18,6 +18,7 @@ import {
   parseXmlToolCall
 } from '../index.js';
 import { randomUUID } from 'crypto';
+import { processXmlWithThinkingAndRecovery } from './xmlParsingUtils.js';
 
 // Create configured tool instances
 export function createTools(configOptions) {
@@ -134,82 +135,15 @@ User: Find all markdown files in the docs directory, but only at the top level.
  * @returns {Object|null} - The parsed tool call or null if no valid tool call found
  */
 export function parseXmlToolCallWithThinking(xmlString, validTools) {
-  // Extract thinking content if present (for potential logging or analysis)
-  const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
-  const thinkingContent = thinkingMatch ? thinkingMatch[1].trim() : null;
-
-  // Remove thinking tags and their content from the XML string
-  let cleanedXmlString = xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
-
-  // Enhanced recovery logic for attempt_complete shorthand
-  // Check for various forms of attempt_complete tags:
-  // 1. Perfect shorthand: <attempt_complete>
-  // 2. Self-closing: <attempt_complete/>  
-  // 3. Empty with closing tag: <attempt_complete></attempt_complete>
-  // 4. Incomplete: <attempt_complete (missing closing bracket)
-  // 5. With trailing content that should be ignored
-  const attemptCompletePatterns = [
-    // Standard shorthand with optional whitespace
-    /^<attempt_complete>\s*$/,
-    // Empty with proper closing tag (common case from the logs)
-    /^<attempt_complete>\s*<\/attempt_complete>\s*$/,
-    // Self-closing variant
-    /^<attempt_complete\s*\/>\s*$/,
-    // Incomplete opening tag (missing closing bracket)
-    /^<attempt_complete\s*$/,
-    // With trailing content (extract just the tag part) - must come after empty tag pattern
-    /^<attempt_complete>(.*)$/s,
-    // Self-closing with trailing content
-    /^<attempt_complete\s*\/>(.*)$/s
-  ];
-
-  for (const pattern of attemptCompletePatterns) {
-    const match = cleanedXmlString.match(pattern);
-    if (match) {
-      // Convert any form of attempt_complete to the standard format
-      return {
-        toolName: 'attempt_completion',
-        params: { result: '__PREVIOUS_RESPONSE__' }
-      };
-    }
-  }
-
-  // Additional recovery: check if the string contains attempt_complete anywhere
-  // and treat the entire response as a completion signal if no other tool tags are found
-  if (cleanedXmlString.includes('<attempt_complete') && !hasOtherToolTags(cleanedXmlString, validTools)) {
-    // This handles malformed cases where attempt_complete appears but is broken
-    return {
-      toolName: 'attempt_completion', 
-      params: { result: '__PREVIOUS_RESPONSE__' }
-    };
-  }
-
-  // Use the original parseXmlToolCall function to parse the cleaned XML string
-  const parsedTool = parseXmlToolCall(cleanedXmlString, validTools);
-
-  // If debugging is enabled, log the thinking content
-  if (process.env.DEBUG === '1' && thinkingContent) {
-    console.log(`[DEBUG] AI Thinking Process:\n${thinkingContent}`);
+  // Use the shared processing logic
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  
+  // If recovery found an attempt_complete pattern, return it
+  if (recoveryResult) {
+    return recoveryResult;
   }
 
-  return parsedTool;
+  // Otherwise, use the original parseXmlToolCall function to parse the cleaned XML string
+  return parseXmlToolCall(cleanedXmlString, validTools);
 }
 
-/**
- * Helper function to check if the XML string contains other tool tags
- * @param {string} xmlString - The XML string to check
- * @param {string[]} validTools - List of valid tool names
- * @returns {boolean} - True if other tool tags are found
- */
-function hasOtherToolTags(xmlString, validTools = []) {
-  const defaultTools = ['search', 'query', 'extract', 'listFiles', 'searchFiles', 'implement', 'attempt_completion'];
-  const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
-  
-  // Check for any tool tags other than attempt_complete variants
-  for (const tool of toolsToCheck) {
-    if (tool !== 'attempt_completion' && xmlString.includes(`<${tool}`)) {
-      return true;
-    }
-  }
-  return false;
-}

package/build/agent/xmlParsingUtils.js

@@ -0,0 +1,118 @@
+/**
+ * Shared XML parsing utilities used by both CLI/SDK and MCP modes
+ * This module contains the core logic for thinking tag removal and attempt_complete recovery
+ */
+
+/**
+ * Remove thinking tags and their content from XML string
+ * @param {string} xmlString - The XML string to clean
+ * @returns {string} - Cleaned XML string without thinking tags
+ */
+export function removeThinkingTags(xmlString) {
+  return xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
+}
+
+/**
+ * Extract thinking content for potential logging
+ * @param {string} xmlString - The XML string to extract from
+ * @returns {string|null} - Thinking content or null if not found
+ */
+export function extractThinkingContent(xmlString) {
+  const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
+  return thinkingMatch ? thinkingMatch[1].trim() : null;
+}
+
+/**
+ * Check for attempt_complete recovery patterns and return standardized result
+ * @param {string} cleanedXmlString - XML string with thinking tags already removed
+ * @param {Array<string>} validTools - List of valid tool names
+ * @returns {Object|null} - Standardized attempt_completion result or null
+ */
+export function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
+  // Enhanced recovery logic for attempt_complete shorthand
+  const attemptCompletePatterns = [
+    // Standard shorthand with optional whitespace
+    /^<attempt_complete>\s*$/,
+    // Empty with proper closing tag (common case from the logs)
+    /^<attempt_complete>\s*<\/attempt_complete>\s*$/,
+    // Self-closing variant
+    /^<attempt_complete\s*\/>\s*$/,
+    // Incomplete opening tag (missing closing bracket)
+    /^<attempt_complete\s*$/,
+    // With trailing content (extract just the tag part) - must come after empty tag pattern
+    /^<attempt_complete>(.*)$/s,
+    // Self-closing with trailing content
+    /^<attempt_complete\s*\/>(.*)$/s
+  ];
+
+  for (const pattern of attemptCompletePatterns) {
+    const match = cleanedXmlString.match(pattern);
+    if (match) {
+      // Convert any form of attempt_complete to the standard format
+      return {
+        toolName: 'attempt_completion',
+        params: { result: '__PREVIOUS_RESPONSE__' }
+      };
+    }
+  }
+
+  // Additional recovery: check if the string contains attempt_complete anywhere
+  // and treat the entire response as a completion signal if no other tool tags are found
+  if (cleanedXmlString.includes('<attempt_complete') && !hasOtherToolTags(cleanedXmlString, validTools)) {
+    // This handles malformed cases where attempt_complete appears but is broken
+    return {
+      toolName: 'attempt_completion', 
+      params: { result: '__PREVIOUS_RESPONSE__' }
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Helper function to check if the XML string contains other tool tags
+ * @param {string} xmlString - The XML string to check
+ * @param {string[]} validTools - List of valid tool names
+ * @returns {boolean} - True if other tool tags are found
+ */
+function hasOtherToolTags(xmlString, validTools = []) {
+  const defaultTools = ['search', 'query', 'extract', 'listFiles', 'searchFiles', 'implement', 'attempt_completion'];
+  const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
+  
+  // Check for any tool tags other than attempt_complete variants
+  for (const tool of toolsToCheck) {
+    if (tool !== 'attempt_completion' && xmlString.includes(`<${tool}`)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Apply the full thinking tag removal and attempt_complete recovery logic
+ * This replicates the core logic from parseXmlToolCallWithThinking
+ * @param {string} xmlString - The XML string to process
+ * @param {Array<string>} validTools - List of valid tool names
+ * @returns {Object} - Processing result with cleanedXml and potentialRecovery
+ */
+export function processXmlWithThinkingAndRecovery(xmlString, validTools = []) {
+  // Extract thinking content if present (for potential logging or analysis)
+  const thinkingContent = extractThinkingContent(xmlString);
+
+  // Remove thinking tags and their content from the XML string
+  const cleanedXmlString = removeThinkingTags(xmlString);
+
+  // Check for attempt_complete recovery patterns
+  const recoveryResult = checkAttemptCompleteRecovery(cleanedXmlString, validTools);
+
+  // If debugging is enabled, log the thinking content
+  if (process.env.DEBUG === '1' && thinkingContent) {
+    console.log(`[DEBUG] AI Thinking Process:\n${thinkingContent}`);
+  }
+
+  return {
+    cleanedXmlString,
+    thinkingContent,
+    recoveryResult
+  };
+}

package/cjs/agent/ProbeAgent.cjs

@@ -29863,19 +29863,15 @@ var init_index = __esm({
   }
 });
 
-// src/agent/tools.js
-function createTools(configOptions) {
-  return {
-    searchTool: searchTool(configOptions),
-    queryTool: queryTool(configOptions),
-    extractTool: extractTool(configOptions),
-    delegateTool: delegateTool(configOptions)
-  };
+// src/agent/xmlParsingUtils.js
+function removeThinkingTags(xmlString) {
+  return xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
 }
-function parseXmlToolCallWithThinking(xmlString, validTools) {
+function extractThinkingContent(xmlString) {
   const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
-  const thinkingContent = thinkingMatch ? thinkingMatch[1].trim() : null;
-  let cleanedXmlString = xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
+  return thinkingMatch ? thinkingMatch[1].trim() : null;
+}
+function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
   const attemptCompletePatterns = [
     // Standard shorthand with optional whitespace
     /^<attempt_complete>\s*$/,
@@ -29905,12 +29901,7 @@ function parseXmlToolCallWithThinking(xmlString, validTools) {
       params: { result: "__PREVIOUS_RESPONSE__" }
     };
   }
-  const parsedTool = parseXmlToolCall(cleanedXmlString, validTools);
-  if (process.env.DEBUG === "1" && thinkingContent) {
-    console.log(`[DEBUG] AI Thinking Process:
-${thinkingContent}`);
-  }
-  return parsedTool;
+  return null;
 }
 function hasOtherToolTags(xmlString, validTools = []) {
   const defaultTools = ["search", "query", "extract", "listFiles", "searchFiles", "implement", "attempt_completion"];
@@ -29922,12 +29913,49 @@ function hasOtherToolTags(xmlString, validTools = []) {
   }
   return false;
 }
+function processXmlWithThinkingAndRecovery(xmlString, validTools = []) {
+  const thinkingContent = extractThinkingContent(xmlString);
+  const cleanedXmlString = removeThinkingTags(xmlString);
+  const recoveryResult = checkAttemptCompleteRecovery(cleanedXmlString, validTools);
+  if (process.env.DEBUG === "1" && thinkingContent) {
+    console.log(`[DEBUG] AI Thinking Process:
+${thinkingContent}`);
+  }
+  return {
+    cleanedXmlString,
+    thinkingContent,
+    recoveryResult
+  };
+}
+var init_xmlParsingUtils = __esm({
+  "src/agent/xmlParsingUtils.js"() {
+    "use strict";
+  }
+});
+
+// src/agent/tools.js
+function createTools(configOptions) {
+  return {
+    searchTool: searchTool(configOptions),
+    queryTool: queryTool(configOptions),
+    extractTool: extractTool(configOptions),
+    delegateTool: delegateTool(configOptions)
+  };
+}
+function parseXmlToolCallWithThinking(xmlString, validTools) {
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+  return parseXmlToolCall(cleanedXmlString, validTools);
+}
 var import_crypto3, implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition;
 var init_tools2 = __esm({
   "src/agent/tools.js"() {
     "use strict";
     init_index();
     import_crypto3 = require("crypto");
+    init_xmlParsingUtils();
     implementToolDefinition = `
 ## implement
 Description: Implement a given task. Can modify files. Can be used ONLY if task explicitly stated that something requires modification or implementation.
@@ -31872,11 +31900,9 @@ function parseXmlMcpToolCall(xmlString, mcpToolNames = []) {
   return null;
 }
 function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
-  for (const toolName of nativeTools) {
-    const nativeResult = parseNativeXmlTool(xmlString, toolName);
-    if (nativeResult) {
-      return { ...nativeResult, type: "native" };
-    }
+  const nativeResult = parseNativeXmlToolWithThinking(xmlString, nativeTools);
+  if (nativeResult) {
+    return { ...nativeResult, type: "native" };
   }
   if (mcpBridge) {
     const mcpResult = parseXmlMcpToolCall(xmlString, mcpBridge.getToolNames());
@@ -31886,6 +31912,19 @@ function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
   }
   return null;
 }
+function parseNativeXmlToolWithThinking(xmlString, validTools) {
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+  for (const toolName of validTools) {
+    const result = parseNativeXmlTool(cleanedXmlString, toolName);
+    if (result) {
+      return result;
+    }
+  }
+  return null;
+}
 function parseNativeXmlTool(xmlString, toolName) {
   const openTag = `<${toolName}>`;
   const closeTag = `</${toolName}>`;
@@ -31915,6 +31954,7 @@ var init_xmlBridge = __esm({
     "use strict";
     init_client2();
     init_config();
+    init_xmlParsingUtils();
     MCPXmlBridge = class {
       constructor(options = {}) {
         this.debug = options.debug || false;

package/cjs/index.cjs

@@ -29949,19 +29949,15 @@ var init_tokenCounter = __esm({
   }
 });
 
-// src/agent/tools.js
-function createTools(configOptions) {
-  return {
-    searchTool: searchTool(configOptions),
-    queryTool: queryTool(configOptions),
-    extractTool: extractTool(configOptions),
-    delegateTool: delegateTool(configOptions)
-  };
+// src/agent/xmlParsingUtils.js
+function removeThinkingTags(xmlString) {
+  return xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
 }
-function parseXmlToolCallWithThinking(xmlString, validTools) {
+function extractThinkingContent(xmlString) {
   const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
-  const thinkingContent = thinkingMatch ? thinkingMatch[1].trim() : null;
-  let cleanedXmlString = xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
+  return thinkingMatch ? thinkingMatch[1].trim() : null;
+}
+function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
   const attemptCompletePatterns = [
     // Standard shorthand with optional whitespace
     /^<attempt_complete>\s*$/,
@@ -29991,12 +29987,7 @@ function parseXmlToolCallWithThinking(xmlString, validTools) {
       params: { result: "__PREVIOUS_RESPONSE__" }
     };
   }
-  const parsedTool = parseXmlToolCall(cleanedXmlString, validTools);
-  if (process.env.DEBUG === "1" && thinkingContent) {
-    console.log(`[DEBUG] AI Thinking Process:
-${thinkingContent}`);
-  }
-  return parsedTool;
+  return null;
 }
 function hasOtherToolTags(xmlString, validTools = []) {
   const defaultTools = ["search", "query", "extract", "listFiles", "searchFiles", "implement", "attempt_completion"];
@@ -30008,12 +29999,49 @@ function hasOtherToolTags(xmlString, validTools = []) {
   }
   return false;
 }
+function processXmlWithThinkingAndRecovery(xmlString, validTools = []) {
+  const thinkingContent = extractThinkingContent(xmlString);
+  const cleanedXmlString = removeThinkingTags(xmlString);
+  const recoveryResult = checkAttemptCompleteRecovery(cleanedXmlString, validTools);
+  if (process.env.DEBUG === "1" && thinkingContent) {
+    console.log(`[DEBUG] AI Thinking Process:
+${thinkingContent}`);
+  }
+  return {
+    cleanedXmlString,
+    thinkingContent,
+    recoveryResult
+  };
+}
+var init_xmlParsingUtils = __esm({
+  "src/agent/xmlParsingUtils.js"() {
+    "use strict";
+  }
+});
+
+// src/agent/tools.js
+function createTools(configOptions) {
+  return {
+    searchTool: searchTool(configOptions),
+    queryTool: queryTool(configOptions),
+    extractTool: extractTool(configOptions),
+    delegateTool: delegateTool(configOptions)
+  };
+}
+function parseXmlToolCallWithThinking(xmlString, validTools) {
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+  return parseXmlToolCall(cleanedXmlString, validTools);
+}
 var import_crypto3, implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition;
 var init_tools2 = __esm({
   "src/agent/tools.js"() {
     "use strict";
     init_index();
     import_crypto3 = require("crypto");
+    init_xmlParsingUtils();
     implementToolDefinition = `
 ## implement
 Description: Implement a given task. Can modify files. Can be used ONLY if task explicitly stated that something requires modification or implementation.
@@ -31958,11 +31986,9 @@ function parseXmlMcpToolCall(xmlString, mcpToolNames = []) {
   return null;
 }
 function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
-  for (const toolName of nativeTools) {
-    const nativeResult = parseNativeXmlTool(xmlString, toolName);
-    if (nativeResult) {
-      return { ...nativeResult, type: "native" };
-    }
+  const nativeResult = parseNativeXmlToolWithThinking(xmlString, nativeTools);
+  if (nativeResult) {
+    return { ...nativeResult, type: "native" };
   }
   if (mcpBridge) {
     const mcpResult = parseXmlMcpToolCall(xmlString, mcpBridge.getToolNames());
@@ -31972,6 +31998,19 @@ function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
   }
   return null;
 }
+function parseNativeXmlToolWithThinking(xmlString, validTools) {
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+  for (const toolName of validTools) {
+    const result = parseNativeXmlTool(cleanedXmlString, toolName);
+    if (result) {
+      return result;
+    }
+  }
+  return null;
+}
 function parseNativeXmlTool(xmlString, toolName) {
   const openTag = `<${toolName}>`;
   const closeTag = `</${toolName}>`;
@@ -32001,6 +32040,7 @@ var init_xmlBridge = __esm({
     "use strict";
     init_client2();
     init_config();
+    init_xmlParsingUtils();
     MCPXmlBridge = class {
       constructor(options = {}) {
         this.debug = options.debug || false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc104",
+  "version": "0.6.0-rc105",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/agent/mcp/xmlBridge.js

@@ -5,6 +5,7 @@
 
 import { MCPClientManager } from './client.js';
 import { loadMCPConfiguration } from './config.js';
+import { processXmlWithThinkingAndRecovery } from '../xmlParsingUtils.js';
 
 /**
  * Convert MCP tool to XML definition format
@@ -254,18 +255,18 @@ export class MCPXmlBridge {
 
 /**
  * Enhanced XML parser that handles both native and MCP tools
+ * Uses the exact same logic as CLI/SDK mode to ensure consistency
  * @param {string} xmlString - XML string to parse
  * @param {Array<string>} nativeTools - List of native tool names
  * @param {MCPXmlBridge} mcpBridge - MCP bridge instance
  * @returns {Object|null} Parsed tool call
  */
 export function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
-  // First try native tools with standard XML parsing
-  for (const toolName of nativeTools) {
-    const nativeResult = parseNativeXmlTool(xmlString, toolName);
-    if (nativeResult) {
-      return { ...nativeResult, type: 'native' };
-    }
+  // First try native tools with the same logic as CLI/SDK mode
+  // This includes thinking tag removal and attempt_complete recovery logic
+  const nativeResult = parseNativeXmlToolWithThinking(xmlString, nativeTools);
+  if (nativeResult) {
+    return { ...nativeResult, type: 'native' };
   }
 
   // Then try MCP tools if bridge is available
@@ -279,6 +280,33 @@ export function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge =
   return null;
 }
 
+/**
+ * Parse native XML tools using the same logic as CLI/SDK mode
+ * Now uses shared utilities instead of duplicating code
+ * @param {string} xmlString - XML string to parse
+ * @param {Array<string>} validTools - List of valid tool names
+ * @returns {Object|null} Parsed tool call
+ */
+function parseNativeXmlToolWithThinking(xmlString, validTools) {
+  // Use the shared processing logic
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  
+  // If recovery found an attempt_complete pattern, return it
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+
+  // Use the original parseNativeXmlTool function to parse the cleaned XML string
+  for (const toolName of validTools) {
+    const result = parseNativeXmlTool(cleanedXmlString, toolName);
+    if (result) {
+      return result;
+    }
+  }
+
+  return null;
+}
+
 /**
  * Parse native XML tool (existing format)
  * @param {string} xmlString - XML string

package/src/agent/tools.js

@@ -18,6 +18,7 @@ import {
   parseXmlToolCall
 } from '../index.js';
 import { randomUUID } from 'crypto';
+import { processXmlWithThinkingAndRecovery } from './xmlParsingUtils.js';
 
 // Create configured tool instances
 export function createTools(configOptions) {
@@ -134,82 +135,15 @@ User: Find all markdown files in the docs directory, but only at the top level.
  * @returns {Object|null} - The parsed tool call or null if no valid tool call found
  */
 export function parseXmlToolCallWithThinking(xmlString, validTools) {
-  // Extract thinking content if present (for potential logging or analysis)
-  const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
-  const thinkingContent = thinkingMatch ? thinkingMatch[1].trim() : null;
-
-  // Remove thinking tags and their content from the XML string
-  let cleanedXmlString = xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
-
-  // Enhanced recovery logic for attempt_complete shorthand
-  // Check for various forms of attempt_complete tags:
-  // 1. Perfect shorthand: <attempt_complete>
-  // 2. Self-closing: <attempt_complete/>  
-  // 3. Empty with closing tag: <attempt_complete></attempt_complete>
-  // 4. Incomplete: <attempt_complete (missing closing bracket)
-  // 5. With trailing content that should be ignored
-  const attemptCompletePatterns = [
-    // Standard shorthand with optional whitespace
-    /^<attempt_complete>\s*$/,
-    // Empty with proper closing tag (common case from the logs)
-    /^<attempt_complete>\s*<\/attempt_complete>\s*$/,
-    // Self-closing variant
-    /^<attempt_complete\s*\/>\s*$/,
-    // Incomplete opening tag (missing closing bracket)
-    /^<attempt_complete\s*$/,
-    // With trailing content (extract just the tag part) - must come after empty tag pattern
-    /^<attempt_complete>(.*)$/s,
-    // Self-closing with trailing content
-    /^<attempt_complete\s*\/>(.*)$/s
-  ];
-
-  for (const pattern of attemptCompletePatterns) {
-    const match = cleanedXmlString.match(pattern);
-    if (match) {
-      // Convert any form of attempt_complete to the standard format
-      return {
-        toolName: 'attempt_completion',
-        params: { result: '__PREVIOUS_RESPONSE__' }
-      };
-    }
-  }
-
-  // Additional recovery: check if the string contains attempt_complete anywhere
-  // and treat the entire response as a completion signal if no other tool tags are found
-  if (cleanedXmlString.includes('<attempt_complete') && !hasOtherToolTags(cleanedXmlString, validTools)) {
-    // This handles malformed cases where attempt_complete appears but is broken
-    return {
-      toolName: 'attempt_completion', 
-      params: { result: '__PREVIOUS_RESPONSE__' }
-    };
-  }
-
-  // Use the original parseXmlToolCall function to parse the cleaned XML string
-  const parsedTool = parseXmlToolCall(cleanedXmlString, validTools);
-
-  // If debugging is enabled, log the thinking content
-  if (process.env.DEBUG === '1' && thinkingContent) {
-    console.log(`[DEBUG] AI Thinking Process:\n${thinkingContent}`);
+  // Use the shared processing logic
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  
+  // If recovery found an attempt_complete pattern, return it
+  if (recoveryResult) {
+    return recoveryResult;
   }
 
-  return parsedTool;
+  // Otherwise, use the original parseXmlToolCall function to parse the cleaned XML string
+  return parseXmlToolCall(cleanedXmlString, validTools);
 }
 
-/**
- * Helper function to check if the XML string contains other tool tags
- * @param {string} xmlString - The XML string to check
- * @param {string[]} validTools - List of valid tool names
- * @returns {boolean} - True if other tool tags are found
- */
-function hasOtherToolTags(xmlString, validTools = []) {
-  const defaultTools = ['search', 'query', 'extract', 'listFiles', 'searchFiles', 'implement', 'attempt_completion'];
-  const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
-  
-  // Check for any tool tags other than attempt_complete variants
-  for (const tool of toolsToCheck) {
-    if (tool !== 'attempt_completion' && xmlString.includes(`<${tool}`)) {
-      return true;
-    }
-  }
-  return false;
-}

package/src/agent/xmlParsingUtils.js

@@ -0,0 +1,118 @@
+/**
+ * Shared XML parsing utilities used by both CLI/SDK and MCP modes
+ * This module contains the core logic for thinking tag removal and attempt_complete recovery
+ */
+
+/**
+ * Remove thinking tags and their content from XML string
+ * @param {string} xmlString - The XML string to clean
+ * @returns {string} - Cleaned XML string without thinking tags
+ */
+export function removeThinkingTags(xmlString) {
+  return xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
+}
+
+/**
+ * Extract thinking content for potential logging
+ * @param {string} xmlString - The XML string to extract from
+ * @returns {string|null} - Thinking content or null if not found
+ */
+export function extractThinkingContent(xmlString) {
+  const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
+  return thinkingMatch ? thinkingMatch[1].trim() : null;
+}
+
+/**
+ * Check for attempt_complete recovery patterns and return standardized result
+ * @param {string} cleanedXmlString - XML string with thinking tags already removed
+ * @param {Array<string>} validTools - List of valid tool names
+ * @returns {Object|null} - Standardized attempt_completion result or null
+ */
+export function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
+  // Enhanced recovery logic for attempt_complete shorthand
+  const attemptCompletePatterns = [
+    // Standard shorthand with optional whitespace
+    /^<attempt_complete>\s*$/,
+    // Empty with proper closing tag (common case from the logs)
+    /^<attempt_complete>\s*<\/attempt_complete>\s*$/,
+    // Self-closing variant
+    /^<attempt_complete\s*\/>\s*$/,
+    // Incomplete opening tag (missing closing bracket)
+    /^<attempt_complete\s*$/,
+    // With trailing content (extract just the tag part) - must come after empty tag pattern
+    /^<attempt_complete>(.*)$/s,
+    // Self-closing with trailing content
+    /^<attempt_complete\s*\/>(.*)$/s
+  ];
+
+  for (const pattern of attemptCompletePatterns) {
+    const match = cleanedXmlString.match(pattern);
+    if (match) {
+      // Convert any form of attempt_complete to the standard format
+      return {
+        toolName: 'attempt_completion',
+        params: { result: '__PREVIOUS_RESPONSE__' }
+      };
+    }
+  }
+
+  // Additional recovery: check if the string contains attempt_complete anywhere
+  // and treat the entire response as a completion signal if no other tool tags are found
+  if (cleanedXmlString.includes('<attempt_complete') && !hasOtherToolTags(cleanedXmlString, validTools)) {
+    // This handles malformed cases where attempt_complete appears but is broken
+    return {
+      toolName: 'attempt_completion', 
+      params: { result: '__PREVIOUS_RESPONSE__' }
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Helper function to check if the XML string contains other tool tags
+ * @param {string} xmlString - The XML string to check
+ * @param {string[]} validTools - List of valid tool names
+ * @returns {boolean} - True if other tool tags are found
+ */
+function hasOtherToolTags(xmlString, validTools = []) {
+  const defaultTools = ['search', 'query', 'extract', 'listFiles', 'searchFiles', 'implement', 'attempt_completion'];
+  const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
+  
+  // Check for any tool tags other than attempt_complete variants
+  for (const tool of toolsToCheck) {
+    if (tool !== 'attempt_completion' && xmlString.includes(`<${tool}`)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Apply the full thinking tag removal and attempt_complete recovery logic
+ * This replicates the core logic from parseXmlToolCallWithThinking
+ * @param {string} xmlString - The XML string to process
+ * @param {Array<string>} validTools - List of valid tool names
+ * @returns {Object} - Processing result with cleanedXml and potentialRecovery
+ */
+export function processXmlWithThinkingAndRecovery(xmlString, validTools = []) {
+  // Extract thinking content if present (for potential logging or analysis)
+  const thinkingContent = extractThinkingContent(xmlString);
+
+  // Remove thinking tags and their content from the XML string
+  const cleanedXmlString = removeThinkingTags(xmlString);
+
+  // Check for attempt_complete recovery patterns
+  const recoveryResult = checkAttemptCompleteRecovery(cleanedXmlString, validTools);
+
+  // If debugging is enabled, log the thinking content
+  if (process.env.DEBUG === '1' && thinkingContent) {
+    console.log(`[DEBUG] AI Thinking Process:\n${thinkingContent}`);
+  }
+
+  return {
+    cleanedXmlString,
+    thinkingContent,
+    recoveryResult
+  };
+}