@probelabs/probe 0.6.0-rc206 → 0.6.0-rc207

package/build/agent/ProbeAgent.js

@@ -91,6 +91,45 @@ const MAX_TOOL_ITERATIONS = (() => {
 })();
 const MAX_HISTORY_MESSAGES = 100;
 
+/**
+ * Extract tool name from wrapped_tool:toolName format
+ * @param {string} wrappedToolError - Error string in format 'wrapped_tool:toolName'
+ * @returns {string} The extracted tool name or 'unknown' if format is invalid
+ */
+function extractWrappedToolName(wrappedToolError) {
+  if (!wrappedToolError || typeof wrappedToolError !== 'string') {
+    return 'unknown';
+  }
+  const colonIndex = wrappedToolError.indexOf(':');
+  return colonIndex !== -1 ? wrappedToolError.slice(colonIndex + 1) : 'unknown';
+}
+
+/**
+ * Check if an error indicates a wrapped tool format error
+ * @param {string|null} error - Error from detectUnrecognizedToolCall
+ * @returns {boolean} True if it's a wrapped tool error
+ */
+function isWrappedToolError(error) {
+  return error && typeof error === 'string' && error.startsWith('wrapped_tool:');
+}
+
+/**
+ * Create error message for wrapped tool format issues
+ * @param {string} wrappedToolName - The tool name that was incorrectly wrapped
+ * @returns {string} User-friendly error message with correct format instructions
+ */
+function createWrappedToolErrorMessage(wrappedToolName) {
+  return `Your response contained an incorrectly formatted tool call (${wrappedToolName} wrapped in XML tags). This cannot be used.
+
+Please use the CORRECT format:
+
+<${wrappedToolName}>
+Your content here
+</${wrappedToolName}>
+
+Do NOT wrap in other tags like <api_call>, <tool_name>, <function>, etc.`;
+}
+
 // Supported image file extensions (imported from shared config)
 
 // Maximum image file size (20MB) to prevent OOM attacks
@@ -2542,6 +2581,11 @@ Follow these instructions carefully:
         }
       }
 
