@probelabs/probe 0.6.0-rc205 → 0.6.0-rc207

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) {
@@ -9718,10 +9734,10 @@ var init_vercel = __esm({
             let extractOptions = { cwd: effectiveCwd };
             if (input_content) {
               const { writeFileSync: writeFileSync2, unlinkSync } = await import("fs");
-              const { join: join4 } = await import("path");
-              const { tmpdir } = await import("os");
-              const { randomUUID: randomUUID8 } = await import("crypto");
-              tempFilePath = join4(tmpdir(), `probe-extract-${randomUUID8()}.txt`);
+              const { join: join5 } = await import("path");
+              const { tmpdir: tmpdir2 } = await import("os");
+              const { randomUUID: randomUUID9 } = await import("crypto");
+              tempFilePath = join5(tmpdir2(), `probe-extract-${randomUUID9()}.txt`);
               writeFileSync2(tempFilePath, input_content);
               if (debug) {
                 console.error(`Created temporary file for input content: ${tempFilePath}`);
@@ -67117,10 +67133,88 @@ var init_contextCompactor = __esm({
   }
 });
 
+// src/agent/outputTruncator.js
+import { writeFile, mkdir } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+function validateTokenLimit(value) {
+  const num = Number(value);
+  if (isNaN(num) || num <= 0) {
+    return DEFAULT_MAX_OUTPUT_TOKENS;
+  }
+  return num;
+}
+function getMaxOutputTokens(constructorValue) {
+  if (constructorValue !== void 0 && constructorValue !== null) {
+    const validated = validateTokenLimit(constructorValue);
+    if (validated !== DEFAULT_MAX_OUTPUT_TOKENS || Number(constructorValue) === DEFAULT_MAX_OUTPUT_TOKENS) {
+      return validated;
+    }
+  }
+  if (process.env.PROBE_MAX_OUTPUT_TOKENS) {
+    return validateTokenLimit(process.env.PROBE_MAX_OUTPUT_TOKENS);
+  }
+  return DEFAULT_MAX_OUTPUT_TOKENS;
+}
+async function truncateIfNeeded(content, tokenCounter, sessionId, maxTokens) {
+  const limit = validateTokenLimit(maxTokens);
+  const tokenCount = tokenCounter.countTokens(content);
+  if (tokenCount <= limit) {
+    return { truncated: false, content };
+  }
+  const maxChars = limit * CHARS_PER_TOKEN;
+  const truncatedContent = content.substring(0, maxChars);
+  let tempFilePath = null;
+  let fileError = null;
+  try {
+    const tempDir = join4(tmpdir(), "probe-output");
+    await mkdir(tempDir, { recursive: true });
+    tempFilePath = join4(tempDir, `tool-output-${sessionId || "unknown"}-${randomUUID4()}.txt`);
+    await writeFile(tempFilePath, content, "utf8");
+  } catch (err) {
+    fileError = err.message || "Unknown file system error";
+    tempFilePath = null;
+  }
+  let message;
+  if (tempFilePath) {
+    message = `Output exceeded maximum size (${tokenCount} tokens, limit: ${limit}).
+Full output saved to: ${tempFilePath}
+
+--- Truncated Output (first ${limit} tokens approx) ---
+${truncatedContent}
+...
+--- End of Truncated Output ---`;
+  } else {
+    message = `Output exceeded maximum size (${tokenCount} tokens, limit: ${limit}).
+Warning: Could not save full output to file (${fileError}).
+
+--- Truncated Output (first ${limit} tokens approx) ---
+${truncatedContent}
+...
+--- End of Truncated Output ---`;
+  }
+  return {
+    truncated: true,
+    content: message,
+    tempFilePath: tempFilePath || void 0,
+    originalTokens: tokenCount,
+    error: fileError || void 0
+  };
+}
+var DEFAULT_MAX_OUTPUT_TOKENS, CHARS_PER_TOKEN;
+var init_outputTruncator = __esm({
+  "src/agent/outputTruncator.js"() {
+    "use strict";
+    DEFAULT_MAX_OUTPUT_TOKENS = 2e4;
+    CHARS_PER_TOKEN = 4;
+  }
+});
+
 // src/agent/mcp/built-in-server.js
 import { createServer } from "http";
 import { EventEmitter as EventEmitter3 } from "events";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { Server as MCPServer } from "@modelcontextprotocol/sdk/server/index.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -67372,7 +67466,7 @@ var init_built_in_server = __esm({
             }
             const eventStore = new InMemoryEventStore();
             transport = new StreamableHTTPServerTransport({
-              sessionIdGenerator: () => randomUUID4(),
+              sessionIdGenerator: () => randomUUID5(),
               eventStore,
               // Enable resumability
               onsessioninitialized: (newSessionId) => {
@@ -68593,11 +68687,32 @@ import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
 import { createGoogleGenerativeAI as createGoogleGenerativeAI2 } from "@ai-sdk/google";
 import { createAmazonBedrock as createAmazonBedrock2 } from "@ai-sdk/amazon-bedrock";
 import { streamText as streamText2 } from "ai";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 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"() {
@@ -68622,6 +68737,7 @@ var init_ProbeAgent = __esm({
     init_FallbackManager();
     init_contextCompactor();
     init_error_types();
+    init_outputTruncator();
     init_tasks();
     dotenv2.config();
     MAX_TOOL_ITERATIONS = (() => {
@@ -68681,9 +68797,10 @@ var init_ProbeAgent = __esm({
        * @param {boolean} [options.fallback.stopOnSuccess=true] - Stop on first success
        * @param {number} [options.fallback.maxTotalAttempts=10] - Maximum total attempts across all providers
        * @param {string} [options.completionPrompt] - Custom prompt to run after attempt_completion for validation/review (runs before mermaid/JSON validation)
+       * @param {number} [options.maxOutputTokens] - Maximum tokens for tool output before truncation (default: 20000, can also be set via PROBE_MAX_OUTPUT_TOKENS env var)
        */
       constructor(options = {}) {
-        this.sessionId = options.sessionId || randomUUID5();
+        this.sessionId = options.sessionId || randomUUID6();
         this.customPrompt = options.systemPrompt || options.customPrompt || null;
         this.promptType = options.promptType || "code-explorer";
         this.allowEdit = !!options.allowEdit;
@@ -68742,6 +68859,7 @@ var init_ProbeAgent = __esm({
         this.clientApiKey = null;
         this.clientApiUrl = null;
         this.tokenCounter = new TokenCounter();
+        this.maxOutputTokens = getMaxOutputTokens(options.maxOutputTokens);
         if (this.debug) {
           console.log(`[DEBUG] Generated session ID for agent: ${this.sessionId}`);
           console.log(`[DEBUG] Maximum tool iterations configured: ${MAX_TOOL_ITERATIONS}`);
@@ -70594,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");
@@ -70792,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.";
@@ -70833,7 +70969,21 @@ You are working with a repository located at: ${searchDirectory}
 `);
                     }
                     const executionResult = await this.mcpBridge.mcpTools[toolName].execute(params);
-                    const toolResultContent = typeof executionResult === "string" ? executionResult : JSON.stringify(executionResult, null, 2);
+                    let toolResultContent = typeof executionResult === "string" ? executionResult : JSON.stringify(executionResult, null, 2);
+                    try {
+                      const truncateResult = await truncateIfNeeded(toolResultContent, this.tokenCounter, this.sessionId, this.maxOutputTokens);
+                      if (truncateResult.truncated) {
+                        toolResultContent = truncateResult.content;
+                        if (this.debug) {
+                          console.log(`[DEBUG] Tool output truncated: ${truncateResult.originalTokens} tokens -> saved to ${truncateResult.tempFilePath || "N/A"}`);
+                          if (truncateResult.error) {
+                            console.log(`[DEBUG] Truncation file error: ${truncateResult.error}`);
+                          }
+                        }
+                      }
+                    } catch (truncateError) {
+                      console.error(`[WARN] Tool output truncation failed: ${truncateError.message}`);
+                    }
                     if (this.debug) {
                       const preview = toolResultContent.length > 500 ? toolResultContent.substring(0, 500) + "..." : toolResultContent;
                       console.error(`[DEBUG] ========================================`);
@@ -70982,7 +71132,21 @@ ${errorXml}
                       throw toolError;
                     }
                     currentMessages.push({ role: "assistant", content: assistantResponseContent });
-                    const toolResultContent = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult, null, 2);
+                    let toolResultContent = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult, null, 2);
+                    try {
+                      const truncateResult = await truncateIfNeeded(toolResultContent, this.tokenCounter, this.sessionId, this.maxOutputTokens);
+                      if (truncateResult.truncated) {
+                        toolResultContent = truncateResult.content;
+                        if (this.debug) {
+                          console.log(`[DEBUG] Tool output truncated: ${truncateResult.originalTokens} tokens -> saved to ${truncateResult.tempFilePath || "N/A"}`);
+                          if (truncateResult.error) {
+                            console.log(`[DEBUG] Truncation file error: ${truncateResult.error}`);
+                          }
+                        }
+                      }
+                    } catch (truncateError) {
+                      console.error(`[WARN] Tool output truncation failed: ${truncateError.message}`);
+                    }
                     const toolResultMessage = `<tool_result>
 ${toolResultContent}
 </tool_result>`;
@@ -71035,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.`);
                 }
@@ -71046,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:
@@ -71075,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;
@@ -71591,7 +71814,7 @@ Convert your previous response content into actual JSON data that follows this s
        */
       clone(options = {}) {
         const {
-          sessionId = randomUUID5(),
+          sessionId = randomUUID6(),
           stripInternalMessages = true,
           keepSystemMessage = true,
           deepCopy = true,
@@ -71818,7 +72041,7 @@ import { readFileSync as readFileSync2, existsSync as existsSync7 } from "fs";
 import { resolve as resolve7 } from "path";
 
 // src/agent/acp/server.js
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/agent/acp/connection.js
 import { EventEmitter as EventEmitter6 } from "events";
@@ -72310,7 +72533,7 @@ var ACPServer = class {
    * Handle new session request
    */
   async handleNewSession(params) {
-    const sessionId = params?.sessionId || randomUUID6();
+    const sessionId = params?.sessionId || randomUUID7();
     const mode = params?.mode || SessionMode.NORMAL;
     const session = new ACPSession(sessionId, mode);
     this.sessions.set(sessionId, session);
@@ -72482,7 +72705,7 @@ var ACPServer = class {
 };
 
 // src/agent/acp/tools.js
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 
 // src/agent/index.js
 dotenv3.config();

package/build/agent/outputTruncator.js

@@ -0,0 +1,108 @@
+import { writeFile, mkdir } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+
+const DEFAULT_MAX_OUTPUT_TOKENS = 20000;
+const CHARS_PER_TOKEN = 4; // Conservative approximation
+
+/**
+ * Validate and normalize a token limit value.
+ * Returns the default if the value is invalid (NaN, negative, zero).
+ * @param {any} value - The value to validate
+ * @returns {number} A valid positive token limit
+ */
+function validateTokenLimit(value) {
+  const num = Number(value);
+  if (isNaN(num) || num <= 0) {
+    return DEFAULT_MAX_OUTPUT_TOKENS;
+  }
+  return num;
+}
+
+/**
+ * Get the maximum output tokens limit based on priority:
+ * 1. Constructor value (if provided and valid)
+ * 2. Environment variable PROBE_MAX_OUTPUT_TOKENS (if valid)
+ * 3. Default (20000)
+ * @param {number|undefined} constructorValue - Value passed to ProbeAgent constructor
+ * @returns {number} The maximum output tokens limit (always a valid positive number)
+ */
+export function getMaxOutputTokens(constructorValue) {
+  if (constructorValue !== undefined && constructorValue !== null) {
+    const validated = validateTokenLimit(constructorValue);
+    // Only use constructor value if it was valid; otherwise fall through to env/default
+    if (validated !== DEFAULT_MAX_OUTPUT_TOKENS || Number(constructorValue) === DEFAULT_MAX_OUTPUT_TOKENS) {
+      return validated;
+    }
+  }
+  if (process.env.PROBE_MAX_OUTPUT_TOKENS) {
+    return validateTokenLimit(process.env.PROBE_MAX_OUTPUT_TOKENS);
+  }
+  return DEFAULT_MAX_OUTPUT_TOKENS;
+}
+
+/**
+ * Truncate tool output if it exceeds the token limit.
+ * When truncated, saves full output to a temp file and returns a message with the file path.
+ * If file system operations fail, returns truncated content without file reference.
+ *
+ * @param {string} content - The tool output content to potentially truncate
+ * @param {Object} tokenCounter - TokenCounter instance with countTokens method
+ * @param {string} sessionId - Session ID for naming temp files
+ * @param {number} maxTokens - Maximum tokens allowed (defaults to 20000)
+ * @returns {Promise<{truncated: boolean, content: string, tempFilePath?: string, originalTokens?: number, error?: string}>}
+ */
+export async function truncateIfNeeded(content, tokenCounter, sessionId, maxTokens) {
+  const limit = validateTokenLimit(maxTokens);
+  const tokenCount = tokenCounter.countTokens(content);
+
+  if (tokenCount <= limit) {
+    return { truncated: false, content };
+  }
+
+  // Truncate to approximately maxTokens worth of characters
+  const maxChars = limit * CHARS_PER_TOKEN;
+  const truncatedContent = content.substring(0, maxChars);
+
+  // Try to write full output to temp file
+  let tempFilePath = null;
+  let fileError = null;
+
+  try {
+    const tempDir = join(tmpdir(), 'probe-output');
+    await mkdir(tempDir, { recursive: true });
+    tempFilePath = join(tempDir, `tool-output-${sessionId || 'unknown'}-${randomUUID()}.txt`);
+    await writeFile(tempFilePath, content, 'utf8');
+  } catch (err) {
+    fileError = err.message || 'Unknown file system error';
+    tempFilePath = null;
+  }
+
+  let message;
+  if (tempFilePath) {
+    message = `Output exceeded maximum size (${tokenCount} tokens, limit: ${limit}).
+Full output saved to: ${tempFilePath}
+
+--- Truncated Output (first ${limit} tokens approx) ---
+${truncatedContent}
+...
+--- End of Truncated Output ---`;
+  } else {
+    message = `Output exceeded maximum size (${tokenCount} tokens, limit: ${limit}).
+Warning: Could not save full output to file (${fileError}).
+
+--- Truncated Output (first ${limit} tokens approx) ---
+${truncatedContent}
+...
+--- End of Truncated Output ---`;
+  }
+
+  return {
+    truncated: true,
+    content: message,
+    tempFilePath: tempFilePath || undefined,
+    originalTokens: tokenCount,
+    error: fileError || undefined
+  };
+}

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;
 }