@probelabs/probe 0.6.0-rc159 → 0.6.0-rc161

package/build/agent/index.js

@@ -2007,7 +2007,7 @@ async function waitForFileLock(lockPath, binaryPath) {
       }
     } catch {
     }
-    await new Promise((resolve5) => setTimeout(resolve5, LOCK_POLL_INTERVAL_MS));
+    await new Promise((resolve6) => setTimeout(resolve6, LOCK_POLL_INTERVAL_MS));
   }
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Timeout waiting for file lock`);
@@ -2978,7 +2978,7 @@ Command: ${command}`;
   }
 }
 function extractWithStdin(binaryPath, cliArgs, content, options) {
-  return new Promise((resolve5, reject2) => {
+  return new Promise((resolve6, reject2) => {
     const childProcess = spawn(binaryPath, ["extract", ...cliArgs], {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -3000,7 +3000,7 @@ function extractWithStdin(binaryPath, cliArgs, content, options) {
       }
       try {
         const result = processExtractOutput(stdout, options);
-        resolve5(result);
+        resolve6(result);
       } catch (error) {
         reject2(error);
       }
@@ -7560,7 +7560,7 @@ function parseTargets(targets) {
   }
   return targets.split(/\s+/).filter((f) => f.length > 0);
 }
-var searchSchema, querySchema, extractSchema, delegateSchema, bashSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
+var searchSchema, querySchema, extractSchema, delegateSchema, bashSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, bashToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
 var init_common = __esm({
   "src/tools/common.js"() {
     "use strict";
@@ -7573,11 +7573,12 @@ var init_common = __esm({
       pattern: external_exports.string().describe("AST pattern to search for. Use $NAME for variable names, $$$PARAMS for parameter lists, etc."),
       path: external_exports.string().optional().default(".").describe("Path to search in"),
       language: external_exports.string().optional().default("rust").describe("Programming language to use for parsing"),
-      allow_tests: external_exports.boolean().optional().default(false).describe("Allow test files in search results")
+      allow_tests: external_exports.boolean().optional().default(true).describe("Allow test files in search results")
     });
     extractSchema = external_exports.object({
       targets: external_exports.string().optional().describe('File paths or symbols to extract from. Formats: "file.js" (whole file), "file.js:42" (line 42), "file.js:10-20" (lines 10-20), "file.js#funcName" (symbol). Multiple targets separated by spaces.'),
-      input_content: external_exports.string().optional().describe("Text content to extract file paths from (alternative to targets)")
+      input_content: external_exports.string().optional().describe("Text content to extract file paths from (alternative to targets)"),
+      allow_tests: external_exports.boolean().optional().default(true).describe("Include test files in extraction results")
     });
     delegateSchema = external_exports.object({
       task: external_exports.string().describe("The task to delegate to a subagent. Be specific about what needs to be accomplished.")
@@ -7704,7 +7705,7 @@ 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: false) Allow test files in search results (true/false).
+- allow_tests: (optional, default: true) Allow test files in search results (true/false).
 Usage Example:
 
 <examples>
@@ -7729,6 +7730,7 @@ Full file extraction should be the LAST RESORT! Always prefer search.
 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:
 
@@ -7795,6 +7797,61 @@ 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>
+`;
+    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>
 `;
     searchDescription = "Search code in the repository using Elasticsearch-like query syntax. Use this tool first for any code-related questions.";
     queryDescription = "Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.";
@@ -8894,14 +8951,14 @@ async function executeBashCommand(command, options = {}) {
     console.log(`[BashExecutor] Working directory: "${cwd}"`);
     console.log(`[BashExecutor] Timeout: ${timeout}ms`);
   }
-  return new Promise((resolve5, reject2) => {
+  return new Promise((resolve6, reject2) => {
     const processEnv = {
       ...process.env,
       ...env
     };
     const args = parseCommandForExecution(command);
     if (!args || args.length === 0) {
-      resolve5({
+      resolve6({
         success: false,
         error: "Failed to parse command",
         stdout: "",
@@ -8984,7 +9041,7 @@ async function executeBashCommand(command, options = {}) {
         success = false;
         error = `Command exited with code ${code}`;
       }
-      resolve5({
+      resolve6({
         success,
         error,
         stdout: stdout.trim(),
@@ -9004,7 +9061,7 @@ async function executeBashCommand(command, options = {}) {
       if (debug) {
         console.log(`[BashExecutor] Spawn error:`, error);
       }
-      resolve5({
+      resolve6({
         success: false,
         error: `Failed to execute command: ${error.message}`,
         stdout: "",
@@ -9276,6 +9333,283 @@ Command failed with exit code ${result.exitCode}`;
   }
 });
 
+// src/tools/edit.js
+import { tool as tool3 } from "ai";
+import { promises as fs4 } from "fs";
+import { dirname, resolve as resolve3, isAbsolute, sep } from "path";
+import { existsSync as existsSync2 } from "fs";
+function isPathAllowed(filePath, allowedFolders) {
+  if (!allowedFolders || allowedFolders.length === 0) {
+    const resolvedPath2 = resolve3(filePath);
+    const cwd = resolve3(process.cwd());
+    return resolvedPath2 === cwd || resolvedPath2.startsWith(cwd + sep);
+  }
+  const resolvedPath = resolve3(filePath);
+  return allowedFolders.some((folder) => {
+    const allowedPath = resolve3(folder);
+    return resolvedPath === allowedPath || resolvedPath.startsWith(allowedPath + sep);
+  });
+}
+function parseFileToolOptions(options = {}) {
+  return {
+    debug: options.debug || false,
+    allowedFolders: options.allowedFolders || [],
+    defaultPath: options.defaultPath
+  };
+}
+var editTool, createTool, editDescription, createDescription, editToolDefinition, createToolDefinition;
+var init_edit = __esm({
+  "src/tools/edit.js"() {
+    "use strict";
+    editTool = (options = {}) => {
+      const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+      return tool3({
+        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 resolvedPath = isAbsolute(file_path) ? file_path : resolve3(defaultPath || process.cwd(), file_path);
+            if (debug) {
+              console.error(`[Edit] Attempting to edit file: ${resolvedPath}`);
+            }
+            if (!isPathAllowed(resolvedPath, allowedFolders)) {
+              return `Error editing file: Permission denied - ${file_path} is outside allowed directories`;
+            }
+            if (!existsSync2(resolvedPath)) {
+              return `Error editing file: File not found - ${file_path}`;
+            }
+            const content = await fs4.readFile(resolvedPath, "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 fs4.writeFile(resolvedPath, newContent, "utf-8");
+            const replacedCount = replace_all ? occurrences : 1;
+            if (debug) {
+              console.error(`[Edit] Successfully edited ${resolvedPath}, replaced ${replacedCount} occurrence(s)`);
+            }
+            return `Successfully edited ${file_path} (${replacedCount} replacement${replacedCount !== 1 ? "s" : ""})`;
+          } catch (error) {
+            console.error("[Edit] Error:", error);
+            return `Error editing file: ${error.message}`;
+          }
+        }
+      });
+    };
+    createTool = (options = {}) => {
+      const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+      return tool3({
+        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 resolvedPath = isAbsolute(file_path) ? file_path : resolve3(defaultPath || process.cwd(), file_path);
+            if (debug) {
+              console.error(`[Create] Attempting to create file: ${resolvedPath}`);
+            }
+            if (!isPathAllowed(resolvedPath, allowedFolders)) {
+              return `Error creating file: Permission denied - ${file_path} is outside allowed directories`;
+            }
+            if (existsSync2(resolvedPath) && !overwrite) {
+              return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
+            }
+            const dir = dirname(resolvedPath);
+            await fs4.mkdir(dir, { recursive: true });
+            await fs4.writeFile(resolvedPath, content, "utf-8");
+            const action = existsSync2(resolvedPath) && overwrite ? "overwrote" : "created";
+            const bytes = Buffer.byteLength(content, "utf-8");
+            if (debug) {
+              console.error(`[Create] Successfully ${action} ${resolvedPath}`);
+            }
+            return `Successfully ${action} ${file_path} (${bytes} bytes)`;
+          } catch (error) {
+            console.error("[Create] Error:", error);
+            return `Error creating file: ${error.message}`;
+          }
+        }
+      });
+    };
+    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
 var init_langchain = __esm({
   "src/tools/langchain.js"() {
@@ -9425,8 +9759,10 @@ var init_tools = __esm({
     "use strict";
     init_vercel();
     init_bash();
+    init_edit();
     init_langchain();
     init_common();
+    init_edit();
     init_system_message();
     init_vercel();
     init_bash();
@@ -9443,7 +9779,7 @@ var init_tools = __esm({
 });
 
 // src/utils/file-lister.js
-import fs4 from "fs";
+import fs5 from "fs";
 import path4 from "path";
 import { promisify as promisify6 } from "util";
 import { exec as exec4 } from "child_process";
@@ -9453,10 +9789,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!fs4.existsSync(directory)) {
+  if (!fs5.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = fs4.existsSync(path4.join(directory, ".git"));
+  const gitDirExists = fs5.existsSync(path4.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -9487,7 +9823,7 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = fs4.readdirSync(dir, { withFileTypes: true });
+      const entries = fs5.readdirSync(dir, { withFileTypes: true });
       const files = entries.filter((entry) => entry.isFile());
       for (const file of files) {
         if (result.length >= maxFiles) break;
@@ -9512,11 +9848,11 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 }
 function loadGitignorePatterns(directory) {
   const gitignorePath = path4.join(directory, ".gitignore");
-  if (!fs4.existsSync(gitignorePath)) {
+  if (!fs5.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = fs4.readFileSync(gitignorePath, "utf8");
+    const content = fs5.readFileSync(gitignorePath, "utf8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error) {
     console.error(`Warning: Could not read .gitignore: ${error.message}`);
@@ -9543,8 +9879,8 @@ var init_file_lister = __esm({
 });
 
 // src/agent/simpleTelemetry.js
-import { existsSync as existsSync2, mkdirSync, createWriteStream } from "fs";
-import { dirname } from "path";
+import { existsSync as existsSync3, mkdirSync, createWriteStream } from "fs";
+import { dirname as dirname2 } from "path";
 function initializeSimpleTelemetryFromOptions(options) {
   const telemetry = new SimpleTelemetry({
     serviceName: "probe-agent",
@@ -9571,8 +9907,8 @@ var init_simpleTelemetry = __esm({
       }
       initializeFileExporter() {
         try {
-          const dir = dirname(this.filePath);
-          if (!existsSync2(dir)) {
+          const dir = dirname2(this.filePath);
+          if (!existsSync3(dir)) {
             mkdirSync(dir, { recursive: true });
           }
           this.stream = createWriteStream(this.filePath, { flags: "a" });
@@ -9636,20 +9972,20 @@ var init_simpleTelemetry = __esm({
       }
       async flush() {
         if (this.stream) {
-          return new Promise((resolve5) => {
-            this.stream.once("drain", resolve5);
+          return new Promise((resolve6) => {
+            this.stream.once("drain", resolve6);
             if (!this.stream.writableNeedDrain) {
-              resolve5();
+              resolve6();
             }
           });
         }
       }
       async shutdown() {
         if (this.stream) {
-          return new Promise((resolve5) => {
+          return new Promise((resolve6) => {
             this.stream.end(() => {
               console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
-              resolve5();
+              resolve6();
             });
           });
         }
@@ -10612,7 +10948,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);
@@ -10685,8 +11021,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 = "[^/]";
@@ -13448,10 +13784,10 @@ var init_esm3 = __esm({
        * Return a void Promise that resolves once the stream ends.
        */
       async promise() {
-        return new Promise((resolve5, reject2) => {
+        return new Promise((resolve6, reject2) => {
           this.on(DESTROYED, () => reject2(new Error("stream destroyed")));
           this.on("error", (er) => reject2(er));
-          this.on("end", () => resolve5());
+          this.on("end", () => resolve6());
         });
       }
       /**
@@ -13475,7 +13811,7 @@ var init_esm3 = __esm({
             return Promise.resolve({ done: false, value: res });
           if (this[EOF])
             return stop();
-          let resolve5;
+          let resolve6;
           let reject2;
           const onerr = (er) => {
             this.off("data", ondata);
@@ -13489,19 +13825,19 @@ var init_esm3 = __esm({
             this.off("end", onend);
             this.off(DESTROYED, ondestroy);
             this.pause();
-            resolve5({ value, done: !!this[EOF] });
+            resolve6({ value, done: !!this[EOF] });
           };
           const onend = () => {
             this.off("error", onerr);
             this.off("data", ondata);
             this.off(DESTROYED, ondestroy);
             stop();
-            resolve5({ done: true, value: void 0 });
+            resolve6({ done: true, value: void 0 });
           };
           const ondestroy = () => onerr(new Error("stream destroyed"));
           return new Promise((res2, rej) => {
             reject2 = rej;
-            resolve5 = res2;
+            resolve6 = res2;
             this.once(DESTROYED, ondestroy);
             this.once("error", onerr);
             this.once("end", onend);
@@ -14481,9 +14817,9 @@ var init_esm4 = __esm({
         if (this.#asyncReaddirInFlight) {
           await this.#asyncReaddirInFlight;
         } else {
-          let resolve5 = () => {
+          let resolve6 = () => {
           };
-          this.#asyncReaddirInFlight = new Promise((res) => resolve5 = res);
+          this.#asyncReaddirInFlight = new Promise((res) => resolve6 = res);
           try {
             for (const e of await this.#fs.promises.readdir(fullpath, {
               withFileTypes: true
@@ -14496,7 +14832,7 @@ var init_esm4 = __esm({
             children.provisional = 0;
           }
           this.#asyncReaddirInFlight = void 0;
-          resolve5();
+          resolve6();
         }
         return children.slice(0, children.provisional);
       }
@@ -14726,8 +15062,8 @@ var init_esm4 = __esm({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs6);
+      constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs7);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = fileURLToPath4(cwd);
         }
@@ -14737,7 +15073,7 @@ var init_esm4 = __esm({
         this.#resolveCache = new ResolveCache();
         this.#resolvePosixCache = new ResolveCache();
         this.#children = new ChildrenCache(childrenCacheSize);
-        const split = cwdPath.substring(this.rootPath.length).split(sep2);
+        const split = cwdPath.substring(this.rootPath.length).split(sep3);
         if (split.length === 1 && !split[0]) {
           split.pop();
         }
@@ -15285,8 +15621,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs6) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+      newRoot(fs7) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -15314,8 +15650,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs6) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+      newRoot(fs7) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -16455,7 +16791,7 @@ import { exec as exec5 } from "child_process";
 import { promisify as promisify7 } from "util";
 import { randomUUID as randomUUID2 } from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
-import fs5 from "fs";
+import fs6 from "fs";
 import { promises as fsPromises } from "fs";
 import path6 from "path";
 function isSessionCancelled(sessionId) {
@@ -16515,6 +16851,20 @@ function createWrappedTools(baseTools) {
       baseTools.bashTool.execute
     );
   }
+  if (baseTools.editTool) {
+    wrappedTools.editToolInstance = wrapToolWithEmitter(
+      baseTools.editTool,
+      "edit",
+      baseTools.editTool.execute
+    );
+  }
+  if (baseTools.createTool) {
+    wrappedTools.createToolInstance = wrapToolWithEmitter(
+      baseTools.createTool,
+      "create",
+      baseTools.createTool.execute
+    );
+  }
   return wrappedTools;
 }
 var toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
@@ -16525,9 +16875,9 @@ var init_probeTool = __esm({
     init_esm5();
     toolCallEmitter = new EventEmitter2();
     activeToolExecutions = /* @__PURE__ */ new Map();
-    wrapToolWithEmitter = (tool3, toolName, baseExecute) => {
+    wrapToolWithEmitter = (tool4, toolName, baseExecute) => {
       return {
-        ...tool3,
+        ...tool4,
         // Spread schema, description etc.
         execute: async (params) => {
           const debug = process.env.DEBUG === "1";
@@ -16762,8 +17112,10 @@ var init_index = __esm({
     init_file_lister();
     init_system_message();
     init_common();
+    init_edit();
     init_vercel();
     init_bash();
+    init_edit();
     init_ProbeAgent();
     init_simpleTelemetry();
     init_probeTool();
@@ -16845,8 +17197,8 @@ function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
 function hasOtherToolTags(xmlString, validTools = []) {
   const defaultTools = ["search", "query", "extract", "listFiles", "searchFiles", "implement", "attempt_completion"];
   const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
-  for (const tool3 of toolsToCheck) {
-    if (tool3 !== "attempt_completion" && xmlString.includes(`<${tool3}`)) {
+  for (const tool4 of toolsToCheck) {
+    if (tool4 !== "attempt_completion" && xmlString.includes(`<${tool4}`)) {
       return true;
     }
   }
@@ -16884,6 +17236,10 @@ function createTools(configOptions) {
   if (configOptions.enableBash) {
     tools2.bashTool = bashTool(configOptions);
   }
+  if (configOptions.allowEdit) {
+    tools2.editTool = editTool(configOptions);
+    tools2.createTool = createTool(configOptions);
+  }
   return tools2;
 }
 function parseXmlToolCallWithThinking(xmlString, validTools) {
@@ -16984,7 +17340,7 @@ function createMockProvider() {
       provider: "mock",
       // Mock the doGenerate method used by Vercel AI SDK
       doGenerate: async ({ messages, tools: tools2 }) => {
-        await new Promise((resolve5) => setTimeout(resolve5, 10));
+        await new Promise((resolve6) => setTimeout(resolve6, 10));
         return {
           text: "This is a mock response for testing",
           toolCalls: [],
@@ -28971,16 +29327,6 @@ var init_parser2 = __esm({
         this.subgraph = this.RULE("subgraph", () => {
           this.CONSUME(SubgraphKeyword);
           this.OR([
-            {
-              ALT: () => {
-                this.CONSUME(Identifier, { LABEL: "subgraphId" });
-                this.OPTION(() => {
-                  this.CONSUME1(SquareOpen);
-                  this.SUBRULE(this.nodeContent);
-                  this.CONSUME1(SquareClose);
-                });
-              }
-            },
             {
               ALT: () => {
                 this.CONSUME(QuotedString, { LABEL: "subgraphTitleQ" });
@@ -28992,6 +29338,33 @@ var init_parser2 = __esm({
                 this.SUBRULE2(this.nodeContent);
                 this.CONSUME2(SquareClose);
               }
+            },
+            {
+              ALT: () => {
+                this.CONSUME1(Identifier, { LABEL: "subgraphIdOrFirstWord" });
+                this.OPTION(() => {
+                  this.OR1([
+                    {
+                      ALT: () => {
+                        this.CONSUME1(SquareOpen);
+                        this.SUBRULE(this.nodeContent);
+                        this.CONSUME1(SquareClose);
+                      }
+                    },
+                    {
+                      ALT: () => {
+                        this.AT_LEAST_ONE(() => {
+                          this.OR2([
+                            { ALT: () => this.CONSUME2(Identifier) },
+                            { ALT: () => this.CONSUME(Text) },
+                            { ALT: () => this.CONSUME(NumberLiteral) }
+                          ]);
+                        });
+                      }
+                    }
+                  ]);
+                });
+              }
             }
           ]);
           this.CONSUME(Newline);
@@ -29595,7 +29968,6 @@ var init_semantics = __esm({
             const last2 = allChildren[allChildren.length - 1];
             const isSlash = (t) => t.image === "/" || t.image === "\\";
             if (isSlash(first2) && isSlash(last2)) {
-              continue;
             }
           }
           const opens = ch.RoundOpen || [];
@@ -30389,16 +30761,19 @@ function mapFlowchartParserError(err, text) {
     const subgraphIdx = lineStr.indexOf("subgraph");
     if (subgraphIdx !== -1) {
       const afterSubgraph = lineStr.slice(subgraphIdx + 8).trim();
-      if (afterSubgraph && !afterSubgraph.startsWith('"') && !afterSubgraph.startsWith("'") && afterSubgraph.includes(" ")) {
-        return {
-          line,
-          column,
-          severity: "error",
-          code: "FL-SUBGRAPH-UNQUOTED-TITLE",
-          message: "Subgraph titles with spaces must be quoted.",
-          hint: 'Example: subgraph "Existing Logic Path" or use underscores: subgraph Existing_Logic_Path',
-          length: afterSubgraph.length
-        };
+      if (afterSubgraph && !afterSubgraph.startsWith('"') && !afterSubgraph.startsWith("'")) {
+        const hasHazard = /[\[\](){}/:|"'\\]/.test(afterSubgraph);
+        if (hasHazard) {
+          return {
+            line,
+            column,
+            severity: "error",
+            code: "FL-SUBGRAPH-UNQUOTED-TITLE",
+            message: "Subgraph title contains special characters; wrap it in quotes.",
+            hint: 'Example: subgraph "Streams (inside Gateway)"',
+            length: afterSubgraph.length
+          };
+        }
       }
     }
   }
@@ -31096,11 +31471,11 @@ function validateFlowchart(text, options = {}) {
         const byLine = /* @__PURE__ */ new Map();
         const collect = (arr) => {
           for (const e of arr || []) {
-            if (e && e.code === "FL-LABEL-PARENS-UNQUOTED") {
+            if (e && (e.code === "FL-LABEL-PARENS-UNQUOTED" || e.code === "FL-LABEL-AT-IN-UNQUOTED")) {
               const ln = e.line ?? 0;
               const col = e.column ?? 1;
               const list = byLine.get(ln) || [];
-              list.push(col);
+              list.push({ start: col, end: col });
               byLine.set(ln, list);
             }
           }
@@ -31109,33 +31484,91 @@ function validateFlowchart(text, options = {}) {
         collect(errs);
         const lines2 = text2.split(/\r?\n/);
         for (let ii = 0; ii < lines2.length; ii++) {
-          const raw2 = lines2[ii] || "";
-          if (!raw2.includes("[") || !raw2.includes("]"))
+          const raw = lines2[ii] || "";
+          if (!raw.includes("[") || !raw.includes("]"))
             continue;
-          let search2 = 0;
-          while (true) {
-            const open2 = raw2.indexOf("[", search2);
-            if (open2 === -1)
-              break;
-            const close2 = raw2.indexOf("]", open2 + 1);
-            if (close2 === -1)
-              break;
-            const seg2 = raw2.slice(open2 + 1, close2);
-            const trimmed2 = seg2.trim();
-            const ln2 = ii + 1;
-            const lsp = trimmed2.slice(0, 1);
-            const rsp = trimmed2.slice(-1);
-            const isSlashPair = (lsp === "/" || lsp === "\\") && (rsp === "/" || rsp === "\\");
-            const isParenWrapped = lsp === "(" && rsp === ")";
-            const segStartCol = open2 + 2;
-            const segEndCol = close2 + 1;
-            const existing = byLine.get(ln2) || [];
-            const covered = existing.some((c) => c >= segStartCol && c <= segEndCol);
-            if (!covered && !/^".*"$/.test(trimmed2) && (seg2.includes("(") || seg2.includes(")")) && !isSlashPair && !isParenWrapped) {
-              errs.push({ line: ln2, column: segStartCol, severity: "error", code: "FL-LABEL-PARENS-UNQUOTED", message: "Parentheses inside an unquoted label are not supported by Mermaid.", hint: 'Wrap the label in quotes, e.g., A["Mark (X)"] \u2014 or replace ( and ) with HTML entities: &#40; and &#41;.' });
-              byLine.set(ln2, existing.concat([segStartCol]));
+          let i = 0;
+          const n = raw.length;
+          let inQuote = false;
+          let esc = false;
+          while (i < n) {
+            const ch = raw[i];
+            if (inQuote) {
+              if (esc) {
+                esc = false;
+              } else if (ch === "\\") {
+                esc = true;
+              } else if (ch === '"') {
+                inQuote = false;
+              }
+              i++;
+              continue;
+            }
+            if (ch === '"') {
+              inQuote = true;
+              i++;
+              continue;
+            }
+            if (ch === "[") {
+              let j = i + 1;
+              let inQ = false;
+              let esc2 = false;
+              let depth = 1;
+              while (j < n && depth > 0) {
+                const cj = raw[j];
+                if (inQ) {
+                  if (esc2) {
+                    esc2 = false;
+                  } else if (cj === "\\") {
+                    esc2 = true;
+                  } else if (cj === '"') {
+                    inQ = false;
+                  }
+                  j++;
+                  continue;
+                }
+                if (cj === '"') {
+                  inQ = true;
+                  j++;
+                  continue;
+                }
+                if (cj === "[")
+                  depth++;
+                else if (cj === "]")
+                  depth--;
+                j++;
+              }
+              if (depth === 0) {
+                const startCol = i + 2;
+                const endCol = j;
+                const seg = raw.slice(i + 1, j - 1);
+                const trimmed = seg.trim();
+                const ln = ii + 1;
+                const lsp = trimmed.slice(0, 1), rsp = trimmed.slice(-1);
+                const isSlashPair = (lsp === "/" || lsp === "\\") && (rsp === "/" || rsp === "\\");
+                const isParenWrapped = lsp === "(" && rsp === ")";
+                const isQuoted = /^"[\s\S]*"$/.test(trimmed);
+                const existing = byLine.get(ln) || [];
+                const covered = existing.some((r) => !(endCol < r.start || startCol > r.end));
+                const hasParens = seg.includes("(") || seg.includes(")");
+                const hasAt = seg.includes("@");
+                if (!covered && !isQuoted && !isParenWrapped && hasParens) {
+                  errs.push({ line: ln, column: startCol, severity: "error", code: "FL-LABEL-PARENS-UNQUOTED", message: "Parentheses inside an unquoted label are not supported by Mermaid.", hint: 'Wrap the label in quotes, e.g., A["Mark (X)"] \u2014 or replace ( and ) with HTML entities: &#40; and &#41;.' });
+                  existing.push({ start: startCol, end: endCol });
+                  byLine.set(ln, existing);
+                }
+                if (!covered && !isQuoted && !isSlashPair && hasAt) {
+                  errs.push({ line: ln, column: startCol, severity: "error", code: "FL-LABEL-AT-IN-UNQUOTED", message: "'@' inside an unquoted label can be misparsed by Mermaid.", hint: 'Wrap the label in quotes, e.g., B["@probelabs/probe v0.6.0-rc149"]' });
+                  existing.push({ start: startCol, end: endCol });
+                  byLine.set(ln, existing);
+                }
+                i = j;
+                continue;
+              } else {
+                break;
+              }
             }
-            search2 = close2 + 1;
+            i++;
           }
         }
       }
@@ -42621,7 +43054,7 @@ var require_bk = __commonJS({
       return xs;
     }
     function buildBlockGraph(g, layering, root2, reverseSep) {
-      var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep2(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
+      var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep3(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
       _.forEach(layering, function(layer) {
         var u;
         _.forEach(layer, function(v) {
@@ -42711,7 +43144,7 @@ var require_bk = __commonJS({
       alignCoordinates(xss, smallestWidth);
       return balance(xss, g.graph().align);
     }
-    function sep2(nodeSep, edgeSep, reverseSep) {
+    function sep3(nodeSep, edgeSep, reverseSep) {
       return function(g, v, w) {
         var vLabel = g.node(v);
         var wLabel = g.node(w);
@@ -50005,7 +50438,7 @@ var require_compile = __commonJS({
       const schOrFunc = root2.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve5.call(this, root2, ref);
+      let _sch = resolve6.call(this, root2, ref);
       if (_sch === void 0) {
         const schema = (_a = root2.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -50032,7 +50465,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve5(root2, ref) {
+    function resolve6(root2, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -50607,7 +51040,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve5(baseURI, relativeURI, options) {
+    function resolve6(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -50834,7 +51267,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize2,
-      resolve: resolve5,
+      resolve: resolve6,
       resolveComponent,
       equal,
       serialize,
@@ -54852,15 +55285,15 @@ Provide only the corrected Mermaid diagram within a mermaid code block. Do not a
 });
 
 // src/agent/mcp/config.js
-import { readFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
+import { readFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join2, dirname as dirname3 } from "path";
 import { homedir } from "os";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!existsSync3(configPath)) {
+  if (!existsSync4(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
@@ -54889,7 +55322,7 @@ function loadMCPConfiguration() {
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
-    if (existsSync3(configPath)) {
+    if (existsSync4(configPath)) {
       try {
         const content = readFileSync(configPath, "utf8");
         config = JSON.parse(content);
@@ -54992,7 +55425,7 @@ var init_config = __esm({
   "src/agent/mcp/config.js"() {
     "use strict";
     __filename4 = fileURLToPath6(import.meta.url);
-    __dirname4 = dirname2(__filename4);
+    __dirname4 = dirname3(__filename4);
     DEFAULT_CONFIG = {
       mcpServers: {
         // Example probe server configuration
@@ -55181,12 +55614,12 @@ var init_client = __esm({
           const toolsResponse = await client.listTools();
           const toolCount = toolsResponse?.tools?.length || 0;
           if (toolsResponse && toolsResponse.tools) {
-            for (const tool3 of toolsResponse.tools) {
-              const qualifiedName = `${name}_${tool3.name}`;
+            for (const tool4 of toolsResponse.tools) {
+              const qualifiedName = `${name}_${tool4.name}`;
               this.tools.set(qualifiedName, {
-                ...tool3,
+                ...tool4,
                 serverName: name,
-                originalName: tool3.name
+                originalName: tool4.name
               });
               if (this.debug) {
                 console.error(`[MCP DEBUG]     Registered tool: ${qualifiedName}`);
@@ -55209,13 +55642,13 @@ var init_client = __esm({
        * @param {Object} args - Tool arguments
        */
       async callTool(toolName, args) {
-        const tool3 = this.tools.get(toolName);
-        if (!tool3) {
+        const tool4 = this.tools.get(toolName);
+        if (!tool4) {
           throw new Error(`Unknown tool: ${toolName}`);
         }
-        const clientInfo = this.clients.get(tool3.serverName);
+        const clientInfo = this.clients.get(tool4.serverName);
         if (!clientInfo) {
-          throw new Error(`Server ${tool3.serverName} not connected`);
+          throw new Error(`Server ${tool4.serverName} not connected`);
         }
         try {
           if (this.debug) {
@@ -55229,7 +55662,7 @@ var init_client = __esm({
           });
           const result = await Promise.race([
             clientInfo.client.callTool({
-              name: tool3.originalName,
+              name: tool4.originalName,
               arguments: args
             }),
             timeoutPromise
@@ -55252,11 +55685,11 @@ var init_client = __esm({
        */
       getTools() {
         const tools2 = {};
-        for (const [name, tool3] of this.tools.entries()) {
+        for (const [name, tool4] of this.tools.entries()) {
           tools2[name] = {
-            description: tool3.description,
-            inputSchema: tool3.inputSchema,
-            serverName: tool3.serverName
+            description: tool4.description,
+            inputSchema: tool4.inputSchema,
+            serverName: tool4.serverName
           };
         }
         return tools2;
@@ -55267,10 +55700,10 @@ var init_client = __esm({
        */
       getVercelTools() {
         const tools2 = {};
-        for (const [name, tool3] of this.tools.entries()) {
+        for (const [name, tool4] of this.tools.entries()) {
           tools2[name] = {
-            description: tool3.description,
-            inputSchema: tool3.inputSchema,
+            description: tool4.description,
+            inputSchema: tool4.inputSchema,
             execute: async (args) => {
               const result = await this.callTool(name, args);
               if (result.content && result.content[0]) {
@@ -55319,9 +55752,9 @@ var init_client = __esm({
 });
 
 // src/agent/mcp/xmlBridge.js
-function mcpToolToXmlDefinition(name, tool3) {
-  const description = tool3.description || "MCP tool";
-  const inputSchema = tool3.inputSchema || tool3.parameters || {};
+function mcpToolToXmlDefinition(name, tool4) {
+  const description = tool4.description || "MCP tool";
+  const inputSchema = tool4.inputSchema || tool4.parameters || {};
   let paramDocs = "";
   if (inputSchema.properties) {
     paramDocs = "\n\nParameters (provide as JSON object):";
@@ -55500,8 +55933,8 @@ var init_xmlBridge = __esm({
           const vercelTools = this.mcpManager.getVercelTools();
           this.mcpTools = vercelTools;
           const toolCount = Object.keys(vercelTools).length;
-          for (const [name, tool3] of Object.entries(vercelTools)) {
-            this.xmlDefinitions[name] = mcpToolToXmlDefinition(name, tool3);
+          for (const [name, tool4] of Object.entries(vercelTools)) {
+            this.xmlDefinitions[name] = mcpToolToXmlDefinition(name, tool4);
           }
           if (toolCount === 0) {
             console.error("[MCP INFO] MCP initialization complete: 0 tools loaded");
@@ -55548,14 +55981,14 @@ var init_xmlBridge = __esm({
           console.error(`[MCP DEBUG] Executing MCP tool: ${toolName}`);
           console.error(`[MCP DEBUG] Parameters:`, JSON.stringify(params, null, 2));
         }
-        const tool3 = this.mcpTools[toolName];
-        if (!tool3) {
+        const tool4 = this.mcpTools[toolName];
+        if (!tool4) {
           console.error(`[MCP ERROR] Unknown MCP tool: ${toolName}`);
           console.error(`[MCP ERROR] Available tools: ${this.getToolNames().join(", ")}`);
           throw new Error(`Unknown MCP tool: ${toolName}`);
         }
         try {
-          const result = await tool3.execute(params);
+          const result = await tool4.execute(params);
           if (this.debug) {
             console.error(`[MCP DEBUG] Tool ${toolName} executed successfully`);
           }
@@ -55609,22 +56042,636 @@ var init_mcp = __esm({
   }
 });
 
+// src/agent/RetryManager.js
+function isRetryableError(error, retryableErrors = DEFAULT_RETRYABLE_ERRORS) {
+  if (!error) return false;
+  const errorString = error.toString().toLowerCase();
+  const errorMessage = (error.message || "").toLowerCase();
+  const errorCode = (error.code || "").toLowerCase();
+  const errorType = (error.type || "").toLowerCase();
+  const statusCode = error.statusCode || error.status;
+  for (const pattern of retryableErrors) {
+    const lowerPattern = pattern.toLowerCase();
+    if (errorString.includes(lowerPattern) || errorMessage.includes(lowerPattern) || errorCode.includes(lowerPattern) || errorType.includes(lowerPattern) || statusCode?.toString() === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractErrorInfo(error) {
+  return {
+    message: error.message || error.toString(),
+    type: error.type || error.constructor.name,
+    code: error.code,
+    statusCode: error.statusCode || error.status,
+    provider: error.provider,
+    isRetryable: isRetryableError(error)
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+var DEFAULT_RETRYABLE_ERRORS, RetryManager;
+var init_RetryManager = __esm({
+  "src/agent/RetryManager.js"() {
+    "use strict";
+    DEFAULT_RETRYABLE_ERRORS = [
+      "Overloaded",
+      "overloaded",
+      "rate_limit",
+      "rate limit",
+      "429",
+      "500",
+      "502",
+      "503",
+      "504",
+      "timeout",
+      "ECONNRESET",
+      "ETIMEDOUT",
+      "ENOTFOUND",
+      "api_error"
+    ];
+    RetryManager = class {
+      /**
+       * Create a new RetryManager
+       * @param {Object} options - Configuration options
+       * @param {number} [options.maxRetries=3] - Maximum retry attempts
+       * @param {number} [options.initialDelay=1000] - Initial delay in ms (1 second)
+       * @param {number} [options.maxDelay=30000] - Maximum delay in ms (30 seconds)
+       * @param {number} [options.backoffFactor=2] - Exponential backoff multiplier
+       * @param {Array<string>} [options.retryableErrors] - List of retryable error patterns
+       * @param {boolean} [options.debug=false] - Enable debug logging
+       */
+      constructor(options = {}) {
+        this.maxRetries = this._validateNumber(options.maxRetries, 3, "maxRetries", 0, 100);
+        this.initialDelay = this._validateNumber(options.initialDelay, 1e3, "initialDelay", 0, 6e4);
+        this.maxDelay = this._validateNumber(options.maxDelay, 3e4, "maxDelay", 0, 3e5);
+        this.backoffFactor = this._validateNumber(options.backoffFactor, 2, "backoffFactor", 1, 10);
+        this.retryableErrors = options.retryableErrors || DEFAULT_RETRYABLE_ERRORS;
+        this.debug = options.debug ?? false;
+        this.jitter = options.jitter ?? true;
+        if (this.maxDelay < this.initialDelay) {
+          throw new Error("maxDelay must be greater than or equal to initialDelay");
+        }
+        this.stats = {
+          totalAttempts: 0,
+          totalRetries: 0,
+          successfulRetries: 0,
+          failedRetries: 0
+        };
+      }
+      /**
+       * Validate a numeric parameter
+       * @param {*} value - Value to validate
+       * @param {number} defaultValue - Default if undefined
+       * @param {string} name - Parameter name for error messages
+       * @param {number} min - Minimum allowed value
+       * @param {number} max - Maximum allowed value
+       * @returns {number} - Validated number
+       * @private
+       */
+      _validateNumber(value, defaultValue, name, min, max) {
+        if (value === void 0 || value === null) {
+          return defaultValue;
+        }
+        const num = Number(value);
+        if (isNaN(num)) {
+          throw new Error(`${name} must be a number, got: ${value}`);
+        }
+        if (num < min || num > max) {
+          throw new Error(`${name} must be between ${min} and ${max}, got: ${num}`);
+        }
+        return num;
+      }
+      /**
+       * Execute a function with retry logic
+       * @param {Function} fn - Async function to execute
+       * @param {Object} [context={}] - Context information for logging
+       * @param {AbortSignal} [context.signal] - Optional abort signal for cancellation
+       * @returns {Promise<*>} - Result from the function
+       * @throws {Error} - If all retries are exhausted or operation is aborted
+       */
+      async executeWithRetry(fn, context = {}) {
+        let lastError = null;
+        let currentDelay = this.initialDelay;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+          if (context.signal?.aborted) {
+            const abortError = new Error("Operation aborted");
+            abortError.name = "AbortError";
+            throw abortError;
+          }
+          this.stats.totalAttempts++;
+          try {
+            if (this.debug && attempt > 0) {
+              console.log(`[RetryManager] Retry attempt ${attempt}/${this.maxRetries}`, context);
+            }
+            const result = await fn();
+            if (attempt > 0) {
+              this.stats.successfulRetries++;
+              if (this.debug) {
+                console.log(`[RetryManager] \u2705 Retry successful on attempt ${attempt + 1}`, context);
+              }
+            }
+            return result;
+          } catch (error) {
+            lastError = error;
+            const errorInfo = extractErrorInfo(error);
+            const shouldRetry = isRetryableError(error, this.retryableErrors);
+            const hasRetriesLeft = attempt < this.maxRetries;
+            if (this.debug) {
+              console.log(`[RetryManager] \u274C Attempt ${attempt + 1}/${this.maxRetries + 1} failed:`, {
+                ...context,
+                error: errorInfo,
+                shouldRetry,
+                hasRetriesLeft
+              });
+            }
+            if (!shouldRetry) {
+              if (this.debug) {
+                console.log(`[RetryManager] Error is not retryable, failing immediately`, errorInfo);
+              }
+              throw error;
+            }
+            if (!hasRetriesLeft) {
+              this.stats.failedRetries++;
+              if (this.debug) {
+                console.log(`[RetryManager] Max retries (${this.maxRetries}) exhausted`, context);
+              }
+              throw error;
+            }
+            this.stats.totalRetries++;
+            let delayWithJitter = currentDelay;
+            if (this.jitter) {
+              const jitterAmount = currentDelay * 0.25;
+              delayWithJitter = currentDelay + (Math.random() * jitterAmount * 2 - jitterAmount);
+            }
+            if (this.debug) {
+              console.log(`[RetryManager] Waiting ${Math.round(delayWithJitter)}ms before retry...`);
+            }
+            await sleep(delayWithJitter);
+            currentDelay = Math.min(currentDelay * this.backoffFactor, this.maxDelay);
+          }
+        }
+        throw lastError;
+      }
+      /**
+       * Check if an error is retryable
+       * @param {Error} error - The error to check
+       * @returns {boolean} - True if error should be retried
+       */
+      isRetryable(error) {
+        return isRetryableError(error, this.retryableErrors);
+      }
+      /**
+       * Get retry statistics
+       * @returns {Object} - Statistics object
+       */
+      getStats() {
+        return { ...this.stats };
+      }
+      /**
+       * Reset statistics
+       */
+      resetStats() {
+        this.stats = {
+          totalAttempts: 0,
+          totalRetries: 0,
+          successfulRetries: 0,
+          failedRetries: 0
+        };
+      }
+    };
+  }
+});
+
+// src/agent/FallbackManager.js
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+function createFallbackManagerFromEnv(debug = false) {
+  const fallbackProvidersEnv = process.env.FALLBACK_PROVIDERS;
+  const fallbackModelsEnv = process.env.FALLBACK_MODELS;
+  if (!fallbackProvidersEnv && !fallbackModelsEnv) {
+    return null;
+  }
+  let providers = [];
+  let models = [];
+  let strategy = FALLBACK_STRATEGIES.ANY;
+  if (fallbackProvidersEnv) {
+    try {
+      if (typeof fallbackProvidersEnv !== "string" || fallbackProvidersEnv.length > 1e4) {
+        console.error("[FallbackManager] FALLBACK_PROVIDERS must be a valid JSON string under 10KB");
+        return null;
+      }
+      const parsed = JSON.parse(fallbackProvidersEnv);
+      if (!Array.isArray(parsed)) {
+        console.error("[FallbackManager] FALLBACK_PROVIDERS must be a JSON array");
+        return null;
+      }
+      providers = parsed;
+      strategy = FALLBACK_STRATEGIES.CUSTOM;
+    } catch (error) {
+      console.error("[FallbackManager] Failed to parse FALLBACK_PROVIDERS:", error.message);
+      return null;
+    }
+  }
+  if (fallbackModelsEnv) {
+    try {
+      if (typeof fallbackModelsEnv !== "string" || fallbackModelsEnv.length > 1e4) {
+        console.error("[FallbackManager] FALLBACK_MODELS must be a valid JSON string under 10KB");
+        return null;
+      }
+      const parsed = JSON.parse(fallbackModelsEnv);
+      if (!Array.isArray(parsed)) {
+        console.error("[FallbackManager] FALLBACK_MODELS must be a JSON array");
+        return null;
+      }
+      models = parsed;
+      strategy = FALLBACK_STRATEGIES.SAME_PROVIDER;
+    } catch (error) {
+      console.error("[FallbackManager] Failed to parse FALLBACK_MODELS:", error.message);
+      return null;
+    }
+  }
+  const maxTotalAttempts = process.env.FALLBACK_MAX_TOTAL_ATTEMPTS ? (() => {
+    const val = parseInt(process.env.FALLBACK_MAX_TOTAL_ATTEMPTS, 10);
+    if (isNaN(val) || val < 1 || val > 100) {
+      console.warn("[FallbackManager] FALLBACK_MAX_TOTAL_ATTEMPTS must be between 1 and 100, using default: 10");
+      return 10;
+    }
+    return val;
+  })() : 10;
+  return new FallbackManager({
+    strategy,
+    providers,
+    models,
+    maxTotalAttempts,
+    debug
+  });
+}
+function buildFallbackProvidersFromEnv(options = {}) {
+  const providers = [];
+  const anthropicApiKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN;
+  const openaiApiKey = process.env.OPENAI_API_KEY;
+  const googleApiKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GOOGLE_API_KEY;
+  const awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID;
+  const awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+  const awsRegion = process.env.AWS_REGION;
+  const awsApiKey = process.env.AWS_BEDROCK_API_KEY;
+  const llmBaseUrl = process.env.LLM_BASE_URL;
+  const anthropicApiUrl = process.env.ANTHROPIC_API_URL || process.env.ANTHROPIC_BASE_URL || llmBaseUrl;
+  const openaiApiUrl = process.env.OPENAI_API_URL || llmBaseUrl;
+  const googleApiUrl = process.env.GOOGLE_API_URL || llmBaseUrl;
+  const awsBedrockBaseUrl = process.env.AWS_BEDROCK_BASE_URL || llmBaseUrl;
+  const primaryProvider = options.primaryProvider?.toLowerCase();
+  const primaryModel = options.primaryModel;
+  if (primaryProvider === "anthropic" && anthropicApiKey) {
+    providers.push({
+      provider: "anthropic",
+      apiKey: anthropicApiKey,
+      ...anthropicApiUrl && { baseURL: anthropicApiUrl },
+      ...primaryModel && { model: primaryModel }
+    });
+  } else if (primaryProvider === "openai" && openaiApiKey) {
+    providers.push({
+      provider: "openai",
+      apiKey: openaiApiKey,
+      ...openaiApiUrl && { baseURL: openaiApiUrl },
+      ...primaryModel && { model: primaryModel }
+    });
+  } else if (primaryProvider === "google" && googleApiKey) {
+    providers.push({
+      provider: "google",
+      apiKey: googleApiKey,
+      ...googleApiUrl && { baseURL: googleApiUrl },
+      ...primaryModel && { model: primaryModel }
+    });
+  } else if (primaryProvider === "bedrock" && (awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey)) {
+    const config = { provider: "bedrock" };
+    if (awsApiKey) {
+      config.apiKey = awsApiKey;
+    } else {
+      config.accessKeyId = awsAccessKeyId;
+      config.secretAccessKey = awsSecretAccessKey;
+      config.region = awsRegion;
+      if (process.env.AWS_SESSION_TOKEN) {
+        config.sessionToken = process.env.AWS_SESSION_TOKEN;
+      }
+    }
+    if (awsBedrockBaseUrl) config.baseURL = awsBedrockBaseUrl;
+    if (primaryModel) config.model = primaryModel;
+    providers.push(config);
+  }
+  if (anthropicApiKey && primaryProvider !== "anthropic") {
+    providers.push({
+      provider: "anthropic",
+      apiKey: anthropicApiKey,
+      ...anthropicApiUrl && { baseURL: anthropicApiUrl }
+    });
+  }
+  if (openaiApiKey && primaryProvider !== "openai") {
+    providers.push({
+      provider: "openai",
+      apiKey: openaiApiKey,
+      ...openaiApiUrl && { baseURL: openaiApiUrl }
+    });
+  }
+  if (googleApiKey && primaryProvider !== "google") {
+    providers.push({
+      provider: "google",
+      apiKey: googleApiKey,
+      ...googleApiUrl && { baseURL: googleApiUrl }
+    });
+  }
+  if ((awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey) && primaryProvider !== "bedrock") {
+    const config = { provider: "bedrock" };
+    if (awsApiKey) {
+      config.apiKey = awsApiKey;
+    } else {
+      config.accessKeyId = awsAccessKeyId;
+      config.secretAccessKey = awsSecretAccessKey;
+      config.region = awsRegion;
+      if (process.env.AWS_SESSION_TOKEN) {
+        config.sessionToken = process.env.AWS_SESSION_TOKEN;
+      }
+    }
+    if (awsBedrockBaseUrl) config.baseURL = awsBedrockBaseUrl;
+    providers.push(config);
+  }
+  return providers;
+}
+var FALLBACK_STRATEGIES, DEFAULT_MODELS, FallbackManager;
+var init_FallbackManager = __esm({
+  "src/agent/FallbackManager.js"() {
+    "use strict";
+    FALLBACK_STRATEGIES = {
+      SAME_MODEL: "same-model",
+      // Try same model on different providers
+      SAME_PROVIDER: "same-provider",
+      // Try different models on same provider
+      ANY: "any",
+      // Try any available provider/model
+      CUSTOM: "custom"
+      // Use custom provider list
+    };
+    DEFAULT_MODELS = {
+      anthropic: "claude-sonnet-4-5-20250929",
+      openai: "gpt-4o",
+      google: "gemini-2.0-flash-exp",
+      bedrock: "anthropic.claude-sonnet-4-20250514-v1:0"
+    };
+    FallbackManager = class {
+      /**
+       * Create a new FallbackManager
+       * @param {Object} options - Configuration options
+       * @param {string} [options.strategy='any'] - Fallback strategy
+       * @param {Array<string>} [options.models] - List of models for same-provider fallback
+       * @param {Array<ProviderConfig>} [options.providers] - List of provider configurations
+       * @param {boolean} [options.stopOnSuccess=true] - Stop on first success
+       * @param {boolean} [options.continueOnNonRetryableError=false] - Continue to fallback on non-retryable errors
+       * @param {number} [options.maxTotalAttempts=10] - Maximum total attempts across all providers
+       * @param {boolean} [options.debug=false] - Enable debug logging
+       */
+      constructor(options = {}) {
+        this.strategy = options.strategy || FALLBACK_STRATEGIES.ANY;
+        this.models = Array.isArray(options.models) ? options.models : [];
+        this.providers = Array.isArray(options.providers) ? options.providers : [];
+        this.stopOnSuccess = options.stopOnSuccess ?? true;
+        this.continueOnNonRetryableError = options.continueOnNonRetryableError ?? false;
+        this.debug = options.debug ?? false;
+        const maxAttempts = options.maxTotalAttempts ?? 10;
+        if (typeof maxAttempts !== "number" || isNaN(maxAttempts) || maxAttempts < 1 || maxAttempts > 100) {
+          throw new Error(`FallbackManager: maxTotalAttempts must be a number between 1 and 100, got: ${maxAttempts}`);
+        }
+        this.maxTotalAttempts = maxAttempts;
+        this.stats = {
+          totalAttempts: 0,
+          providerAttempts: {},
+          successfulProvider: null,
+          failedProviders: []
+        };
+        this._validateConfiguration();
+      }
+      /**
+       * Validate the fallback configuration
+       * @private
+       */
+      _validateConfiguration() {
+        if (this.strategy === FALLBACK_STRATEGIES.SAME_PROVIDER && this.models.length === 0) {
+          throw new Error('FallbackManager: strategy "same-provider" requires models list');
+        }
+        if (this.strategy === FALLBACK_STRATEGIES.CUSTOM && this.providers.length === 0) {
+          throw new Error('FallbackManager: strategy "custom" requires providers list');
+        }
+        for (const config of this.providers) {
+          if (!config.provider) {
+            throw new Error('FallbackManager: Each provider config must have a "provider" field');
+          }
+          if (!["anthropic", "openai", "google", "bedrock"].includes(config.provider)) {
+            throw new Error(`FallbackManager: Invalid provider "${config.provider}". Must be: anthropic, openai, google, or bedrock`);
+          }
+          if (config.provider === "bedrock") {
+            const hasCredentials = config.accessKeyId && config.secretAccessKey && config.region;
+            const hasApiKey = config.apiKey;
+            if (!hasCredentials && !hasApiKey) {
+              throw new Error("FallbackManager: Bedrock provider requires either (accessKeyId, secretAccessKey, region) or apiKey");
+            }
+          } else {
+            if (!config.apiKey) {
+              throw new Error(`FallbackManager: Provider "${config.provider}" requires apiKey`);
+            }
+          }
+        }
+      }
+      /**
+       * Create a provider instance from configuration
+       * @param {ProviderConfig} config - Provider configuration
+       * @returns {Object} - Provider instance
+       * @throws {Error} - If provider creation fails
+       * @private
+       */
+      _createProviderInstance(config) {
+        try {
+          switch (config.provider) {
+            case "anthropic":
+              return createAnthropic({
+                apiKey: config.apiKey,
+                ...config.baseURL && { baseURL: config.baseURL }
+              });
+            case "openai":
+              return createOpenAI({
+                compatibility: "strict",
+                apiKey: config.apiKey,
+                ...config.baseURL && { baseURL: config.baseURL }
+              });
+            case "google":
+              return createGoogleGenerativeAI({
+                apiKey: config.apiKey,
+                ...config.baseURL && { baseURL: config.baseURL }
+              });
+            case "bedrock": {
+              const bedrockConfig = {};
+              if (config.apiKey) {
+                bedrockConfig.apiKey = config.apiKey;
+              } else if (config.accessKeyId && config.secretAccessKey) {
+                bedrockConfig.accessKeyId = config.accessKeyId;
+                bedrockConfig.secretAccessKey = config.secretAccessKey;
+                if (config.sessionToken) {
+                  bedrockConfig.sessionToken = config.sessionToken;
+                }
+              }
+              if (config.region) {
+                bedrockConfig.region = config.region;
+              }
+              if (config.baseURL) {
+                bedrockConfig.baseURL = config.baseURL;
+              }
+              return createAmazonBedrock(bedrockConfig);
+            }
+            default:
+              throw new Error(`FallbackManager: Unknown provider "${config.provider}"`);
+          }
+        } catch (error) {
+          const providerName = this._getProviderDisplayName(config);
+          throw new Error(`Failed to create provider instance for ${providerName}: ${error.message}`);
+        }
+      }
+      /**
+       * Get the model name for a provider configuration
+       * @param {ProviderConfig} config - Provider configuration
+       * @returns {string} - Model name
+       * @private
+       */
+      _getModelName(config) {
+        return config.model || DEFAULT_MODELS[config.provider];
+      }
+      /**
+       * Get provider display name for logging
+       * @param {ProviderConfig} config - Provider configuration
+       * @returns {string} - Display name
+       * @private
+       */
+      _getProviderDisplayName(config) {
+        const model = this._getModelName(config);
+        const provider = config.provider;
+        const url = config.baseURL ? ` (${config.baseURL})` : "";
+        return `${provider}/${model}${url}`;
+      }
+      /**
+       * Execute a function with fallback support
+       * @param {Function} fn - Function that takes (provider, model, config) and returns a Promise
+       * @returns {Promise<*>} - Result from the function
+       * @throws {Error} - If all fallbacks are exhausted
+       */
+      async executeWithFallback(fn) {
+        if (this.providers.length === 0) {
+          throw new Error("FallbackManager: No providers configured for fallback");
+        }
+        let lastError = null;
+        let totalAttempts = 0;
+        for (const config of this.providers) {
+          if (totalAttempts >= this.maxTotalAttempts) {
+            if (this.debug) {
+              console.log(`[FallbackManager] \u26A0\uFE0F  Max total attempts (${this.maxTotalAttempts}) reached`);
+            }
+            break;
+          }
+          totalAttempts++;
+          this.stats.totalAttempts++;
+          const providerName = this._getProviderDisplayName(config);
+          this.stats.providerAttempts[providerName] = (this.stats.providerAttempts[providerName] || 0) + 1;
+          try {
+            if (this.debug) {
+              console.log(`[FallbackManager] Attempting provider: ${providerName} (attempt ${totalAttempts}/${this.maxTotalAttempts})`);
+            }
+            const provider = this._createProviderInstance(config);
+            const model = this._getModelName(config);
+            const result = await fn(provider, model, config);
+            this.stats.successfulProvider = providerName;
+            if (this.debug) {
+              console.log(`[FallbackManager] \u2705 Success with provider: ${providerName}`);
+            }
+            return result;
+          } catch (error) {
+            lastError = error;
+            const errorInfo = {
+              message: error.message || error.toString(),
+              type: error.type || error.constructor.name,
+              statusCode: error.statusCode || error.status
+            };
+            this.stats.failedProviders.push({
+              provider: providerName,
+              error: errorInfo
+            });
+            if (this.debug) {
+              console.log(`[FallbackManager] \u274C Failed with provider: ${providerName}`, errorInfo);
+            }
+            if (!this.continueOnNonRetryableError && error.nonRetryable) {
+              if (this.debug) {
+                console.log(`[FallbackManager] Non-retryable error, stopping fallback chain`);
+              }
+              throw error;
+            }
+            if (this.debug) {
+              const remaining = this.providers.length - (this.providers.indexOf(config) + 1);
+              console.log(`[FallbackManager] Trying next provider (${remaining} remaining)...`);
+            }
+          }
+        }
+        if (this.debug) {
+          console.log(`[FallbackManager] \u274C All providers exhausted. Total attempts: ${totalAttempts}`);
+        }
+        const fallbackError = new Error(
+          `All provider fallbacks exhausted after ${totalAttempts} attempts. Last error: ${lastError?.message || "Unknown error"}`
+        );
+        fallbackError.cause = lastError;
+        fallbackError.stats = this.getStats();
+        fallbackError.allProvidersFailed = true;
+        throw fallbackError;
+      }
+      /**
+       * Get fallback statistics
+       * @returns {Object} - Statistics object
+       */
+      getStats() {
+        return {
+          ...this.stats,
+          providerAttempts: { ...this.stats.providerAttempts },
+          failedProviders: [...this.stats.failedProviders]
+        };
+      }
+      /**
+       * Reset statistics
+       */
+      resetStats() {
+        this.stats = {
+          totalAttempts: 0,
+          providerAttempts: {},
+          successfulProvider: null,
+          failedProviders: []
+        };
+      }
+    };
+  }
+});
+
 // src/agent/ProbeAgent.js
 var ProbeAgent_exports = {};
 __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
 import dotenv2 from "dotenv";
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
+import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI as createGoogleGenerativeAI2 } from "@ai-sdk/google";
+import { createAmazonBedrock as createAmazonBedrock2 } from "@ai-sdk/amazon-bedrock";
 import { streamText } from "ai";
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter as EventEmitter3 } from "events";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { readFile, stat } from "fs/promises";
-import { resolve as resolve3, isAbsolute, dirname as dirname3 } from "path";
+import { resolve as resolve4, isAbsolute as isAbsolute2, dirname as dirname4 } from "path";
 var MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
@@ -55641,8 +56688,17 @@ var init_ProbeAgent = __esm({
     init_schemaUtils();
     init_xmlParsingUtils();
     init_mcp();
+    init_RetryManager();
+    init_FallbackManager();
     dotenv2.config();
-    MAX_TOOL_ITERATIONS = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
+    MAX_TOOL_ITERATIONS = (() => {
+      const val = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
+      if (isNaN(val) || val < 1 || val > 200) {
+        console.warn("[ProbeAgent] MAX_TOOL_ITERATIONS must be between 1 and 200, using default: 30");
+        return 30;
+      }
+      return val;
+    })();
     MAX_HISTORY_MESSAGES = 100;
     MAX_IMAGE_FILE_SIZE = 20 * 1024 * 1024;
     ProbeAgent = class _ProbeAgent {
@@ -55669,6 +56725,18 @@ var init_ProbeAgent = __esm({
        * @param {Array} [options.mcpServers] - Deprecated, use mcpConfig instead
        * @param {Object} [options.storageAdapter] - Custom storage adapter for history management
        * @param {Object} [options.hooks] - Hook callbacks for events (e.g., {'tool:start': callback})
+       * @param {Object} [options.retry] - Retry configuration
+       * @param {number} [options.retry.maxRetries=3] - Maximum retry attempts per provider
+       * @param {number} [options.retry.initialDelay=1000] - Initial delay in ms
+       * @param {number} [options.retry.maxDelay=30000] - Maximum delay in ms
+       * @param {number} [options.retry.backoffFactor=2] - Exponential backoff multiplier
+       * @param {Array<string>} [options.retry.retryableErrors] - List of retryable error patterns
+       * @param {Object} [options.fallback] - Fallback configuration
+       * @param {string} [options.fallback.strategy] - Fallback strategy: 'same-model', 'same-provider', 'any', 'custom'
+       * @param {Array<string>} [options.fallback.models] - List of models for same-provider fallback
+       * @param {Array<Object>} [options.fallback.providers] - List of provider configurations for custom fallback
+       * @param {boolean} [options.fallback.stopOnSuccess=true] - Stop on first success
+       * @param {number} [options.fallback.maxTotalAttempts=10] - Maximum total attempts across all providers
        */
       constructor(options = {}) {
         this.sessionId = options.sessionId || randomUUID4();
@@ -55680,7 +56748,13 @@ var init_ProbeAgent = __esm({
         this.cancelled = false;
         this.tracer = options.tracer || null;
         this.outline = !!options.outline;
-        this.maxResponseTokens = options.maxResponseTokens || parseInt(process.env.MAX_RESPONSE_TOKENS || "0", 10) || null;
+        this.maxResponseTokens = options.maxResponseTokens || (() => {
+          const val = parseInt(process.env.MAX_RESPONSE_TOKENS || "0", 10);
+          if (isNaN(val) || val < 0 || val > 2e5) {
+            return null;
+          }
+          return val || null;
+        })();
         this.maxIterations = options.maxIterations || null;
         this.disableMermaidValidation = !!options.disableMermaidValidation;
         this.disableJsonValidation = !!options.disableJsonValidation;
@@ -55721,6 +56795,10 @@ var init_ProbeAgent = __esm({
         this.mcpServers = options.mcpServers || null;
         this.mcpBridge = null;
         this._mcpInitialized = false;
+        this.retryConfig = options.retry || {};
+        this.retryManager = null;
+        this.fallbackConfig = options.fallback || null;
+        this.fallbackManager = null;
         this.initializeModel();
       }
       /**
@@ -55805,6 +56883,14 @@ var init_ProbeAgent = __esm({
         if (this.enableBash && wrappedTools.bashToolInstance) {
           this.toolImplementations.bash = wrappedTools.bashToolInstance;
         }
+        if (this.allowEdit) {
+          if (wrappedTools.editToolInstance) {
+            this.toolImplementations.edit = wrappedTools.editToolInstance;
+          }
+          if (wrappedTools.createToolInstance) {
+            this.toolImplementations.create = wrappedTools.createToolInstance;
+          }
+        }
         this.wrappedTools = wrappedTools;
         if (this.debug) {
           console.error("\n[DEBUG] ========================================");
@@ -55855,36 +56941,147 @@ var init_ProbeAgent = __esm({
         if (forceProvider) {
           if (forceProvider === "anthropic" && anthropicApiKey) {
             this.initializeAnthropicModel(anthropicApiKey, anthropicApiUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           } else if (forceProvider === "openai" && openaiApiKey) {
             this.initializeOpenAIModel(openaiApiKey, openaiApiUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           } else if (forceProvider === "google" && googleApiKey) {
             this.initializeGoogleModel(googleApiKey, googleApiUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           } else if (forceProvider === "bedrock" && (awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey)) {
             this.initializeBedrockModel(awsAccessKeyId, awsSecretAccessKey, awsRegion, awsSessionToken, awsApiKey, awsBedrockBaseUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           }
           console.warn(`WARNING: Forced provider "${forceProvider}" selected but required API key is missing or invalid! Falling back to auto-detection.`);
         }
         if (anthropicApiKey) {
           this.initializeAnthropicModel(anthropicApiKey, anthropicApiUrl, modelName);
+          this.initializeFallbackManager("anthropic", modelName);
         } else if (openaiApiKey) {
           this.initializeOpenAIModel(openaiApiKey, openaiApiUrl, modelName);
+          this.initializeFallbackManager("openai", modelName);
         } else if (googleApiKey) {
           this.initializeGoogleModel(googleApiKey, googleApiUrl, modelName);
+          this.initializeFallbackManager("google", modelName);
         } else if (awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey) {
           this.initializeBedrockModel(awsAccessKeyId, awsSecretAccessKey, awsRegion, awsSessionToken, awsApiKey, awsBedrockBaseUrl, modelName);
+          this.initializeFallbackManager("bedrock", modelName);
         } else {
           throw new Error("No API key provided. Please set ANTHROPIC_API_KEY (or ANTHROPIC_AUTH_TOKEN), OPENAI_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY (or GOOGLE_API_KEY), AWS credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION), or AWS_BEDROCK_API_KEY environment variables.");
         }
       }
+      /**
+       * Initialize fallback manager based on configuration
+       * @param {string} primaryProvider - The primary provider being used
+       * @param {string} primaryModel - The primary model being used
+       * @private
+       */
+      initializeFallbackManager(primaryProvider, primaryModel) {
+        if (this.fallbackConfig === false || process.env.DISABLE_FALLBACK === "1") {
+          return;
+        }
+        if (this.fallbackConfig && this.fallbackConfig.providers) {
+          try {
+            this.fallbackManager = new FallbackManager({
+              ...this.fallbackConfig,
+              debug: this.debug
+            });
+            if (this.debug) {
+              console.log(`[DEBUG] Fallback manager initialized with ${this.fallbackManager.providers.length} providers`);
+            }
+          } catch (error) {
+            console.error("[WARNING] Failed to initialize fallback manager:", error.message);
+          }
+          return;
+        }
+        const envFallbackManager = createFallbackManagerFromEnv(this.debug);
+        if (envFallbackManager) {
+          this.fallbackManager = envFallbackManager;
+          if (this.debug) {
+            console.log(`[DEBUG] Fallback manager initialized from environment variables`);
+          }
+          return;
+        }
+        if (process.env.AUTO_FALLBACK === "1" || this.fallbackConfig?.auto) {
+          const providers = buildFallbackProvidersFromEnv({
+            primaryProvider,
+            primaryModel
+          });
+          if (providers.length > 1) {
+            try {
+              this.fallbackManager = new FallbackManager({
+                strategy: "custom",
+                providers,
+                debug: this.debug
+              });
+              if (this.debug) {
+                console.log(`[DEBUG] Auto-fallback enabled with ${providers.length} providers`);
+              }
+            } catch (error) {
+              console.error("[WARNING] Failed to initialize auto-fallback:", error.message);
+            }
+          }
+        }
+      }
+      /**
+       * Execute streamText with retry and fallback support
+       * @param {Object} options - streamText options
+       * @returns {Promise<Object>} - streamText result
+       * @private
+       */
+      async streamTextWithRetryAndFallback(options) {
+        if (!this.retryManager) {
+          this.retryManager = new RetryManager({
+            maxRetries: this.retryConfig.maxRetries ?? 3,
+            initialDelay: this.retryConfig.initialDelay ?? 1e3,
+            maxDelay: this.retryConfig.maxDelay ?? 3e4,
+            backoffFactor: this.retryConfig.backoffFactor ?? 2,
+            retryableErrors: this.retryConfig.retryableErrors,
+            debug: this.debug
+          });
+        }
+        if (!this.fallbackManager) {
+          return await this.retryManager.executeWithRetry(
+            () => streamText(options),
+            {
+              provider: this.apiType,
+              model: this.model
+            }
+          );
+        }
+        return await this.fallbackManager.executeWithFallback(
+          async (provider, model, config) => {
+            const fallbackOptions = {
+              ...options,
+              model: provider(model)
+            };
+            const providerRetryManager = new RetryManager({
+              maxRetries: config.maxRetries ?? this.retryConfig.maxRetries ?? 3,
+              initialDelay: this.retryConfig.initialDelay ?? 1e3,
+              maxDelay: this.retryConfig.maxDelay ?? 3e4,
+              backoffFactor: this.retryConfig.backoffFactor ?? 2,
+              retryableErrors: this.retryConfig.retryableErrors,
+              debug: this.debug
+            });
+            return await providerRetryManager.executeWithRetry(
+              () => streamText(fallbackOptions),
+              {
+                provider: config.provider,
+                model
+              }
+            );
+          }
+        );
+      }
       /**
        * Initialize Anthropic model
        */
       initializeAnthropicModel(apiKey, apiUrl, modelName) {
-        this.provider = createAnthropic({
+        this.provider = createAnthropic2({
           apiKey,
           ...apiUrl && { baseURL: apiUrl }
         });
@@ -55898,7 +57095,7 @@ var init_ProbeAgent = __esm({
        * Initialize OpenAI model
        */
       initializeOpenAIModel(apiKey, apiUrl, modelName) {
-        this.provider = createOpenAI({
+        this.provider = createOpenAI2({
           compatibility: "strict",
           apiKey,
           ...apiUrl && { baseURL: apiUrl }
@@ -55913,7 +57110,7 @@ var init_ProbeAgent = __esm({
        * Initialize Google model
        */
       initializeGoogleModel(apiKey, apiUrl, modelName) {
-        this.provider = createGoogleGenerativeAI({
+        this.provider = createGoogleGenerativeAI2({
           apiKey,
           ...apiUrl && { baseURL: apiUrl }
         });
@@ -55943,7 +57140,7 @@ var init_ProbeAgent = __esm({
         if (baseURL) {
           config.baseURL = baseURL;
         }
-        this.provider = createAmazonBedrock(config);
+        this.provider = createAmazonBedrock2(config);
         this.model = modelName || "anthropic.claude-sonnet-4-20250514-v1:0";
         this.apiType = "bedrock";
         if (this.debug) {
@@ -55988,7 +57185,7 @@ var init_ProbeAgent = __esm({
           let resolvedPath = imagePath;
           if (!imagePath.includes("/") && !imagePath.includes("\\")) {
             for (const dir of listFilesDirectories) {
-              const potentialPath = resolve3(dir, imagePath);
+              const potentialPath = resolve4(dir, imagePath);
               const loaded = await this.loadImageIfValid(potentialPath);
               if (loaded) {
                 if (this.debug) {
@@ -56013,7 +57210,7 @@ var init_ProbeAgent = __esm({
         let match2;
         while ((match2 = fileHeaderPattern.exec(content)) !== null) {
           const filePath = match2[1].trim();
-          const dir = dirname3(filePath);
+          const dir = dirname4(filePath);
           if (dir && dir !== ".") {
             directories.push(dir);
             if (this.debug) {
@@ -56057,21 +57254,21 @@ var init_ProbeAgent = __esm({
           }
           const allowedDirs = this.allowedFolders && this.allowedFolders.length > 0 ? this.allowedFolders : [process.cwd()];
           let absolutePath;
-          let isPathAllowed = false;
-          if (isAbsolute(imagePath)) {
+          let isPathAllowed2 = false;
+          if (isAbsolute2(imagePath)) {
             absolutePath = imagePath;
-            isPathAllowed = allowedDirs.some((dir) => absolutePath.startsWith(resolve3(dir)));
+            isPathAllowed2 = allowedDirs.some((dir) => absolutePath.startsWith(resolve4(dir)));
           } else {
             for (const dir of allowedDirs) {
-              const resolvedPath = resolve3(dir, imagePath);
-              if (resolvedPath.startsWith(resolve3(dir))) {
+              const resolvedPath = resolve4(dir, imagePath);
+              if (resolvedPath.startsWith(resolve4(dir))) {
                 absolutePath = resolvedPath;
-                isPathAllowed = true;
+                isPathAllowed2 = true;
                 break;
               }
             }
           }
-          if (!isPathAllowed) {
+          if (!isPathAllowed2) {
             if (this.debug) {
               console.log(`[DEBUG] Image path outside allowed directories: ${imagePath}`);
             }
@@ -56270,6 +57467,14 @@ ${attemptCompletionToolDefinition}
 `;
         if (this.allowEdit) {
           toolDefinitions += `${implementToolDefinition}
+`;
+          toolDefinitions += `${editToolDefinition}
+`;
+          toolDefinitions += `${createToolDefinition}
+`;
+        }
+        if (this.enableBash) {
+          toolDefinitions += `${bashToolDefinition}
 `;
         }
         if (this.enableDelegate) {
@@ -56337,7 +57542,7 @@ Available Tools:
 - extract: Extract specific code blocks or lines from files.
 - listFiles: List files and directories in a specified location.
 - searchFiles: Find files matching a glob pattern with recursive search capability.
-${this.allowEdit ? "- implement: Implement a feature or fix a bug using aider.\n" : ""}${this.enableDelegate ? "- delegate: Delegate big distinct tasks to specialized probe subagents.\n" : ""}
+${this.allowEdit ? "- implement: Implement a feature or fix a bug using aider.\n- edit: Edit files using exact string replacement.\n- create: Create new files with specified content.\n" : ""}${this.enableDelegate ? "- delegate: Delegate big distinct tasks to specialized probe subagents.\n" : ""}${this.enableBash ? "- bash: Execute bash commands for system operations.\n" : ""}
 - attempt_completion: Finalize the task and provide the result to the user.
 - attempt_complete: Quick completion using previous response (shorthand).
 `;
@@ -56351,7 +57556,10 @@ Follow these instructions carefully:
 6. You MUST respond with exactly ONE tool call per message, using the specified XML format, until the task is complete.
 7. Wait for the tool execution result (provided in the next user message in a <tool_result> block) before proceeding to the next step.
 8. Once the task is fully completed, use the '<attempt_completion>' tool to provide the final result. This is the ONLY way to signal completion.
-9. Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.
+9. Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.${this.allowEdit ? `
+10. When modifying files, choose the appropriate tool:
+    - Use 'edit' for precise changes to existing files (requires exact string match)
+    - Use 'create' for new files or complete file rewrites` : ""}
 </instructions>
 `;
         const predefinedPrompts = {
@@ -56603,7 +57811,7 @@ You are working with a repository located at: ${searchDirectory}
             try {
               const executeAIRequest = async () => {
                 const messagesForAI = this.prepareMessagesWithImages(currentMessages);
-                const result = await streamText({
+                const result = await this.streamTextWithRetryAndFallback({
                   model: this.provider(this.model),
                   messages: messagesForAI,
                   maxTokens: maxResponseTokens,
@@ -56655,7 +57863,10 @@ You are working with a repository located at: ${searchDirectory}
               "attempt_completion"
             ];
             if (this.allowEdit) {
-              validTools.push("implement");
+              validTools.push("implement", "edit", "create");
+            }
+            if (this.enableBash) {
+              validTools.push("bash");
             }
             if (this.enableDelegate) {
               validTools.push("delegate");
@@ -57569,8 +58780,8 @@ import {
   ListToolsRequestSchema,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
-import { readFileSync as readFileSync2, existsSync as existsSync5 } from "fs";
-import { resolve as resolve4 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync6 } from "fs";
+import { resolve as resolve5 } from "path";
 
 // src/agent/acp/server.js
 import { randomUUID as randomUUID5 } from "crypto";
@@ -57829,8 +59040,8 @@ var ACPConnection = class extends EventEmitter4 {
     if (params !== null) {
       message.params = params;
     }
-    return new Promise((resolve5, reject2) => {
-      this.pendingRequests.set(id, { resolve: resolve5, reject: reject2 });
+    return new Promise((resolve6, reject2) => {
+      this.pendingRequests.set(id, { resolve: resolve6, reject: reject2 });
       this.sendMessage(message);
       setTimeout(() => {
         if (this.pendingRequests.has(id)) {
@@ -58244,8 +59455,8 @@ dotenv3.config();
 function readInputContent(input) {
   if (!input) return null;
   try {
-    const resolvedPath = resolve4(input);
-    if (existsSync5(resolvedPath)) {
+    const resolvedPath = resolve5(input);
+    if (existsSync6(resolvedPath)) {
       return readFileSync2(resolvedPath, "utf-8").trim();
     }
   } catch (error) {
@@ -58253,7 +59464,7 @@ function readInputContent(input) {
   return input;
 }
 function readFromStdin() {
-  return new Promise((resolve5, reject2) => {
+  return new Promise((resolve6, reject2) => {
     let data = "";
     let hasReceivedData = false;
     let dataChunks = [];
@@ -58278,7 +59489,7 @@ function readFromStdin() {
       if (!trimmed && dataChunks.length === 0) {
         reject2(new Error("No input received from stdin"));
       } else {
-        resolve5(trimmed);
+        resolve6(trimmed);
       }
     });
     process.stdin.on("error", (error) => {
@@ -58804,7 +60015,7 @@ async function main() {
         bashConfig.timeout = timeout;
       }
       if (config.bashWorkingDir) {
-        if (!existsSync5(config.bashWorkingDir)) {
+        if (!existsSync6(config.bashWorkingDir)) {
           console.error(`Error: Bash working directory does not exist: ${config.bashWorkingDir}`);
           process.exit(1);
         }