+      // Circuit breaker for repeated format errors
+      let lastFormatErrorType = null;
+      let sameFormatErrorCount = 0;
+      const MAX_REPEATED_FORMAT_ERRORS = 3;
+
       // Tool iteration loop (only for non-CLI engines like Vercel/Anthropic/OpenAI)
       while (currentIteration < maxIterations && !completionAttempted) {
         currentIteration++;
@@ -2835,7 +2879,28 @@ Follow these instructions carefully:
               );
 
               if (lastAssistantMessage) {
-                finalResult = lastAssistantMessage.content;
+                const prevContent = lastAssistantMessage.content;
+
+                // Check for patterns indicating a failed/wrapped tool call attempt
+                // Use detectUnrecognizedToolCall for consistent detection logic
+                const wrappedToolError = detectUnrecognizedToolCall(prevContent, validTools);
+
+                if (isWrappedToolError(wrappedToolError)) {
+                  // Previous response was a broken tool call attempt - don't reuse it
+                  const wrappedToolName = extractWrappedToolName(wrappedToolError);
+                  if (this.debug) {
+                    console.log(`[DEBUG] Previous response contains wrapped tool '${wrappedToolName}' - rejecting for __PREVIOUS_RESPONSE__`);
+                  }
+                  currentMessages.push({ role: 'assistant', content: assistantResponseContent });
+                  currentMessages.push({
+                    role: 'user',
+                    content: createWrappedToolErrorMessage(wrappedToolName)
+                  });
+                  completionAttempted = false;
+                  continue; // Don't use broken response, continue the loop
+                }
+
+                finalResult = prevContent;
                 if (this.debug) console.log(`[DEBUG] Using previous response as completion: ${finalResult.substring(0, 100)}...`);
               } else {
                 finalResult = 'Error: No previous response found to use as completion.';
@@ -3165,7 +3230,32 @@ Follow these instructions carefully:
           const unrecognizedTool = detectUnrecognizedToolCall(assistantResponseContent, validTools);
 
           let reminderContent;
-          if (unrecognizedTool) {
+          if (isWrappedToolError(unrecognizedTool)) {
+            // AI wrapped a valid tool name in arbitrary XML tags - provide clear format error
+            const wrappedToolName = extractWrappedToolName(unrecognizedTool);
+            if (this.debug) {
+              console.log(`[DEBUG] Detected wrapped tool '${wrappedToolName}' in assistant response - wrong XML format.`);
+            }
+            const toolError = new ParameterError(
+              `Tool '${wrappedToolName}' found but in WRONG FORMAT - do not wrap tools in other XML tags.`,
+              {
+                suggestion: `Use the tool tag DIRECTLY without any wrapper:
+
+CORRECT FORMAT:
+<${wrappedToolName}>
+<param>value</param>
+</${wrappedToolName}>
+
+WRONG (what you did - do not wrap in other tags):
+<api_call><tool_name>${wrappedToolName}</tool_name>...</api_call>
+<function>${wrappedToolName}</function>
+<call name="${wrappedToolName}">...</call>
+
+Remove ALL wrapper tags and use <${wrappedToolName}> directly as the outermost tag.`
+              }
+            );
+            reminderContent = `<tool_result>\n${formatErrorForAI(toolError)}\n</tool_result>`;
+          } else if (unrecognizedTool) {
             // AI tried to use a tool that's not available - provide clear error
             if (this.debug) {
               console.log(`[DEBUG] Detected unrecognized tool '${unrecognizedTool}' in assistant response.`);
@@ -3175,6 +3265,33 @@ Follow these instructions carefully:
             });
             reminderContent = `<tool_result>\n${formatErrorForAI(toolError)}\n</tool_result>`;
           } else {
+            // No tool call detected at all - check if this is the last iteration
+            // On the last iteration, if the AI gave a substantive response without using
+            // attempt_completion, accept it as the final answer rather than losing the content
+            if (currentIteration >= maxIterations) {
+              // Clean up the response - remove thinking tags
+              let cleanedResponse = assistantResponseContent;
+              // Remove <thinking>...</thinking> blocks
+              cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*?<\/thinking>/gi, '').trim();
+              // Also remove unclosed thinking tags
+              cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*$/gi, '').trim();
+
+              // Only use if there's substantial content (not just a failed tool call attempt)
+              const hasSubstantialContent = cleanedResponse.length > 50 &&
+                !cleanedResponse.includes('<api_call>') &&
+                !cleanedResponse.includes('<tool_name>') &&
+                !cleanedResponse.includes('<function>');
+
+              if (hasSubstantialContent) {
+                if (this.debug) {
+                  console.log(`[DEBUG] Max iterations reached - accepting AI response as final answer (${cleanedResponse.length} chars)`);
+                }
+                finalResult = cleanedResponse;
+                completionAttempted = true;
+                break;
+              }
+            }
+
             // Standard reminder - no tool call detected at all
             reminderContent = `Please use one of the available tools to help answer the question, or use attempt_completion if you have enough information to provide a final answer.
 
@@ -3206,6 +3323,31 @@ Note: <attempt_complete></attempt_complete> reuses your PREVIOUS assistant messa
               console.log(`[DEBUG] No tool call detected in assistant response. Prompting for tool use.`);
             }
           }
+
+          // Circuit breaker: track repeated format errors and break early
+          // For wrapped_tool errors, track them as a category (any wrapped_tool counts)
+          // For other errors, track the exact error type
+          if (unrecognizedTool) {
+            const isWrapped = isWrappedToolError(unrecognizedTool);
+            const errorCategory = isWrapped ? 'wrapped_tool' : unrecognizedTool;
+
+            if (errorCategory === lastFormatErrorType) {
+              sameFormatErrorCount++;
+              if (sameFormatErrorCount >= MAX_REPEATED_FORMAT_ERRORS) {
+                const errorDesc = isWrapped ? 'wrapped tool format' : unrecognizedTool;
+                console.error(`[ERROR] Format error category '${errorCategory}' repeated ${sameFormatErrorCount} times. Breaking loop early to prevent infinite iteration.`);
+                finalResult = `Error: Unable to complete request. The AI model repeatedly used incorrect tool call format (${errorDesc}). Please try rephrasing your question or using a different model.`;
+                break;
+              }
+            } else {
+              lastFormatErrorType = errorCategory;
+              sameFormatErrorCount = 1;
+            }
+          } else {
+            // Reset counter if it's a different kind of "no tool call" situation
+            lastFormatErrorType = null;
+            sameFormatErrorCount = 0;
+          }
         }
 
         // Keep message history manageable

package/build/agent/index.js

@@ -9059,6 +9059,22 @@ function detectUnrecognizedToolCall(xmlString, validTools) {
       return toolName;
     }
   }
+  const allToolNames = [.../* @__PURE__ */ new Set([...knownToolNames, ...validTools])];
+  for (const toolName of allToolNames) {
+    const escapedToolName = toolName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const wrapperPatterns = [
+      new RegExp(`<tool_name>\\s*${escapedToolName}\\s*</tool_name>`, "i"),
+      new RegExp(`<function>\\s*${escapedToolName}\\s*</function>`, "i"),
+      new RegExp(`<name>\\s*${escapedToolName}\\s*</name>`, "i"),
+      // Also check for tool name immediately after api_call or call opening tag
+      new RegExp(`<(?:api_call|call)[^>]*>[\\s\\S]*?<tool_name>\\s*${escapedToolName}`, "i")
+    ];
+    for (const pattern of wrapperPatterns) {
+      if (pattern.test(xmlString)) {
+        return `wrapped_tool:${toolName}`;
+      }
+    }
+  }
   return null;
 }
 function parseTargets(targets) {
@@ -68676,6 +68692,27 @@ import { EventEmitter as EventEmitter5 } from "events";
 import { existsSync as existsSync6 } from "fs";
 import { readFile as readFile3, stat, readdir as readdir3 } from "fs/promises";
 import { resolve as resolve6, isAbsolute as isAbsolute5, dirname as dirname5, basename, normalize as normalize2, sep as sep5 } from "path";
+function extractWrappedToolName(wrappedToolError) {
+  if (!wrappedToolError || typeof wrappedToolError !== "string") {
+    return "unknown";
+  }
+  const colonIndex = wrappedToolError.indexOf(":");
+  return colonIndex !== -1 ? wrappedToolError.slice(colonIndex + 1) : "unknown";
+}
+function isWrappedToolError(error) {
+  return error && typeof error === "string" && error.startsWith("wrapped_tool:");
+}
+function createWrappedToolErrorMessage(wrappedToolName) {
+  return `Your response contained an incorrectly formatted tool call (${wrappedToolName} wrapped in XML tags). This cannot be used.
+
+Please use the CORRECT format:
+
+<${wrappedToolName}>
+Your content here
+</${wrappedToolName}>
+
+Do NOT wrap in other tags like <api_call>, <tool_name>, <function>, etc.`;
+}
 var MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
@@ -70675,6 +70712,9 @@ You are working with a repository located at: ${searchDirectory}
               console.log(`[DEBUG] Schema provided, using extended iteration limit: ${maxIterations} (base: ${baseMaxIterations})`);
             }
           }
+          let lastFormatErrorType = null;
+          let sameFormatErrorCount = 0;
+          const MAX_REPEATED_FORMAT_ERRORS = 3;
           while (currentIteration < maxIterations && !completionAttempted) {
             currentIteration++;
             if (this.cancelled) throw new Error("Request was cancelled by the user");
@@ -70873,7 +70913,22 @@ You are working with a repository located at: ${searchDirectory}
                     (msg) => msg.role === "assistant" && msg.content && !(this.mcpBridge ? parseHybridXmlToolCall(msg.content, validTools, this.mcpBridge) : parseXmlToolCallWithThinking(msg.content, validTools))
                   );
                   if (lastAssistantMessage) {
-                    finalResult = lastAssistantMessage.content;
+                    const prevContent = lastAssistantMessage.content;
+                    const wrappedToolError = detectUnrecognizedToolCall(prevContent, validTools);
+                    if (isWrappedToolError(wrappedToolError)) {
+                      const wrappedToolName = extractWrappedToolName(wrappedToolError);
+                      if (this.debug) {
+                        console.log(`[DEBUG] Previous response contains wrapped tool '${wrappedToolName}' - rejecting for __PREVIOUS_RESPONSE__`);
+                      }
+                      currentMessages.push({ role: "assistant", content: assistantResponseContent });
+                      currentMessages.push({
+                        role: "user",
+                        content: createWrappedToolErrorMessage(wrappedToolName)
+                      });
+                      completionAttempted = false;
+                      continue;
+                    }
+                    finalResult = prevContent;
                     if (this.debug) console.log(`[DEBUG] Using previous response as completion: ${finalResult.substring(0, 100)}...`);
                   } else {
                     finalResult = "Error: No previous response found to use as completion.";
@@ -71144,7 +71199,33 @@ ${errorXml}
               currentMessages.push({ role: "assistant", content: assistantResponseContent });
               const unrecognizedTool = detectUnrecognizedToolCall(assistantResponseContent, validTools);
               let reminderContent;
-              if (unrecognizedTool) {
+              if (isWrappedToolError(unrecognizedTool)) {
+                const wrappedToolName = extractWrappedToolName(unrecognizedTool);
+                if (this.debug) {
+                  console.log(`[DEBUG] Detected wrapped tool '${wrappedToolName}' in assistant response - wrong XML format.`);
+                }
+                const toolError = new ParameterError(
+                  `Tool '${wrappedToolName}' found but in WRONG FORMAT - do not wrap tools in other XML tags.`,
+                  {
+                    suggestion: `Use the tool tag DIRECTLY without any wrapper:
+
+CORRECT FORMAT:
+<${wrappedToolName}>
+<param>value</param>
+</${wrappedToolName}>
+
+WRONG (what you did - do not wrap in other tags):
+<api_call><tool_name>${wrappedToolName}</tool_name>...</api_call>
+<function>${wrappedToolName}</function>
+<call name="${wrappedToolName}">...</call>
+
+Remove ALL wrapper tags and use <${wrappedToolName}> directly as the outermost tag.`
+                  }
+                );
+                reminderContent = `<tool_result>
+${formatErrorForAI(toolError)}
+</tool_result>`;
+              } else if (unrecognizedTool) {
                 if (this.debug) {
                   console.log(`[DEBUG] Detected unrecognized tool '${unrecognizedTool}' in assistant response.`);
                 }
@@ -71155,6 +71236,20 @@ ${errorXml}
 ${formatErrorForAI(toolError)}
 </tool_result>`;
               } else {
+                if (currentIteration >= maxIterations) {
+                  let cleanedResponse = assistantResponseContent;
+                  cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*?<\/thinking>/gi, "").trim();
+                  cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*$/gi, "").trim();
+                  const hasSubstantialContent = cleanedResponse.length > 50 && !cleanedResponse.includes("<api_call>") && !cleanedResponse.includes("<tool_name>") && !cleanedResponse.includes("<function>");
+                  if (hasSubstantialContent) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] Max iterations reached - accepting AI response as final answer (${cleanedResponse.length} chars)`);
+                    }
+                    finalResult = cleanedResponse;
+                    completionAttempted = true;
+                    break;
+                  }
+                }
                 reminderContent = `Please use one of the available tools to help answer the question, or use attempt_completion if you have enough information to provide a final answer.
 
 Remember: Use proper XML format with BOTH opening and closing tags:
