@probelabs/probe 0.6.0-rc198 → 0.6.0-rc200

package/cjs/index.cjs

@@ -30515,261 +30515,6 @@ var init_imageConfig = __esm({
   }
 });
 
-// src/agent/xmlParsingUtils.js
-function removeThinkingTags(xmlString) {
-  let result = xmlString;
-  result = result.replace(/<thinking>[\s\S]*?<\/thinking>/g, "");
-  const thinkingIndex = result.indexOf("<thinking>");
-  if (thinkingIndex !== -1) {
-    const afterThinking = result.substring(thinkingIndex + "<thinking>".length);
-    const toolPattern = /<(search|query|extract|listFiles|searchFiles|implement|attempt_completion|attempt_complete)>/;
-    const toolMatch = afterThinking.match(toolPattern);
-    if (toolMatch) {
-      const toolStart = thinkingIndex + "<thinking>".length + toolMatch.index;
-      result = result.substring(0, thinkingIndex) + result.substring(toolStart);
-    } else {
-      result = result.substring(0, thinkingIndex);
-    }
-  }
-  return result.trim();
-}
-function extractThinkingContent(xmlString) {
-  const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
-  return thinkingMatch ? thinkingMatch[1].trim() : null;
-}
-function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
-  const openTagIndex = cleanedXmlString.indexOf("<attempt_completion>");
-  if (openTagIndex !== -1) {
-    const afterOpenTag = cleanedXmlString.substring(openTagIndex + "<attempt_completion>".length);
-    const closeTagIndex = cleanedXmlString.lastIndexOf("</attempt_completion>");
-    let content;
-    let hasClosingTag = false;
-    if (closeTagIndex !== -1 && closeTagIndex >= openTagIndex + "<attempt_completion>".length) {
-      content = cleanedXmlString.substring(
-        openTagIndex + "<attempt_completion>".length,
-        closeTagIndex
-      ).trim();
-      hasClosingTag = true;
-    } else {
-      content = afterOpenTag.trim();
-      hasClosingTag = false;
-    }
-    if (content) {
-      return {
-        toolName: "attempt_completion",
-        params: { result: content }
-      };
-    }
-    return {
-      toolName: "attempt_completion",
-      params: { result: hasClosingTag ? "" : "__PREVIOUS_RESPONSE__" }
-    };
-  }
-  const attemptCompletePatterns = [
-    // Standard shorthand with optional whitespace
-    /^<attempt_complete>\s*$/,
-    // Empty with proper closing tag (common case from the logs)
-    /^<attempt_complete>\s*<\/attempt_complete>\s*$/,
-    // Self-closing variant
-    /^<attempt_complete\s*\/>\s*$/,
-    // Incomplete opening tag (missing closing bracket)
-    /^<attempt_complete\s*$/,
-    // With trailing content (extract just the tag part) - must come after empty tag pattern
-    /^<attempt_complete>(.*)$/s,
-    // Self-closing with trailing content
-    /^<attempt_complete\s*\/>(.*)$/s
-  ];
-  for (const pattern of attemptCompletePatterns) {
-    const match2 = cleanedXmlString.match(pattern);
-    if (match2) {
-      return {
-        toolName: "attempt_completion",
-        params: { result: "__PREVIOUS_RESPONSE__" }
-      };
-    }
-  }
-  if (cleanedXmlString.includes("<attempt_complete") && !hasOtherToolTags(cleanedXmlString, validTools)) {
-    return {
-      toolName: "attempt_completion",
-      params: { result: "__PREVIOUS_RESPONSE__" }
-    };
-  }
-  return null;
-}
-function hasOtherToolTags(xmlString, validTools = []) {
-  const defaultTools = ["search", "query", "extract", "listFiles", "searchFiles", "implement", "attempt_completion"];
-  const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
-  for (const tool4 of toolsToCheck) {
-    if (tool4 !== "attempt_completion" && xmlString.includes(`<${tool4}`)) {
-      return true;
-    }
-  }
-  return false;
-}
-function processXmlWithThinkingAndRecovery(xmlString, validTools = []) {
-  const thinkingContent = extractThinkingContent(xmlString);
-  const cleanedXmlString = removeThinkingTags(xmlString);
-  const recoveryResult = checkAttemptCompleteRecovery(cleanedXmlString, validTools);
-  if (process.env.DEBUG === "1" && thinkingContent) {
-    console.log(`[DEBUG] AI Thinking Process:
-${thinkingContent}`);
-  }
-  return {
-    cleanedXmlString,
-    thinkingContent,
-    recoveryResult
-  };
-}
-var init_xmlParsingUtils = __esm({
-  "src/agent/xmlParsingUtils.js"() {
-    "use strict";
-  }
-});
-
-// src/agent/tools.js
-function createTools(configOptions) {
-  const tools2 = {};
-  const isToolAllowed = configOptions.isToolAllowed || ((toolName) => {
-    if (!configOptions.allowedTools) return true;
-    return configOptions.allowedTools.isEnabled(toolName);
-  });
-  if (isToolAllowed("search")) {
-    tools2.searchTool = searchTool(configOptions);
-  }
-  if (isToolAllowed("query")) {
-    tools2.queryTool = queryTool(configOptions);
-  }
-  if (isToolAllowed("extract")) {
-    tools2.extractTool = extractTool(configOptions);
-  }
-  if (configOptions.enableDelegate && isToolAllowed("delegate")) {
-    tools2.delegateTool = delegateTool(configOptions);
-  }
-  if (configOptions.enableBash && isToolAllowed("bash")) {
-    tools2.bashTool = bashTool(configOptions);
-  }
-  if (configOptions.allowEdit && isToolAllowed("edit")) {
-    tools2.editTool = editTool(configOptions);
-  }
-  if (configOptions.allowEdit && isToolAllowed("create")) {
-    tools2.createTool = createTool(configOptions);
-  }
-  return tools2;
-}
-function parseXmlToolCallWithThinking(xmlString, validTools) {
-  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
-  if (recoveryResult) {
-    return recoveryResult;
-  }
-  return parseXmlToolCall(cleanedXmlString, validTools);
-}
-var import_crypto2, implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition, readImageToolDefinition;
-var init_tools = __esm({
-  "src/agent/tools.js"() {
-    "use strict";
-    init_index();
-    import_crypto2 = require("crypto");
-    init_xmlParsingUtils();
-    implementToolDefinition = `
-## implement
-Description: Implement a given task. Can modify files. Can be used ONLY if task explicitly stated that something requires modification or implementation.
-
-Parameters:
-- task: (required) The task description. Should be as detailed as possible, ideally pointing to exact files which needs be modified or created.
-- autoCommits: (optional) Whether to enable auto-commits in aider. Default is false.
-
-Usage Example:
-
-<examples>
-
-User: Can you implement a function to calculate Fibonacci numbers in main.js?
-<implement>
-<task>Implement a recursive function to calculate the nth Fibonacci number in main.js</task>
-</implement>
-
-User: Can you implement a function to calculate Fibonacci numbers in main.js with auto-commits?
-<implement>
-<task>Implement a recursive function to calculate the nth Fibonacci number in main.js</task>
-<autoCommits>true</autoCommits>
-</implement>
-
-</examples>
-`;
-    listFilesToolDefinition = `
-## listFiles
-Description: List files and directories in a specified location.
-
-Parameters:
-- directory: (optional) The directory path to list files from. Defaults to current directory if not specified.
-
-Usage Example:
-
-<examples>
-
-User: Can you list the files in the src directory?
-<listFiles>
-<directory>src</directory>
-</listFiles>
-
-User: What files are in the current directory?
-<listFiles>
-</listFiles>
-
-</examples>
-`;
-    searchFilesToolDefinition = `
-## searchFiles
-Description: Find files with name matching a glob pattern with recursive search capability.
-
-Parameters:
-- pattern: (required) The glob pattern to search for (e.g., "**/*.js", "*.md").
-- directory: (optional) The directory to search in. Defaults to current directory if not specified.
-- recursive: (optional) Whether to search recursively. Defaults to true.
-
-Usage Example:
-
-<examples>
-
-User: Can you find all JavaScript files in the project?
-<searchFiles>
-<pattern>**/*.js</pattern>
-</searchFiles>
-
-User: Find all markdown files in the docs directory, but only at the top level.
-<searchFiles>
-<pattern>*.md</pattern>
-<directory>docs</directory>
-<recursive>false</recursive>
-</searchFiles>
-
-</examples>
-`;
-    readImageToolDefinition = `
-## readImage
-Description: Read and load an image file so it can be viewed by the AI. Use this when you need to analyze, describe, or work with image content. Images from user messages are automatically loaded, but use this tool to explicitly read images mentioned in tool outputs or when you need to examine specific image files.
-
-Parameters:
-- path: (required) The path to the image file to read. Supports png, jpg, jpeg, webp, bmp, and svg formats.
-
-Usage Example:
-
-<examples>
-
-User: Can you describe what's in screenshot.png?
-<readImage>
-<path>screenshot.png</path>
-</readImage>
-
-User: Analyze the diagram in docs/architecture.svg
-<readImage>
-<path>docs/architecture.svg</path>
-</readImage>
-
-</examples>
-`;
-  }
-});
-
 // node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType;
 var init_util2 = __esm({
@@ -34876,7 +34621,332 @@ var init_zod = __esm({
   }
 });
 
+// src/tools/edit.js
+function isPathAllowed(filePath, allowedFolders) {
+  if (!allowedFolders || allowedFolders.length === 0) {
+    const resolvedPath3 = (0, import_path5.resolve)(filePath);
+    const cwd = (0, import_path5.resolve)(process.cwd());
+    return resolvedPath3 === cwd || resolvedPath3.startsWith(cwd + import_path5.sep);
+  }
+  const resolvedPath2 = (0, import_path5.resolve)(filePath);
+  return allowedFolders.some((folder) => {
+    const allowedPath = (0, import_path5.resolve)(folder);
+    return resolvedPath2 === allowedPath || resolvedPath2.startsWith(allowedPath + import_path5.sep);
+  });
+}
+function parseFileToolOptions(options = {}) {
+  return {
+    debug: options.debug || false,
+    allowedFolders: options.allowedFolders || [],
+    cwd: options.cwd
+  };
+}
+var import_ai, import_fs4, import_path5, import_fs5, editTool, createTool, editSchema, createSchema, editDescription, createDescription, editToolDefinition, createToolDefinition;
+var init_edit = __esm({
+  "src/tools/edit.js"() {
+    "use strict";
+    import_ai = require("ai");
+    import_fs4 = require("fs");
+    import_path5 = require("path");
+    import_fs5 = require("fs");
+    editTool = (options = {}) => {
+      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
+      return (0, import_ai.tool)({
+        name: "edit",
+        description: `Edit files using exact string replacement (Claude Code style).
+
+This tool performs exact string replacements in files. It requires the old_string to match exactly what's in the file, including all whitespace and indentation.
+
+Parameters:
+- file_path: Path to the file to edit (absolute or relative)
+- old_string: Exact text to find and replace (must be unique in the file unless replace_all is true)
+- new_string: Text to replace with
+- replace_all: (optional) Replace all occurrences instead of requiring uniqueness
+
+Important:
+- The old_string must match EXACTLY including whitespace
+- If old_string appears multiple times and replace_all is false, the edit will fail
+- Use larger context around the string to ensure uniqueness when needed`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_path: {
+              type: "string",
+              description: "Path to the file to edit"
+            },
+            old_string: {
+              type: "string",
+              description: "Exact text to find and replace"
+            },
+            new_string: {
+              type: "string",
+              description: "Text to replace with"
+            },
+            replace_all: {
+              type: "boolean",
+              description: "Replace all occurrences (default: false)",
+              default: false
+            }
+          },
+          required: ["file_path", "old_string", "new_string"]
+        },
+        execute: async ({ file_path, old_string, new_string, replace_all = false }) => {
+          try {
+            if (!file_path || typeof file_path !== "string" || file_path.trim() === "") {
+              return `Error editing file: Invalid file_path - must be a non-empty string`;
+            }
+            if (old_string === void 0 || old_string === null || typeof old_string !== "string") {
+              return `Error editing file: Invalid old_string - must be a string`;
+            }
+            if (new_string === void 0 || new_string === null || typeof new_string !== "string") {
+              return `Error editing file: Invalid new_string - must be a string`;
+            }
+            const resolvedPath2 = (0, import_path5.isAbsolute)(file_path) ? file_path : (0, import_path5.resolve)(cwd || process.cwd(), file_path);
+            if (debug) {
+              console.error(`[Edit] Attempting to edit file: ${resolvedPath2}`);
+            }
+            if (!isPathAllowed(resolvedPath2, allowedFolders)) {
+              return `Error editing file: Permission denied - ${file_path} is outside allowed directories`;
+            }
+            if (!(0, import_fs5.existsSync)(resolvedPath2)) {
+              return `Error editing file: File not found - ${file_path}`;
+            }
+            const content = await import_fs4.promises.readFile(resolvedPath2, "utf-8");
+            if (!content.includes(old_string)) {
+              return `Error editing file: String not found - the specified old_string was not found in ${file_path}`;
+            }
+            const occurrences = content.split(old_string).length - 1;
+            if (!replace_all && occurrences > 1) {
+              return `Error editing file: Multiple occurrences found - the old_string appears ${occurrences} times. Use replace_all: true to replace all occurrences, or provide more context to make the string unique.`;
+            }
+            let newContent;
+            if (replace_all) {
+              newContent = content.replaceAll(old_string, new_string);
+            } else {
+              newContent = content.replace(old_string, new_string);
+            }
+            if (newContent === content) {
+              return `Error editing file: No changes made - old_string and new_string might be the same`;
+            }
+            await import_fs4.promises.writeFile(resolvedPath2, newContent, "utf-8");
+            const replacedCount = replace_all ? occurrences : 1;
+            if (debug) {
+              console.error(`[Edit] Successfully edited ${resolvedPath2}, replaced ${replacedCount} occurrence(s)`);
+            }
+            return `Successfully edited ${file_path} (${replacedCount} replacement${replacedCount !== 1 ? "s" : ""})`;
+          } catch (error2) {
+            console.error("[Edit] Error:", error2);
+            return `Error editing file: ${error2.message}`;
+          }
+        }
+      });
+    };
+    createTool = (options = {}) => {
+      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
+      return (0, import_ai.tool)({
+        name: "create",
+        description: `Create new files with specified content.
+
+This tool creates new files in the filesystem. It will create parent directories if they don't exist.
+
+Parameters:
+- file_path: Path where the file should be created (absolute or relative)
+- content: Content to write to the file
+- overwrite: (optional) Whether to overwrite if file exists (default: false)
+
+Important:
+- By default, will fail if the file already exists
+- Set overwrite: true to replace existing files
+- Parent directories will be created automatically if needed`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_path: {
+              type: "string",
+              description: "Path where the file should be created"
+            },
+            content: {
+              type: "string",
+              description: "Content to write to the file"
+            },
+            overwrite: {
+              type: "boolean",
+              description: "Overwrite if file exists (default: false)",
+              default: false
+            }
+          },
+          required: ["file_path", "content"]
+        },
+        execute: async ({ file_path, content, overwrite = false }) => {
+          try {
+            if (!file_path || typeof file_path !== "string" || file_path.trim() === "") {
+              return `Error creating file: Invalid file_path - must be a non-empty string`;
+            }
+            if (content === void 0 || content === null || typeof content !== "string") {
+              return `Error creating file: Invalid content - must be a string`;
+            }
+            const resolvedPath2 = (0, import_path5.isAbsolute)(file_path) ? file_path : (0, import_path5.resolve)(cwd || process.cwd(), file_path);
+            if (debug) {
+              console.error(`[Create] Attempting to create file: ${resolvedPath2}`);
+            }
+            if (!isPathAllowed(resolvedPath2, allowedFolders)) {
+              return `Error creating file: Permission denied - ${file_path} is outside allowed directories`;
+            }
+            if ((0, import_fs5.existsSync)(resolvedPath2) && !overwrite) {
+              return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
+            }
+            const dir = (0, import_path5.dirname)(resolvedPath2);
+            await import_fs4.promises.mkdir(dir, { recursive: true });
+            await import_fs4.promises.writeFile(resolvedPath2, content, "utf-8");
+            const action = (0, import_fs5.existsSync)(resolvedPath2) && overwrite ? "overwrote" : "created";
+            const bytes = Buffer.byteLength(content, "utf-8");
+            if (debug) {
+              console.error(`[Create] Successfully ${action} ${resolvedPath2}`);
+            }
+            return `Successfully ${action} ${file_path} (${bytes} bytes)`;
+          } catch (error2) {
+            console.error("[Create] Error:", error2);
+            return `Error creating file: ${error2.message}`;
+          }
+        }
+      });
+    };
+    editSchema = {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Path to the file to edit"
+        },
+        old_string: {
+          type: "string",
+          description: "Exact text to find and replace"
+        },
+        new_string: {
+          type: "string",
+          description: "Text to replace with"
+        },
+        replace_all: {
+          type: "boolean",
+          description: "Replace all occurrences (default: false)"
+        }
+      },
+      required: ["file_path", "old_string", "new_string"]
+    };
+    createSchema = {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Path where the file should be created"
+        },
+        content: {
+          type: "string",
+          description: "Content to write to the file"
+        },
+        overwrite: {
+          type: "boolean",
+          description: "Overwrite if file exists (default: false)"
+        }
+      },
+      required: ["file_path", "content"]
+    };
+    editDescription = "Edit files using exact string replacement. Requires exact match including whitespace.";
+    createDescription = "Create new files with specified content. Will create parent directories if needed.";
+    editToolDefinition = `
+## edit
+Description: ${editDescription}
+
+When to use:
+- For precise, surgical edits to existing files
+- When you need to change specific lines or blocks of code
+- For renaming functions, variables, or updating configuration values
+- When the exact text to replace is known and unique (or use replace_all for multiple occurrences)
+
+When NOT to use:
+- For creating new files (use 'create' tool instead)
+- When you cannot determine the exact text to replace
+- When changes span multiple locations that would be better handled together
+
+Parameters:
+- file_path: (required) Path to the file to edit
+- old_string: (required) Exact text to find and replace (must match including whitespace, newlines, and indentation)
+- new_string: (required) Text to replace with
+- replace_all: (optional, default: false) Replace all occurrences if the string appears multiple times
+
+Important notes:
+- The old_string MUST match EXACTLY, including all whitespace, indentation, and line breaks
+- If old_string appears multiple times and replace_all is false, the tool will fail
+- Always verify the exact formatting of the text you want to replace
+
+Examples:
+<edit>
+<file_path>src/main.js</file_path>
+<old_string>function oldName() {
+  return 42;
+}</old_string>
+<new_string>function newName() {
+  return 42;
+}</new_string>
+</edit>
+
+<edit>
+<file_path>config.json</file_path>
+<old_string>"debug": false</old_string>
+<new_string>"debug": true</new_string>
+<replace_all>true</replace_all>
+</edit>`;
+    createToolDefinition = `
+## create
+Description: ${createDescription}
+
+When to use:
+- For creating brand new files from scratch
+- When you need to add configuration files, documentation, or new modules
+- For generating boilerplate code or templates
+- When you have the complete content ready to write
+
+When NOT to use:
+- For editing existing files (use 'edit' tool instead)
+- When a file already exists unless you explicitly want to overwrite it
+
+Parameters:
+- file_path: (required) Path where the file should be created
+- content: (required) Complete content to write to the file
+- overwrite: (optional, default: false) Whether to overwrite if file already exists
+
+Important notes:
+- Parent directories will be created automatically if they don't exist
+- The tool will fail if the file already exists and overwrite is false
+- Be careful with the overwrite option as it completely replaces existing files
+
+Examples:
+<create>
+<file_path>src/newFile.js</file_path>
+<content>export function hello() {
+  return "Hello, world!";
+}</content>
+</create>
+
+<create>
+<file_path>README.md</file_path>
+<content># My Project
+
+This is a new project.</content>
+<overwrite>true</overwrite>
+</create>`;
+  }
+});
+
 // src/tools/common.js
