@probelabs/probe 0.6.0-rc206 → 0.6.0-rc208

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) {
@@ -10585,9 +10601,11 @@ var init_bashPermissions = __esm({
        * @param {boolean} [config.disableDefaultAllow] - Disable default allow list
        * @param {boolean} [config.disableDefaultDeny] - Disable default deny list
        * @param {boolean} [config.debug] - Enable debug logging
+       * @param {Object} [config.tracer] - Optional tracer for telemetry
        */
       constructor(config = {}) {
         this.debug = config.debug || false;
+        this.tracer = config.tracer || null;
         this.allowPatterns = [];
         if (!config.disableDefaultAllow) {
           this.allowPatterns.push(...DEFAULT_ALLOW_PATTERNS);
@@ -10617,6 +10635,24 @@ var init_bashPermissions = __esm({
         if (this.debug) {
           console.log(`[BashPermissions] Total patterns - Allow: ${this.allowPatterns.length}, Deny: ${this.denyPatterns.length}`);
         }
+        this.recordBashEvent("permissions.initialized", {
+          allowPatternCount: this.allowPatterns.length,
+          denyPatternCount: this.denyPatterns.length,
+          hasCustomAllowPatterns: !!(config.allow && config.allow.length > 0),
+          hasCustomDenyPatterns: !!(config.deny && config.deny.length > 0),
+          disableDefaultAllow: !!config.disableDefaultAllow,
+          disableDefaultDeny: !!config.disableDefaultDeny
+        });
+      }
+      /**
+       * Record a bash telemetry event if tracer is available
+       * @param {string} eventType - Event type (e.g., 'permission.checked', 'permission.denied')
+       * @param {Object} data - Event data
+       */
+      recordBashEvent(eventType, data = {}) {
+        if (this.tracer && typeof this.tracer.recordBashEvent === "function") {
+          this.tracer.recordBashEvent(eventType, data);
+        }
       }
       /**
        * Check if a simple command is allowed (complex commands allowed if they match patterns)
@@ -10625,11 +10661,17 @@ var init_bashPermissions = __esm({
        */
       check(command) {
         if (!command || typeof command !== "string") {
-          return {
+          const result2 = {
             allowed: false,
             reason: "Invalid or empty command",
             command
           };
+          this.recordBashEvent("permission.denied", {
+            command: String(command),
+            reason: result2.reason,
+            isComplex: false
+          });
+          return result2;
         }
         const commandIsComplex = isComplexCommand(command);
         if (commandIsComplex) {
@@ -10637,18 +10679,31 @@ var init_bashPermissions = __esm({
         }
         const parsed = parseCommand(command);
         if (parsed.error) {
-          return {
+          const result2 = {
             allowed: false,
             reason: parsed.error,
             command
           };
+          this.recordBashEvent("permission.denied", {
+            command,
+            reason: result2.reason,
+            isComplex: false,
+            parseError: true
+          });
+          return result2;
         }
         if (!parsed.command) {
-          return {
+          const result2 = {
             allowed: false,
             reason: "No valid command found",
             command
           };
+          this.recordBashEvent("permission.denied", {
+            command,
+            reason: result2.reason,
+            isComplex: false
+          });
+          return result2;
         }
         if (this.debug) {
           console.log(`[BashPermissions] Checking simple command: "${command}"`);
@@ -10656,22 +10711,37 @@ var init_bashPermissions = __esm({
         }
         if (matchesAnyPattern(parsed, this.denyPatterns)) {
           const matchedPatterns = this.denyPatterns.filter((pattern) => matchesPattern(parsed, pattern));
-          return {
+          const result2 = {
             allowed: false,
             reason: `Command matches deny pattern: ${matchedPatterns[0]}`,
             command,
             parsed,
             matchedPatterns
           };
+          this.recordBashEvent("permission.denied", {
+            command,
+            parsedCommand: parsed.command,
+            reason: "matches_deny_pattern",
+            matchedPattern: matchedPatterns[0],
+            isComplex: false
+          });
+          return result2;
         }
         if (this.allowPatterns.length > 0) {
           if (!matchesAnyPattern(parsed, this.allowPatterns)) {
-            return {
+            const result2 = {
               allowed: false,
               reason: "Command not in allow list",
               command,
               parsed
             };
+            this.recordBashEvent("permission.denied", {
+              command,
+              parsedCommand: parsed.command,
+              reason: "not_in_allow_list",
+              isComplex: false
+            });
+            return result2;
           }
         }
         const result = {
@@ -10683,6 +10753,11 @@ var init_bashPermissions = __esm({
         if (this.debug) {
           console.log(`[BashPermissions] ALLOWED - command passed all checks`);
         }
+        this.recordBashEvent("permission.allowed", {
+          command,
+          parsedCommand: parsed.command,
+          isComplex: false
+        });
         return result;
       }
       /**
@@ -10706,13 +10781,20 @@ var init_bashPermissions = __esm({
             if (this.debug) {
               console.log(`[BashPermissions] DENIED - matches complex deny pattern: ${pattern}`);
             }
-            return {
+            const result = {
               allowed: false,
               reason: `Command matches deny pattern: ${pattern}`,
               command,
               isComplex: true,
               matchedPatterns: [pattern]
             };
+            this.recordBashEvent("permission.denied", {
+              command,
+              reason: "matches_deny_pattern",
+              matchedPattern: pattern,
+              isComplex: true
+            });
+            return result;
           }
         }
         for (const pattern of complexAllowPatterns) {
@@ -10720,17 +10802,28 @@ var init_bashPermissions = __esm({
             if (this.debug) {
               console.log(`[BashPermissions] ALLOWED - matches complex allow pattern: ${pattern}`);
             }
-            return {
+            const result = {
               allowed: true,
               command,
               isComplex: true,
               matchedPattern: pattern
             };
+            this.recordBashEvent("permission.allowed", {
+              command,
+              matchedPattern: pattern,
+              isComplex: true
+            });
+            return result;
           }
         }
         if (this.debug) {
           console.log(`[BashPermissions] DENIED - no matching complex pattern found`);
         }
+        this.recordBashEvent("permission.denied", {
+          command,
+          reason: "no_matching_complex_pattern",
+          isComplex: true
+        });
         return {
           allowed: false,
           reason: 'Complex shell commands require explicit allow patterns (e.g., "cd * && git *")',
@@ -11028,14 +11121,16 @@ var init_bash = __esm({
         bashConfig = {},
         debug = false,
         cwd,
-        allowedFolders = []
+        allowedFolders = [],
+        tracer = null
       } = options;
       const permissionChecker = new BashPermissionChecker({
         allow: bashConfig.allow,
         deny: bashConfig.deny,
         disableDefaultAllow: bashConfig.disableDefaultAllow,
         disableDefaultDeny: bashConfig.disableDefaultDeny,
-        debug
+        debug,
+        tracer
       });
       const getDefaultWorkingDirectory = () => {
         if (bashConfig.workingDirectory) {
@@ -11665,6 +11760,28 @@ var init_simpleTelemetry = __esm({
           ...data
         });
       }
+      /**
+       * Record MCP (Model Context Protocol) events
+       * Tracks server connections, tool discovery, method filtering, and tool execution
+       */
+      recordMcpEvent(eventType, data = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`mcp.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data
+        });
+      }
+      /**
+       * Record bash tool events
+       * Tracks command permission checks, allowed/denied commands, and execution
+       */
+      recordBashEvent(eventType, data = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`bash.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data
+        });
+      }
       setAttributes(attributes) {
         if (this.telemetry && this.telemetry.enableConsole) {
           console.log("[Attributes]", attributes);
@@ -57891,6 +58008,47 @@ function validateTimeout(value) {
   if (!Number.isFinite(num) || num < 0) return void 0;
   return Math.min(num, MAX_TIMEOUT);
 }
+function validateMethodFilter(serverConfig, serverName = "unknown") {
+  const result = { allowedMethods: null, blockedMethods: null };
+  const debug = process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1";
+  if (serverConfig.allowedMethods && serverConfig.blockedMethods) {
+    console.error(`[MCP WARN] Server '${serverName}' has both allowedMethods and blockedMethods - using allowedMethods only`);
+  }
+  if (serverConfig.allowedMethods) {
+    if (!Array.isArray(serverConfig.allowedMethods)) {
+      console.error(`[MCP WARN] Server '${serverName}' allowedMethods must be an array, ignoring`);
+    } else {
+      const validMethods = serverConfig.allowedMethods.filter((m) => typeof m === "string" && m.length > 0);
+      if (validMethods.length !== serverConfig.allowedMethods.length) {
+        console.error(`[MCP WARN] Server '${serverName}' allowedMethods contains non-string values, skipping those`);
+      }
+      if (validMethods.length > 0) {
+        result.allowedMethods = validMethods;
+        if (debug) {
+          console.error(`[MCP DEBUG] Server '${serverName}' allowedMethods: ${validMethods.join(", ")}`);
+        }
+      }
+    }
+    return result;
+  }
+  if (serverConfig.blockedMethods) {
+    if (!Array.isArray(serverConfig.blockedMethods)) {
+      console.error(`[MCP WARN] Server '${serverName}' blockedMethods must be an array, ignoring`);
+    } else {
+      const validMethods = serverConfig.blockedMethods.filter((m) => typeof m === "string" && m.length > 0);
+      if (validMethods.length !== serverConfig.blockedMethods.length) {
+        console.error(`[MCP WARN] Server '${serverName}' blockedMethods contains non-string values, skipping those`);
+      }
+      if (validMethods.length > 0) {
+        result.blockedMethods = validMethods;
+        if (debug) {
+          console.error(`[MCP DEBUG] Server '${serverName}' blockedMethods: ${validMethods.join(", ")}`);
+        }
+      }
+    }
+  }
+  return result;
+}
 function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
@@ -57984,6 +58142,12 @@ function mergeWithEnvironment(config) {
             console.error(`[MCP WARN] Invalid timeout value for ${normalizedName}: ${value}`);
           }
           break;
+        case "ALLOWLIST":
+          config.mcpServers[normalizedName].allowedMethods = value.split(",").map((m) => m.trim()).filter(Boolean);
+          break;
+        case "BLOCKLIST":
+          config.mcpServers[normalizedName].blockedMethods = value.split(",").map((m) => m.trim()).filter(Boolean);
+          break;
       }
     }
   }
@@ -58034,6 +58198,9 @@ function parseEnabledServers(config) {
       }
       server.timeout = validatedTimeout;
     }
+    const methodFilter = validateMethodFilter(serverConfig, name);
+    server.allowedMethods = methodFilter.allowedMethods;
+    server.blockedMethods = methodFilter.blockedMethods;
     servers.push(server);
   }
   return servers;
@@ -58071,6 +58238,22 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
+function isMethodAllowed(methodName, allowedMethods, blockedMethods) {
+  const matchesPattern2 = (name, pattern) => {
+    if (!pattern.includes("*")) {
+      return name === pattern;
+    }
+    const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${regexPattern}$`).test(name);
+  };
+  if (allowedMethods && allowedMethods.length > 0) {
+    return allowedMethods.some((pattern) => matchesPattern2(methodName, pattern));
+  }
+  if (blockedMethods && blockedMethods.length > 0) {
+    return !blockedMethods.some((pattern) => matchesPattern2(methodName, pattern));
+  }
+  return true;
+}
 function createTransport(serverConfig) {
   const { transport, command, args, url, env } = serverConfig;
   switch (transport) {
@@ -58151,6 +58334,17 @@ var init_client = __esm({
         this.tools = /* @__PURE__ */ new Map();
         this.debug = options.debug || process.env.DEBUG_MCP === "1";
         this.config = null;
+        this.tracer = options.tracer || null;
+      }
+      /**
+       * Record an MCP telemetry event if tracer is available
+       * @param {string} eventType - Event type (e.g., 'server.connect', 'tool.discovered')
+       * @param {Object} data - Event data
+       */
+      recordMcpEvent(eventType, data = {}) {
+        if (this.tracer && typeof this.tracer.recordMcpEvent === "function") {
+          this.tracer.recordMcpEvent(eventType, data);
+        }
       }
       /**
        * Initialize MCP clients from configuration
@@ -58159,10 +58353,20 @@ var init_client = __esm({
       async initialize(config = null) {
         this.config = config || loadMCPConfiguration();
         const servers = parseEnabledServers(this.config);
+        this.recordMcpEvent("initialization.started", {
+          serverCount: servers.length,
+          serverNames: servers.map((s) => s.name)
+        });
         console.error(`[MCP INFO] Found ${servers.length} enabled MCP server${servers.length !== 1 ? "s" : ""}`);
         if (servers.length === 0) {
           console.error("[MCP INFO] No MCP servers configured or enabled");
           console.error("[MCP INFO] 0 MCP tools available");
+          this.recordMcpEvent("initialization.completed", {
+            connected: 0,
+            total: 0,
+            toolCount: 0,
+            tools: []
+          });
           return {
             connected: 0,
             total: 0,
@@ -58199,10 +58403,17 @@ var init_client = __esm({
             console.error(`[MCP DEBUG]   - ${toolName}`);
           });
         }
+        const toolNames = Array.from(this.tools.keys());
+        this.recordMcpEvent("initialization.completed", {
+          connected: connectedCount,
+          total: servers.length,
+          toolCount: this.tools.size,
+          tools: toolNames
+        });
         return {
           connected: connectedCount,
           total: servers.length,
-          tools: Array.from(this.tools.keys())
+          tools: toolNames
         };
       }
       /**
@@ -58211,6 +58422,12 @@ var init_client = __esm({
        */
       async connectToServer(serverConfig) {
         const { name } = serverConfig;
+        this.recordMcpEvent("server.connecting", {
+          serverName: name,
+          transport: serverConfig.transport,
+          hasAllowedMethods: !!(serverConfig.allowedMethods && serverConfig.allowedMethods.length > 0),
+          hasBlockedMethods: !!(serverConfig.blockedMethods && serverConfig.blockedMethods.length > 0)
+        });
         try {
           if (this.debug) {
             console.error(`[MCP DEBUG] Connecting to ${name} via ${serverConfig.transport}...`);
@@ -58232,27 +58449,92 @@ var init_client = __esm({
             config: serverConfig
           });
           const toolsResponse = await client.listTools();
-          const toolCount = toolsResponse?.tools?.length || 0;
+          const totalToolCount = toolsResponse?.tools?.length || 0;
+          let registeredCount = 0;
+          let filteredCount = 0;
+          const registeredTools = [];
+          const filteredTools = [];
           if (toolsResponse && toolsResponse.tools) {
+            const { allowedMethods, blockedMethods } = serverConfig;
+            const allToolNames = toolsResponse.tools.map((t) => t.name);
+            this.recordMcpEvent("tools.discovered", {
+              serverName: name,
+              toolCount: totalToolCount,
+              tools: allToolNames
+            });
             for (const tool4 of toolsResponse.tools) {
+              if (!isMethodAllowed(tool4.name, allowedMethods, blockedMethods)) {
+                filteredCount++;
+                filteredTools.push(tool4.name);
+                if (this.debug) {
+                  console.error(`[MCP DEBUG]     Filtered out tool: ${tool4.name} (not allowed by method filter)`);
+                }
+                continue;
+              }
               const qualifiedName = `${name}_${tool4.name}`;
               this.tools.set(qualifiedName, {
                 ...tool4,
                 serverName: name,
                 originalName: tool4.name
               });
+              registeredCount++;
+              registeredTools.push(qualifiedName);
               if (this.debug) {
                 console.error(`[MCP DEBUG]     Registered tool: ${qualifiedName}`);
               }
             }
+            if (filteredCount > 0) {
+              this.recordMcpEvent("tools.filtered", {
+                serverName: name,
+                filteredCount,
+                filteredTools,
+                allowedMethods: allowedMethods || [],
+                blockedMethods: blockedMethods || []
+              });
+            }
+            if (allowedMethods && allowedMethods.length > 0) {
+              const unmatchedPatterns = allowedMethods.filter((pattern) => {
+                return !allToolNames.some((toolName) => isMethodAllowed(toolName, [pattern], null));
+              });
+              if (unmatchedPatterns.length > 0) {
+                console.error(`[MCP WARN] Server '${name}': The following allowedMethods patterns did not match any tools: ${unmatchedPatterns.join(", ")}`);
+                console.error(`[MCP WARN] Available methods from '${name}': ${allToolNames.join(", ")}`);
+              }
+            }
+            if (blockedMethods && blockedMethods.length > 0) {
+              const unmatchedPatterns = blockedMethods.filter((pattern) => {
+                return !allToolNames.some((toolName) => !isMethodAllowed(toolName, null, [pattern]));
+              });
+              if (unmatchedPatterns.length > 0) {
+                console.error(`[MCP WARN] Server '${name}': The following blockedMethods patterns did not match any tools: ${unmatchedPatterns.join(", ")}`);
+                console.error(`[MCP WARN] Available methods from '${name}': ${allToolNames.join(", ")}`);
+              }
+            }
           }
-          console.error(`[MCP INFO] Connected to ${name}: ${toolCount} tool${toolCount !== 1 ? "s" : ""} loaded`);
+          if (filteredCount > 0) {
+            console.error(`[MCP INFO] Connected to ${name}: ${registeredCount} tool${registeredCount !== 1 ? "s" : ""} loaded (${filteredCount} filtered out)`);
+          } else {
+            console.error(`[MCP INFO] Connected to ${name}: ${registeredCount} tool${registeredCount !== 1 ? "s" : ""} loaded`);
+          }
+          this.recordMcpEvent("server.connected", {
+            serverName: name,
+            transport: serverConfig.transport,
+            totalToolCount,
+            registeredCount,
+            filteredCount,
+            registeredTools
+          });
           return true;
         } catch (error) {
           console.error(`[MCP ERROR] Error connecting to ${name}:`, error.message);
           if (this.debug) {
             console.error(`[MCP DEBUG] Full error details:`, error);
           }
+          this.recordMcpEvent("server.connection_failed", {
+            serverName: name,
+            transport: serverConfig.transport,
+            error: error.message
+          });
           return false;
         }
       }
@@ -58264,12 +58546,27 @@ var init_client = __esm({
       async callTool(toolName, args) {
         const tool4 = this.tools.get(toolName);
         if (!tool4) {
+          this.recordMcpEvent("tool.call_failed", {
+            toolName,
+            error: "Unknown tool"
+          });
           throw new Error(`Unknown tool: ${toolName}`);
         }
         const clientInfo = this.clients.get(tool4.serverName);
         if (!clientInfo) {
+          this.recordMcpEvent("tool.call_failed", {
+            toolName,
+            serverName: tool4.serverName,
+            error: "Server not connected"
+          });
           throw new Error(`Server ${tool4.serverName} not connected`);
         }
+        const startTime = Date.now();
+        this.recordMcpEvent("tool.call_started", {
+          toolName,
+          serverName: tool4.serverName,
+          originalToolName: tool4.originalName
+        });
         try {
           if (this.debug) {
             console.error(`[MCP DEBUG] Calling ${toolName} with args:`, JSON.stringify(args, null, 2));
@@ -58289,15 +58586,31 @@ var init_client = __esm({
             }),
             timeoutPromise
           ]);
+          const durationMs = Date.now() - startTime;
           if (this.debug) {
             console.error(`[MCP DEBUG] Tool ${toolName} executed successfully`);
           }
+          this.recordMcpEvent("tool.call_completed", {
+            toolName,
+            serverName: tool4.serverName,
+            originalToolName: tool4.originalName,
+            durationMs
+          });
           return result;
         } catch (error) {
+          const durationMs = Date.now() - startTime;
           console.error(`[MCP ERROR] Error calling tool ${toolName}:`, error.message);
           if (this.debug) {
             console.error(`[MCP DEBUG] Full error details:`, error);
           }
+          this.recordMcpEvent("tool.call_failed", {
+            toolName,
+            serverName: tool4.serverName,
+            originalToolName: tool4.originalName,
+            error: error.message,
+            durationMs,
+            isTimeout: error.message.includes("timeout")
+          });
           throw error;
         }
       }
@@ -58342,12 +58655,17 @@ var init_client = __esm({
        */
       async disconnect() {
         const disconnectPromises = [];
+        const serverNames = Array.from(this.clients.keys());
         if (this.clients.size === 0) {
           if (this.debug) {
             console.error("[MCP DEBUG] No MCP clients to disconnect");
           }
           return;
         }
+        this.recordMcpEvent("disconnection.started", {
+          serverCount: this.clients.size,
+          serverNames
+        });
         if (this.debug) {
           console.error(`[MCP DEBUG] Disconnecting from ${this.clients.size} MCP server${this.clients.size !== 1 ? "s" : ""}...`);
         }
@@ -58357,14 +58675,25 @@ var init_client = __esm({
               if (this.debug) {
                 console.error(`[MCP DEBUG] Disconnected from ${name}`);
               }
+              this.recordMcpEvent("server.disconnected", {
+                serverName: name
+              });
             }).catch((error) => {
               console.error(`[MCP ERROR] Error disconnecting from ${name}:`, error.message);
+              this.recordMcpEvent("server.disconnect_failed", {
+                serverName: name,
+                error: error.message
+              });
             })
           );
         }
         await Promise.all(disconnectPromises);
         this.clients.clear();
         this.tools.clear();
+        this.recordMcpEvent("disconnection.completed", {
+          serverCount: serverNames.length,
+          serverNames
+        });
         if (this.debug) {
           console.error("[MCP DEBUG] All MCP connections closed");
         }
@@ -58508,6 +58837,7 @@ var init_xmlBridge = __esm({
     MCPXmlBridge = class {
       constructor(options = {}) {
         this.debug = options.debug || false;
+        this.tracer = options.tracer || null;
         this.mcpTools = {};
         this.mcpManager = null;
         this.xmlDefinitions = {};
@@ -58550,7 +58880,7 @@ var init_xmlBridge = __esm({
           if (this.debug) {
             console.error("[MCP DEBUG] Initializing MCP client manager...");
           }
-          this.mcpManager = new MCPClientManager({ debug: this.debug });
+          this.mcpManager = new MCPClientManager({ debug: this.debug, tracer: this.tracer });
           const result = await this.mcpManager.initialize(mcpConfigs);
           const vercelTools = this.mcpManager.getVercelTools();
           this.mcpTools = vercelTools;
@@ -58574,11 +58904,15 @@ var init_xmlBridge = __esm({
         }
       }
       /**
-       * Get all XML tool definitions for inclusion in system prompt
+       * Get XML tool definitions for inclusion in system prompt
+       * @param {Array<string>|null} filterToolNames - Optional list of tool names to include (if null, include all)
        * @returns {string} Combined XML tool definitions
        */
-      getXmlToolDefinitions() {
-        return Object.values(this.xmlDefinitions).join("\n\n");
+      getXmlToolDefinitions(filterToolNames = null) {
+        if (filterToolNames === null) {
+          return Object.values(this.xmlDefinitions).join("\n\n");
+        }
+        return Object.entries(this.xmlDefinitions).filter(([name]) => filterToolNames.includes(name)).map(([, def]) => def).join("\n\n");
       }
       /**
        * Get list of MCP tool names
@@ -68676,6 +69010,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 +71030,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 +71231,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 +71517,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 +71554,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 +71597,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;