@@ -71184,6 +71279,25 @@ Note: <attempt_complete></attempt_complete> reuses your PREVIOUS assistant messa
                   console.log(`[DEBUG] No tool call detected in assistant response. Prompting for tool use.`);
                 }
               }
+              if (unrecognizedTool) {
+                const isWrapped = isWrappedToolError(unrecognizedTool);
+                const errorCategory = isWrapped ? "wrapped_tool" : unrecognizedTool;
+                if (errorCategory === lastFormatErrorType) {
+                  sameFormatErrorCount++;
+                  if (sameFormatErrorCount >= MAX_REPEATED_FORMAT_ERRORS) {
+                    const errorDesc = isWrapped ? "wrapped tool format" : unrecognizedTool;
+                    console.error(`[ERROR] Format error category '${errorCategory}' repeated ${sameFormatErrorCount} times. Breaking loop early to prevent infinite iteration.`);
+                    finalResult = `Error: Unable to complete request. The AI model repeatedly used incorrect tool call format (${errorDesc}). Please try rephrasing your question or using a different model.`;
+                    break;
+                  }
+                } else {
+                  lastFormatErrorType = errorCategory;
+                  sameFormatErrorCount = 1;
+                }
+              } else {
+                lastFormatErrorType = null;
+                sameFormatErrorCount = 0;
+              }
             }
             if (currentMessages.length > MAX_HISTORY_MESSAGES) {
               const messagesBefore = currentMessages.length;

package/build/tools/common.js

@@ -617,6 +617,37 @@ export function detectUnrecognizedToolCall(xmlString, validTools) {
 		}
 	}
 
