@probelabs/probe 0.6.0-rc265 → 0.6.0-rc267

package/build/tools/common.js

@@ -5,8 +5,6 @@
 
 import { z } from 'zod';
 import { resolve, isAbsolute } from 'path';
-import { editSchema, createSchema, multiEditSchema } from './edit.js';
-import { taskSchema } from '../agent/tasks/taskTool.js';
 
 // Common schemas for tool parameters (used for internal execution after XML parsing)
 export const searchSchema = z.object({
@@ -51,6 +49,20 @@ export const useSkillSchema = z.object({
 	name: z.string().describe('Skill name to load and activate.')
 });
 
+export const listFilesSchema = z.object({
+	directory: z.string().optional().describe('Directory to list files from. Defaults to current directory.')
+});
+
+export const searchFilesSchema = z.object({
+	pattern: z.string().describe('Glob pattern to search for (e.g., "**/*.js", "*.md")'),
+	directory: z.string().optional().describe('Directory to search in. Defaults to current directory.'),
+	recursive: z.boolean().optional().default(true).describe('Whether to search recursively')
+});
+
+export const readImageSchema = z.object({
+	path: z.string().describe('Path to the image file to read. Supports png, jpg, jpeg, webp, bmp, and svg formats.')
+});
+
 export const bashSchema = z.object({
 	command: z.string().describe('The bash command to execute'),
 	workingDirectory: z.string().optional().describe('Directory to execute the command in (optional)'),
@@ -135,301 +147,7 @@ export const attemptCompletionSchema = {
 };
 
 
-// Tool descriptions for the system prompt (using XML format)
-
-export const searchToolDefinition = `
-## search
-Description: Search code in the repository. You may provide a free-form question about the code or a concise Elasticsearch-style keyword query (field based queries, e.g. "filename:..." NOT supported).
-Note: This tool may internally use a dedicated search subagent when search delegation is enabled. This is separate from the "delegate" tool and does not require an explicit delegate call.
-
-You need to focus on main keywords when constructing the query, and always use elastic search syntax like OR AND and brackets to group keywords.
-
-**Session Management & Caching:**
-- Ensure not to re-read the same symbols twice - reuse context from previous tool calls
-- Probe returns a session ID on first run - reuse it for subsequent calls to avoid redundant searches
-- Once data is returned, it's cached and won't return on next runs (this is expected behavior)
-
-Parameters:
-- query: (required) Search query. Free-form questions are accepted, but for best results prefer Elasticsearch-style syntax with quotes for exact matches ("functionName"), AND/OR for boolean logic, - for negation, + for important terms.
-- path: (optional, default: '.') Path to search in. All dependencies located in /dep folder, under language sub folders, like this: "/dep/go/github.com/owner/repo", "/dep/js/package_name", or "/dep/rust/cargo_name" etc.
-- exact: (optional, default: false) Set to true for precise symbol lookup without stemming/tokenization. Use when you know the exact symbol name (e.g., "getUserData" matches only "getUserData", not "get", "user", "data").
-- session: (optional) Session ID for pagination. Pass the session ID returned from a previous search to get the next page of results. Results already shown are automatically excluded.
-- nextPage: (optional, default: false) Set to true when requesting the next page of results. Requires passing the same session ID from the previous search.
-
-**Workflow:** Always start with search, then use extract for detailed context when needed.
-
-Usage Example:
-
-<examples>
-
-User: Where is the login logic?
-Assistant workflow:
-1. <search>
-<query>login AND auth AND token</query>
-<path>.</path>
-</search>
-2. Now lets look closer: <extract>
-<targets>session.rs#AuthService.login auth.rs:2-100</targets>
-</extract>
-
-User: How to calculate the total amount in the payments module?
-<search>
-<query>calculate AND payment</query>
-<path>src/utils</path>
-</search>
-
-User: How do the user authentication and authorization work?
-<search>
-<query>+user AND (authentication OR authorization OR authz)</query>
-<path>.</path>
-</search>
-
-User: Find all react imports in the project.
-<search>
-<query>"import" AND "react"</query>
-<path>.</path>
-</search>
-
-User: Find how decompound library works?
-<search>
-<query>decompound</query>
-<path>/dep/rust/decompound</path>
-</search>
-
-</examples>
-`;
-
-export const queryToolDefinition = `
-## query
-Description: Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.
-Parameters:
-- pattern: (required) AST pattern to search for. Use $NAME for variable names, $$$PARAMS for parameter lists, etc.
-- path: (optional, default: '.') Path to search in.
-- language: (optional, default: 'rust') Programming language to use for parsing.
-- allow_tests: (optional, default: true) Allow test files in search results (true/false).
-Usage Example:
-
-<examples>
-
-<query>
-<pattern>function $FUNC($$$PARAMS) { $$$BODY }</pattern>
-<path>src/parser</path>
-<language>js</language>
-</query>
-
-</examples>
-`;
-
-export const extractToolDefinition = `
-## extract
-Description: Extract code blocks from files based on file paths and optional line numbers. Use this tool to see complete context after finding relevant files. It can be used to read full files as well.
-Full file extraction should be the LAST RESORT! Always prefer search.
-
-**Multiple Extraction:** You can extract multiple symbols/files in one call by providing multiple file paths separated by spaces.
-
-**Session Awareness:** Reuse context from previous tool calls. Don't re-extract the same symbols you already have.
-
-Parameters:
-- targets: (required) File paths or symbols to extract from. Formats: "file.js" (whole file), "file.js:42" (code block at line 42), "file.js:10-20" (lines 10-20), "file.js#funcName" (specific symbol). Multiple targets separated by spaces.
-- input_content: (optional) Text content to extract file paths from (alternative to targets for processing diffs/logs).
-- allow_tests: (optional, default: true) Include test files in extraction results.
-
-Usage Example:
-
-<examples>
-
-User: Where is the login logic? (After search found relevant files)
-<extract>
-<targets>session.rs#AuthService.login auth.rs:2-100 config.rs#DatabaseConfig</targets>
-</extract>
-
-User: How does error handling work? (After search identified files)
-<extract>
-<targets>error.rs#ErrorType utils.rs#handle_error src/main.rs:50-80</targets>
-</extract>
-
-User: How RankManager works
-<extract>
-<targets>src/search/ranking.rs#RankManager</targets>
-</extract>
-
-User: Lets read the whole file
-<extract>
-<targets>src/search/ranking.rs</targets>
-</extract>
-
-User: Read the first 10 lines of the file
-<extract>
-<targets>src/search/ranking.rs:1-10</targets>
-</extract>
-
-User: Read file inside the dependency
-<extract>
-<targets>/dep/go/github.com/gorilla/mux/router.go</targets>
-</extract>
-
-</examples>
-
-**Edit Integration:** The line numbers shown in extract output (e.g. "42 | code") can be used directly with the edit tool's start_line/end_line parameters for precise line-targeted editing. To edit inside a large function: extract it by symbol name first (e.g. "file.js#myFunction"), then use the line numbers from the output to make surgical edits with start_line/end_line.
-`;
-
-export const delegateToolDefinition = `
-## delegate
-Description: Automatically delegate big distinct tasks to specialized probe subagents within the agentic loop. Use this when you recognize that a user's request involves multiple large, distinct components that would benefit from parallel processing or specialized focus. The AI agent should automatically identify opportunities for task separation and use delegation without explicit user instruction.
-
-Parameters:
-- task: (required) A complete, self-contained task that can be executed independently by a subagent. Should be specific and focused on one area of expertise.
-
-Usage Pattern:
-When the AI agent encounters complex multi-part requests, it should automatically break them down and delegate:
-
-<delegate>
-<task>Analyze all authentication and authorization code in the codebase for security vulnerabilities and provide specific remediation recommendations</task>
-</delegate>
-
-<delegate>
-<task>Review database queries and API endpoints for performance bottlenecks and suggest optimization strategies</task>
-</delegate>
-
-The agent uses this tool automatically when it identifies that work can be separated into distinct, parallel tasks for more efficient processing.
-`;
-
-export const attemptCompletionToolDefinition = `
-## attempt_completion
-Description: Use this tool ONLY when the task is fully complete and you have received confirmation of success for all previous tool uses. Presents the final result to the user. You can provide your response directly inside the XML tags without any parameter wrapper.
-Parameters:
-- No validation required - provide your complete answer directly inside the XML tags.
-Usage Example:
-<attempt_completion>
-I have refactored the search module according to the requirements and verified the tests pass. The module now uses the new BM25 ranking algorithm and has improved error handling.
-</attempt_completion>
-`;
-
-export const analyzeAllToolDefinition = `
-## analyze_all
-Description: Intelligent bulk data analysis tool. Process ALL data matching your question using a 3-phase approach:
-1. **PLANNING**: AI analyzes your question and determines the optimal search strategy
-2. **PROCESSING**: Map-reduce processes all matching data in parallel chunks
-3. **SYNTHESIS**: Comprehensive answer with evidence and organization
-
-**Use this for questions requiring 100% data coverage:**
-- "What features are customers using?"
-- "List all API endpoints in the codebase"
-- "Summarize the error handling patterns"
-- "Count all TODO comments and their contexts"
-
-**Do NOT use for:**
-- Simple searches where a sample is sufficient
-- Finding a specific function or class
-- Quick exploration (use search instead)
-
-**WARNING:** Makes multiple LLM calls - slower and costlier than search.
-
-Parameters:
-- question: (required) Free-form question to answer - the AI determines the best search strategy automatically
-- path: (optional) Directory to search in (default: current directory)
-
-<examples>
-
-User: What are all the different tools available in this codebase?
-<analyze_all>
-<question>What are all the different tools available in this codebase and what do they do?</question>
-<path>./src</path>
-</analyze_all>
-
-User: I need to understand all the error handling patterns
-<analyze_all>
-<question>What error handling patterns are used throughout the codebase? Include examples.</question>
-</analyze_all>
-
-User: Count and categorize all the environment variables
-<analyze_all>
-<question>What environment variables are used? Categorize them by purpose.</question>
-<path>./src</path>
-</analyze_all>
-
-</examples>
-`;
-
-export const bashToolDefinition = `
-## bash
-Description: Execute bash commands for system exploration and development tasks. This tool has built-in security with allow/deny lists. By default, only safe read-only commands are allowed for code exploration.
-
-Parameters:
-- command: (required) The bash command to execute
-- workingDirectory: (optional) Directory to execute the command in
-- timeout: (optional) Command timeout in milliseconds
-- env: (optional) Additional environment variables as an object
-
-Security: Commands are filtered through allow/deny lists for safety:
-- Allowed by default: ls, cat, git status, npm list, find, grep, etc.
-- Denied by default: rm -rf, sudo, npm install, dangerous system commands
-
-Usage Examples:
-
-<examples>
-
-User: What files are in the src directory?
-<bash>
-<command>ls -la src/</command>
-</bash>
-
-User: Show me the git status
-<bash>
-<command>git status</command>
-</bash>
-
-User: Find all TypeScript files
-<bash>
-<command>find . -name "*.ts" -type f</command>
-</bash>
-
-User: Check installed npm packages
-<bash>
-<command>npm list --depth=0</command>
-</bash>
-
-User: Search for TODO comments in code
-<bash>
-<command>grep -r "TODO" src/</command>
-</bash>
-
-User: Show recent git commits
-<bash>
-<command>git log --oneline -10</command>
-</bash>
-
-User: Check system info
-<bash>
-<command>uname -a</command>
-</bash>
-
-</examples>
-`;
-
-export const googleSearchToolDefinition = `
-## gemini_google_search (Gemini Built-in)
-Description: Web search powered by Google. This is a built-in Gemini capability that automatically searches the web when the model needs current information. The model decides when to search and integrates results directly into its response with source citations.
-
-This tool is invoked automatically by the model — you do NOT need to use XML tool calls for it. Simply ask questions that require up-to-date or real-world information and the model will search the web as needed.
-
-Capabilities:
-- Real-time web search with grounded citations
-- Automatic query generation and result synthesis
-- Source attribution with URLs
-`;
-
-export const urlContextToolDefinition = `
-## gemini_url_context (Gemini Built-in)
-Description: URL content reader powered by Google. This is a built-in Gemini capability that automatically fetches and analyzes the content of URLs mentioned in the conversation. When you include URLs in your message, the model can read and understand their content.
-
-This tool is invoked automatically by the model — you do NOT need to use XML tool calls for it. Simply include URLs in your message and the model will fetch and analyze their content.
-
-Capabilities:
-- Fetch and read web page content from URLs in the prompt
-- Supports up to 20 URLs per request
-- Processes HTML content (does not execute JavaScript)
-`;
+// Tool descriptions (used by Vercel tool() definitions)
 
 export const searchDescription = 'Search code in the repository. Free-form questions are accepted, but Elasticsearch-style keyword queries work best. Use this tool first for any code-related questions.';
 export const queryDescription = 'Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.';
@@ -438,261 +156,6 @@ export const delegateDescription = 'Automatically delegate big distinct tasks to
 export const bashDescription = 'Execute bash commands for system exploration and development tasks. Secure by default with built-in allow/deny lists.';
 export const analyzeAllDescription = 'Answer questions that require analyzing ALL matching data in the codebase. Use for aggregate questions like "What features exist?", "List all API endpoints", "Count TODO comments". The AI automatically plans the search strategy, processes all results via map-reduce, and synthesizes a comprehensive answer. WARNING: Slower than search - only use when you need complete coverage.';
 
-// Valid tool names that should be parsed as tool calls
-// This is the canonical list - all other tool lists should reference this
-export const DEFAULT_VALID_TOOLS = [
-	'search',
-	'query',
-	'extract',
-	'delegate',
-	'analyze_all',
-	'execute_plan',
-	'cleanup_execute_plan',
-	'listSkills',
-	'useSkill',
-	'listFiles',
-	'searchFiles',
-	'bash',
-	'task',
-	'attempt_completion'
-];
-
-/**
- * Build a regex pattern to match any tool tag from the valid tools list
- * @param {string[]} tools - List of tool names (defaults to DEFAULT_VALID_TOOLS)
- * @returns {RegExp} - Regex pattern to match tool opening tags
- */
-export function buildToolTagPattern(tools = DEFAULT_VALID_TOOLS) {
-	// Also include attempt_complete as an alias for attempt_completion
-	const allTools = [...tools];
-	if (allTools.includes('attempt_completion') && !allTools.includes('attempt_complete')) {
-		allTools.push('attempt_complete');
-	}
-	const escaped = allTools.map(t => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
-	return new RegExp(`<(${escaped.join('|')})>`);
-}
-
-/**
- * Get valid parameter names for a specific tool from its schema
- * @param {string} toolName - Name of the tool
- * @returns {string[]} - Array of valid parameter names for this tool
- */
-function getValidParamsForTool(toolName) {
-	// Map tool names to their schemas (supports both Zod and JSON Schema formats)
-	const schemaMap = {
-		search: searchSchema,
-		query: querySchema,
-		extract: extractSchema,
-		delegate: delegateSchema,
-		analyze_all: analyzeAllSchema,
-		execute_plan: executePlanSchema,
-		listSkills: listSkillsSchema,
-		useSkill: useSkillSchema,
-		bash: bashSchema,
-		task: taskSchema,
-		attempt_completion: attemptCompletionSchema,
-		edit: editSchema,
-		create: createSchema,
-		multi_edit: multiEditSchema
-	};
-
-	const schema = schemaMap[toolName];
-	if (!schema) {
-		// For tools without schema (listFiles, searchFiles), return common params
-		// These are the shared params that appear across multiple tools
-		return ['path', 'directory', 'pattern', 'recursive', 'includeHidden', 'task', 'files', 'result'];
-	}
-
-	// For attempt_completion, it has custom validation, just return 'result'
-	if (toolName === 'attempt_completion') {
-		return ['result'];
-	}
-
-	// Extract keys from Zod schema
-	if (schema._def && schema._def.shape) {
-		return Object.keys(schema._def.shape());
-	}
-
-	// Extract keys from JSON Schema (used by edit and create tools)
-	if (schema.properties) {
-		return Object.keys(schema.properties);
-	}
-
-	// Fallback: return empty array if we can't extract schema keys
-	return [];
-}
-
-/**
- * Unescape standard XML entities in a string value.
- * Order matters: &amp; must be decoded LAST to avoid double-decoding
- * (e.g., &amp;lt; should become &lt;, not <).
- * @param {string} str - The string to unescape
- * @returns {string} The unescaped string
- */
-export function unescapeXmlEntities(str) {
-	if (typeof str !== 'string') return str;
-	return str
-		.replace(/&lt;/g, '<')
-		.replace(/&gt;/g, '>')
-		.replace(/&quot;/g, '"')
-		.replace(/&apos;/g, "'")
-		.replace(/&amp;/g, '&');
-}
-
-// Parameters that contain arbitrary code/file content — use lastIndexOf for closing tag
-// to handle cases where the content itself contains the closing tag string.
-const RAW_CONTENT_PARAMS = new Set(['content', 'new_string', 'old_string']);
-
-// Tools whose content can include their own closing tag string (e.g., file content
-// containing </create> or </edit>). Use lastIndexOf for outer tag boundary, same
-// strategy already used for attempt_completion.
-const LAST_INDEX_TOOLS = new Set(['attempt_completion', 'create', 'edit']);
-
-// Simple XML parser helper - safer string-based approach
-export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
-	// Find the tool that appears EARLIEST in the string
-	// This prevents parameter tags (like <query> inside <analyze_all>) from being matched as tools
-	let earliestToolName = null;
-	let earliestOpenIndex = Infinity;
-
-	for (const toolName of validTools) {
-		const openTag = `<${toolName}>`;
-		const openIndex = xmlString.indexOf(openTag);
-		if (openIndex !== -1 && openIndex < earliestOpenIndex) {
-			earliestOpenIndex = openIndex;
-			earliestToolName = toolName;
-		}
-	}
-
-	// No valid tool found
-	if (earliestToolName === null) {
-		return null;
-	}
-
-	const toolName = earliestToolName;
-	const openTag = `<${toolName}>`;
-	const closeTag = `</${toolName}>`;
-	const openIndex = earliestOpenIndex;
-
-	// For tools that contain arbitrary content (file content, code), use lastIndexOf
-	// to find the LAST occurrence of the closing tag. This prevents issues where the
-	// content itself contains the closing tag string (e.g., file content with </create>).
-	// For other tools, use indexOf from the opening tag position.
-	let closeIndex;
-	if (LAST_INDEX_TOOLS.has(toolName)) {
-		// Find the last occurrence of the closing tag in the entire string
-		closeIndex = xmlString.lastIndexOf(closeTag);
-		// Make sure the closing tag is after the opening tag
-		if (closeIndex !== -1 && closeIndex <= openIndex + openTag.length) {
-			closeIndex = -1; // Invalid, treat as no closing tag
-		}
-	} else {
-		closeIndex = xmlString.indexOf(closeTag, openIndex + openTag.length);
-	}
-
-	let hasClosingTag = closeIndex !== -1;
-
-	// If no closing tag found, use content until end of string
-	// This makes the parser more resilient to AI formatting errors
-	if (closeIndex === -1) {
-		closeIndex = xmlString.length;
-	}
-
-	// Extract the content between tags (or until end if no closing tag)
-	const innerContent = xmlString.substring(
-		openIndex + openTag.length,
-		closeIndex
-	);
-
-	const params = {};
-
-	// Get valid parameters for this specific tool from its schema
-	const validParams = getValidParamsForTool(toolName);
-
-	// Parse parameters using string-based approach for better safety
-	// Only look for parameters that are valid for this specific tool
-	for (const paramName of validParams) {
-		const paramOpenTag = `<${paramName}>`;
-		const paramCloseTag = `</${paramName}>`;
-
-		const paramOpenIndex = innerContent.indexOf(paramOpenTag);
-		if (paramOpenIndex === -1) {
-			continue; // Parameter not found
-		}
-
-		// For raw content params (file content, code), use lastIndexOf to find the
-		// LAST closing tag — the content itself may contain the closing tag string.
-		// For other params (file_path, overwrite, etc.), use indexOf (first match).
-		let paramCloseIndex;
-		if (RAW_CONTENT_PARAMS.has(paramName)) {
-			paramCloseIndex = innerContent.lastIndexOf(paramCloseTag);
-			// Ensure it's after the opening tag
-			if (paramCloseIndex !== -1 && paramCloseIndex <= paramOpenIndex + paramOpenTag.length) {
-				paramCloseIndex = -1;
-			}
-		} else {
-			paramCloseIndex = innerContent.indexOf(paramCloseTag, paramOpenIndex + paramOpenTag.length);
-		}
-
-		// Handle unclosed parameter tags - use content until next tag or end of content
-		if (paramCloseIndex === -1) {
-			// Find the next opening tag after this parameter
-			let nextTagIndex = innerContent.length;
-			for (const nextParam of validParams) {
-				const nextOpenTag = `<${nextParam}>`;
-				const nextIndex = innerContent.indexOf(nextOpenTag, paramOpenIndex + paramOpenTag.length);
-				if (nextIndex !== -1 && nextIndex < nextTagIndex) {
-					nextTagIndex = nextIndex;
-				}
-			}
-			paramCloseIndex = nextTagIndex;
-		}
-
-		const rawValue = innerContent.substring(
-			paramOpenIndex + paramOpenTag.length,
-			paramCloseIndex
-		);
-
-		// For raw content params, preserve whitespace (only strip XML formatting newlines).
-		// For other params, trim all whitespace.
-		let paramValue;
-		if (RAW_CONTENT_PARAMS.has(paramName)) {
-			paramValue = unescapeXmlEntities(rawValue.replace(/^\n/, '').replace(/\n$/, ''));
-		} else {
-			paramValue = unescapeXmlEntities(rawValue.trim());
-		}
-
-		// Type coercion for non-content params only (content/new_string/old_string must stay strings)
-		if (!RAW_CONTENT_PARAMS.has(paramName)) {
-			if (paramValue.toLowerCase() === 'true') {
-				paramValue = true;
-			} else if (paramValue.toLowerCase() === 'false') {
-				paramValue = false;
-			} else if (!isNaN(paramValue) && paramValue.trim() !== '') {
-				// Check if it's potentially a number (handle integers and floats)
-				const num = Number(paramValue);
-				if (Number.isFinite(num)) { // Use Number.isFinite to avoid Infinity/NaN
-					paramValue = num;
-				}
-				// Keep as string if not a valid finite number
-			}
-		}
-
-		params[paramName] = paramValue;
-	}
-
-	// Special handling for attempt_completion - use entire inner content as result
-	if (toolName === 'attempt_completion') {
-		params['result'] = unescapeXmlEntities(innerContent.trim());
-		// Remove command parameter if it was parsed by generic logic above (legacy compatibility)
-		if (params.command) {
-			delete params.command;
-		}
-	}
-
-	// Return the parsed tool call
-	return { toolName, params };
-}
 
 /**
  * Creates an improved preview of a message showing start and end portions
@@ -723,161 +186,6 @@ export function createMessagePreview(message, charsPerSide = 200) {
 	return `${start}...${end}`;
 }
 
-/**
- * Detect if the response contains an XML-style tool tag that wasn't recognized
- * This helps identify when the AI tried to use a tool that's not in the validTools list
- *
- * @param {string} xmlString - The XML string to search
- * @param {string[]} validTools - List of valid tool names that would have been recognized
- * @returns {string|null} - The unrecognized tool name, or null if no unrecognized tools found
- */
-export function detectUnrecognizedToolCall(xmlString, validTools) {
-	if (!xmlString || typeof xmlString !== 'string') {
-		return null;
-	}
-
-	// Common tool names that AI might try to use (these should appear as top-level tags)
-	const knownToolNames = [
-		'search', 'query', 'extract', 'listFiles', 'searchFiles',
-		'listSkills', 'useSkill', 'readImage', 'edit',
-		'create', 'multi_edit', 'delegate', 'bash', 'task', 'attempt_completion',
-		'attempt_complete', 'read_file', 'write_file', 'run_command',
-		'grep', 'find', 'cat', 'list_directory'
-	];
-
-	// Look for XML tags that match known tool patterns
-	// Only consider a tag as a tool call if:
-	// 1. It's not in the validTools list (wouldn't have been parsed)
-	// 2. It appears as a top-level tag (not nested inside another tool)
-	for (const toolName of knownToolNames) {
-		if (validTools.includes(toolName)) {
-			continue; // Skip valid tools - these would have been parsed
-		}
-
-		const openTag = `<${toolName}>`;
-		const closeTag = `</${toolName}>`;
-
-		// Check if this tool tag exists
-		const openIndex = xmlString.indexOf(openTag);
-		if (openIndex === -1) {
-			continue;
-		}
-
-		// Check if this tag is nested inside a valid tool tag
-		let isNested = false;
-		for (const validTool of validTools) {
-			const validOpenTag = `<${validTool}>`;
-			const validCloseTag = `</${validTool}>`;
-			const validOpenIndex = xmlString.indexOf(validOpenTag);
-			const validCloseIndex = xmlString.indexOf(validCloseTag);
-
-			// If the unrecognized tool tag is between a valid tool's open and close tags, it's nested (a parameter)
-			if (validOpenIndex !== -1 && validCloseIndex !== -1 &&
-			    validOpenIndex < openIndex && openIndex < validCloseIndex) {
-				isNested = true;
-				break;
-			}
-		}
-
-		if (!isNested) {
-			return toolName;
-		}
-	}
-
-	// 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;
-}
-
-/**
- * Detect if a response indicates the agent is "stuck" and cannot proceed.
- * This uses semantic pattern matching to catch variations of "I cannot proceed"
- * that would bypass exact string matching.
- *
- * @param {string} response - The assistant response to check
- * @returns {boolean} - True if the response indicates a stuck state
- */
-export function detectStuckResponse(response) {
-	if (!response || typeof response !== 'string') {
-		return false;
-	}
-
-	const lowerResponse = response.toLowerCase();
-
-	// Patterns that indicate the agent is stuck
-	// Note: Use [''] to match both straight and curly apostrophes
-	const stuckPatterns = [
-		// Cannot proceed patterns
-		/\bi\s+cannot\s+proceed\b/i,
-		/\bi\s+can['']t\s+(?:proceed|continue|move\s+forward)\b/i,
-		/\bunable\s+to\s+(?:proceed|continue|complete)\b/i,
-		/\bblocked\b.*\b(?:proceed|continue)\b/i,
-		// Missing information patterns
-		/\bneed\s+(?:the|an?)\s+\w+(?:\s+\w+)?\s+to\s+(?:proceed|continue)\b/i,
-		/\brequire[sd]?\s+(?:the|an?)\s+\w+\b.*\bto\s+(?:proceed|continue)\b/i,
-		/\bmissing\s+(?:required|necessary|essential)\b/i,
-		// Deadlock/loop patterns
-		/\bdeadlock\b/i,
-		/\bwe\s+are\s+in\s+a\s+loop\b/i,
-		/\bstuck\s+in\s+a\s+loop\b/i,
-		/\bi\s+(?:have|['']ve)\s+(?:explained|stated|mentioned)\s+(?:this|the\s+situation|it)\s+(?:multiple|several)\s+times\b/i,
-		// Cannot find/get patterns
-		/\bi\s+(?:cannot|can['']t|could\s+not|couldn['']t)\s+(?:find|locate|get|retrieve|obtain)\s+(?:the|this|that|an?)\b/i,
-		/\bno\s+way\s+to\s+(?:find|get|obtain|retrieve)\b/i,
-		// Exhausted options patterns
-		/\bi\s+(?:have|['']ve)\s+exhausted\s+(?:all|my)\s+(?:available\s+)?(?:options|methods|approaches)\b/i,
-		/\bneither\s+of\s+these\s+methods\b/i,
-	];
-
-	for (const pattern of stuckPatterns) {
-		if (pattern.test(response)) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * Check if two responses are semantically similar (both indicate being stuck)
- * This is a lightweight check that groups stuck responses together
- *
- * @param {string} response1 - First response
- * @param {string} response2 - Second response
- * @returns {boolean} - True if both responses indicate a stuck state
- */
-export function areBothStuckResponses(response1, response2) {
-	return detectStuckResponse(response1) && detectStuckResponse(response2);
-}
 
 /**
  * Parse targets string into array of file specifications