+function buildToolTagPattern(tools2 = DEFAULT_VALID_TOOLS) {
+  const allTools = [...tools2];
+  if (allTools.includes("attempt_completion") && !allTools.includes("attempt_complete")) {
+    allTools.push("attempt_complete");
+  }
+  const escaped = allTools.map((t4) => t4.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(`<(${escaped.join("|")})>`);
+}
 function getValidParamsForTool(toolName) {
   const schemaMap = {
     search: searchSchema,
@@ -34884,7 +34954,9 @@ function getValidParamsForTool(toolName) {
     extract: extractSchema,
     delegate: delegateSchema,
     bash: bashSchema,
-    attempt_completion: attemptCompletionSchema
+    attempt_completion: attemptCompletionSchema,
+    edit: editSchema,
+    create: createSchema
   };
   const schema = schemaMap[toolName];
   if (!schema) {
@@ -34893,9 +34965,12 @@ function getValidParamsForTool(toolName) {
   if (toolName === "attempt_completion") {
     return ["result"];
   }
-  if (schema && schema._def && schema._def.shape) {
+  if (schema._def && schema._def.shape) {
     return Object.keys(schema._def.shape());
   }
+  if (schema.properties) {
+    return Object.keys(schema.properties);
+  }
   return [];
 }
 function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
@@ -34995,10 +35070,10 @@ function parseAndResolvePaths(pathStr, cwd) {
   if (!pathStr) return [];
   const paths = pathStr.split(",").map((p4) => p4.trim()).filter((p4) => p4.length > 0);
   return paths.map((p4) => {
-    if ((0, import_path5.isAbsolute)(p4)) {
+    if ((0, import_path6.isAbsolute)(p4)) {
       return p4;
     }
-    return cwd ? (0, import_path5.resolve)(cwd, p4) : p4;
+    return cwd ? (0, import_path6.resolve)(cwd, p4) : p4;
   });
 }
 function resolveTargetPath(target, cwd) {
@@ -35016,17 +35091,18 @@ function resolveTargetPath(target, cwd) {
     filePart = target;
     suffix = "";
   }
-  if (!(0, import_path5.isAbsolute)(filePart) && cwd) {
-    filePart = (0, import_path5.resolve)(cwd, filePart);
+  if (!(0, import_path6.isAbsolute)(filePart) && cwd) {
+    filePart = (0, import_path6.resolve)(cwd, filePart);
   }
   return filePart + suffix;
 }
-var import_path5, searchSchema, querySchema, extractSchema, delegateSchema, bashSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, bashToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, bashDescription, DEFAULT_VALID_TOOLS;
+var import_path6, searchSchema, querySchema, extractSchema, delegateSchema, bashSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, bashToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, bashDescription, DEFAULT_VALID_TOOLS;
 var init_common2 = __esm({
   "src/tools/common.js"() {
     "use strict";
     init_zod();
-    import_path5 = require("path");
+    import_path6 = require("path");
+    init_edit();
     searchSchema = external_exports.object({
       query: external_exports.string().describe("Search query with Elasticsearch syntax. Use quotes for exact matches, AND/OR for boolean logic, - for negation."),
       path: external_exports.string().optional().default(".").describe('Path to search in. For dependencies use "go:github.com/owner/repo", "js:package_name", or "rust:cargo_name" etc.')
@@ -35328,11 +35404,267 @@ User: Check system info
       "listFiles",
       "searchFiles",
       "implement",
+      "bash",
       "attempt_completion"
     ];
   }
 });
 
+// src/agent/xmlParsingUtils.js
+function removeThinkingTags(xmlString) {
+  let result = xmlString;
+  result = result.replace(/<thinking>[\s\S]*?<\/thinking>/g, "");
+  const thinkingIndex = result.indexOf("<thinking>");
+  if (thinkingIndex !== -1) {
+    const afterThinking = result.substring(thinkingIndex + "<thinking>".length);
+    const toolPattern = buildToolTagPattern(DEFAULT_VALID_TOOLS);
+    const toolMatch = afterThinking.match(toolPattern);
+    if (toolMatch) {
+      const toolStart = thinkingIndex + "<thinking>".length + toolMatch.index;
+      result = result.substring(0, thinkingIndex) + result.substring(toolStart);
+    } else {
+      result = result.substring(0, thinkingIndex);
+    }
+  }
+  return result.trim();
+}
+function extractThinkingContent(xmlString) {
+  const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
+  return thinkingMatch ? thinkingMatch[1].trim() : null;
+}
+function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
+  const openTagIndex = cleanedXmlString.indexOf("<attempt_completion>");
+  if (openTagIndex !== -1) {
+    const afterOpenTag = cleanedXmlString.substring(openTagIndex + "<attempt_completion>".length);
+    const closeTagIndex = cleanedXmlString.lastIndexOf("</attempt_completion>");
+    let content;
+    let hasClosingTag = false;
+    if (closeTagIndex !== -1 && closeTagIndex >= openTagIndex + "<attempt_completion>".length) {
+      content = cleanedXmlString.substring(
+        openTagIndex + "<attempt_completion>".length,
+        closeTagIndex
+      ).trim();
+      hasClosingTag = true;
+    } else {
+      content = afterOpenTag.trim();
+      hasClosingTag = false;
+    }
+    if (content) {
+      return {
+        toolName: "attempt_completion",
+        params: { result: content }
+      };
+    }
+    return {
+      toolName: "attempt_completion",
+      params: { result: hasClosingTag ? "" : "__PREVIOUS_RESPONSE__" }
+    };
+  }
+  const attemptCompletePatterns = [
+    // Standard shorthand with optional whitespace
+    /^<attempt_complete>\s*$/,
+    // Empty with proper closing tag (common case from the logs)
+    /^<attempt_complete>\s*<\/attempt_complete>\s*$/,
+    // Self-closing variant
+    /^<attempt_complete\s*\/>\s*$/,
+    // Incomplete opening tag (missing closing bracket)
+    /^<attempt_complete\s*$/,
+    // With trailing content (extract just the tag part) - must come after empty tag pattern
+    /^<attempt_complete>(.*)$/s,
+    // Self-closing with trailing content
+    /^<attempt_complete\s*\/>(.*)$/s
+  ];
+  for (const pattern of attemptCompletePatterns) {
+    const match2 = cleanedXmlString.match(pattern);
+    if (match2) {
+      return {
+        toolName: "attempt_completion",
+        params: { result: "__PREVIOUS_RESPONSE__" }
+      };
+    }
+  }
+  if (cleanedXmlString.includes("<attempt_complete") && !hasOtherToolTags(cleanedXmlString, validTools)) {
+    return {
+      toolName: "attempt_completion",
+      params: { result: "__PREVIOUS_RESPONSE__" }
+    };
+  }
+  return null;
+}
+function hasOtherToolTags(xmlString, validTools = []) {
+  const toolsToCheck = validTools.length > 0 ? validTools : DEFAULT_VALID_TOOLS;
+  for (const tool4 of toolsToCheck) {
+    if (tool4 !== "attempt_completion" && xmlString.includes(`<${tool4}`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function processXmlWithThinkingAndRecovery(xmlString, validTools = []) {
+  const thinkingContent = extractThinkingContent(xmlString);
+  const cleanedXmlString = removeThinkingTags(xmlString);
+  const recoveryResult = checkAttemptCompleteRecovery(cleanedXmlString, validTools);
+  if (process.env.DEBUG === "1" && thinkingContent) {
+    console.log(`[DEBUG] AI Thinking Process:
+${thinkingContent}`);
+  }
+  return {
+    cleanedXmlString,
+    thinkingContent,
+    recoveryResult
+  };
+}
+var init_xmlParsingUtils = __esm({
+  "src/agent/xmlParsingUtils.js"() {
+    "use strict";
+    init_common2();
+  }
+});
+
+// src/agent/tools.js
+function createTools(configOptions) {
+  const tools2 = {};
+  const isToolAllowed = configOptions.isToolAllowed || ((toolName) => {
+    if (!configOptions.allowedTools) return true;
+    return configOptions.allowedTools.isEnabled(toolName);
+  });
+  if (isToolAllowed("search")) {
+    tools2.searchTool = searchTool(configOptions);
+  }
+  if (isToolAllowed("query")) {
+    tools2.queryTool = queryTool(configOptions);
+  }
+  if (isToolAllowed("extract")) {
+    tools2.extractTool = extractTool(configOptions);
+  }
+  if (configOptions.enableDelegate && isToolAllowed("delegate")) {
+    tools2.delegateTool = delegateTool(configOptions);
+  }
+  if (configOptions.enableBash && isToolAllowed("bash")) {
+    tools2.bashTool = bashTool(configOptions);
+  }
+  if (configOptions.allowEdit && isToolAllowed("edit")) {
+    tools2.editTool = editTool(configOptions);
+  }
+  if (configOptions.allowEdit && isToolAllowed("create")) {
+    tools2.createTool = createTool(configOptions);
+  }
+  return tools2;
+}
+function parseXmlToolCallWithThinking(xmlString, validTools) {
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+  return parseXmlToolCall(cleanedXmlString, validTools);
+}
+var import_crypto2, implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition, readImageToolDefinition;
+var init_tools = __esm({
+  "src/agent/tools.js"() {
+    "use strict";
+    init_index();
+    import_crypto2 = require("crypto");
+    init_xmlParsingUtils();
+    implementToolDefinition = `
+## implement
+Description: Implement a given task. Can modify files. Can be used ONLY if task explicitly stated that something requires modification or implementation.
+
+Parameters:
+- task: (required) The task description. Should be as detailed as possible, ideally pointing to exact files which needs be modified or created.
+- autoCommits: (optional) Whether to enable auto-commits in aider. Default is false.
+
+Usage Example:
+
+<examples>
+
+User: Can you implement a function to calculate Fibonacci numbers in main.js?
+<implement>
+<task>Implement a recursive function to calculate the nth Fibonacci number in main.js</task>
+</implement>
+
+User: Can you implement a function to calculate Fibonacci numbers in main.js with auto-commits?
+<implement>
+<task>Implement a recursive function to calculate the nth Fibonacci number in main.js</task>
+<autoCommits>true</autoCommits>
+</implement>
+
+</examples>
+`;
+    listFilesToolDefinition = `
+## listFiles
+Description: List files and directories in a specified location.
+
+Parameters:
+- directory: (optional) The directory path to list files from. Defaults to current directory if not specified.
+
+Usage Example:
+
+<examples>
+
+User: Can you list the files in the src directory?
+<listFiles>
+<directory>src</directory>
+</listFiles>
+
+User: What files are in the current directory?
+<listFiles>
+</listFiles>
+
+</examples>
+`;
+    searchFilesToolDefinition = `
+## searchFiles
+Description: Find files with name matching a glob pattern with recursive search capability.
+
+Parameters:
+- pattern: (required) The glob pattern to search for (e.g., "**/*.js", "*.md").
+- directory: (optional) The directory to search in. Defaults to current directory if not specified.
+- recursive: (optional) Whether to search recursively. Defaults to true.
+
+Usage Example:
+
+<examples>
+
+User: Can you find all JavaScript files in the project?
+<searchFiles>
+<pattern>**/*.js</pattern>
+</searchFiles>
+
+User: Find all markdown files in the docs directory, but only at the top level.
+<searchFiles>
+<pattern>*.md</pattern>
+<directory>docs</directory>
+<recursive>false</recursive>
+</searchFiles>
+
+</examples>
+`;
+    readImageToolDefinition = `
+## readImage
+Description: Read and load an image file so it can be viewed by the AI. Use this when you need to analyze, describe, or work with image content. Images from user messages are automatically loaded, but use this tool to explicitly read images mentioned in tool outputs or when you need to examine specific image files.
+
+Parameters:
+- path: (required) The path to the image file to read. Supports png, jpg, jpeg, webp, bmp, and svg formats.
+
+Usage Example:
+
+<examples>
+
+User: Can you describe what's in screenshot.png?
+<readImage>
+<path>screenshot.png</path>
+</readImage>
+
+User: Analyze the diagram in docs/architecture.svg
+<readImage>
+<path>docs/architecture.svg</path>
+</readImage>
+
+</examples>
+`;
+  }
+});
+
 // node_modules/balanced-match/index.js
 var require_balanced_match = __commonJS({
   "node_modules/balanced-match/index.js"(exports2, module2) {
@@ -36178,7 +36510,7 @@ var init_escape = __esm({
 });
 
 // node_modules/minimatch/dist/esm/index.js
-var import_brace_expansion, minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
+var import_brace_expansion, minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep2, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
 var init_esm = __esm({
   "node_modules/minimatch/dist/esm/index.js"() {
     import_brace_expansion = __toESM(require_brace_expansion(), 1);
@@ -36251,8 +36583,8 @@ var init_esm = __esm({
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    sep = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
-    minimatch.sep = sep;
+    sep2 = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
+    minimatch.sep = sep2;
     GLOBSTAR = Symbol("globstar **");
     minimatch.GLOBSTAR = GLOBSTAR;
     qmark2 = "[^/]";
@@ -39166,22 +39498,22 @@ var init_esm3 = __esm({
 });
 
 // node_modules/path-scurry/dist/esm/index.js
-var import_node_path, import_node_url, import_fs4, actualFS, import_promises, realpathSync, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
+var import_node_path, import_node_url, import_fs6, actualFS, import_promises, realpathSync, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
 var init_esm4 = __esm({
   "node_modules/path-scurry/dist/esm/index.js"() {
     init_esm2();
     import_node_path = require("node:path");
     import_node_url = require("node:url");
-    import_fs4 = require("fs");
+    import_fs6 = require("fs");
     actualFS = __toESM(require("node:fs"), 1);
     import_promises = require("node:fs/promises");
     init_esm3();
-    realpathSync = import_fs4.realpathSync.native;
+    realpathSync = import_fs6.realpathSync.native;
     defaultFS = {
-      lstatSync: import_fs4.lstatSync,
-      readdir: import_fs4.readdir,
-      readdirSync: import_fs4.readdirSync,
-      readlinkSync: import_fs4.readlinkSync,
+      lstatSync: import_fs6.lstatSync,
+      readdir: import_fs6.readdir,
+      readdirSync: import_fs6.readdirSync,
+      readlinkSync: import_fs6.readlinkSync,
       realpathSync,
       promises: {
         lstat: import_promises.lstat,
@@ -42090,7 +42422,7 @@ function createWrappedTools(baseTools) {
   }
   return wrappedTools;
 }
-var import_child_process6, import_util11, import_crypto3, import_events, import_fs5, import_fs6, import_path6, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var import_child_process6, import_util11, import_crypto3, import_events, import_fs7, import_fs8, import_path7, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
 var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
@@ -42099,9 +42431,9 @@ var init_probeTool = __esm({
     import_util11 = require("util");
     import_crypto3 = require("crypto");
     import_events = require("events");
-    import_fs5 = __toESM(require("fs"), 1);
-    import_fs6 = require("fs");
-    import_path6 = __toESM(require("path"), 1);
+    import_fs7 = __toESM(require("fs"), 1);
+    import_fs8 = require("fs");
+    import_path7 = __toESM(require("path"), 1);
     init_esm5();
     init_symlink_utils();
     toolCallEmitter = new import_events.EventEmitter();
@@ -42190,17 +42522,17 @@ var init_probeTool = __esm({
       execute: async (params) => {
         const { directory = ".", workingDirectory } = params;
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path6.default.resolve(baseCwd);
+        const secureBaseDir = import_path7.default.resolve(baseCwd);
         const isDependencyPath = directory.startsWith("/dep/") || directory.startsWith("go:") || directory.startsWith("js:") || directory.startsWith("rust:");
         let targetDir;
-        if (import_path6.default.isAbsolute(directory)) {
-          targetDir = import_path6.default.resolve(directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path6.default.sep) && targetDir !== secureBaseDir) {
+        if (import_path7.default.isAbsolute(directory)) {
+          targetDir = import_path7.default.resolve(directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
           }
         } else {
-          targetDir = import_path6.default.resolve(secureBaseDir, directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path6.default.sep) && targetDir !== secureBaseDir) {
+          targetDir = import_path7.default.resolve(secureBaseDir, directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
           }
         }
@@ -42209,7 +42541,7 @@ var init_probeTool = __esm({
           console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
         }
         try {
-          const files = await import_fs6.promises.readdir(targetDir, { withFileTypes: true });
+          const files = await import_fs8.promises.readdir(targetDir, { withFileTypes: true });
           const formatSize = (size) => {
             if (size < 1024) return `${size}B`;
             if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
@@ -42217,7 +42549,7 @@ var init_probeTool = __esm({
             return `${(size / (1024 * 1024 * 1024)).toFixed(1)}G`;
           };
           const entries = await Promise.all(files.map(async (file) => {
-            const fullPath = import_path6.default.join(targetDir, file.name);
+            const fullPath = import_path7.default.join(targetDir, file.name);
             const entryType = await getEntryType(file, fullPath);
             return {
               name: file.name,
@@ -42254,17 +42586,17 @@ var init_probeTool = __esm({
           throw new Error("Pattern is required for file search");
         }
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path6.default.resolve(baseCwd);
+        const secureBaseDir = import_path7.default.resolve(baseCwd);
         const isDependencyPath = directory.startsWith("/dep/") || directory.startsWith("go:") || directory.startsWith("js:") || directory.startsWith("rust:");
         let targetDir;
-        if (import_path6.default.isAbsolute(directory)) {
-          targetDir = import_path6.default.resolve(directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path6.default.sep) && targetDir !== secureBaseDir) {
+        if (import_path7.default.isAbsolute(directory)) {
+          targetDir = import_path7.default.resolve(directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
           }
         } else {
-          targetDir = import_path6.default.resolve(secureBaseDir, directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path6.default.sep) && targetDir !== secureBaseDir) {
+          targetDir = import_path7.default.resolve(secureBaseDir, directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
           }
         }
@@ -80589,11 +80921,11 @@ function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!(0, import_fs7.existsSync)(configPath)) {
+  if (!(0, import_fs9.existsSync)(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
-    const content = (0, import_fs7.readFileSync)(configPath, "utf8");
+    const content = (0, import_fs9.readFileSync)(configPath, "utf8");
     const config = JSON.parse(content);
     if (process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1") {
       console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
@@ -80608,19 +80940,19 @@ function loadMCPConfiguration() {
     // Environment variable path
     process.env.MCP_CONFIG_PATH,
     // Local project paths
-    (0, import_path7.join)(process.cwd(), ".mcp", "config.json"),
-    (0, import_path7.join)(process.cwd(), "mcp.config.json"),
+    (0, import_path8.join)(process.cwd(), ".mcp", "config.json"),
+    (0, import_path8.join)(process.cwd(), "mcp.config.json"),
     // Home directory paths
-    (0, import_path7.join)((0, import_os3.homedir)(), ".config", "probe", "mcp.json"),
-    (0, import_path7.join)((0, import_os3.homedir)(), ".mcp", "config.json"),
+    (0, import_path8.join)((0, import_os3.homedir)(), ".config", "probe", "mcp.json"),
+    (0, import_path8.join)((0, import_os3.homedir)(), ".mcp", "config.json"),
     // Claude-style config location
-    (0, import_path7.join)((0, import_os3.homedir)(), "Library", "Application Support", "Claude", "mcp_config.json")
+    (0, import_path8.join)((0, import_os3.homedir)(), "Library", "Application Support", "Claude", "mcp_config.json")
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
-    if ((0, import_fs7.existsSync)(configPath)) {
+    if ((0, import_fs9.existsSync)(configPath)) {
       try {
-        const content = (0, import_fs7.readFileSync)(configPath, "utf8");
+        const content = (0, import_fs9.readFileSync)(configPath, "utf8");
         config = JSON.parse(content);
         if (process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1") {
           console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
@@ -80732,16 +81064,16 @@ function parseEnabledServers(config) {
   }
   return servers;
 }
-var import_fs7, import_path7, import_os3, import_url4, __filename4, __dirname4, DEFAULT_TIMEOUT, MAX_TIMEOUT, DEFAULT_CONFIG;
+var import_fs9, import_path8, import_os3, import_url4, __filename4, __dirname4, DEFAULT_TIMEOUT, MAX_TIMEOUT, DEFAULT_CONFIG;
 var init_config = __esm({
   "src/agent/mcp/config.js"() {
     "use strict";
-    import_fs7 = require("fs");
-    import_path7 = require("path");
+    import_fs9 = require("fs");
+    import_path8 = require("path");
     import_os3 = require("os");
     import_url4 = require("url");
     __filename4 = (0, import_url4.fileURLToPath)("file:///");
-    __dirname4 = (0, import_path7.dirname)(__filename4);
+    __dirname4 = (0, import_path8.dirname)(__filename4);
     DEFAULT_TIMEOUT = 3e4;
     MAX_TIMEOUT = 6e5;
     DEFAULT_CONFIG = {
@@ -80749,7 +81081,7 @@ var init_config = __esm({
         // Example probe server configuration
         "probe-local": {
           command: "node",
-          args: [(0, import_path7.join)(__dirname4, "../../../examples/chat/mcpServer.js")],
+          args: [(0, import_path8.join)(__dirname4, "../../../examples/chat/mcpServer.js")],
           transport: "stdio",
           enabled: false
         },
@@ -82871,12 +83203,12 @@ async function createEnhancedClaudeCLIEngine(options = {}) {
       console.log("[DEBUG] Built-in MCP server started");
       console.log("[DEBUG] MCP URL:", `http://${host}:${port}/mcp`);
     }
-    mcpConfigPath = import_path8.default.join(import_os4.default.tmpdir(), `probe-mcp-${session.id}.json`);
+    mcpConfigPath = import_path9.default.join(import_os4.default.tmpdir(), `probe-mcp-${session.id}.json`);
     const mcpConfig = {
       mcpServers: {
         probe: {
           command: "node",
-          args: [import_path8.default.join(process.cwd(), "mcp-probe-server.js")],
+          args: [import_path9.default.join(process.cwd(), "mcp-probe-server.js")],
           env: {
             PROBE_WORKSPACE: process.cwd(),
             DEBUG: debug ? "true" : "false"
@@ -83245,14 +83577,14 @@ function combinePrompts(systemPrompt, customPrompt, agent) {
   }
   return systemPrompt || "";
 }
-var import_child_process7, import_crypto5, import_promises2, import_path8, import_os4, import_events3;
+var import_child_process7, import_crypto5, import_promises2, import_path9, import_os4, import_events3;
 var init_enhanced_claude_code = __esm({
   "src/agent/engines/enhanced-claude-code.js"() {
     "use strict";
     import_child_process7 = require("child_process");
     import_crypto5 = require("crypto");
     import_promises2 = __toESM(require("fs/promises"), 1);
-    import_path8 = __toESM(require("path"), 1);
+    import_path9 = __toESM(require("path"), 1);
     import_os4 = __toESM(require("os"), 1);
     import_events3 = require("events");
     init_built_in_server();
@@ -83596,11 +83928,11 @@ function createEnhancedVercelEngine(agent) {
     }
   };
 }
-var import_ai;
+var import_ai2;
 var init_enhanced_vercel = __esm({
   "src/agent/engines/enhanced-vercel.js"() {
     "use strict";
-    import_ai = require("ai");
+    import_ai2 = require("ai");
   }
 });
 
@@ -83609,7 +83941,7 @@ var ProbeAgent_exports = {};
 __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
-var import_dotenv, import_anthropic2, import_openai2, import_google2, import_ai2, import_crypto7, import_events4, import_fs8, import_promises3, import_path9, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
+var import_dotenv, import_anthropic2, import_openai2, import_google2, import_ai3, import_crypto7, import_events4, import_fs10, import_promises3, import_path10, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     "use strict";
@@ -83618,12 +83950,12 @@ var init_ProbeAgent = __esm({
     import_openai2 = require("@ai-sdk/openai");
     import_google2 = require("@ai-sdk/google");
     init_dist3();
-    import_ai2 = require("ai");
+    import_ai3 = require("ai");
     import_crypto7 = require("crypto");
     import_events4 = require("events");
-    import_fs8 = require("fs");
+    import_fs10 = require("fs");
     import_promises3 = require("fs/promises");
-    import_path9 = require("path");
+    import_path10 = require("path");
     init_tokenCounter();
     init_InMemoryStorageAdapter();
     init_HookManager();
@@ -83950,7 +84282,7 @@ var init_ProbeAgent = __esm({
               if (!imagePath) {
                 throw new Error("Image path is required");
               }
-              const filename = (0, import_path9.basename)(imagePath);
+              const filename = (0, import_path10.basename)(imagePath);
               const extension = filename.toLowerCase().split(".").pop();
               if (!extension || !SUPPORTED_IMAGE_EXTENSIONS.includes(extension)) {
                 throw new Error(`Invalid or unsupported image extension: ${extension}. Supported formats: ${SUPPORTED_IMAGE_EXTENSIONS.join(", ")}`);
@@ -84268,7 +84600,7 @@ var init_ProbeAgent = __esm({
         }
         if (!this.fallbackManager) {
           return await this.retryManager.executeWithRetry(
-            () => (0, import_ai2.streamText)(options),
+            () => (0, import_ai3.streamText)(options),
             {
               provider: this.apiType,
               model: this.model
@@ -84290,7 +84622,7 @@ var init_ProbeAgent = __esm({
               debug: this.debug
             });
             return await providerRetryManager.executeWithRetry(
-              () => (0, import_ai2.streamText)(fallbackOptions),
+              () => (0, import_ai3.streamText)(fallbackOptions),
               {
                 provider: config.provider,
                 model
@@ -84505,7 +84837,7 @@ var init_ProbeAgent = __esm({
           let resolvedPath2 = imagePath;
           if (!imagePath.includes("/") && !imagePath.includes("\\")) {
             for (const dir of listFilesDirectories) {
-              const potentialPath = (0, import_path9.resolve)(dir, imagePath);
+              const potentialPath = (0, import_path10.resolve)(dir, imagePath);
               const loaded = await this.loadImageIfValid(potentialPath);
               if (loaded) {
                 if (this.debug) {
@@ -84530,7 +84862,7 @@ var init_ProbeAgent = __esm({
         let match2;
         while ((match2 = fileHeaderPattern.exec(content)) !== null) {
           const filePath = match2[1].trim();
-          const dir = (0, import_path9.dirname)(filePath);
+          const dir = (0, import_path10.dirname)(filePath);
           if (dir && dir !== ".") {
             directories.push(dir);
             if (this.debug) {
@@ -84575,17 +84907,17 @@ var init_ProbeAgent = __esm({
           const allowedDirs = this.allowedFolders && this.allowedFolders.length > 0 ? this.allowedFolders : [process.cwd()];
           let absolutePath;
           let isPathAllowed2 = false;
-          if ((0, import_path9.isAbsolute)(imagePath)) {
-            absolutePath = (0, import_path9.normalize)((0, import_path9.resolve)(imagePath));
+          if ((0, import_path10.isAbsolute)(imagePath)) {
+            absolutePath = (0, import_path10.normalize)((0, import_path10.resolve)(imagePath));
             isPathAllowed2 = allowedDirs.some((dir) => {
-              const normalizedDir = (0, import_path9.normalize)((0, import_path9.resolve)(dir));
-              return absolutePath === normalizedDir || absolutePath.startsWith(normalizedDir + import_path9.sep);
+              const normalizedDir = (0, import_path10.normalize)((0, import_path10.resolve)(dir));
+              return absolutePath === normalizedDir || absolutePath.startsWith(normalizedDir + import_path10.sep);
             });
           } else {
             for (const dir of allowedDirs) {
-              const normalizedDir = (0, import_path9.normalize)((0, import_path9.resolve)(dir));
-              const resolvedPath2 = (0, import_path9.normalize)((0, import_path9.resolve)(dir, imagePath));
-              if (resolvedPath2 === normalizedDir || resolvedPath2.startsWith(normalizedDir + import_path9.sep)) {
+              const normalizedDir = (0, import_path10.normalize)((0, import_path10.resolve)(dir));
+              const resolvedPath2 = (0, import_path10.normalize)((0, import_path10.resolve)(dir, imagePath));
+              if (resolvedPath2 === normalizedDir || resolvedPath2.startsWith(normalizedDir + import_path10.sep)) {
                 absolutePath = resolvedPath2;
                 isPathAllowed2 = true;
                 break;
@@ -85517,10 +85849,10 @@ ${toolResultContent}
                   try {
                     let resolvedWorkingDirectory = this.cwd || this.allowedFolders && this.allowedFolders[0] || process.cwd();
                     if (params.workingDirectory) {
-                      const requestedDir = (0, import_path9.isAbsolute)(params.workingDirectory) ? (0, import_path9.resolve)(params.workingDirectory) : (0, import_path9.resolve)(resolvedWorkingDirectory, params.workingDirectory);
+                      const requestedDir = (0, import_path10.isAbsolute)(params.workingDirectory) ? (0, import_path10.resolve)(params.workingDirectory) : (0, import_path10.resolve)(resolvedWorkingDirectory, params.workingDirectory);
                       const isWithinAllowed = !this.allowedFolders || this.allowedFolders.length === 0 || this.allowedFolders.some((folder) => {
-                        const resolvedFolder = (0, import_path9.resolve)(folder);
-                        return requestedDir === resolvedFolder || requestedDir.startsWith(resolvedFolder + import_path9.sep);
+                        const resolvedFolder = (0, import_path10.resolve)(folder);
+                        return requestedDir === resolvedFolder || requestedDir.startsWith(resolvedFolder + import_path10.sep);
                       });
                       if (isWithinAllowed) {
                         resolvedWorkingDirectory = requestedDir;
@@ -86470,7 +86802,9 @@ async function delegate({
       debug,
       tracer,
       path: path9,
-      // Inherit from parent
+      // Workspace root (from delegateTool)
+      cwd: path9,
+      // Explicitly set cwd to workspace root to prevent path doubling
       provider,
       // Inherit from parent
       model,
@@ -86681,11 +87015,11 @@ var init_delegate = __esm({
 });
 
 // src/tools/vercel.js
-var import_ai3, searchTool, queryTool, extractTool, delegateTool;
+var import_ai4, searchTool, queryTool, extractTool, delegateTool;
 var init_vercel = __esm({
   "src/tools/vercel.js"() {
     "use strict";
-    import_ai3 = require("ai");
+    import_ai4 = require("ai");
     init_search();
     init_query();
     init_extract();
@@ -86693,7 +87027,7 @@ var init_vercel = __esm({
     init_common2();
     searchTool = (options = {}) => {
       const { sessionId, maxTokens = 1e4, debug = false, outline = false } = options;
-      return (0, import_ai3.tool)({
+      return (0, import_ai4.tool)({
         name: "search",
         description: searchDescription,
         inputSchema: searchSchema,
@@ -86739,7 +87073,7 @@ var init_vercel = __esm({
     };
     queryTool = (options = {}) => {
       const { debug = false } = options;
-      return (0, import_ai3.tool)({
+      return (0, import_ai4.tool)({
         name: "query",
         description: queryDescription,
         inputSchema: querySchema,
@@ -86775,7 +87109,7 @@ var init_vercel = __esm({
     };
     extractTool = (options = {}) => {
       const { debug = false, outline = false } = options;
-      return (0, import_ai3.tool)({
+      return (0, import_ai4.tool)({
         name: "extract",
         description: extractDescription,
         inputSchema: extractSchema,
@@ -86851,7 +87185,7 @@ var init_vercel = __esm({
     };
     delegateTool = (options = {}) => {
       const { debug = false, timeout = 300, cwd, allowedFolders, enableBash = false, bashConfig } = options;
-      return (0, import_ai3.tool)({
+      return (0, import_ai4.tool)({
         name: "delegate",
         description: delegateDescription,
         inputSchema: delegateSchema,
@@ -86880,14 +87214,15 @@ var init_vercel = __esm({
           if (model !== void 0 && model !== null && typeof model !== "string") {
             throw new TypeError("model must be a string, null, or undefined");
           }
-          const effectivePath = path9 || cwd || allowedFolders && allowedFolders[0];
+          const workspaceRoot = allowedFolders && allowedFolders[0];
+          const effectivePath = path9 || workspaceRoot || cwd;
           if (debug) {
             console.error(`Executing delegate with task: "${task.substring(0, 100)}${task.length > 100 ? "..." : ""}"`);
             if (parentSessionId) {
               console.error(`Parent session: ${parentSessionId}`);
             }
             if (effectivePath && effectivePath !== path9) {
-              console.error(`Using inherited path: ${effectivePath}`);
+              console.error(`Using workspace root: ${effectivePath} (cwd was: ${cwd || "not set"})`);
             }
           }
           const result = await delegate({
@@ -87834,8 +88169,8 @@ async function executeBashCommand(command, options = {}) {
   } = options;
   let cwd = workingDirectory;
   try {
-    cwd = (0, import_path10.resolve)(cwd);
-    if (!(0, import_fs9.existsSync)(cwd)) {
+    cwd = (0, import_path11.resolve)(cwd);
+    if (!(0, import_fs11.existsSync)(cwd)) {
       throw new Error(`Working directory does not exist: ${cwd}`);
     }
   } catch (error2) {
@@ -88059,7 +88394,7 @@ function validateExecutionOptions(options = {}) {
   if (options.workingDirectory) {
     if (typeof options.workingDirectory !== "string") {
       errors.push("workingDirectory must be a string");
-    } else if (!(0, import_fs9.existsSync)(options.workingDirectory)) {
+    } else if (!(0, import_fs11.existsSync)(options.workingDirectory)) {
       errors.push(`workingDirectory does not exist: ${options.workingDirectory}`);
     }
   }
@@ -88072,24 +88407,24 @@ function validateExecutionOptions(options = {}) {
     warnings
   };
 }
-var import_child_process9, import_path10, import_fs9;
+var import_child_process9, import_path11, import_fs11;
 var init_bashExecutor = __esm({
   "src/agent/bashExecutor.js"() {
     "use strict";
     import_child_process9 = require("child_process");
-    import_path10 = require("path");
-    import_fs9 = require("fs");
+    import_path11 = require("path");
+    import_fs11 = require("fs");
     init_bashCommandUtils();
   }
 });
 
 // src/tools/bash.js
-var import_ai4, import_path11, bashTool;
+var import_ai5, import_path12, bashTool;
 var init_bash = __esm({
   "src/tools/bash.js"() {
     "use strict";
-    import_ai4 = require("ai");
-    import_path11 = require("path");
+    import_ai5 = require("ai");
+    import_path12 = require("path");
     init_bashPermissions();
     init_bashExecutor();
     bashTool = (options = {}) => {
@@ -88118,7 +88453,7 @@ var init_bash = __esm({
         }
         return process.cwd();
       };
-      return (0, import_ai4.tool)({
+      return (0, import_ai5.tool)({
         name: "bash",
         description: `Execute bash commands for system exploration and development tasks.
 
@@ -88198,12 +88533,12 @@ For code exploration, try these safe alternatives:
 - npm list, pip list for package information`;
             }
             const defaultDir = getDefaultWorkingDirectory();
-            const workingDir = workingDirectory ? (0, import_path11.isAbsolute)(workingDirectory) ? (0, import_path11.resolve)(workingDirectory) : (0, import_path11.resolve)(defaultDir, workingDirectory) : defaultDir;
+            const workingDir = workingDirectory ? (0, import_path12.isAbsolute)(workingDirectory) ? (0, import_path12.resolve)(workingDirectory) : (0, import_path12.resolve)(defaultDir, workingDirectory) : defaultDir;
             if (allowedFolders && allowedFolders.length > 0) {
-              const resolvedWorkingDir = (0, import_path11.resolve)(workingDir);
+              const resolvedWorkingDir = (0, import_path12.resolve)(workingDir);
               const isAllowed = allowedFolders.some((folder) => {
-                const resolvedFolder = (0, import_path11.resolve)(folder);
-                return resolvedWorkingDir === resolvedFolder || resolvedWorkingDir.startsWith(resolvedFolder + import_path11.sep);
+                const resolvedFolder = (0, import_path12.resolve)(folder);
+                return resolvedWorkingDir === resolvedFolder || resolvedWorkingDir.startsWith(resolvedFolder + import_path12.sep);
               });
               if (!isAllowed) {
                 return `Error: Working directory "${workingDir}" is not within allowed folders: ${allowedFolders.join(", ")}`;
@@ -88255,323 +88590,6 @@ Command failed with exit code ${result.exitCode}`;
   }
 });
 
-// src/tools/edit.js
-function isPathAllowed(filePath, allowedFolders) {
-  if (!allowedFolders || allowedFolders.length === 0) {
-    const resolvedPath3 = (0, import_path12.resolve)(filePath);
-    const cwd = (0, import_path12.resolve)(process.cwd());
-    return resolvedPath3 === cwd || resolvedPath3.startsWith(cwd + import_path12.sep);
-  }
-  const resolvedPath2 = (0, import_path12.resolve)(filePath);
-  return allowedFolders.some((folder) => {
-    const allowedPath = (0, import_path12.resolve)(folder);
-    return resolvedPath2 === allowedPath || resolvedPath2.startsWith(allowedPath + import_path12.sep);
-  });
-}
-function parseFileToolOptions(options = {}) {
-  return {
-    debug: options.debug || false,
-    allowedFolders: options.allowedFolders || [],
-    cwd: options.cwd
-  };
-}
-var import_ai5, import_fs10, import_path12, import_fs11, editTool, createTool, editSchema, createSchema, editDescription, createDescription, editToolDefinition, createToolDefinition;
-var init_edit = __esm({
-  "src/tools/edit.js"() {
-    "use strict";
-    import_ai5 = require("ai");
-    import_fs10 = require("fs");
-    import_path12 = require("path");
-    import_fs11 = require("fs");
-    editTool = (options = {}) => {
-      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
-      return (0, import_ai5.tool)({
-        name: "edit",
-        description: `Edit files using exact string replacement (Claude Code style).
-
-This tool performs exact string replacements in files. It requires the old_string to match exactly what's in the file, including all whitespace and indentation.
-
-Parameters:
-- file_path: Path to the file to edit (absolute or relative)
-- old_string: Exact text to find and replace (must be unique in the file unless replace_all is true)
-- new_string: Text to replace with
-- replace_all: (optional) Replace all occurrences instead of requiring uniqueness
-
-Important:
-- The old_string must match EXACTLY including whitespace
-- If old_string appears multiple times and replace_all is false, the edit will fail
-- Use larger context around the string to ensure uniqueness when needed`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            file_path: {
-              type: "string",
-              description: "Path to the file to edit"
-            },
-            old_string: {
-              type: "string",
-              description: "Exact text to find and replace"
-            },
-            new_string: {
-              type: "string",
-              description: "Text to replace with"
-            },
-            replace_all: {
-              type: "boolean",
-              description: "Replace all occurrences (default: false)",
-              default: false
-            }
-          },
-          required: ["file_path", "old_string", "new_string"]
-        },
-        execute: async ({ file_path, old_string, new_string, replace_all = false }) => {
-          try {
-            if (!file_path || typeof file_path !== "string" || file_path.trim() === "") {
-              return `Error editing file: Invalid file_path - must be a non-empty string`;
-            }
-            if (old_string === void 0 || old_string === null || typeof old_string !== "string") {
-              return `Error editing file: Invalid old_string - must be a string`;
-            }
-            if (new_string === void 0 || new_string === null || typeof new_string !== "string") {
-              return `Error editing file: Invalid new_string - must be a string`;
-            }
-            const resolvedPath2 = (0, import_path12.isAbsolute)(file_path) ? file_path : (0, import_path12.resolve)(cwd || process.cwd(), file_path);
-            if (debug) {
-              console.error(`[Edit] Attempting to edit file: ${resolvedPath2}`);
-            }
-            if (!isPathAllowed(resolvedPath2, allowedFolders)) {
-              return `Error editing file: Permission denied - ${file_path} is outside allowed directories`;
-            }
-            if (!(0, import_fs11.existsSync)(resolvedPath2)) {
-              return `Error editing file: File not found - ${file_path}`;
-            }
-            const content = await import_fs10.promises.readFile(resolvedPath2, "utf-8");
-            if (!content.includes(old_string)) {
-              return `Error editing file: String not found - the specified old_string was not found in ${file_path}`;
-            }
-            const occurrences = content.split(old_string).length - 1;
-            if (!replace_all && occurrences > 1) {
-              return `Error editing file: Multiple occurrences found - the old_string appears ${occurrences} times. Use replace_all: true to replace all occurrences, or provide more context to make the string unique.`;
-            }
-            let newContent;
-            if (replace_all) {
-              newContent = content.replaceAll(old_string, new_string);
-            } else {
-              newContent = content.replace(old_string, new_string);
-            }
-            if (newContent === content) {
-              return `Error editing file: No changes made - old_string and new_string might be the same`;
-            }
-            await import_fs10.promises.writeFile(resolvedPath2, newContent, "utf-8");
-            const replacedCount = replace_all ? occurrences : 1;
-            if (debug) {
-              console.error(`[Edit] Successfully edited ${resolvedPath2}, replaced ${replacedCount} occurrence(s)`);
-            }
-            return `Successfully edited ${file_path} (${replacedCount} replacement${replacedCount !== 1 ? "s" : ""})`;
-          } catch (error2) {
-            console.error("[Edit] Error:", error2);
-            return `Error editing file: ${error2.message}`;
-          }
-        }
-      });
-    };
-    createTool = (options = {}) => {
-      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
-      return (0, import_ai5.tool)({
-        name: "create",
-        description: `Create new files with specified content.
-
-This tool creates new files in the filesystem. It will create parent directories if they don't exist.
-
-Parameters:
-- file_path: Path where the file should be created (absolute or relative)
-- content: Content to write to the file
-- overwrite: (optional) Whether to overwrite if file exists (default: false)
-
-Important:
-- By default, will fail if the file already exists
-- Set overwrite: true to replace existing files
-- Parent directories will be created automatically if needed`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            file_path: {
-              type: "string",
-              description: "Path where the file should be created"
-            },
-            content: {
-              type: "string",
-              description: "Content to write to the file"
-            },
-            overwrite: {
-              type: "boolean",
-              description: "Overwrite if file exists (default: false)",
-              default: false
-            }
-          },
-          required: ["file_path", "content"]
-        },
-        execute: async ({ file_path, content, overwrite = false }) => {
-          try {
-            if (!file_path || typeof file_path !== "string" || file_path.trim() === "") {
-              return `Error creating file: Invalid file_path - must be a non-empty string`;
-            }
-            if (content === void 0 || content === null || typeof content !== "string") {
-              return `Error creating file: Invalid content - must be a string`;
-            }
-            const resolvedPath2 = (0, import_path12.isAbsolute)(file_path) ? file_path : (0, import_path12.resolve)(cwd || process.cwd(), file_path);
-            if (debug) {
-              console.error(`[Create] Attempting to create file: ${resolvedPath2}`);
-            }
-            if (!isPathAllowed(resolvedPath2, allowedFolders)) {
-              return `Error creating file: Permission denied - ${file_path} is outside allowed directories`;
-            }
-            if ((0, import_fs11.existsSync)(resolvedPath2) && !overwrite) {
-              return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
-            }
-            const dir = (0, import_path12.dirname)(resolvedPath2);
-            await import_fs10.promises.mkdir(dir, { recursive: true });
-            await import_fs10.promises.writeFile(resolvedPath2, content, "utf-8");
-            const action = (0, import_fs11.existsSync)(resolvedPath2) && overwrite ? "overwrote" : "created";
-            const bytes = Buffer.byteLength(content, "utf-8");
-            if (debug) {
-              console.error(`[Create] Successfully ${action} ${resolvedPath2}`);
-            }
-            return `Successfully ${action} ${file_path} (${bytes} bytes)`;
-          } catch (error2) {
-            console.error("[Create] Error:", error2);
-            return `Error creating file: ${error2.message}`;
-          }
-        }
-      });
-    };
-    editSchema = {
-      type: "object",
-      properties: {
-        file_path: {
-          type: "string",
-          description: "Path to the file to edit"
-        },
-        old_string: {
-          type: "string",
-          description: "Exact text to find and replace"
-        },
-        new_string: {
-          type: "string",
-          description: "Text to replace with"
-        },
-        replace_all: {
-          type: "boolean",
-          description: "Replace all occurrences (default: false)"
-        }
-      },
-      required: ["file_path", "old_string", "new_string"]
-    };
-    createSchema = {
-      type: "object",
-      properties: {
-        file_path: {
-          type: "string",
-          description: "Path where the file should be created"
-        },
-        content: {
-          type: "string",
-          description: "Content to write to the file"
-        },
-        overwrite: {
-          type: "boolean",
-          description: "Overwrite if file exists (default: false)"
-        }
-      },
-      required: ["file_path", "content"]
-    };
-    editDescription = "Edit files using exact string replacement. Requires exact match including whitespace.";
-    createDescription = "Create new files with specified content. Will create parent directories if needed.";
-    editToolDefinition = `
-## edit
-Description: ${editDescription}
-
-When to use:
-- For precise, surgical edits to existing files
-- When you need to change specific lines or blocks of code
-- For renaming functions, variables, or updating configuration values
-- When the exact text to replace is known and unique (or use replace_all for multiple occurrences)
-
-When NOT to use:
-- For creating new files (use 'create' tool instead)
-- When you cannot determine the exact text to replace
-- When changes span multiple locations that would be better handled together
-
-Parameters:
-- file_path: (required) Path to the file to edit
-- old_string: (required) Exact text to find and replace (must match including whitespace, newlines, and indentation)
-- new_string: (required) Text to replace with
-- replace_all: (optional, default: false) Replace all occurrences if the string appears multiple times
-
-Important notes:
-- The old_string MUST match EXACTLY, including all whitespace, indentation, and line breaks
-- If old_string appears multiple times and replace_all is false, the tool will fail
-- Always verify the exact formatting of the text you want to replace
-
-Examples:
-<edit>
-<file_path>src/main.js</file_path>
-<old_string>function oldName() {
-  return 42;
-}</old_string>
-<new_string>function newName() {
-  return 42;
-}</new_string>
-</edit>
-
-<edit>
-<file_path>config.json</file_path>
-<old_string>"debug": false</old_string>
-<new_string>"debug": true</new_string>
-<replace_all>true</replace_all>
-</edit>`;
-    createToolDefinition = `
-## create
-Description: ${createDescription}
-
-When to use:
-- For creating brand new files from scratch
-- When you need to add configuration files, documentation, or new modules
-- For generating boilerplate code or templates
-- When you have the complete content ready to write
-
-When NOT to use:
-- For editing existing files (use 'edit' tool instead)
-- When a file already exists unless you explicitly want to overwrite it
-
-Parameters:
-- file_path: (required) Path where the file should be created
-- content: (required) Complete content to write to the file
-- overwrite: (optional, default: false) Whether to overwrite if file already exists
-
-Important notes:
-- Parent directories will be created automatically if they don't exist
-- The tool will fail if the file already exists and overwrite is false
-- Be careful with the overwrite option as it completely replaces existing files
-
-Examples:
-<create>
-<file_path>src/newFile.js</file_path>
-<content>export function hello() {
-  return "Hello, world!";
-}</content>
-</create>
-
-<create>
-<file_path>README.md</file_path>
-<content># My Project
-
-This is a new project.</content>
-<overwrite>true</overwrite>
-</create>`;
-  }
-});
-
 // src/tools/langchain.js
 function createSearchTool(options = {}) {
   const { cwd } = options;
@@ -88796,12 +88814,14 @@ For GitHub-compatible mermaid diagrams, avoid single quotes and parentheses in n
 var tools_exports = {};
 __export(tools_exports, {
   DEFAULT_SYSTEM_MESSAGE: () => DEFAULT_SYSTEM_MESSAGE,
+  DEFAULT_VALID_TOOLS: () => DEFAULT_VALID_TOOLS,
   attemptCompletionSchema: () => attemptCompletionSchema,
   attemptCompletionToolDefinition: () => attemptCompletionToolDefinition,
   bashDescription: () => bashDescription,
   bashSchema: () => bashSchema,
   bashTool: () => bashTool,
   bashToolDefinition: () => bashToolDefinition,
+  buildToolTagPattern: () => buildToolTagPattern,
   createDescription: () => createDescription,
   createExtractTool: () => createExtractTool,
   createQueryTool: () => createQueryTool,