+	// Check if any valid tool name appears inside specific wrapper patterns
+	// This catches cases where AI wraps tools in arbitrary tags like:
+	// <api_call><tool_name>attempt_completion</tool_name>...</api_call>
+	// <function>search</function>
+	// <call name="extract">...</call>
+	// Only match specific wrapper patterns to avoid false positives with normal text
+	const allToolNames = [...new Set([...knownToolNames, ...validTools])];
+	for (const toolName of allToolNames) {
+		// Escape regex metacharacters in tool name to prevent regex errors
+		const escapedToolName = toolName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+		// Match specific wrapper patterns that indicate a tool call attempt:
+		// 1. <tool_name>toolName</tool_name> - common Claude API-style wrapper
+		// 2. <function>toolName</function> - function call style
+		// 3. <name>toolName</name> - generic name wrapper
+		// 4. <call><name>toolName - partial wrapper patterns
+		const wrapperPatterns = [
+			new RegExp(`<tool_name>\\s*${escapedToolName}\\s*</tool_name>`, 'i'),
+			new RegExp(`<function>\\s*${escapedToolName}\\s*</function>`, 'i'),
+			new RegExp(`<name>\\s*${escapedToolName}\\s*</name>`, 'i'),
+			// Also check for tool name immediately after api_call or call opening tag
+			new RegExp(`<(?:api_call|call)[^>]*>[\\s\\S]*?<tool_name>\\s*${escapedToolName}`, 'i')
+		];
+
+		for (const pattern of wrapperPatterns) {
+			if (pattern.test(xmlString)) {
+				return `wrapped_tool:${toolName}`;
+			}
+		}
+	}
+
 	return null;
 }
 

package/cjs/agent/ProbeAgent.cjs

@@ -36006,6 +36006,22 @@ function detectUnrecognizedToolCall(xmlString, validTools) {
       return toolName;
     }
   }
+  const allToolNames = [.../* @__PURE__ */ new Set([...knownToolNames, ...validTools])];
+  for (const toolName of allToolNames) {
+    const escapedToolName = toolName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const wrapperPatterns = [
+      new RegExp(`<tool_name>\\s*${escapedToolName}\\s*</tool_name>`, "i"),
+      new RegExp(`<function>\\s*${escapedToolName}\\s*</function>`, "i"),
+      new RegExp(`<name>\\s*${escapedToolName}\\s*</name>`, "i"),
+      // Also check for tool name immediately after api_call or call opening tag
+      new RegExp(`<(?:api_call|call)[^>]*>[\\s\\S]*?<tool_name>\\s*${escapedToolName}`, "i")
+    ];
+    for (const pattern of wrapperPatterns) {
+      if (pattern.test(xmlString)) {
+        return `wrapped_tool:${toolName}`;
+      }
+    }
+  }
   return null;
 }
 function parseTargets(targets) {
@@ -95379,6 +95395,27 @@ __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
 module.exports = __toCommonJS(ProbeAgent_exports);
+function extractWrappedToolName(wrappedToolError) {
+  if (!wrappedToolError || typeof wrappedToolError !== "string") {
+    return "unknown";
+  }
+  const colonIndex = wrappedToolError.indexOf(":");
+  return colonIndex !== -1 ? wrappedToolError.slice(colonIndex + 1) : "unknown";
+}
+function isWrappedToolError(error2) {
+  return error2 && typeof error2 === "string" && error2.startsWith("wrapped_tool:");
+}
+function createWrappedToolErrorMessage(wrappedToolName) {
+  return `Your response contained an incorrectly formatted tool call (${wrappedToolName} wrapped in XML tags). This cannot be used.
+
+Please use the CORRECT format:
+
+<${wrappedToolName}>
+Your content here
+</${wrappedToolName}>
+
+Do NOT wrap in other tags like <api_call>, <tool_name>, <function>, etc.`;
+}
 var import_dotenv2, import_anthropic2, import_openai2, import_google2, import_ai5, import_crypto9, import_events4, import_fs14, import_promises6, import_path17, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
@@ -97388,6 +97425,9 @@ You are working with a repository located at: ${searchDirectory}
               console.log(`[DEBUG] Schema provided, using extended iteration limit: ${maxIterations} (base: ${baseMaxIterations})`);
             }
           }
