@probelabs/probe 0.6.0-rc104 → 0.6.0-rc106

package/cjs/index.cjs

@@ -1234,7 +1234,7 @@ function createMessagePreview(message, charsPerSide = 200) {
   const end = message.substring(message.length - charsPerSide);
   return `${start}...${end}`;
 }
-var import_zod, searchSchema, querySchema, extractSchema, delegateSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
+var import_zod, searchSchema, querySchema, extractSchema, delegateSchema, bashSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, bashToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, bashDescription, DEFAULT_VALID_TOOLS;
 var init_common = __esm({
   "src/tools/common.js"() {
     "use strict";
@@ -1266,6 +1266,12 @@ var init_common = __esm({
     delegateSchema = import_zod.z.object({
       task: import_zod.z.string().describe("The task to delegate to a subagent. Be specific about what needs to be accomplished.")
     });
+    bashSchema = import_zod.z.object({
+      command: import_zod.z.string().describe("The bash command to execute"),
+      workingDirectory: import_zod.z.string().optional().describe("Directory to execute the command in (optional)"),
+      timeout: import_zod.z.number().optional().describe("Command timeout in milliseconds (optional)"),
+      env: import_zod.z.record(import_zod.z.string()).optional().describe("Additional environment variables (optional)")
+    });
     attemptCompletionSchema = {
       // Custom validation that requires result parameter but allows direct XML response
       safeParse: (params) => {
@@ -1488,11 +1494,67 @@ 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.";
     extractDescription = "Extract code blocks from files based on file paths and optional line numbers. Use this tool to see complete context after finding relevant files.";
     delegateDescription = "Automatically delegate big distinct tasks to specialized probe subagents within the agentic loop. Used by AI agents to break down complex requests into focused, parallel tasks.";
+    bashDescription = "Execute bash commands for system exploration and development tasks. Secure by default with built-in allow/deny lists.";
     DEFAULT_VALID_TOOLS = [
       "search",
       "query",
@@ -1546,7 +1608,7 @@ async function delegate({ task, timeout = 300, debug = false, currentIteration =
       console.error(`[DELEGATE] Using binary at: ${binaryPath}`);
       console.error(`[DELEGATE] Command args: ${args.join(" ")}`);
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       const delegationSpan = tracer ? tracer.createDelegationSpan(sessionId, task) : null;
       const process2 = (0, import_child_process5.spawn)(binaryPath, args, {
         stdio: ["pipe", "pipe", "pipe"],
@@ -1611,7 +1673,7 @@ async function delegate({ task, timeout = 300, debug = false, currentIteration =
               delegationSpan.end();
             }
           }
-          resolve2(response);
+          resolve4(response);
         } else {
           const errorMessage = stderr.trim() || `Delegate process failed with exit code ${code}`;
           if (debug) {
@@ -1807,10 +1869,10 @@ var init_vercel = __esm({
             let extractOptions = { path: extractPath };
             if (input_content) {
               const { writeFileSync: writeFileSync2, unlinkSync } = await import("fs");
-              const { join: join2 } = await import("path");
+              const { join: join3 } = await import("path");
               const { tmpdir } = await import("os");
               const { randomUUID: randomUUID5 } = await import("crypto");
-              tempFilePath = join2(tmpdir(), `probe-extract-${randomUUID5()}.txt`);
+              tempFilePath = join3(tmpdir(), `probe-extract-${randomUUID5()}.txt`);
               writeFileSync2(tempFilePath, input_content);
               if (debug) {
                 console.error(`Created temporary file for input content: ${tempFilePath}`);
@@ -1887,6 +1949,1248 @@ var init_vercel = __esm({
   }
 });
 
+// src/agent/bashDefaults.js
+var DEFAULT_ALLOW_PATTERNS, DEFAULT_DENY_PATTERNS;
+var init_bashDefaults = __esm({
+  "src/agent/bashDefaults.js"() {
+    "use strict";
+    DEFAULT_ALLOW_PATTERNS = [
+      // Basic navigation and listing
+      "ls",
+      "dir",
+      "pwd",
+      "cd",
+      "cd:*",
+      // File reading commands
+      "cat",
+      "cat:*",
+      "head",
+      "head:*",
+      "tail",
+      "tail:*",
+      "less",
+      "more",
+      "view",
+      // File information and metadata
+      "file",
+      "file:*",
+      "stat",
+      "stat:*",
+      "wc",
+      "wc:*",
+      "du",
+      "du:*",
+      "df",
+      "df:*",
+      "realpath",
+      "realpath:*",
+      // Search and find commands (read-only) - find restricted to safe operations
+      "find",
+      "find:-name:*",
+      "find:-type:*",
+      "find:-size:*",
+      "find:-mtime:*",
+      "find:-newer:*",
+      "find:-path:*",
+      "find:-iname:*",
+      "find:-maxdepth:*",
+      "find:-mindepth:*",
+      "find:-print",
+      "grep",
+      "grep:*",
+      "egrep",
+      "egrep:*",
+      "fgrep",
+      "fgrep:*",
+      "rg",
+      "rg:*",
+      "ag",
+      "ag:*",
+      "ack",
+      "ack:*",
+      "which",
+      "which:*",
+      "whereis",
+      "whereis:*",
+      "locate",
+      "locate:*",
+      "type",
+      "type:*",
+      "command",
+      "command:*",
+      // Tree and structure visualization
+      "tree",
+      "tree:*",
+      // Git read-only operations
+      "git:status",
+      "git:log",
+      "git:log:*",
+      "git:diff",
+      "git:diff:*",
+      "git:show",
+      "git:show:*",
+      "git:branch",
+      "git:branch:*",
+      "git:tag",
+      "git:tag:*",
+      "git:describe",
+      "git:describe:*",
+      "git:remote",
+      "git:remote:*",
+      "git:config:*",
+      "git:blame",
+      "git:blame:*",
+      "git:shortlog",
+      "git:reflog",
+      "git:ls-files",
+      "git:ls-tree",
+      "git:rev-parse",
+      "git:rev-list",
+      "git:--version",
+      "git:help",
+      "git:help:*",
+      // Package managers (information only)
+      "npm:list",
+      "npm:ls",
+      "npm:view",
+      "npm:info",
+      "npm:show",
+      "npm:outdated",
+      "npm:audit",
+      "npm:--version",
+      "yarn:list",
+      "yarn:info",
+      "yarn:--version",
+      "pnpm:list",
+      "pnpm:--version",
+      "pip:list",
+      "pip:show",
+      "pip:--version",
+      "pip3:list",
+      "pip3:show",
+      "pip3:--version",
+      "gem:list",
+      "gem:--version",
+      "bundle:list",
+      "bundle:show",
+      "bundle:--version",
+      "composer:show",
+      "composer:--version",
+      // Language and runtime versions
+      "node:--version",
+      "node:-v",
+      "python:--version",
+      "python:-V",
+      "python3:--version",
+      "python3:-V",
+      "ruby:--version",
+      "ruby:-v",
+      "go:version",
+      "go:env",
+      "go:list",
+      "go:mod:graph",
+      "rustc:--version",
+      "cargo:--version",
+      "cargo:tree",
+      "cargo:metadata",
+      "java:--version",
+      "java:-version",
+      "javac:--version",
+      "mvn:--version",
+      "gradle:--version",
+      "php:--version",
+      "dotnet:--version",
+      "dotnet:list",
+      // Database client versions (connection info only)
+      "psql:--version",
+      "mysql:--version",
+      "redis-cli:--version",
+      "mongo:--version",
+      "sqlite3:--version",
+      // System information
+      "uname",
+      "uname:*",
+      "hostname",
+      "whoami",
+      "id",
+      "groups",
+      "date",
+      "cal",
+      "uptime",
+      "w",
+      "users",
+      "sleep",
+      "sleep:*",
+      // Environment and shell
+      "env",
+      "printenv",
+      "echo",
+      "echo:*",
+      "printf",
+      "printf:*",
+      "export",
+      "export:*",
+      "set",
+      "unset",
+      // Process information (read-only)
+      "ps",
+      "ps:*",
+      "pgrep",
+      "pgrep:*",
+      "jobs",
+      "top:-n:1",
+      // Network information (read-only)
+      "ifconfig",
+      "ip:addr",
+      "ip:link",
+      "hostname:-I",
+      "ping:-c:*",
+      "traceroute",
+      "nslookup",
+      "dig",
+      // Text processing and utilities (awk removed - too powerful)
+      "sed:-n:*",
+      "cut",
+      "cut:*",
+      "sort",
+      "sort:*",
+      "uniq",
+      "uniq:*",
+      "tr",
+      "tr:*",
+      "column",
+      "column:*",
+      "paste",
+      "paste:*",
+      "join",
+      "join:*",
+      "comm",
+      "comm:*",
+      "diff",
+      "diff:*",
+      "cmp",
+      "cmp:*",
+      "patch:--dry-run:*",
+      // Hashing and encoding (read-only)
+      "md5sum",
+      "md5sum:*",
+      "sha1sum",
+      "sha1sum:*",
+      "sha256sum",
+      "sha256sum:*",
+      "base64",
+      "base64:-d",
+      "od",
+      "od:*",
+      "hexdump",
+      "hexdump:*",
+      // Archive and compression (list/view only)
+      "tar:-tf:*",
+      "tar:-tzf:*",
+      "unzip:-l:*",
+      "zip:-l:*",
+      "gzip:-l:*",
+      "gunzip:-l:*",
+      // Help and documentation
+      "man",
+      "man:*",
+      "--help",
+      "help",
+      "info",
+      "info:*",
+      "whatis",
+      "whatis:*",
+      "apropos",
+      "apropos:*",
+      // Make (dry run and info)
+      "make:-n",
+      "make:--dry-run",
+      "make:-p",
+      "make:--print-data-base",
+      // Docker (read-only operations)
+      "docker:ps",
+      "docker:images",
+      "docker:version",
+      "docker:info",
+      "docker:logs:*",
+      "docker:inspect:*",
+      // Test runners (list/info only)
+      "jest:--listTests",
+      "mocha:--help",
+      "pytest:--collect-only"
+    ];
+    DEFAULT_DENY_PATTERNS = [
+      // Dangerous file operations
+      "rm:-rf",
+      "rm:-f:/",
+      "rm:/",
+      "rm:-rf:*",
+      "rmdir",
+      "chmod:777",
+      "chmod:-R:777",
+      "chown",
+      "chgrp",
+      "dd",
+      "dd:*",
+      "shred",
+      "shred:*",
+      // Dangerous find operations that can execute arbitrary commands
+      "find:-exec:*",
+      "find:*:-exec:*",
+      "find:-execdir:*",
+      "find:*:-execdir:*",
+      "find:-ok:*",
+      "find:*:-ok:*",
+      "find:-okdir:*",
+      "find:*:-okdir:*",
+      // Powerful scripting tools that can execute arbitrary commands
+      "awk",
+      "awk:*",
+      "perl",
+      "perl:*",
+      "python:-c:*",
+      "node:-e:*",
+      // System administration and modification
+      "sudo:*",
+      "su",
+      "su:*",
+      "passwd",
+      "adduser",
+      "useradd",
+      "userdel",
+      "usermod",
+      "groupadd",
+      "groupdel",
+      "visudo",
+      // Package installation and removal
+      "npm:install",
+      "npm:i",
+      "npm:uninstall",
+      "npm:publish",
+      "npm:unpublish",
+      "npm:link",
+      "npm:update",
+      "yarn:install",
+      "yarn:add",
+      "yarn:remove",
+      "yarn:upgrade",
+      "pnpm:install",
+      "pnpm:add",
+      "pnpm:remove",
+      "pip:install",
+      "pip:uninstall",
+      "pip:upgrade",
+      "pip3:install",
+      "pip3:uninstall",
+      "pip3:upgrade",
+      "gem:install",
+      "gem:uninstall",
+      "gem:update",
+      "bundle:install",
+      "bundle:update",
+      "composer:install",
+      "composer:update",
+      "composer:remove",
+      "apt:*",
+      "apt-get:*",
+      "yum:*",
+      "dnf:*",
+      "zypper:*",
+      "brew:install",
+      "brew:uninstall",
+      "brew:upgrade",
+      "conda:install",
+      "conda:remove",
+      "conda:update",
+      // Service and system control
+      "systemctl:*",
+      "service:*",
+      "chkconfig:*",
+      "initctl:*",
+      "upstart:*",
+      // Network operations that could be dangerous
+      "curl:-d:*",
+      "curl:--data:*",
+      "curl:-X:POST:*",
+      "curl:-X:PUT:*",
+      "wget:-O:/",
+      "wget:--post-data:*",
+      "ssh",
+      "ssh:*",
+      "scp",
+      "scp:*",
+      "sftp",
+      "sftp:*",
+      "rsync:*",
+      "nc",
+      "nc:*",
+      "netcat",
+      "netcat:*",
+      "telnet",
+      "telnet:*",
+      "ftp",
+      "ftp:*",
+      // Process control and termination
+      "kill",
+      "kill:*",
+      "killall",
+      "killall:*",
+      "pkill",
+      "pkill:*",
+      "nohup:*",
+      "disown:*",
+      // System control and shutdown
+      "shutdown",
+      "shutdown:*",
+      "reboot",
+      "halt",
+      "poweroff",
+      "init",
+      "telinit",
+      // Kernel and module operations
+      "insmod",
+      "insmod:*",
+      "rmmod",
+      "rmmod:*",
+      "modprobe",
+      "modprobe:*",
+      "sysctl:-w:*",
+      // Dangerous git operations
+      "git:push",
+      "git:push:*",
+      "git:force",
+      "git:reset:--hard:*",
+      "git:clean:-fd",
+      "git:rm:*",
+      "git:commit",
+      "git:merge",
+      "git:rebase",
+      "git:cherry-pick",
+      "git:stash:drop",
+      // File system mounting and partitioning
+      "mount",
+      "mount:*",
+      "umount",
+      "umount:*",
+      "fdisk",
+      "fdisk:*",
+      "parted",
+      "parted:*",
+      "mkfs",
+      "mkfs:*",
+      "fsck",
+      "fsck:*",
+      // Cron and scheduling
+      "crontab",
+      "crontab:*",
+      "at",
+      "at:*",
+      "batch",
+      "batch:*",
+      // Compression with potential overwrite
+      "tar:-xf:*",
+      "unzip",
+      "unzip:*",
+      "gzip:*",
+      "gunzip:*",
+      // Build and compilation that might modify files
+      "make",
+      "make:install",
+      "make:clean",
+      "cargo:build",
+      "cargo:install",
+      "npm:run:build",
+      "yarn:build",
+      "mvn:install",
+      "gradle:build",
+      // Docker operations that could modify state
+      "docker:run",
+      "docker:run:*",
+      "docker:exec",
+      "docker:exec:*",
+      "docker:build",
+      "docker:build:*",
+      "docker:pull",
+      "docker:push",
+      "docker:rm",
+      "docker:rmi",
+      "docker:stop",
+      "docker:start",
+      // Database operations
+      "mysql:-e:DROP",
+      "psql:-c:DROP",
+      "redis-cli:FLUSHALL",
+      "mongo:--eval:*",
+      // Text editors that could modify files
+      "vi",
+      "vi:*",
+      "vim",
+      "vim:*",
+      "nano",
+      "nano:*",
+      "emacs",
+      "emacs:*",
+      "sed:-i:*",
+      "perl:-i:*",
+      // Potentially dangerous utilities
+      "eval",
+      "eval:*",
+      "exec",
+      "exec:*",
+      "source",
+      "source:*",
+      "bash:-c:*",
+      "sh:-c:*",
+      "zsh:-c:*"
+    ];
+  }
+});
+
+// src/agent/bashCommandUtils.js
+function parseSimpleCommand(command) {
+  if (!command || typeof command !== "string") {
+    return {
+      success: false,
+      error: "Command must be a non-empty string",
+      command: null,
+      args: [],
+      isComplex: false
+    };
+  }
+  const trimmed = command.trim();
+  if (!trimmed) {
+    return {
+      success: false,
+      error: "Command cannot be empty",
+      command: null,
+      args: [],
+      isComplex: false
+    };
+  }
+  const complexPatterns = [
+    /\|/,
+    // Pipes
+    /&&/,
+    // Logical AND
+    /\|\|/,
+    // Logical OR
+    /(?<!\\);/,
+    // Command separator (but not escaped \;)
+    /&$/,
+    // Background execution
+    /\$\(/,
+    // Command substitution $()
+    /`/,
+    // Command substitution ``
+    />/,
+    // Redirection >
+    /</,
+    // Redirection <
+    /\*\*/,
+    // Glob patterns (potentially dangerous)
+    /^\s*\{.*,.*\}|\{.*\.\.\.*\}/
+    // Brace expansion like {a,b} or {1..10} (but not find {} placeholders)
+  ];
+  for (const pattern of complexPatterns) {
+    if (pattern.test(trimmed)) {
+      return {
+        success: false,
+        error: "Complex shell commands with pipes, operators, or redirections are not supported for security reasons",
+        command: null,
+        args: [],
+        isComplex: true,
+        detected: pattern.toString()
+      };
+    }
+  }
+  const args = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  let escaped = false;
+  for (let i3 = 0; i3 < trimmed.length; i3++) {
+    const char = trimmed[i3];
+    const nextChar = i3 + 1 < trimmed.length ? trimmed[i3 + 1] : "";
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && !inQuotes) {
+      escaped = true;
+      continue;
+    }
+    if (!inQuotes && (char === '"' || char === "'")) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (inQuotes && char === quoteChar) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (!inQuotes && char === " ") {
+      if (current.trim()) {
+        args.push(current.trim());
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    args.push(current.trim());
+  }
+  if (inQuotes) {
+    return {
+      success: false,
+      error: `Unclosed quote in command: ${quoteChar}`,
+      command: null,
+      args: [],
+      isComplex: false
+    };
+  }
+  if (args.length === 0) {
+    return {
+      success: false,
+      error: "No command found after parsing",
+      command: null,
+      args: [],
+      isComplex: false
+    };
+  }
+  const [baseCommand, ...commandArgs] = args;
+  return {
+    success: true,
+    error: null,
+    command: baseCommand,
+    args: commandArgs,
+    fullArgs: args,
+    isComplex: false,
+    original: command
+  };
+}
+function isComplexCommand(command) {
+  const result = parseSimpleCommand(command);
+  return result.isComplex;
+}
+function parseCommand(command) {
+  const result = parseSimpleCommand(command);
+  if (!result.success) {
+    return {
+      command: "",
+      args: [],
+      error: result.error,
+      isComplex: result.isComplex
+    };
+  }
+  return {
+    command: result.command,
+    args: result.args,
+    error: null,
+    isComplex: result.isComplex
+  };
+}
+function parseCommandForExecution(command) {
+  const result = parseSimpleCommand(command);
+  if (!result.success) {
+    return null;
+  }
+  return result.fullArgs;
+}
+var init_bashCommandUtils = __esm({
+  "src/agent/bashCommandUtils.js"() {
+    "use strict";
+  }
+});
+
+// src/agent/bashPermissions.js
+function matchesPattern(parsedCommand, pattern) {
+  if (!parsedCommand || !pattern) return false;
+  const { command, args } = parsedCommand;
+  if (!command) return false;
+  const patternParts = pattern.split(":");
+  const commandName = patternParts[0];
+  if (commandName === "*") {
+    return true;
+  } else if (commandName !== command) {
+    return false;
+  }
+  if (patternParts.length === 1) {
+    return true;
+  }
+  for (let i3 = 1; i3 < patternParts.length; i3++) {
+    const patternArg = patternParts[i3];
+    const argIndex = i3 - 1;
+    if (patternArg === "*") {
+      continue;
+    }
+    if (argIndex >= args.length) {
+      return false;
+    }
+    const actualArg = args[argIndex];
+    if (patternArg !== actualArg) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchesAnyPattern(parsedCommand, patterns) {
+  if (!patterns || patterns.length === 0) return false;
+  return patterns.some((pattern) => matchesPattern(parsedCommand, pattern));
+}
+var BashPermissionChecker;
+var init_bashPermissions = __esm({
+  "src/agent/bashPermissions.js"() {
+    "use strict";
+    init_bashDefaults();
+    init_bashCommandUtils();
+    BashPermissionChecker = class {
+      /**
+       * Create a permission checker
+       * @param {Object} config - Configuration options
+       * @param {string[]} [config.allow] - Additional allow patterns
+       * @param {string[]} [config.deny] - Additional deny patterns
+       * @param {boolean} [config.disableDefaultAllow] - Disable default allow list
+       * @param {boolean} [config.disableDefaultDeny] - Disable default deny list
+       * @param {boolean} [config.debug] - Enable debug logging
+       */
+      constructor(config = {}) {
+        this.debug = config.debug || false;
+        this.allowPatterns = [];
+        if (!config.disableDefaultAllow) {
+          this.allowPatterns.push(...DEFAULT_ALLOW_PATTERNS);
+          if (this.debug) {
+            console.log(`[BashPermissions] Added ${DEFAULT_ALLOW_PATTERNS.length} default allow patterns`);
+          }
+        }
+        if (config.allow && Array.isArray(config.allow)) {
+          this.allowPatterns.push(...config.allow);
+          if (this.debug) {
+            console.log(`[BashPermissions] Added ${config.allow.length} custom allow patterns:`, config.allow);
+          }
+        }
+        this.denyPatterns = [];
+        if (!config.disableDefaultDeny) {
+          this.denyPatterns.push(...DEFAULT_DENY_PATTERNS);
+          if (this.debug) {
+            console.log(`[BashPermissions] Added ${DEFAULT_DENY_PATTERNS.length} default deny patterns`);
+          }
+        }
+        if (config.deny && Array.isArray(config.deny)) {
+          this.denyPatterns.push(...config.deny);
+          if (this.debug) {
+            console.log(`[BashPermissions] Added ${config.deny.length} custom deny patterns:`, config.deny);
+          }
+        }
+        if (this.debug) {
+          console.log(`[BashPermissions] Total patterns - Allow: ${this.allowPatterns.length}, Deny: ${this.denyPatterns.length}`);
+        }
+      }
+      /**
+       * Check if a simple command is allowed (rejects complex commands for security)
+       * @param {string} command - Command to check
+       * @returns {Object} Permission result
+       */
+      check(command) {
+        if (!command || typeof command !== "string") {
+          return {
+            allowed: false,
+            reason: "Invalid or empty command",
+            command
+          };
+        }
+        if (isComplexCommand(command)) {
+          return {
+            allowed: false,
+            reason: "Complex shell commands with pipes, operators, or redirections are not supported for security reasons",
+            command,
+            isComplex: true
+          };
+        }
+        const parsed = parseCommand(command);
+        if (parsed.error) {
+          return {
+            allowed: false,
+            reason: parsed.error,
+            command
+          };
+        }
+        if (!parsed.command) {
+          return {
+            allowed: false,
+            reason: "No valid command found",
+            command
+          };
+        }
+        if (this.debug) {
+          console.log(`[BashPermissions] Checking simple command: "${command}"`);
+          console.log(`[BashPermissions] Parsed: ${parsed.command} with args: [${parsed.args.join(", ")}]`);
+        }
+        if (matchesAnyPattern(parsed, this.denyPatterns)) {
+          const matchedPatterns = this.denyPatterns.filter((pattern) => matchesPattern(parsed, pattern));
+          return {
+            allowed: false,
+            reason: `Command matches deny pattern: ${matchedPatterns[0]}`,
+            command,
+            parsed,
+            matchedPatterns
+          };
+        }
+        if (this.allowPatterns.length > 0) {
+          if (!matchesAnyPattern(parsed, this.allowPatterns)) {
+            return {
+              allowed: false,
+              reason: "Command not in allow list",
+              command,
+              parsed
+            };
+          }
+        }
+        const result = {
+          allowed: true,
+          command,
+          parsed,
+          isComplex: false
+        };
+        if (this.debug) {
+          console.log(`[BashPermissions] ALLOWED - command passed all checks`);
+        }
+        return result;
+      }
+      /**
+       * Get configuration summary
+       * @returns {Object} Configuration info
+       */
+      getConfig() {
+        return {
+          allowPatterns: this.allowPatterns.length,
+          denyPatterns: this.denyPatterns.length,
+          totalPatterns: this.allowPatterns.length + this.denyPatterns.length
+        };
+      }
+    };
+  }
+});
+
+// src/agent/bashExecutor.js
+async function executeBashCommand(command, options = {}) {
+  const {
+    workingDirectory = process.cwd(),
+    timeout = 12e4,
+    // 2 minutes default
+    env = {},
+    maxBuffer = 10 * 1024 * 1024,
+    // 10MB
+    debug = false
+  } = options;
+  let cwd = workingDirectory;
+  try {
+    cwd = (0, import_path4.resolve)(cwd);
+    if (!(0, import_fs.existsSync)(cwd)) {
+      throw new Error(`Working directory does not exist: ${cwd}`);
+    }
+  } catch (error2) {
+    return {
+      success: false,
+      error: `Invalid working directory: ${error2.message}`,
+      stdout: "",
+      stderr: "",
+      exitCode: 1,
+      command,
+      workingDirectory: cwd,
+      duration: 0
+    };
+  }
+  const startTime = Date.now();
+  if (debug) {
+    console.log(`[BashExecutor] Executing command: "${command}"`);
+    console.log(`[BashExecutor] Working directory: "${cwd}"`);
+    console.log(`[BashExecutor] Timeout: ${timeout}ms`);
+  }
+  return new Promise((resolve4, reject) => {
+    const processEnv = {
+      ...process.env,
+      ...env
+    };
+    const args = parseCommandForExecution(command);
+    if (!args || args.length === 0) {
+      resolve4({
+        success: false,
+        error: "Failed to parse command",
+        stdout: "",
+        stderr: "",
+        exitCode: 1,
+        command,
+        workingDirectory: cwd,
+        duration: Date.now() - startTime
+      });
+      return;
+    }
+    const [cmd, ...cmdArgs] = args;
+    const child = (0, import_child_process6.spawn)(cmd, cmdArgs, {
+      cwd,
+      env: processEnv,
+      stdio: ["ignore", "pipe", "pipe"],
+      // stdin ignored, capture stdout/stderr
+      shell: false,
+      // For security
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    let timeoutHandle;
+    if (timeout > 0) {
+      timeoutHandle = setTimeout(() => {
+        if (!killed) {
+          killed = true;
+          child.kill("SIGTERM");
+          setTimeout(() => {
+            if (child.exitCode === null) {
+              child.kill("SIGKILL");
+            }
+          }, 5e3);
+        }
+      }, timeout);
+    }
+    child.stdout.on("data", (data2) => {
+      const chunk = data2.toString();
+      if (stdout.length + chunk.length <= maxBuffer) {
+        stdout += chunk;
+      } else {
+        if (!killed) {
+          killed = true;
+          child.kill("SIGTERM");
+        }
+      }
+    });
+    child.stderr.on("data", (data2) => {
+      const chunk = data2.toString();
+      if (stderr.length + chunk.length <= maxBuffer) {
+        stderr += chunk;
+      } else {
+        if (!killed) {
+          killed = true;
+          child.kill("SIGTERM");
+        }
+      }
+    });
+    child.on("close", (code, signal) => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      const duration = Date.now() - startTime;
+      if (debug) {
+        console.log(`[BashExecutor] Command completed - Code: ${code}, Signal: ${signal}, Duration: ${duration}ms`);
+        console.log(`[BashExecutor] Stdout length: ${stdout.length}, Stderr length: ${stderr.length}`);
+      }
+      let success = true;
+      let error2 = "";
+      if (killed) {
+        success = false;
+        if (stdout.length + stderr.length > maxBuffer) {
+          error2 = `Command output exceeded maximum buffer size (${maxBuffer} bytes)`;
+        } else {
+          error2 = `Command timed out after ${timeout}ms`;
+        }
+      } else if (code !== 0) {
+        success = false;
+        error2 = `Command exited with code ${code}`;
+      }
+      resolve4({
+        success,
+        error: error2,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code,
+        signal,
+        command,
+        workingDirectory: cwd,
+        duration,
+        killed
+      });
+    });
+    child.on("error", (error2) => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      if (debug) {
+        console.log(`[BashExecutor] Spawn error:`, error2);
+      }
+      resolve4({
+        success: false,
+        error: `Failed to execute command: ${error2.message}`,
+        stdout: "",
+        stderr: "",
+        exitCode: 1,
+        command,
+        workingDirectory: cwd,
+        duration: Date.now() - startTime
+      });
+    });
+  });
+}
+function formatExecutionResult(result, includeMetadata = false) {
+  if (!result) {
+    return "No result available";
+  }
+  let output = "";
+  if (includeMetadata) {
+    output += `Command: ${result.command}
+`;
+    output += `Working directory: ${result.workingDirectory}
+`;
+    output += `Duration: ${result.duration}ms
+`;
+    output += `Exit Code: ${result.exitCode}
+`;
+    if (result.signal) {
+      output += `Signal: ${result.signal}
+`;
+    }
+    output += "\n";
+  }
+  if (result.stdout) {
+    if (includeMetadata) {
+      output += "--- STDOUT ---\n";
+    }
+    output += result.stdout;
+    if (includeMetadata && result.stderr) {
+      output += "\n";
+    }
+  }
+  if (result.stderr) {
+    if (includeMetadata) {
+      if (result.stdout) output += "\n";
+      output += "--- STDERR ---\n";
+    } else if (result.stdout) {
+      output += "\n--- STDERR ---\n";
+    }
+    output += result.stderr;
+  }
+  if (!result.success && result.error && !result.stderr) {
+    if (output) output += "\n";
+    output += `Error: ${result.error}`;
+  }
+  if (!result.success && result.exitCode !== void 0 && result.exitCode !== 0) {
+    if (output) output += "\n";
+    output += `Exit code: ${result.exitCode}`;
+  }
+  return output || (result.success ? "Command completed successfully (no output)" : "Command failed (no output)");
+}
+function validateExecutionOptions(options = {}) {
+  const errors = [];
+  const warnings = [];
+  if (options.timeout !== void 0) {
+    if (typeof options.timeout !== "number" || options.timeout < 0) {
+      errors.push("timeout must be a non-negative number");
+    } else if (options.timeout > 6e5) {
+      warnings.push("timeout is very high (>10 minutes)");
+    }
+  }
+  if (options.maxBuffer !== void 0) {
+    if (typeof options.maxBuffer !== "number" || options.maxBuffer < 1024) {
+      errors.push("maxBuffer must be at least 1024 bytes");
+    } else if (options.maxBuffer > 100 * 1024 * 1024) {
+      warnings.push("maxBuffer is very high (>100MB)");
+    }
+  }
+  if (options.workingDirectory) {
+    if (typeof options.workingDirectory !== "string") {
+      errors.push("workingDirectory must be a string");
+    } else if (!(0, import_fs.existsSync)(options.workingDirectory)) {
+      errors.push(`workingDirectory does not exist: ${options.workingDirectory}`);
+    }
+  }
+  if (options.env && typeof options.env !== "object") {
+    errors.push("env must be an object");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+var import_child_process6, import_path4, import_fs;
+var init_bashExecutor = __esm({
+  "src/agent/bashExecutor.js"() {
+    "use strict";
+    import_child_process6 = require("child_process");
+    import_path4 = require("path");
+    import_fs = require("fs");
+    init_bashCommandUtils();
+  }
+});
+
+// src/tools/bash.js
+var import_ai2, import_path5, bashTool;
+var init_bash = __esm({
+  "src/tools/bash.js"() {
+    "use strict";
+    import_ai2 = require("ai");
+    import_path5 = require("path");
+    init_bashPermissions();
+    init_bashExecutor();
+    bashTool = (options = {}) => {
+      const {
+        bashConfig = {},
+        debug = false,
+        defaultPath,
+        allowedFolders = []
+      } = options;
+      const permissionChecker = new BashPermissionChecker({
+        allow: bashConfig.allow,
+        deny: bashConfig.deny,
+        disableDefaultAllow: bashConfig.disableDefaultAllow,
+        disableDefaultDeny: bashConfig.disableDefaultDeny,
+        debug
+      });
+      const getDefaultWorkingDirectory = () => {
+        if (bashConfig.workingDirectory) {
+          return bashConfig.workingDirectory;
+        }
+        if (defaultPath) {
+          return defaultPath;
+        }
+        if (allowedFolders && allowedFolders.length > 0) {
+          return allowedFolders[0];
+        }
+        return process.cwd();
+      };
+      return (0, import_ai2.tool)({
+        name: "bash",
+        description: `Execute bash commands for system exploration and development tasks.
+
+Security: 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 command in
+- timeout: (optional) Command timeout in milliseconds
+- env: (optional) Additional environment variables
+
+Examples of allowed commands by default:
+- File exploration: ls, cat, head, tail, find, grep
+- Git operations: git status, git log, git diff, git show
+- Package info: npm list, pip list, cargo --version
+- System info: whoami, pwd, uname, date
+
+Dangerous commands are blocked by default (rm -rf, sudo, npm install, etc.)`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            command: {
+              type: "string",
+              description: "The bash command to execute"
+            },
+            workingDirectory: {
+              type: "string",
+              description: "Directory to execute the command in (optional)"
+            },
+            timeout: {
+              type: "number",
+              description: "Command timeout in milliseconds (optional)",
+              minimum: 1e3,
+              maximum: 6e5
+            },
+            env: {
+              type: "object",
+              description: "Additional environment variables (optional)",
+              additionalProperties: {
+                type: "string"
+              }
+            }
+          },
+          required: ["command"],
+          additionalProperties: false
+        },
+        execute: async ({ command, workingDirectory, timeout, env }) => {
+          try {
+            if (command === null || command === void 0 || typeof command !== "string") {
+              return "Error: Command is required and must be a string";
+            }
+            if (command.trim().length === 0) {
+              return "Error: Command cannot be empty";
+            }
+            const permissionResult = permissionChecker.check(command.trim());
+            if (!permissionResult.allowed) {
+              if (debug) {
+                console.log(`[BashTool] Permission denied for command: "${command}"`);
+                console.log(`[BashTool] Reason: ${permissionResult.reason}`);
+              }
+              return `Permission denied: ${permissionResult.reason}
+
+This command is not allowed by the current security policy. 
+
+Common reasons:
+1. The command is in the deny list (potentially dangerous)
+2. The command is not in the allow list (not a recognized safe command)
+
+If you believe this command should be allowed, you can:
+- Use the --bash-allow option to add specific patterns
+- Use the --no-default-bash-deny flag to remove default restrictions (not recommended)
+
+For code exploration, try these safe alternatives:
+- ls, cat, head, tail for file operations
+- find, grep, rg for searching
+- git status, git log, git show for git operations
+- npm list, pip list for package information`;
+            }
+            const workingDir = workingDirectory || getDefaultWorkingDirectory();
+            if (allowedFolders && allowedFolders.length > 0) {
+              const resolvedWorkingDir = (0, import_path5.resolve)(workingDir);
+              const isAllowed = allowedFolders.some((folder) => {
+                const resolvedFolder = (0, import_path5.resolve)(folder);
+                return resolvedWorkingDir.startsWith(resolvedFolder);
+              });
+              if (!isAllowed) {
+                return `Error: Working directory "${workingDir}" is not within allowed folders: ${allowedFolders.join(", ")}`;
+              }
+            }
+            const executionOptions = {
+              workingDirectory: workingDir,
+              timeout: timeout || bashConfig.timeout || 12e4,
+              env: { ...bashConfig.env, ...env },
+              maxBuffer: bashConfig.maxBuffer,
+              debug
+            };
+            const validation = validateExecutionOptions(executionOptions);
+            if (!validation.valid) {
+              return `Error: Invalid execution options: ${validation.errors.join(", ")}`;
+            }
+            if (validation.warnings.length > 0 && debug) {
+              console.log("[BashTool] Warnings:", validation.warnings);
+            }
+            if (debug) {
+              console.log(`[BashTool] Executing command: "${command}"`);
+              console.log(`[BashTool] Working directory: "${workingDir}"`);
+              console.log(`[BashTool] Timeout: ${executionOptions.timeout}ms`);
+            }
+            const result = await executeBashCommand(command.trim(), executionOptions);
+            if (debug) {
+              console.log(`[BashTool] Command completed - Success: ${result.success}, Duration: ${result.duration}ms`);
+            }
+            const formattedResult = formatExecutionResult(result, debug);
+            if (!result.success) {
+              let errorInfo = `
+
+Command failed with exit code ${result.exitCode}`;
+              if (result.killed) {
+                errorInfo += ` (${result.error})`;
+              }
+              return formattedResult + errorInfo;
+            }
+            return formattedResult;
+          } catch (error2) {
+            if (debug) {
+              console.error("[BashTool] Execution error:", error2);
+            }
+            return `Error executing bash command: ${error2.message}`;
+          }
+        }
+      });
+    };
+  }
+});
+
 // src/tools/langchain.js
 function createSearchTool() {
   return {
@@ -2104,6 +3408,10 @@ __export(tools_exports, {
   DEFAULT_SYSTEM_MESSAGE: () => DEFAULT_SYSTEM_MESSAGE,
   attemptCompletionSchema: () => attemptCompletionSchema,
   attemptCompletionToolDefinition: () => attemptCompletionToolDefinition,
+  bashDescription: () => bashDescription,
+  bashSchema: () => bashSchema,
+  bashTool: () => bashTool,
+  bashToolDefinition: () => bashToolDefinition,
   createExtractTool: () => createExtractTool,
   createQueryTool: () => createQueryTool,
   createSearchTool: () => createSearchTool,
@@ -2124,16 +3432,19 @@ var init_tools = __esm({
   "src/tools/index.js"() {
     "use strict";
     init_vercel();
+    init_bash();
     init_langchain();
     init_common();
     init_system_message();
     init_vercel();
+    init_bash();
     init_system_message();
     tools = {
       searchTool: searchTool(),
       queryTool: queryTool(),
       extractTool: extractTool(),
       delegateTool: delegateTool(),
+      bashTool: bashTool(),
       DEFAULT_SYSTEM_MESSAGE
     };
   }
@@ -2146,10 +3457,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!import_fs.default.existsSync(directory)) {
+  if (!import_fs2.default.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = import_fs.default.existsSync(import_path4.default.join(directory, ".git"));
+  const gitDirExists = import_fs2.default.existsSync(import_path6.default.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -2164,8 +3475,8 @@ async function listFilesUsingGit(directory, maxFiles) {
   const { stdout } = await execAsync4("git ls-files", { cwd: directory });
   const files = stdout.split("\n").filter(Boolean);
   const sortedFiles = files.sort((a3, b3) => {
-    const depthA = a3.split(import_path4.default.sep).length;
-    const depthB = b3.split(import_path4.default.sep).length;
+    const depthA = a3.split(import_path6.default.sep).length;
+    const depthB = b3.split(import_path6.default.sep).length;
     return depthA - depthB;
   });
   return sortedFiles.slice(0, maxFiles);
@@ -2180,19 +3491,19 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = import_fs.default.readdirSync(dir, { withFileTypes: true });
+      const entries = import_fs2.default.readdirSync(dir, { withFileTypes: true });
       const files = entries.filter((entry) => entry.isFile());
       for (const file of files) {
         if (result.length >= maxFiles) break;
-        const filePath = import_path4.default.join(dir, file.name);
-        const relativePath = import_path4.default.relative(directory, filePath);
+        const filePath = import_path6.default.join(dir, file.name);
+        const relativePath = import_path6.default.relative(directory, filePath);
         if (shouldIgnore(relativePath, ignorePatterns)) continue;
         result.push(relativePath);
       }
       const dirs = entries.filter((entry) => entry.isDirectory());
       for (const subdir of dirs) {
-        const subdirPath = import_path4.default.join(dir, subdir.name);
-        const relativeSubdirPath = import_path4.default.relative(directory, subdirPath);
+        const subdirPath = import_path6.default.join(dir, subdir.name);
+        const relativeSubdirPath = import_path6.default.relative(directory, subdirPath);
         if (shouldIgnore(relativeSubdirPath, ignorePatterns)) continue;
         if (subdir.name === "node_modules" || subdir.name === ".git") continue;
         queue.push({ dir: subdirPath, level: level + 1 });
@@ -2204,12 +3515,12 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   return result;
 }
 function loadGitignorePatterns(directory) {
-  const gitignorePath = import_path4.default.join(directory, ".gitignore");
-  if (!import_fs.default.existsSync(gitignorePath)) {
+  const gitignorePath = import_path6.default.join(directory, ".gitignore");
+  if (!import_fs2.default.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = import_fs.default.readFileSync(gitignorePath, "utf8");
+    const content = import_fs2.default.readFileSync(gitignorePath, "utf8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error2) {
     console.error(`Warning: Could not read .gitignore: ${error2.message}`);
@@ -2227,15 +3538,15 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs, import_path4, import_util5, import_child_process6, execAsync4;
+var import_fs2, import_path6, import_util5, import_child_process7, execAsync4;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
-    import_fs = __toESM(require("fs"), 1);
-    import_path4 = __toESM(require("path"), 1);
+    import_fs2 = __toESM(require("fs"), 1);
+    import_path6 = __toESM(require("path"), 1);
     import_util5 = require("util");
-    import_child_process6 = require("child_process");
-    execAsync4 = (0, import_util5.promisify)(import_child_process6.exec);
+    import_child_process7 = require("child_process");
+    execAsync4 = (0, import_util5.promisify)(import_child_process7.exec);
   }
 });
 
@@ -4390,7 +5701,7 @@ var require_headStream = __commonJS({
       if ((0, stream_type_check_1.isReadableStream)(stream)) {
         return (0, headStream_browser_1.headStream)(stream, bytes);
       }
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         const collector = new Collector();
         collector.limit = bytes;
         stream.pipe(collector);
@@ -4401,7 +5712,7 @@ var require_headStream = __commonJS({
         collector.on("error", reject);
         collector.on("finish", function() {
           const bytes2 = new Uint8Array(Buffer.concat(this.buffers));
-          resolve2(bytes2);
+          resolve4(bytes2);
         });
       });
     };
@@ -4659,21 +5970,21 @@ var require_dist_cjs15 = __commonJS({
       let sendBody = true;
       if (expect === "100-continue") {
         sendBody = await Promise.race([
-          new Promise((resolve2) => {
-            timeoutId = Number(timing.setTimeout(() => resolve2(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+          new Promise((resolve4) => {
+            timeoutId = Number(timing.setTimeout(() => resolve4(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
           }),
-          new Promise((resolve2) => {
+          new Promise((resolve4) => {
             httpRequest.on("continue", () => {
               timing.clearTimeout(timeoutId);
-              resolve2(true);
+              resolve4(true);
             });
             httpRequest.on("response", () => {
               timing.clearTimeout(timeoutId);
-              resolve2(false);
+              resolve4(false);
             });
             httpRequest.on("error", () => {
               timing.clearTimeout(timeoutId);
-              resolve2(false);
+              resolve4(false);
             });
           })
         ]);
@@ -4709,13 +6020,13 @@ var require_dist_cjs15 = __commonJS({
       constructor(options) {
         this.socketWarningTimestamp = 0;
         this.metadata = { handlerProtocol: "http/1.1" };
-        this.configProvider = new Promise((resolve2, reject) => {
+        this.configProvider = new Promise((resolve4, reject) => {
           if (typeof options === "function") {
             options().then((_options) => {
-              resolve2(this.resolveDefaultConfig(_options));
+              resolve4(this.resolveDefaultConfig(_options));
             }).catch(reject);
           } else {
-            resolve2(this.resolveDefaultConfig(options));
+            resolve4(this.resolveDefaultConfig(options));
           }
         });
       }
@@ -4799,7 +6110,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         return new Promise((_resolve, _reject) => {
           let writeRequestBodyPromise = void 0;
           const timeouts = [];
-          const resolve2 = /* @__PURE__ */ __name(async (arg) => {
+          const resolve4 = /* @__PURE__ */ __name(async (arg) => {
             await writeRequestBodyPromise;
             timeouts.forEach(timing.clearTimeout);
             _resolve(arg);
@@ -4869,7 +6180,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
               headers: getTransformedHeaders(res.headers),
               body: res
             });
-            resolve2({ response: httpResponse });
+            resolve4({ response: httpResponse });
           });
           req.on("error", (err) => {
             if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
@@ -5058,13 +6369,13 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
       constructor(options) {
         this.metadata = { handlerProtocol: "h2" };
         this.connectionManager = new NodeHttp2ConnectionManager({});
-        this.configProvider = new Promise((resolve2, reject) => {
+        this.configProvider = new Promise((resolve4, reject) => {
           if (typeof options === "function") {
             options().then((opts) => {
-              resolve2(opts || {});
+              resolve4(opts || {});
             }).catch(reject);
           } else {
-            resolve2(options || {});
+            resolve4(options || {});
           }
         });
       }
@@ -5097,7 +6408,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         return new Promise((_resolve, _reject) => {
           let fulfilled = false;
           let writeRequestBodyPromise = void 0;
-          const resolve2 = /* @__PURE__ */ __name(async (arg) => {
+          const resolve4 = /* @__PURE__ */ __name(async (arg) => {
             await writeRequestBodyPromise;
             _resolve(arg);
           }, "resolve");
@@ -5153,7 +6464,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
               body: req
             });
             fulfilled = true;
-            resolve2({ response: httpResponse });
+            resolve4({ response: httpResponse });
             if (disableConcurrentStreams) {
               session.close();
               this.connectionManager.deleteSession(authority, session);
@@ -5242,7 +6553,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
       if (isReadableStreamInstance(stream)) {
         return collectReadableStream(stream);
       }
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         const collector = new Collector();
         stream.pipe(collector);
         stream.on("error", (err) => {
@@ -5252,7 +6563,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         collector.on("error", reject);
         collector.on("finish", function() {
           const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
-          resolve2(bytes);
+          resolve4(bytes);
         });
       });
     }, "streamCollector");
@@ -5317,7 +6628,7 @@ var require_dist_cjs16 = __commonJS({
     }
     __name(createRequest, "createRequest");
     function requestTimeout(timeoutInMs = 0) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         if (timeoutInMs) {
           setTimeout(() => {
             const timeoutError = new Error(`Request did not complete within ${timeoutInMs} ms`);
@@ -5444,7 +6755,7 @@ var require_dist_cjs16 = __commonJS({
         ];
         if (abortSignal) {
           raceOfPromises.push(
-            new Promise((resolve2, reject) => {
+            new Promise((resolve4, reject) => {
               const onAbort = /* @__PURE__ */ __name(() => {
                 const abortError = new Error("Request aborted");
                 abortError.name = "AbortError";
@@ -5512,7 +6823,7 @@ var require_dist_cjs16 = __commonJS({
     }
     __name(collectStream, "collectStream");
     function readToBase64(blob) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         const reader = new FileReader();
         reader.onloadend = () => {
           if (reader.readyState !== 2) {
@@ -5521,7 +6832,7 @@ var require_dist_cjs16 = __commonJS({
           const result = reader.result ?? "";
           const commaIndex = result.indexOf(",");
           const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
-          resolve2(result.substring(dataOffset));
+          resolve4(result.substring(dataOffset));
         };
         reader.onabort = () => reject(new Error("Read aborted"));
         reader.onerror = () => reject(reader.error);
@@ -6008,9 +7319,10 @@ var TypeRegistry;
 var init_TypeRegistry = __esm({
   "node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js"() {
     TypeRegistry = class _TypeRegistry {
-      constructor(namespace, schemas = /* @__PURE__ */ new Map()) {
+      constructor(namespace, schemas = /* @__PURE__ */ new Map(), exceptions = /* @__PURE__ */ new Map()) {
         this.namespace = namespace;
         this.schemas = schemas;
+        this.exceptions = exceptions;
       }
       static for(namespace) {
         if (!_TypeRegistry.registries.has(namespace)) {
@@ -6020,8 +7332,7 @@ var init_TypeRegistry = __esm({
       }
       register(shapeId, schema) {
         const qualifiedName = this.normalizeShapeId(shapeId);
-        const registry = _TypeRegistry.for(this.getNamespace(shapeId));
-        registry.schemas.set(qualifiedName, schema);
+        this.schemas.set(qualifiedName, schema);
       }
       getSchema(shapeId) {
         const id = this.normalizeShapeId(shapeId);
@@ -6030,6 +7341,12 @@ var init_TypeRegistry = __esm({
         }
         return this.schemas.get(id);
       }
+      registerError(errorSchema, ctor) {
+        this.exceptions.set(errorSchema, ctor);
+      }
+      getErrorCtor(errorSchema) {
+        return this.exceptions.get(errorSchema);
+      }
       getBaseException() {
         for (const [id, schema] of this.schemas.entries()) {
           if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
@@ -6041,9 +7358,9 @@ var init_TypeRegistry = __esm({
       find(predicate) {
         return [...this.schemas.values()].find(predicate);
       }
-      destroy() {
-        _TypeRegistry.registries.delete(this.namespace);
+      clear() {
         this.schemas.clear();
+        this.exceptions.clear();
       }
       normalizeShapeId(shapeId) {
         if (shapeId.includes("#")) {
@@ -6191,7 +7508,7 @@ var init_ErrorSchema = __esm({
       traits,
       memberNames,
       memberList,
-      ctor
+      ctor: null
     });
   }
 });
@@ -7160,11 +8477,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve2) {
-      resolve2(value);
+    return value instanceof P ? value : new P(function(resolve4) {
+      resolve4(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve2, reject) {
+  return new (P || (P = Promise))(function(resolve4, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -7180,7 +8497,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve4(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -7371,14 +8688,14 @@ function __asyncValues(o3) {
   }, i3);
   function verb(n3) {
     i3[n3] = o3[n3] && function(v3) {
-      return new Promise(function(resolve2, reject) {
-        v3 = o3[n3](v3), settle(resolve2, reject, v3.done, v3.value);
+      return new Promise(function(resolve4, reject) {
+        v3 = o3[n3](v3), settle(resolve4, reject, v3.done, v3.value);
       });
     };
   }
-  function settle(resolve2, reject, d3, v3) {
+  function settle(resolve4, reject, d3, v3) {
     Promise.resolve(v3).then(function(v4) {
-      resolve2({ value: v4, done: d3 });
+      resolve4({ value: v4, done: d3 });
     }, reject);
   }
 }
@@ -12349,16 +13666,18 @@ var init_SmithyRpcV2CborProtocol = __esm({
           if (dataObject.Message) {
             dataObject.message = dataObject.Message;
           }
-          const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
+          const synthetic = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+          const baseExceptionSchema = synthetic.getBaseException();
           if (baseExceptionSchema) {
-            const ErrorCtor = baseExceptionSchema.ctor;
-            throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
+            const ErrorCtor2 = synthetic.getErrorCtor(baseExceptionSchema);
+            throw Object.assign(new ErrorCtor2({ name: errorName }), errorMetadata, dataObject);
           }
           throw Object.assign(new Error(errorName), errorMetadata, dataObject);
         }
         const ns = NormalizedSchema.of(errorSchema);
+        const ErrorCtor = registry.getErrorCtor(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-        const exception = new errorSchema.ctor(message);
+        const exception = new ErrorCtor(message);
         const output = {};
         for (const [name14, member] of ns.structIterator()) {
           output[name14] = this.deserializer.readValue(member, dataObject[name14]);
@@ -18024,7 +19343,7 @@ var require_dist_cjs37 = __commonJS({
         );
       }
       waitForReady(socket, connectionTimeout) {
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve4, reject) => {
           const timeout = setTimeout(() => {
             this.removeNotUsableSockets(socket.url);
             reject({
@@ -18035,7 +19354,7 @@ var require_dist_cjs37 = __commonJS({
           }, connectionTimeout);
           socket.onopen = () => {
             clearTimeout(timeout);
-            resolve2();
+            resolve4();
           };
         });
       }
@@ -18044,10 +19363,10 @@ var require_dist_cjs37 = __commonJS({
         let socketErrorOccurred = false;
         let reject = /* @__PURE__ */ __name(() => {
         }, "reject");
-        let resolve2 = /* @__PURE__ */ __name(() => {
+        let resolve4 = /* @__PURE__ */ __name(() => {
         }, "resolve");
         socket.onmessage = (event) => {
-          resolve2({
+          resolve4({
             done: false,
             value: new Uint8Array(event.data)
           });
@@ -18063,7 +19382,7 @@ var require_dist_cjs37 = __commonJS({
           if (streamError) {
             reject(streamError);
           } else {
-            resolve2({
+            resolve4({
               done: true,
               value: void 0
               // unchecked because done=true.
@@ -18074,7 +19393,7 @@ var require_dist_cjs37 = __commonJS({
           [Symbol.asyncIterator]: () => ({
             next: /* @__PURE__ */ __name(() => {
               return new Promise((_resolve, _reject) => {
-                resolve2 = _resolve;
+                resolve4 = _resolve;
                 reject = _reject;
               });
             }, "next")
@@ -18597,13 +19916,13 @@ var require_dist_cjs42 = __commonJS({
         ...data2.default && { default: data2.default }
       }
     ), "getConfigData");
-    var import_path9 = require("path");
+    var import_path11 = require("path");
     var import_getHomeDir = require_getHomeDir();
     var ENV_CONFIG_PATH = "AWS_CONFIG_FILE";
-    var getConfigFilepath = /* @__PURE__ */ __name(() => process.env[ENV_CONFIG_PATH] || (0, import_path9.join)((0, import_getHomeDir.getHomeDir)(), ".aws", "config"), "getConfigFilepath");
+    var getConfigFilepath = /* @__PURE__ */ __name(() => process.env[ENV_CONFIG_PATH] || (0, import_path11.join)((0, import_getHomeDir.getHomeDir)(), ".aws", "config"), "getConfigFilepath");
     var import_getHomeDir2 = require_getHomeDir();
     var ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE";
-    var getCredentialsFilepath = /* @__PURE__ */ __name(() => process.env[ENV_CREDENTIALS_PATH] || (0, import_path9.join)((0, import_getHomeDir2.getHomeDir)(), ".aws", "credentials"), "getCredentialsFilepath");
+    var getCredentialsFilepath = /* @__PURE__ */ __name(() => process.env[ENV_CREDENTIALS_PATH] || (0, import_path11.join)((0, import_getHomeDir2.getHomeDir)(), ".aws", "credentials"), "getCredentialsFilepath");
     var import_getHomeDir3 = require_getHomeDir();
     var prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/;
     var profileNameBlockList = ["__proto__", "profile __proto__"];
@@ -18661,11 +19980,11 @@ var require_dist_cjs42 = __commonJS({
       const relativeHomeDirPrefix = "~/";
       let resolvedFilepath = filepath;
       if (filepath.startsWith(relativeHomeDirPrefix)) {
-        resolvedFilepath = (0, import_path9.join)(homeDir, filepath.slice(2));
+        resolvedFilepath = (0, import_path11.join)(homeDir, filepath.slice(2));
       }
       let resolvedConfigFilepath = configFilepath;
       if (configFilepath.startsWith(relativeHomeDirPrefix)) {
-        resolvedConfigFilepath = (0, import_path9.join)(homeDir, configFilepath.slice(2));
+        resolvedConfigFilepath = (0, import_path11.join)(homeDir, configFilepath.slice(2));
       }
       const parsedFiles = await Promise.all([
         (0, import_slurpFile.slurpFile)(resolvedConfigFilepath, {
@@ -19320,7 +20639,7 @@ var require_dist_cjs46 = __commonJS({
         this.refillTokenBucket();
         if (amount > this.currentCapacity) {
           const delay = (amount - this.currentCapacity) / this.fillRate * 1e3;
-          await new Promise((resolve2) => _DefaultRateLimiter.setTimeoutFn(resolve2, delay));
+          await new Promise((resolve4) => _DefaultRateLimiter.setTimeoutFn(resolve4, delay));
         }
         this.currentCapacity = this.currentCapacity - amount;
       }
@@ -19711,7 +21030,7 @@ var require_dist_cjs47 = __commonJS({
               const delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
               const delay = Math.max(delayFromResponse || 0, delayFromDecider);
               totalDelay += delay;
-              await new Promise((resolve2) => setTimeout(resolve2, delay));
+              await new Promise((resolve4) => setTimeout(resolve4, delay));
               continue;
             }
             if (!err.$metadata) {
@@ -19871,7 +21190,7 @@ var require_dist_cjs47 = __commonJS({
             attempts = retryToken.getRetryCount();
             const delay = retryToken.getRetryDelay();
             totalRetryDelay += delay;
-            await new Promise((resolve2) => setTimeout(resolve2, delay));
+            await new Promise((resolve4) => setTimeout(resolve4, delay));
           }
         }
       } else {
@@ -20214,7 +21533,7 @@ var require_dist_cjs49 = __commonJS({
     var import_buffer = require("buffer");
     var import_http = require("http");
     function httpRequest(options) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         const req = (0, import_http.request)({
           method: "GET",
           ...options,
@@ -20243,7 +21562,7 @@ var require_dist_cjs49 = __commonJS({
             chunks.push(chunk);
           });
           res.on("end", () => {
-            resolve2(import_buffer.Buffer.concat(chunks));
+            resolve4(import_buffer.Buffer.concat(chunks));
             req.destroy();
           });
         });
@@ -20678,7 +21997,7 @@ var require_retry_wrapper = __commonJS({
           try {
             return await toRetry();
           } catch (e3) {
-            await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+            await new Promise((resolve4) => setTimeout(resolve4, delayMs));
           }
         }
         return await toRetry();
@@ -21122,7 +22441,7 @@ var require_dist_cjs53 = __commonJS({
       calculateBodyLength: () => calculateBodyLength3
     });
     module2.exports = __toCommonJS2(index_exports2);
-    var import_fs7 = require("fs");
+    var import_fs8 = require("fs");
     var calculateBodyLength3 = /* @__PURE__ */ __name((body) => {
       if (!body) {
         return 0;
@@ -21136,9 +22455,9 @@ var require_dist_cjs53 = __commonJS({
       } else if (typeof body.start === "number" && typeof body.end === "number") {
         return body.end + 1 - body.start;
       } else if (typeof body.path === "string" || Buffer.isBuffer(body.path)) {
-        return (0, import_fs7.lstatSync)(body.path).size;
+        return (0, import_fs8.lstatSync)(body.path).size;
       } else if (typeof body.fd === "number") {
-        return (0, import_fs7.fstatSync)(body.fd).size;
+        return (0, import_fs8.fstatSync)(body.fd).size;
       }
       throw new Error(`Body Length computation failed for ${body}`);
     }, "calculateBodyLength");
@@ -23176,8 +24495,8 @@ var require_dist_cjs57 = __commonJS({
       }
     }, "validateTokenKey");
     var import_shared_ini_file_loader = require_dist_cjs42();
-    var import_fs7 = require("fs");
-    var { writeFile } = import_fs7.promises;
+    var import_fs8 = require("fs");
+    var { writeFile } = import_fs8.promises;
     var writeSSOTokenToFile = /* @__PURE__ */ __name((id, ssoToken) => {
       const tokenFilepath = (0, import_shared_ini_file_loader.getSSOTokenFilepath)(id);
       const tokenString = JSON.stringify(ssoToken, null, 2);
@@ -24819,7 +26138,7 @@ var require_dist_cjs59 = __commonJS({
     module2.exports = __toCommonJS2(index_exports2);
     var import_property_provider2 = require_dist_cjs24();
     var import_shared_ini_file_loader = require_dist_cjs42();
-    var import_child_process8 = require("child_process");
+    var import_child_process9 = require("child_process");
     var import_util7 = require("util");
     var import_client7 = (init_client(), __toCommonJS(client_exports));
     var getValidatedProcessCredentials = /* @__PURE__ */ __name((profileName, data2, profiles) => {
@@ -24856,7 +26175,7 @@ var require_dist_cjs59 = __commonJS({
       if (profiles[profileName]) {
         const credentialProcess = profile["credential_process"];
         if (credentialProcess !== void 0) {
-          const execPromise = (0, import_util7.promisify)(import_shared_ini_file_loader.externalDataInterceptor?.getTokenRecord?.().exec ?? import_child_process8.exec);
+          const execPromise = (0, import_util7.promisify)(import_shared_ini_file_loader.externalDataInterceptor?.getTokenRecord?.().exec ?? import_child_process9.exec);
           try {
             const { stdout } = await execPromise(credentialProcess);
             let data2;
@@ -25595,7 +26914,7 @@ var require_dist_cjs64 = __commonJS({
         streamEnded = true;
       });
       while (!generationEnded) {
-        const value = await new Promise((resolve2) => setTimeout(() => resolve2(records.shift()), 0));
+        const value = await new Promise((resolve4) => setTimeout(() => resolve4(records.shift()), 0));
         if (value) {
           yield value;
         }
@@ -28972,16 +30291,16 @@ function prepareTools(mode) {
   }
   const toolWarnings = [];
   const bedrockTools = [];
-  for (const tool2 of tools2) {
-    if (tool2.type === "provider-defined") {
-      toolWarnings.push({ type: "unsupported-tool", tool: tool2 });
+  for (const tool3 of tools2) {
+    if (tool3.type === "provider-defined") {
+      toolWarnings.push({ type: "unsupported-tool", tool: tool3 });
     } else {
       bedrockTools.push({
         toolSpec: {
-          name: tool2.name,
-          description: tool2.description,
+          name: tool3.name,
+          description: tool3.description,
           inputSchema: {
-            json: tool2.parameters
+            json: tool3.parameters
           }
         }
       });
@@ -29949,19 +31268,15 @@ var init_tokenCounter = __esm({
   }
 });
 
-// src/agent/tools.js
-function createTools(configOptions) {
-  return {
-    searchTool: searchTool(configOptions),
-    queryTool: queryTool(configOptions),
-    extractTool: extractTool(configOptions),
-    delegateTool: delegateTool(configOptions)
-  };
+// src/agent/xmlParsingUtils.js
+function removeThinkingTags(xmlString) {
+  return xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
 }
-function parseXmlToolCallWithThinking(xmlString, validTools) {
+function extractThinkingContent(xmlString) {
   const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
-  const thinkingContent = thinkingMatch ? thinkingMatch[1].trim() : null;
-  let cleanedXmlString = xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
+  return thinkingMatch ? thinkingMatch[1].trim() : null;
+}
+function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
   const attemptCompletePatterns = [
     // Standard shorthand with optional whitespace
     /^<attempt_complete>\s*$/,
@@ -29991,29 +31306,65 @@ function parseXmlToolCallWithThinking(xmlString, validTools) {
       params: { result: "__PREVIOUS_RESPONSE__" }
     };
   }
-  const parsedTool = parseXmlToolCall(cleanedXmlString, validTools);
-  if (process.env.DEBUG === "1" && thinkingContent) {
-    console.log(`[DEBUG] AI Thinking Process:
-${thinkingContent}`);
-  }
-  return parsedTool;
+  return null;
 }
 function hasOtherToolTags(xmlString, validTools = []) {
   const defaultTools = ["search", "query", "extract", "listFiles", "searchFiles", "implement", "attempt_completion"];
   const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
-  for (const tool2 of toolsToCheck) {
-    if (tool2 !== "attempt_completion" && xmlString.includes(`<${tool2}`)) {
+  for (const tool3 of toolsToCheck) {
+    if (tool3 !== "attempt_completion" && xmlString.includes(`<${tool3}`)) {
       return true;
     }
   }
   return false;
 }
+function processXmlWithThinkingAndRecovery(xmlString, validTools = []) {
+  const thinkingContent = extractThinkingContent(xmlString);
+  const cleanedXmlString = removeThinkingTags(xmlString);
+  const recoveryResult = checkAttemptCompleteRecovery(cleanedXmlString, validTools);
+  if (process.env.DEBUG === "1" && thinkingContent) {
+    console.log(`[DEBUG] AI Thinking Process:
+${thinkingContent}`);
+  }
+  return {
+    cleanedXmlString,
+    thinkingContent,
+    recoveryResult
+  };
+}
+var init_xmlParsingUtils = __esm({
+  "src/agent/xmlParsingUtils.js"() {
+    "use strict";
+  }
+});
+
+// src/agent/tools.js
+function createTools(configOptions) {
+  const tools2 = {
+    searchTool: searchTool(configOptions),
+    queryTool: queryTool(configOptions),
+    extractTool: extractTool(configOptions),
+    delegateTool: delegateTool(configOptions)
+  };
+  if (configOptions.enableBash) {
+    tools2.bashTool = bashTool(configOptions);
+  }
+  return tools2;
+}
+function parseXmlToolCallWithThinking(xmlString, validTools) {
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+  return parseXmlToolCall(cleanedXmlString, validTools);
+}
 var import_crypto3, implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition;
 var init_tools2 = __esm({
   "src/agent/tools.js"() {
     "use strict";
     init_index();
     import_crypto3 = require("crypto");
+    init_xmlParsingUtils();
     implementToolDefinition = `
 ## implement
 Description: Implement a given task. Can modify files. Can be used ONLY if task explicitly stated that something requires modification or implementation.
@@ -30142,26 +31493,33 @@ function createWrappedTools(baseTools) {
       baseTools.delegateTool.execute
     );
   }
+  if (baseTools.bashTool) {
+    wrappedTools.bashToolInstance = wrapToolWithEmitter(
+      baseTools.bashTool,
+      "bash",
+      baseTools.bashTool.execute
+    );
+  }
   return wrappedTools;
 }
-var import_child_process7, import_util6, import_crypto4, import_events, import_fs2, import_fs3, import_path5, import_glob, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var import_child_process8, import_util6, import_crypto4, import_events, import_fs3, import_fs4, import_path7, import_glob, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
 var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
     init_index();
-    import_child_process7 = require("child_process");
+    import_child_process8 = require("child_process");
     import_util6 = require("util");
     import_crypto4 = require("crypto");
     import_events = require("events");
-    import_fs2 = __toESM(require("fs"), 1);
-    import_fs3 = require("fs");
-    import_path5 = __toESM(require("path"), 1);
+    import_fs3 = __toESM(require("fs"), 1);
+    import_fs4 = require("fs");
+    import_path7 = __toESM(require("path"), 1);
     import_glob = require("glob");
     toolCallEmitter = new import_events.EventEmitter();
     activeToolExecutions = /* @__PURE__ */ new Map();
-    wrapToolWithEmitter = (tool2, toolName, baseExecute) => {
+    wrapToolWithEmitter = (tool3, toolName, baseExecute) => {
       return {
-        ...tool2,
+        ...tool3,
         // Spread schema, description etc.
         execute: async (params) => {
           const debug = process.env.DEBUG === "1";
@@ -30243,9 +31601,9 @@ var init_probeTool = __esm({
       execute: async (params) => {
         const { directory = ".", workingDirectory } = params;
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path5.default.resolve(baseCwd);
-        const targetDir = import_path5.default.resolve(secureBaseDir, directory);
-        if (!targetDir.startsWith(secureBaseDir + import_path5.default.sep) && targetDir !== secureBaseDir) {
+        const secureBaseDir = import_path7.default.resolve(baseCwd);
+        const targetDir = import_path7.default.resolve(secureBaseDir, directory);
+        if (!targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
           throw new Error("Path traversal attempt detected. Access denied.");
         }
         try {
@@ -30268,9 +31626,9 @@ var init_probeTool = __esm({
           throw new Error("Pattern is required for file search");
         }
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path5.default.resolve(baseCwd);
-        const targetDir = import_path5.default.resolve(secureBaseDir, directory);
-        if (!targetDir.startsWith(secureBaseDir + import_path5.default.sep) && targetDir !== secureBaseDir) {
+        const secureBaseDir = import_path7.default.resolve(baseCwd);
+        const targetDir = import_path7.default.resolve(secureBaseDir, directory);
+        if (!targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
           throw new Error("Path traversal attempt detected. Access denied.");
         }
         try {
@@ -30302,7 +31660,7 @@ function createMockProvider() {
       provider: "mock",
       // Mock the doGenerate method used by Vercel AI SDK
       doGenerate: async ({ messages, tools: tools2 }) => {
-        await new Promise((resolve2) => setTimeout(resolve2, 10));
+        await new Promise((resolve4) => setTimeout(resolve4, 10));
         return {
           text: "This is a mock response for testing",
           toolCalls: [],
@@ -30877,7 +32235,7 @@ ${decodedContent}
             }
             if (needsQuoting(content)) {
               wasFixed = true;
-              const safeContent = content.replace(/"/g, "'");
+              const safeContent = content.replace(/"/g, "&quot;").replace(/'/g, "&#39;");
               return `["${safeContent}"]`;
             }
             return match;
@@ -30890,7 +32248,7 @@ ${decodedContent}
             }
             if (needsQuoting(content)) {
               wasFixed = true;
-              const safeContent = content.replace(/"/g, "'");
+              const safeContent = content.replace(/"/g, "&quot;").replace(/'/g, "&#39;");
               return `{"${safeContent}"}`;
             }
             return match;
@@ -31060,7 +32418,7 @@ ${fixedContent}
               }
               if (needsQuoting(content)) {
                 wasFixed = true;
-                const safeContent = content.replace(/"/g, "'");
+                const safeContent = content.replace(/"/g, "&quot;").replace(/'/g, "&#39;");
                 return `["${safeContent}"]`;
               }
               return match;
@@ -31073,7 +32431,7 @@ ${fixedContent}
               }
               if (needsQuoting(content)) {
                 wasFixed = true;
-                const safeContent = content.replace(/"/g, "'");
+                const safeContent = content.replace(/"/g, "&quot;").replace(/'/g, "&#39;");
                 return `{"${safeContent}"}`;
               }
               return match;
@@ -31473,11 +32831,11 @@ function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!(0, import_fs4.existsSync)(configPath)) {
+  if (!(0, import_fs5.existsSync)(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
-    const content = (0, import_fs4.readFileSync)(configPath, "utf8");
+    const content = (0, import_fs5.readFileSync)(configPath, "utf8");
     const config = JSON.parse(content);
     if (process.env.DEBUG === "1") {
       console.error(`[MCP] Loaded configuration from: ${configPath}`);
@@ -31492,19 +32850,19 @@ function loadMCPConfiguration() {
     // Environment variable path
     process.env.MCP_CONFIG_PATH,
     // Local project paths
-    (0, import_path6.join)(process.cwd(), ".mcp", "config.json"),
-    (0, import_path6.join)(process.cwd(), "mcp.config.json"),
+    (0, import_path8.join)(process.cwd(), ".mcp", "config.json"),
+    (0, import_path8.join)(process.cwd(), "mcp.config.json"),
     // Home directory paths
-    (0, import_path6.join)((0, import_os3.homedir)(), ".config", "probe", "mcp.json"),
-    (0, import_path6.join)((0, import_os3.homedir)(), ".mcp", "config.json"),
+    (0, import_path8.join)((0, import_os3.homedir)(), ".config", "probe", "mcp.json"),
+    (0, import_path8.join)((0, import_os3.homedir)(), ".mcp", "config.json"),
     // Claude-style config location
-    (0, import_path6.join)((0, import_os3.homedir)(), "Library", "Application Support", "Claude", "mcp_config.json")
+    (0, import_path8.join)((0, import_os3.homedir)(), "Library", "Application Support", "Claude", "mcp_config.json")
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
-    if ((0, import_fs4.existsSync)(configPath)) {
+    if ((0, import_fs5.existsSync)(configPath)) {
       try {
-        const content = (0, import_fs4.readFileSync)(configPath, "utf8");
+        const content = (0, import_fs5.readFileSync)(configPath, "utf8");
         config = JSON.parse(content);
         if (process.env.DEBUG === "1") {
           console.error(`[MCP] Loaded configuration from: ${configPath}`);
@@ -31600,22 +32958,22 @@ function parseEnabledServers(config) {
   }
   return servers;
 }
-var import_fs4, import_path6, import_os3, import_url4, __filename4, __dirname4, DEFAULT_CONFIG;
+var import_fs5, import_path8, import_os3, import_url4, __filename4, __dirname4, DEFAULT_CONFIG;
 var init_config = __esm({
   "src/agent/mcp/config.js"() {
     "use strict";
-    import_fs4 = require("fs");
-    import_path6 = require("path");
+    import_fs5 = require("fs");
+    import_path8 = require("path");
     import_os3 = require("os");
     import_url4 = require("url");
     __filename4 = (0, import_url4.fileURLToPath)("file:///");
-    __dirname4 = (0, import_path6.dirname)(__filename4);
+    __dirname4 = (0, import_path8.dirname)(__filename4);
     DEFAULT_CONFIG = {
       mcpServers: {
         // Example probe server configuration
         "probe-local": {
           command: "node",
-          args: [(0, import_path6.join)(__dirname4, "../../../examples/chat/mcpServer.js")],
+          args: [(0, import_path8.join)(__dirname4, "../../../examples/chat/mcpServer.js")],
           transport: "stdio",
           enabled: false
         },
@@ -31772,12 +33130,12 @@ var init_client2 = __esm({
           });
           const toolsResponse = await client.listTools();
           if (toolsResponse && toolsResponse.tools) {
-            for (const tool2 of toolsResponse.tools) {
-              const qualifiedName = `${name14}_${tool2.name}`;
+            for (const tool3 of toolsResponse.tools) {
+              const qualifiedName = `${name14}_${tool3.name}`;
               this.tools.set(qualifiedName, {
-                ...tool2,
+                ...tool3,
                 serverName: name14,
-                originalName: tool2.name
+                originalName: tool3.name
               });
               if (this.debug) {
                 console.error(`[MCP]   Registered tool: ${qualifiedName}`);
@@ -31799,20 +33157,20 @@ var init_client2 = __esm({
        * @param {Object} args - Tool arguments
        */
       async callTool(toolName, args) {
-        const tool2 = this.tools.get(toolName);
-        if (!tool2) {
+        const tool3 = this.tools.get(toolName);
+        if (!tool3) {
           throw new Error(`Unknown tool: ${toolName}`);
         }
-        const clientInfo = this.clients.get(tool2.serverName);
+        const clientInfo = this.clients.get(tool3.serverName);
         if (!clientInfo) {
-          throw new Error(`Server ${tool2.serverName} not connected`);
+          throw new Error(`Server ${tool3.serverName} not connected`);
         }
         try {
           if (this.debug) {
             console.error(`[MCP] Calling ${toolName} with args:`, args);
           }
           const result = await clientInfo.client.callTool({
-            name: tool2.originalName,
+            name: tool3.originalName,
             arguments: args
           });
           return result;
@@ -31827,11 +33185,11 @@ var init_client2 = __esm({
        */
       getTools() {
         const tools2 = {};
-        for (const [name14, tool2] of this.tools.entries()) {
+        for (const [name14, tool3] of this.tools.entries()) {
           tools2[name14] = {
-            description: tool2.description,
-            inputSchema: tool2.inputSchema,
-            serverName: tool2.serverName
+            description: tool3.description,
+            inputSchema: tool3.inputSchema,
+            serverName: tool3.serverName
           };
         }
         return tools2;
@@ -31842,10 +33200,10 @@ var init_client2 = __esm({
        */
       getVercelTools() {
         const tools2 = {};
-        for (const [name14, tool2] of this.tools.entries()) {
+        for (const [name14, tool3] of this.tools.entries()) {
           tools2[name14] = {
-            description: tool2.description,
-            inputSchema: tool2.inputSchema,
+            description: tool3.description,
+            inputSchema: tool3.inputSchema,
             execute: async (args) => {
               const result = await this.callTool(name14, args);
               if (result.content && result.content[0]) {
@@ -31882,9 +33240,9 @@ var init_client2 = __esm({
 });
 
 // src/agent/mcp/xmlBridge.js
-function mcpToolToXmlDefinition(name14, tool2) {
-  const description = tool2.description || "MCP tool";
-  const inputSchema = tool2.inputSchema || tool2.parameters || {};
+function mcpToolToXmlDefinition(name14, tool3) {
+  const description = tool3.description || "MCP tool";
+  const inputSchema = tool3.inputSchema || tool3.parameters || {};
   let paramDocs = "";
   if (inputSchema.properties) {
     paramDocs = "\n\nParameters (provide as JSON object):";
@@ -31958,11 +33316,9 @@ function parseXmlMcpToolCall(xmlString, mcpToolNames = []) {
   return null;
 }
 function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
-  for (const toolName of nativeTools) {
-    const nativeResult = parseNativeXmlTool(xmlString, toolName);
-    if (nativeResult) {
-      return { ...nativeResult, type: "native" };
-    }
+  const nativeResult = parseNativeXmlToolWithThinking(xmlString, nativeTools);
+  if (nativeResult) {
+    return { ...nativeResult, type: "native" };
   }
   if (mcpBridge) {
     const mcpResult = parseXmlMcpToolCall(xmlString, mcpBridge.getToolNames());
@@ -31972,6 +33328,19 @@ function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
   }
   return null;
 }
+function parseNativeXmlToolWithThinking(xmlString, validTools) {
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+  for (const toolName of validTools) {
+    const result = parseNativeXmlTool(cleanedXmlString, toolName);
+    if (result) {
+      return result;
+    }
+  }
+  return null;
+}
 function parseNativeXmlTool(xmlString, toolName) {
   const openTag = `<${toolName}>`;
   const closeTag = `</${toolName}>`;
@@ -32001,6 +33370,7 @@ var init_xmlBridge = __esm({
     "use strict";
     init_client2();
     init_config();
+    init_xmlParsingUtils();
     MCPXmlBridge = class {
       constructor(options = {}) {
         this.debug = options.debug || false;
@@ -32032,8 +33402,8 @@ var init_xmlBridge = __esm({
           const result = await this.mcpManager.initialize(mcpConfigs);
           const vercelTools = this.mcpManager.getVercelTools();
           this.mcpTools = vercelTools;
-          for (const [name14, tool2] of Object.entries(vercelTools)) {
-            this.xmlDefinitions[name14] = mcpToolToXmlDefinition(name14, tool2);
+          for (const [name14, tool3] of Object.entries(vercelTools)) {
+            this.xmlDefinitions[name14] = mcpToolToXmlDefinition(name14, tool3);
           }
           if (this.debug) {
             console.error(`[MCP] Loaded ${Object.keys(vercelTools).length} MCP tools from ${result.connected} server(s)`);
@@ -32070,12 +33440,12 @@ var init_xmlBridge = __esm({
         if (this.debug) {
           console.error(`[MCP] Executing MCP tool: ${toolName} with params:`, params);
         }
-        const tool2 = this.mcpTools[toolName];
-        if (!tool2) {
+        const tool3 = this.mcpTools[toolName];
+        if (!tool3) {
           throw new Error(`Unknown MCP tool: ${toolName}`);
         }
         try {
-          const result = await tool2.execute(params);
+          const result = await tool3.execute(params);
           return {
             success: true,
             toolName,
@@ -32127,7 +33497,7 @@ var ProbeAgent_exports = {};
 __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
-var import_anthropic, import_openai, import_google, import_ai2, import_crypto5, import_events2, import_fs5, import_promises, import_path7, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, SUPPORTED_IMAGE_EXTENSIONS, MAX_IMAGE_FILE_SIZE, ProbeAgent;
+var import_anthropic, import_openai, import_google, import_ai3, import_crypto5, import_events2, import_fs6, import_promises, import_path9, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, SUPPORTED_IMAGE_EXTENSIONS, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     "use strict";
@@ -32135,12 +33505,12 @@ var init_ProbeAgent = __esm({
     import_openai = require("@ai-sdk/openai");
     import_google = require("@ai-sdk/google");
     init_dist3();
-    import_ai2 = require("ai");
+    import_ai3 = require("ai");
     import_crypto5 = require("crypto");
     import_events2 = require("events");
-    import_fs5 = require("fs");
+    import_fs6 = require("fs");
     import_promises = require("fs/promises");
-    import_path7 = require("path");
+    import_path9 = require("path");
     init_tokenCounter();
     init_tools2();
     init_common();
@@ -32184,6 +33554,8 @@ var init_ProbeAgent = __esm({
         this.outline = !!options.outline;
         this.maxResponseTokens = options.maxResponseTokens || parseInt(process.env.MAX_RESPONSE_TOKENS || "0", 10) || null;
         this.disableMermaidValidation = !!options.disableMermaidValidation;
+        this.enableBash = !!options.enableBash;
+        this.bashConfig = options.bashConfig || {};
         if (options.allowedFolders && Array.isArray(options.allowedFolders)) {
           this.allowedFolders = options.allowedFolders;
         } else if (options.path) {
@@ -32227,7 +33599,9 @@ var init_ProbeAgent = __esm({
           debug: this.debug,
           defaultPath: this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd(),
           allowedFolders: this.allowedFolders,
-          outline: this.outline
+          outline: this.outline,
+          enableBash: this.enableBash,
+          bashConfig: this.bashConfig
         };
         const baseTools = createTools(configOptions);
         const wrappedTools = createWrappedTools(baseTools);
@@ -32239,6 +33613,9 @@ var init_ProbeAgent = __esm({
           listFiles: listFilesToolInstance,
           searchFiles: searchFilesToolInstance
         };
+        if (this.enableBash && wrappedTools.bashToolInstance) {
+          this.toolImplementations.bash = wrappedTools.bashToolInstance;
+        }
         this.wrappedTools = wrappedTools;
       }
       /**
@@ -32425,13 +33802,13 @@ var init_ProbeAgent = __esm({
           const allowedDirs = this.allowedFolders && this.allowedFolders.length > 0 ? this.allowedFolders : [process.cwd()];
           let absolutePath;
           let isPathAllowed = false;
-          if ((0, import_path7.isAbsolute)(imagePath)) {
+          if ((0, import_path9.isAbsolute)(imagePath)) {
             absolutePath = imagePath;
-            isPathAllowed = allowedDirs.some((dir) => absolutePath.startsWith((0, import_path7.resolve)(dir)));
+            isPathAllowed = allowedDirs.some((dir) => absolutePath.startsWith((0, import_path9.resolve)(dir)));
           } else {
             for (const dir of allowedDirs) {
-              const resolvedPath3 = (0, import_path7.resolve)(dir, imagePath);
-              if (resolvedPath3.startsWith((0, import_path7.resolve)(dir))) {
+              const resolvedPath3 = (0, import_path9.resolve)(dir, imagePath);
+              if (resolvedPath3.startsWith((0, import_path9.resolve)(dir))) {
                 absolutePath = resolvedPath3;
                 isPathAllowed = true;
                 break;
@@ -32926,7 +34303,7 @@ You are working with a repository located at: ${searchDirectory}
             try {
               const executeAIRequest = async () => {
                 const messagesForAI = this.prepareMessagesWithImages(currentMessages);
-                const result = await (0, import_ai2.streamText)({
+                const result = await (0, import_ai3.streamText)({
                   model: this.provider(this.model),
                   messages: messagesForAI,
                   maxTokens: maxResponseTokens,
@@ -33603,12 +34980,12 @@ function initializeSimpleTelemetryFromOptions(options) {
   });
   return telemetry;
 }
-var import_fs6, import_path8, SimpleTelemetry, SimpleAppTracer;
+var import_fs7, import_path10, SimpleTelemetry, SimpleAppTracer;
 var init_simpleTelemetry = __esm({
   "src/agent/simpleTelemetry.js"() {
     "use strict";
-    import_fs6 = require("fs");
-    import_path8 = require("path");
+    import_fs7 = require("fs");
+    import_path10 = require("path");
     SimpleTelemetry = class {
       constructor(options = {}) {
         this.serviceName = options.serviceName || "probe-agent";
@@ -33622,11 +34999,11 @@ var init_simpleTelemetry = __esm({
       }
       initializeFileExporter() {
         try {
-          const dir = (0, import_path8.dirname)(this.filePath);
-          if (!(0, import_fs6.existsSync)(dir)) {
-            (0, import_fs6.mkdirSync)(dir, { recursive: true });
+          const dir = (0, import_path10.dirname)(this.filePath);
+          if (!(0, import_fs7.existsSync)(dir)) {
+            (0, import_fs7.mkdirSync)(dir, { recursive: true });
           }
-          this.stream = (0, import_fs6.createWriteStream)(this.filePath, { flags: "a" });
+          this.stream = (0, import_fs7.createWriteStream)(this.filePath, { flags: "a" });
           this.stream.on("error", (error2) => {
             console.error(`[SimpleTelemetry] Stream error: ${error2.message}`);
           });
@@ -33687,20 +35064,20 @@ var init_simpleTelemetry = __esm({
       }
       async flush() {
         if (this.stream) {
-          return new Promise((resolve2) => {
-            this.stream.once("drain", resolve2);
+          return new Promise((resolve4) => {
+            this.stream.once("drain", resolve4);
             if (!this.stream.writableNeedDrain) {
-              resolve2();
+              resolve4();
             }
           });
         }
       }
       async shutdown() {
         if (this.stream) {
-          return new Promise((resolve2) => {
+          return new Promise((resolve4) => {
             this.stream.end(() => {
               console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
-              resolve2();
+              resolve4();
             });
           });
         }
@@ -33827,6 +35204,9 @@ __export(index_exports, {
   SimpleTelemetry: () => SimpleTelemetry,
   attemptCompletionSchema: () => attemptCompletionSchema,
   attemptCompletionToolDefinition: () => attemptCompletionToolDefinition,
+  bashSchema: () => bashSchema,
+  bashTool: () => bashTool,
+  bashToolDefinition: () => bashToolDefinition,
   delegate: () => delegate,
   delegateSchema: () => delegateSchema,
   delegateTool: () => delegateTool,
@@ -33863,6 +35243,7 @@ var init_index = __esm({
     init_system_message();
     init_common();
     init_vercel();
+    init_bash();
     init_ProbeAgent();
     init_simpleTelemetry();
   }
@@ -33876,6 +35257,9 @@ init_index();
   SimpleTelemetry,
   attemptCompletionSchema,
   attemptCompletionToolDefinition,
+  bashSchema,
+  bashTool,
+  bashToolDefinition,
   delegate,
   delegateSchema,
   delegateTool,