+          let lastFormatErrorType = null;
+          let sameFormatErrorCount = 0;
+          const MAX_REPEATED_FORMAT_ERRORS = 3;
           while (currentIteration < maxIterations && !completionAttempted) {
             currentIteration++;
             if (this.cancelled) throw new Error("Request was cancelled by the user");
@@ -97586,7 +97626,22 @@ You are working with a repository located at: ${searchDirectory}
                     (msg) => msg.role === "assistant" && msg.content && !(this.mcpBridge ? parseHybridXmlToolCall(msg.content, validTools, this.mcpBridge) : parseXmlToolCallWithThinking(msg.content, validTools))
                   );
                   if (lastAssistantMessage) {
-                    finalResult = lastAssistantMessage.content;
+                    const prevContent = lastAssistantMessage.content;
+                    const wrappedToolError = detectUnrecognizedToolCall(prevContent, validTools);
+                    if (isWrappedToolError(wrappedToolError)) {
+                      const wrappedToolName = extractWrappedToolName(wrappedToolError);
+                      if (this.debug) {
+                        console.log(`[DEBUG] Previous response contains wrapped tool '${wrappedToolName}' - rejecting for __PREVIOUS_RESPONSE__`);
+                      }
+                      currentMessages.push({ role: "assistant", content: assistantResponseContent });
+                      currentMessages.push({
+                        role: "user",
+                        content: createWrappedToolErrorMessage(wrappedToolName)
+                      });
+                      completionAttempted = false;
+                      continue;
+                    }
+                    finalResult = prevContent;
                     if (this.debug) console.log(`[DEBUG] Using previous response as completion: ${finalResult.substring(0, 100)}...`);
                   } else {
                     finalResult = "Error: No previous response found to use as completion.";
@@ -97857,7 +97912,33 @@ ${errorXml}
               currentMessages.push({ role: "assistant", content: assistantResponseContent });
               const unrecognizedTool = detectUnrecognizedToolCall(assistantResponseContent, validTools);
               let reminderContent;
-              if (unrecognizedTool) {
+              if (isWrappedToolError(unrecognizedTool)) {
+                const wrappedToolName = extractWrappedToolName(unrecognizedTool);
+                if (this.debug) {
+                  console.log(`[DEBUG] Detected wrapped tool '${wrappedToolName}' in assistant response - wrong XML format.`);
+                }
+                const toolError = new ParameterError(
+                  `Tool '${wrappedToolName}' found but in WRONG FORMAT - do not wrap tools in other XML tags.`,
+                  {
+                    suggestion: `Use the tool tag DIRECTLY without any wrapper:
+
+CORRECT FORMAT:
+<${wrappedToolName}>
+<param>value</param>
+</${wrappedToolName}>
+
+WRONG (what you did - do not wrap in other tags):
+<api_call><tool_name>${wrappedToolName}</tool_name>...</api_call>
+<function>${wrappedToolName}</function>
+<call name="${wrappedToolName}">...</call>
+
+Remove ALL wrapper tags and use <${wrappedToolName}> directly as the outermost tag.`
+                  }
+                );
+                reminderContent = `<tool_result>
+${formatErrorForAI(toolError)}
+</tool_result>`;
+              } else if (unrecognizedTool) {
                 if (this.debug) {
                   console.log(`[DEBUG] Detected unrecognized tool '${unrecognizedTool}' in assistant response.`);
                 }
@@ -97868,6 +97949,20 @@ ${errorXml}
 ${formatErrorForAI(toolError)}
 </tool_result>`;
               } else {
+                if (currentIteration >= maxIterations) {
+                  let cleanedResponse = assistantResponseContent;
+                  cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*?<\/thinking>/gi, "").trim();
+                  cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*$/gi, "").trim();
+                  const hasSubstantialContent = cleanedResponse.length > 50 && !cleanedResponse.includes("<api_call>") && !cleanedResponse.includes("<tool_name>") && !cleanedResponse.includes("<function>");
+                  if (hasSubstantialContent) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] Max iterations reached - accepting AI response as final answer (${cleanedResponse.length} chars)`);
+                    }
+                    finalResult = cleanedResponse;
+                    completionAttempted = true;
+                    break;
+                  }
+                }
                 reminderContent = `Please use one of the available tools to help answer the question, or use attempt_completion if you have enough information to provide a final answer.
 
 Remember: Use proper XML format with BOTH opening and closing tags:
@@ -97897,6 +97992,25 @@ Note: <attempt_complete></attempt_complete> reuses your PREVIOUS assistant messa
                   console.log(`[DEBUG] No tool call detected in assistant response. Prompting for tool use.`);
                 }
               }
+              if (unrecognizedTool) {
+                const isWrapped = isWrappedToolError(unrecognizedTool);
+                const errorCategory = isWrapped ? "wrapped_tool" : unrecognizedTool;
+                if (errorCategory === lastFormatErrorType) {
+                  sameFormatErrorCount++;
+                  if (sameFormatErrorCount >= MAX_REPEATED_FORMAT_ERRORS) {
+                    const errorDesc = isWrapped ? "wrapped tool format" : unrecognizedTool;
+                    console.error(`[ERROR] Format error category '${errorCategory}' repeated ${sameFormatErrorCount} times. Breaking loop early to prevent infinite iteration.`);
+                    finalResult = `Error: Unable to complete request. The AI model repeatedly used incorrect tool call format (${errorDesc}). Please try rephrasing your question or using a different model.`;
+                    break;
+                  }
+                } else {
+                  lastFormatErrorType = errorCategory;
+                  sameFormatErrorCount = 1;
+                }
+              } else {
+                lastFormatErrorType = null;
+                sameFormatErrorCount = 0;
+              }
             }
             if (currentMessages.length > MAX_HISTORY_MESSAGES) {
               const messagesBefore = currentMessages.length;

package/cjs/index.cjs

@@ -35787,6 +35787,22 @@ function detectUnrecognizedToolCall(xmlString, validTools) {
       return toolName;
     }
   }
+  const allToolNames = [.../* @__PURE__ */ new Set([...knownToolNames, ...validTools])];
+  for (const toolName of allToolNames) {
+    const escapedToolName = toolName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const wrapperPatterns = [
+      new RegExp(`<tool_name>\\s*${escapedToolName}\\s*</tool_name>`, "i"),
+      new RegExp(`<function>\\s*${escapedToolName}\\s*</function>`, "i"),
+      new RegExp(`<name>\\s*${escapedToolName}\\s*</name>`, "i"),
+      // Also check for tool name immediately after api_call or call opening tag
+      new RegExp(`<(?:api_call|call)[^>]*>[\\s\\S]*?<tool_name>\\s*${escapedToolName}`, "i")
+    ];
+    for (const pattern of wrapperPatterns) {
+      if (pattern.test(xmlString)) {
+        return `wrapped_tool:${toolName}`;
+      }
+    }
+  }
   return null;
 }
 function parseTargets(targets) {
@@ -93061,6 +93077,27 @@ var ProbeAgent_exports = {};
 __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
+function extractWrappedToolName(wrappedToolError) {
+  if (!wrappedToolError || typeof wrappedToolError !== "string") {
+    return "unknown";
+  }
+  const colonIndex = wrappedToolError.indexOf(":");
+  return colonIndex !== -1 ? wrappedToolError.slice(colonIndex + 1) : "unknown";
+}
+function isWrappedToolError(error2) {
+  return error2 && typeof error2 === "string" && error2.startsWith("wrapped_tool:");
+}
+function createWrappedToolErrorMessage(wrappedToolName) {
+  return `Your response contained an incorrectly formatted tool call (${wrappedToolName} wrapped in XML tags). This cannot be used.
+
+Please use the CORRECT format:
+
+<${wrappedToolName}>
+Your content here
+</${wrappedToolName}>
+
+Do NOT wrap in other tags like <api_call>, <tool_name>, <function>, etc.`;
+}
 var import_dotenv, import_anthropic2, import_openai2, import_google2, import_ai3, import_crypto8, import_events4, import_fs11, import_promises6, import_path13, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
@@ -95071,6 +95108,9 @@ You are working with a repository located at: ${searchDirectory}
               console.log(`[DEBUG] Schema provided, using extended iteration limit: ${maxIterations} (base: ${baseMaxIterations})`);
             }
           }
+          let lastFormatErrorType = null;
+          let sameFormatErrorCount = 0;
+          const MAX_REPEATED_FORMAT_ERRORS = 3;
           while (currentIteration < maxIterations && !completionAttempted) {
             currentIteration++;
             if (this.cancelled) throw new Error("Request was cancelled by the user");
@@ -95269,7 +95309,22 @@ You are working with a repository located at: ${searchDirectory}
                     (msg) => msg.role === "assistant" && msg.content && !(this.mcpBridge ? parseHybridXmlToolCall(msg.content, validTools, this.mcpBridge) : parseXmlToolCallWithThinking(msg.content, validTools))
                   );
                   if (lastAssistantMessage) {
-                    finalResult = lastAssistantMessage.content;
+                    const prevContent = lastAssistantMessage.content;
+                    const wrappedToolError = detectUnrecognizedToolCall(prevContent, validTools);
+                    if (isWrappedToolError(wrappedToolError)) {
+                      const wrappedToolName = extractWrappedToolName(wrappedToolError);
+                      if (this.debug) {
+                        console.log(`[DEBUG] Previous response contains wrapped tool '${wrappedToolName}' - rejecting for __PREVIOUS_RESPONSE__`);
+                      }
+                      currentMessages.push({ role: "assistant", content: assistantResponseContent });
+                      currentMessages.push({
+                        role: "user",
+                        content: createWrappedToolErrorMessage(wrappedToolName)
+                      });
+                      completionAttempted = false;
+                      continue;
+                    }
+                    finalResult = prevContent;
                     if (this.debug) console.log(`[DEBUG] Using previous response as completion: ${finalResult.substring(0, 100)}...`);
                   } else {
                     finalResult = "Error: No previous response found to use as completion.";
@@ -95540,7 +95595,33 @@ ${errorXml}
               currentMessages.push({ role: "assistant", content: assistantResponseContent });
               const unrecognizedTool = detectUnrecognizedToolCall(assistantResponseContent, validTools);
               let reminderContent;
-              if (unrecognizedTool) {
+              if (isWrappedToolError(unrecognizedTool)) {
+                const wrappedToolName = extractWrappedToolName(unrecognizedTool);
+                if (this.debug) {
+                  console.log(`[DEBUG] Detected wrapped tool '${wrappedToolName}' in assistant response - wrong XML format.`);
+                }
+                const toolError = new ParameterError(
+                  `Tool '${wrappedToolName}' found but in WRONG FORMAT - do not wrap tools in other XML tags.`,
+                  {
+                    suggestion: `Use the tool tag DIRECTLY without any wrapper:
+
+CORRECT FORMAT:
+<${wrappedToolName}>
+<param>value</param>
+</${wrappedToolName}>
+
+WRONG (what you did - do not wrap in other tags):
+<api_call><tool_name>${wrappedToolName}</tool_name>...</api_call>
+<function>${wrappedToolName}</function>
+<call name="${wrappedToolName}">...</call>
+
+Remove ALL wrapper tags and use <${wrappedToolName}> directly as the outermost tag.`
+                  }
+                );
+                reminderContent = `<tool_result>
+${formatErrorForAI(toolError)}
+</tool_result>`;
+              } else if (unrecognizedTool) {
                 if (this.debug) {
                   console.log(`[DEBUG] Detected unrecognized tool '${unrecognizedTool}' in assistant response.`);
                 }
@@ -95551,6 +95632,20 @@ ${errorXml}
 ${formatErrorForAI(toolError)}
 </tool_result>`;
               } else {
+                if (currentIteration >= maxIterations) {
+                  let cleanedResponse = assistantResponseContent;
+                  cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*?<\/thinking>/gi, "").trim();
+                  cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*$/gi, "").trim();
+                  const hasSubstantialContent = cleanedResponse.length > 50 && !cleanedResponse.includes("<api_call>") && !cleanedResponse.includes("<tool_name>") && !cleanedResponse.includes("<function>");
+                  if (hasSubstantialContent) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] Max iterations reached - accepting AI response as final answer (${cleanedResponse.length} chars)`);
+                    }
+                    finalResult = cleanedResponse;
+                    completionAttempted = true;
+                    break;
+                  }
+                }
                 reminderContent = `Please use one of the available tools to help answer the question, or use attempt_completion if you have enough information to provide a final answer.
 
 Remember: Use proper XML format with BOTH opening and closing tags:
@@ -95580,6 +95675,25 @@ Note: <attempt_complete></attempt_complete> reuses your PREVIOUS assistant messa
                   console.log(`[DEBUG] No tool call detected in assistant response. Prompting for tool use.`);
                 }
               }
+              if (unrecognizedTool) {
+                const isWrapped = isWrappedToolError(unrecognizedTool);
+                const errorCategory = isWrapped ? "wrapped_tool" : unrecognizedTool;
+                if (errorCategory === lastFormatErrorType) {
+                  sameFormatErrorCount++;
+                  if (sameFormatErrorCount >= MAX_REPEATED_FORMAT_ERRORS) {
+                    const errorDesc = isWrapped ? "wrapped tool format" : unrecognizedTool;
+                    console.error(`[ERROR] Format error category '${errorCategory}' repeated ${sameFormatErrorCount} times. Breaking loop early to prevent infinite iteration.`);
+                    finalResult = `Error: Unable to complete request. The AI model repeatedly used incorrect tool call format (${errorDesc}). Please try rephrasing your question or using a different model.`;
+                    break;
+                  }
+                } else {
+                  lastFormatErrorType = errorCategory;
+                  sameFormatErrorCount = 1;
+                }
+              } else {
+                lastFormatErrorType = null;
+                sameFormatErrorCount = 0;
+              }
             }
             if (currentMessages.length > MAX_HISTORY_MESSAGES) {
               const messagesBefore = currentMessages.length;

package/package.json

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

package/src/agent/ProbeAgent.js

@@ -91,6 +91,45 @@ const MAX_TOOL_ITERATIONS = (() => {
 })();
 const MAX_HISTORY_MESSAGES = 100;
 
+/**
+ * Extract tool name from wrapped_tool:toolName format
+ * @param {string} wrappedToolError - Error string in format 'wrapped_tool:toolName'
+ * @returns {string} The extracted tool name or 'unknown' if format is invalid
+ */
+function extractWrappedToolName(wrappedToolError) {
+  if (!wrappedToolError || typeof wrappedToolError !== 'string') {
+    return 'unknown';
+  }
+  const colonIndex = wrappedToolError.indexOf(':');
+  return colonIndex !== -1 ? wrappedToolError.slice(colonIndex + 1) : 'unknown';
+}
+
+/**
+ * Check if an error indicates a wrapped tool format error
+ * @param {string|null} error - Error from detectUnrecognizedToolCall
+ * @returns {boolean} True if it's a wrapped tool error
+ */
+function isWrappedToolError(error) {
+  return error && typeof error === 'string' && error.startsWith('wrapped_tool:');
+}
+
+/**
+ * Create error message for wrapped tool format issues
+ * @param {string} wrappedToolName - The tool name that was incorrectly wrapped
+ * @returns {string} User-friendly error message with correct format instructions
+ */
+function createWrappedToolErrorMessage(wrappedToolName) {
+  return `Your response contained an incorrectly formatted tool call (${wrappedToolName} wrapped in XML tags). This cannot be used.
+
+Please use the CORRECT format:
+
+<${wrappedToolName}>
+Your content here
+</${wrappedToolName}>
+
+Do NOT wrap in other tags like <api_call>, <tool_name>, <function>, etc.`;
+}
+
 // Supported image file extensions (imported from shared config)
 
 // Maximum image file size (20MB) to prevent OOM attacks
@@ -2542,6 +2581,11 @@ Follow these instructions carefully:
         }
       }
 
+      // Circuit breaker for repeated format errors
+      let lastFormatErrorType = null;
+      let sameFormatErrorCount = 0;
+      const MAX_REPEATED_FORMAT_ERRORS = 3;
+
       // Tool iteration loop (only for non-CLI engines like Vercel/Anthropic/OpenAI)
       while (currentIteration < maxIterations && !completionAttempted) {
         currentIteration++;
@@ -2835,7 +2879,28 @@ Follow these instructions carefully:
               );
 
               if (lastAssistantMessage) {
-                finalResult = lastAssistantMessage.content;
+                const prevContent = lastAssistantMessage.content;
+
+                // Check for patterns indicating a failed/wrapped tool call attempt
+                // Use detectUnrecognizedToolCall for consistent detection logic
+                const wrappedToolError = detectUnrecognizedToolCall(prevContent, validTools);
+
+                if (isWrappedToolError(wrappedToolError)) {
+                  // Previous response was a broken tool call attempt - don't reuse it
+                  const wrappedToolName = extractWrappedToolName(wrappedToolError);
+                  if (this.debug) {
+                    console.log(`[DEBUG] Previous response contains wrapped tool '${wrappedToolName}' - rejecting for __PREVIOUS_RESPONSE__`);
+                  }
+                  currentMessages.push({ role: 'assistant', content: assistantResponseContent });
+                  currentMessages.push({
+                    role: 'user',
+                    content: createWrappedToolErrorMessage(wrappedToolName)
+                  });
+                  completionAttempted = false;
+                  continue; // Don't use broken response, continue the loop
+                }
+
+                finalResult = prevContent;
                 if (this.debug) console.log(`[DEBUG] Using previous response as completion: ${finalResult.substring(0, 100)}...`);
               } else {
                 finalResult = 'Error: No previous response found to use as completion.';
@@ -3165,7 +3230,32 @@ Follow these instructions carefully:
           const unrecognizedTool = detectUnrecognizedToolCall(assistantResponseContent, validTools);
 
           let reminderContent;
-          if (unrecognizedTool) {
+          if (isWrappedToolError(unrecognizedTool)) {
+            // AI wrapped a valid tool name in arbitrary XML tags - provide clear format error
+            const wrappedToolName = extractWrappedToolName(unrecognizedTool);
+            if (this.debug) {
+              console.log(`[DEBUG] Detected wrapped tool '${wrappedToolName}' in assistant response - wrong XML format.`);
+            }
+            const toolError = new ParameterError(
+              `Tool '${wrappedToolName}' found but in WRONG FORMAT - do not wrap tools in other XML tags.`,
+              {
+                suggestion: `Use the tool tag DIRECTLY without any wrapper:
+
+CORRECT FORMAT:
+<${wrappedToolName}>
+<param>value</param>
+</${wrappedToolName}>
+
+WRONG (what you did - do not wrap in other tags):
+<api_call><tool_name>${wrappedToolName}</tool_name>...</api_call>
+<function>${wrappedToolName}</function>
+<call name="${wrappedToolName}">...</call>
+
+Remove ALL wrapper tags and use <${wrappedToolName}> directly as the outermost tag.`
+              }
+            );
+            reminderContent = `<tool_result>\n${formatErrorForAI(toolError)}\n</tool_result>`;
+          } else if (unrecognizedTool) {
             // AI tried to use a tool that's not available - provide clear error
             if (this.debug) {
               console.log(`[DEBUG] Detected unrecognized tool '${unrecognizedTool}' in assistant response.`);
@@ -3175,6 +3265,33 @@ Follow these instructions carefully:
             });
             reminderContent = `<tool_result>\n${formatErrorForAI(toolError)}\n</tool_result>`;
           } else {
+            // No tool call detected at all - check if this is the last iteration
+            // On the last iteration, if the AI gave a substantive response without using
+            // attempt_completion, accept it as the final answer rather than losing the content
+            if (currentIteration >= maxIterations) {
+              // Clean up the response - remove thinking tags
+              let cleanedResponse = assistantResponseContent;
+              // Remove <thinking>...</thinking> blocks
+              cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*?<\/thinking>/gi, '').trim();
+              // Also remove unclosed thinking tags
+              cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*$/gi, '').trim();
+
+              // Only use if there's substantial content (not just a failed tool call attempt)
+              const hasSubstantialContent = cleanedResponse.length > 50 &&
+                !cleanedResponse.includes('<api_call>') &&
+                !cleanedResponse.includes('<tool_name>') &&
+                !cleanedResponse.includes('<function>');
+
+              if (hasSubstantialContent) {
+                if (this.debug) {
+                  console.log(`[DEBUG] Max iterations reached - accepting AI response as final answer (${cleanedResponse.length} chars)`);
+                }
+                finalResult = cleanedResponse;
+                completionAttempted = true;
+                break;
+              }
+            }
+
             // Standard reminder - no tool call detected at all
             reminderContent = `Please use one of the available tools to help answer the question, or use attempt_completion if you have enough information to provide a final answer.
 
@@ -3206,6 +3323,31 @@ Note: <attempt_complete></attempt_complete> reuses your PREVIOUS assistant messa
               console.log(`[DEBUG] No tool call detected in assistant response. Prompting for tool use.`);
             }
           }
+
+          // Circuit breaker: track repeated format errors and break early
+          // For wrapped_tool errors, track them as a category (any wrapped_tool counts)
+          // For other errors, track the exact error type
+          if (unrecognizedTool) {
+            const isWrapped = isWrappedToolError(unrecognizedTool);
+            const errorCategory = isWrapped ? 'wrapped_tool' : unrecognizedTool;
+
+            if (errorCategory === lastFormatErrorType) {
+              sameFormatErrorCount++;
+              if (sameFormatErrorCount >= MAX_REPEATED_FORMAT_ERRORS) {
+                const errorDesc = isWrapped ? 'wrapped tool format' : unrecognizedTool;
+                console.error(`[ERROR] Format error category '${errorCategory}' repeated ${sameFormatErrorCount} times. Breaking loop early to prevent infinite iteration.`);
+                finalResult = `Error: Unable to complete request. The AI model repeatedly used incorrect tool call format (${errorDesc}). Please try rephrasing your question or using a different model.`;
+                break;
+              }
+            } else {
+              lastFormatErrorType = errorCategory;
+              sameFormatErrorCount = 1;
+            }
+          } else {
+            // Reset counter if it's a different kind of "no tool call" situation
+            lastFormatErrorType = null;
+            sameFormatErrorCount = 0;
+          }
         }
 
         // Keep message history manageable

package/src/tools/common.js

@@ -617,6 +617,37 @@ export function detectUnrecognizedToolCall(xmlString, validTools) {
 		}
 	}
 
+	// Check if any valid tool name appears inside specific wrapper patterns
+	// This catches cases where AI wraps tools in arbitrary tags like:
+	// <api_call><tool_name>attempt_completion</tool_name>...</api_call>
+	// <function>search</function>
+	// <call name="extract">...</call>
+	// Only match specific wrapper patterns to avoid false positives with normal text
+	const allToolNames = [...new Set([...knownToolNames, ...validTools])];
+	for (const toolName of allToolNames) {
+		// Escape regex metacharacters in tool name to prevent regex errors
+		const escapedToolName = toolName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+		// Match specific wrapper patterns that indicate a tool call attempt:
+		// 1. <tool_name>toolName</tool_name> - common Claude API-style wrapper
+		// 2. <function>toolName</function> - function call style
+		// 3. <name>toolName</name> - generic name wrapper
+		// 4. <call><name>toolName - partial wrapper patterns
+		const wrapperPatterns = [
+			new RegExp(`<tool_name>\\s*${escapedToolName}\\s*</tool_name>`, 'i'),
+			new RegExp(`<function>\\s*${escapedToolName}\\s*</function>`, 'i'),
+			new RegExp(`<name>\\s*${escapedToolName}\\s*</name>`, 'i'),
+			// Also check for tool name immediately after api_call or call opening tag
+			new RegExp(`<(?:api_call|call)[^>]*>[\\s\\S]*?<tool_name>\\s*${escapedToolName}`, 'i')
+		];
+
+		for (const pattern of wrapperPatterns) {
+			if (pattern.test(xmlString)) {
+				return `wrapped_tool:${toolName}`;
+			}
+		}
+	}
+
 	return null;
 }