@probelabs/probe 0.6.0-rc104 → 0.6.0-rc106

package/build/agent/index.js

@@ -2190,7 +2190,7 @@ var require_headStream = __commonJS({
       if ((0, stream_type_check_1.isReadableStream)(stream)) {
         return (0, headStream_browser_1.headStream)(stream, bytes);
       }
-      return new Promise((resolve3, reject) => {
+      return new Promise((resolve5, reject) => {
         const collector = new Collector();
         collector.limit = bytes;
         stream.pipe(collector);
@@ -2201,7 +2201,7 @@ var require_headStream = __commonJS({
         collector.on("error", reject);
         collector.on("finish", function() {
           const bytes2 = new Uint8Array(Buffer.concat(this.buffers));
-          resolve3(bytes2);
+          resolve5(bytes2);
         });
       });
     };
@@ -2459,21 +2459,21 @@ var require_dist_cjs15 = __commonJS({
       let sendBody = true;
       if (expect === "100-continue") {
         sendBody = await Promise.race([
-          new Promise((resolve3) => {
-            timeoutId = Number(timing.setTimeout(() => resolve3(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+          new Promise((resolve5) => {
+            timeoutId = Number(timing.setTimeout(() => resolve5(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
           }),
-          new Promise((resolve3) => {
+          new Promise((resolve5) => {
             httpRequest.on("continue", () => {
               timing.clearTimeout(timeoutId);
-              resolve3(true);
+              resolve5(true);
             });
             httpRequest.on("response", () => {
               timing.clearTimeout(timeoutId);
-              resolve3(false);
+              resolve5(false);
             });
             httpRequest.on("error", () => {
               timing.clearTimeout(timeoutId);
-              resolve3(false);
+              resolve5(false);
             });
           })
         ]);
@@ -2509,13 +2509,13 @@ var require_dist_cjs15 = __commonJS({
       constructor(options) {
         this.socketWarningTimestamp = 0;
         this.metadata = { handlerProtocol: "http/1.1" };
-        this.configProvider = new Promise((resolve3, reject) => {
+        this.configProvider = new Promise((resolve5, reject) => {
           if (typeof options === "function") {
             options().then((_options) => {
-              resolve3(this.resolveDefaultConfig(_options));
+              resolve5(this.resolveDefaultConfig(_options));
             }).catch(reject);
           } else {
-            resolve3(this.resolveDefaultConfig(options));
+            resolve5(this.resolveDefaultConfig(options));
           }
         });
       }
@@ -2599,7 +2599,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         return new Promise((_resolve, _reject) => {
           let writeRequestBodyPromise = void 0;
           const timeouts = [];
-          const resolve3 = /* @__PURE__ */ __name(async (arg) => {
+          const resolve5 = /* @__PURE__ */ __name(async (arg) => {
             await writeRequestBodyPromise;
             timeouts.forEach(timing.clearTimeout);
             _resolve(arg);
@@ -2669,7 +2669,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
               headers: getTransformedHeaders(res.headers),
               body: res
             });
-            resolve3({ response: httpResponse });
+            resolve5({ response: httpResponse });
           });
           req.on("error", (err) => {
             if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
@@ -2858,13 +2858,13 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
       constructor(options) {
         this.metadata = { handlerProtocol: "h2" };
         this.connectionManager = new NodeHttp2ConnectionManager({});
-        this.configProvider = new Promise((resolve3, reject) => {
+        this.configProvider = new Promise((resolve5, reject) => {
           if (typeof options === "function") {
             options().then((opts) => {
-              resolve3(opts || {});
+              resolve5(opts || {});
             }).catch(reject);
           } else {
-            resolve3(options || {});
+            resolve5(options || {});
           }
         });
       }
@@ -2897,7 +2897,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         return new Promise((_resolve, _reject) => {
           let fulfilled = false;
           let writeRequestBodyPromise = void 0;
-          const resolve3 = /* @__PURE__ */ __name(async (arg) => {
+          const resolve5 = /* @__PURE__ */ __name(async (arg) => {
             await writeRequestBodyPromise;
             _resolve(arg);
           }, "resolve");
@@ -2953,7 +2953,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
               body: req
             });
             fulfilled = true;
-            resolve3({ response: httpResponse });
+            resolve5({ response: httpResponse });
             if (disableConcurrentStreams) {
               session.close();
               this.connectionManager.deleteSession(authority, session);
@@ -3042,7 +3042,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
       if (isReadableStreamInstance(stream)) {
         return collectReadableStream(stream);
       }
-      return new Promise((resolve3, reject) => {
+      return new Promise((resolve5, reject) => {
         const collector = new Collector();
         stream.pipe(collector);
         stream.on("error", (err) => {
@@ -3052,7 +3052,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));
-          resolve3(bytes);
+          resolve5(bytes);
         });
       });
     }, "streamCollector");
@@ -3117,7 +3117,7 @@ var require_dist_cjs16 = __commonJS({
     }
     __name(createRequest, "createRequest");
     function requestTimeout(timeoutInMs = 0) {
-      return new Promise((resolve3, reject) => {
+      return new Promise((resolve5, reject) => {
         if (timeoutInMs) {
           setTimeout(() => {
             const timeoutError = new Error(`Request did not complete within ${timeoutInMs} ms`);
@@ -3244,7 +3244,7 @@ var require_dist_cjs16 = __commonJS({
         ];
         if (abortSignal) {
           raceOfPromises.push(
-            new Promise((resolve3, reject) => {
+            new Promise((resolve5, reject) => {
               const onAbort = /* @__PURE__ */ __name(() => {
                 const abortError = new Error("Request aborted");
                 abortError.name = "AbortError";
@@ -3312,7 +3312,7 @@ var require_dist_cjs16 = __commonJS({
     }
     __name(collectStream, "collectStream");
     function readToBase64(blob) {
-      return new Promise((resolve3, reject) => {
+      return new Promise((resolve5, reject) => {
         const reader = new FileReader();
         reader.onloadend = () => {
           if (reader.readyState !== 2) {
@@ -3321,7 +3321,7 @@ var require_dist_cjs16 = __commonJS({
           const result = reader.result ?? "";
           const commaIndex = result.indexOf(",");
           const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
-          resolve3(result.substring(dataOffset));
+          resolve5(result.substring(dataOffset));
         };
         reader.onabort = () => reject(new Error("Read aborted"));
         reader.onerror = () => reject(reader.error);
@@ -3808,9 +3808,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)) {
@@ -3820,8 +3821,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);
@@ -3830,6 +3830,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")) {
@@ -3841,9 +3847,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("#")) {
@@ -3991,7 +3997,7 @@ var init_ErrorSchema = __esm({
       traits,
       memberNames,
       memberList,
-      ctor
+      ctor: null
     });
   }
 });
@@ -4960,11 +4966,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve3) {
-      resolve3(value);
+    return value instanceof P ? value : new P(function(resolve5) {
+      resolve5(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve3, reject) {
+  return new (P || (P = Promise))(function(resolve5, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -4980,7 +4986,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve3(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve5(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -5171,14 +5177,14 @@ function __asyncValues(o3) {
   }, i3);
   function verb(n3) {
     i3[n3] = o3[n3] && function(v3) {
-      return new Promise(function(resolve3, reject) {
-        v3 = o3[n3](v3), settle(resolve3, reject, v3.done, v3.value);
+      return new Promise(function(resolve5, reject) {
+        v3 = o3[n3](v3), settle(resolve5, reject, v3.done, v3.value);
       });
     };
   }
-  function settle(resolve3, reject, d3, v3) {
+  function settle(resolve5, reject, d3, v3) {
     Promise.resolve(v3).then(function(v4) {
-      resolve3({ value: v4, done: d3 });
+      resolve5({ value: v4, done: d3 });
     }, reject);
   }
 }
@@ -10149,16 +10155,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]);
@@ -15824,7 +15832,7 @@ var require_dist_cjs37 = __commonJS({
         );
       }
       waitForReady(socket, connectionTimeout) {
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve5, reject) => {
           const timeout = setTimeout(() => {
             this.removeNotUsableSockets(socket.url);
             reject({
@@ -15835,7 +15843,7 @@ var require_dist_cjs37 = __commonJS({
           }, connectionTimeout);
           socket.onopen = () => {
             clearTimeout(timeout);
-            resolve3();
+            resolve5();
           };
         });
       }
@@ -15844,10 +15852,10 @@ var require_dist_cjs37 = __commonJS({
         let socketErrorOccurred = false;
         let reject = /* @__PURE__ */ __name(() => {
         }, "reject");
-        let resolve3 = /* @__PURE__ */ __name(() => {
+        let resolve5 = /* @__PURE__ */ __name(() => {
         }, "resolve");
         socket.onmessage = (event) => {
-          resolve3({
+          resolve5({
             done: false,
             value: new Uint8Array(event.data)
           });
@@ -15863,7 +15871,7 @@ var require_dist_cjs37 = __commonJS({
           if (streamError) {
             reject(streamError);
           } else {
-            resolve3({
+            resolve5({
               done: true,
               value: void 0
               // unchecked because done=true.
@@ -15874,7 +15882,7 @@ var require_dist_cjs37 = __commonJS({
           [Symbol.asyncIterator]: () => ({
             next: /* @__PURE__ */ __name(() => {
               return new Promise((_resolve, _reject) => {
-                resolve3 = _resolve;
+                resolve5 = _resolve;
                 reject = _reject;
               });
             }, "next")
@@ -16397,13 +16405,13 @@ var require_dist_cjs42 = __commonJS({
         ...data2.default && { default: data2.default }
       }
     ), "getConfigData");
-    var import_path10 = __require("path");
+    var import_path12 = __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_path10.join)((0, import_getHomeDir.getHomeDir)(), ".aws", "config"), "getConfigFilepath");
+    var getConfigFilepath = /* @__PURE__ */ __name(() => process.env[ENV_CONFIG_PATH] || (0, import_path12.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_path10.join)((0, import_getHomeDir2.getHomeDir)(), ".aws", "credentials"), "getCredentialsFilepath");
+    var getCredentialsFilepath = /* @__PURE__ */ __name(() => process.env[ENV_CREDENTIALS_PATH] || (0, import_path12.join)((0, import_getHomeDir2.getHomeDir)(), ".aws", "credentials"), "getCredentialsFilepath");
     var import_getHomeDir3 = require_getHomeDir();
     var prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/;
     var profileNameBlockList = ["__proto__", "profile __proto__"];
@@ -16461,11 +16469,11 @@ var require_dist_cjs42 = __commonJS({
       const relativeHomeDirPrefix = "~/";
       let resolvedFilepath = filepath;
       if (filepath.startsWith(relativeHomeDirPrefix)) {
-        resolvedFilepath = (0, import_path10.join)(homeDir, filepath.slice(2));
+        resolvedFilepath = (0, import_path12.join)(homeDir, filepath.slice(2));
       }
       let resolvedConfigFilepath = configFilepath;
       if (configFilepath.startsWith(relativeHomeDirPrefix)) {
-        resolvedConfigFilepath = (0, import_path10.join)(homeDir, configFilepath.slice(2));
+        resolvedConfigFilepath = (0, import_path12.join)(homeDir, configFilepath.slice(2));
       }
       const parsedFiles = await Promise.all([
         (0, import_slurpFile.slurpFile)(resolvedConfigFilepath, {
@@ -17120,7 +17128,7 @@ var require_dist_cjs46 = __commonJS({
         this.refillTokenBucket();
         if (amount > this.currentCapacity) {
           const delay = (amount - this.currentCapacity) / this.fillRate * 1e3;
-          await new Promise((resolve3) => _DefaultRateLimiter.setTimeoutFn(resolve3, delay));
+          await new Promise((resolve5) => _DefaultRateLimiter.setTimeoutFn(resolve5, delay));
         }
         this.currentCapacity = this.currentCapacity - amount;
       }
@@ -17511,7 +17519,7 @@ var require_dist_cjs47 = __commonJS({
               const delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
               const delay = Math.max(delayFromResponse || 0, delayFromDecider);
               totalDelay += delay;
-              await new Promise((resolve3) => setTimeout(resolve3, delay));
+              await new Promise((resolve5) => setTimeout(resolve5, delay));
               continue;
             }
             if (!err.$metadata) {
@@ -17671,7 +17679,7 @@ var require_dist_cjs47 = __commonJS({
             attempts = retryToken.getRetryCount();
             const delay = retryToken.getRetryDelay();
             totalRetryDelay += delay;
-            await new Promise((resolve3) => setTimeout(resolve3, delay));
+            await new Promise((resolve5) => setTimeout(resolve5, delay));
           }
         }
       } else {
@@ -18014,7 +18022,7 @@ var require_dist_cjs49 = __commonJS({
     var import_buffer = __require("buffer");
     var import_http = __require("http");
     function httpRequest(options) {
-      return new Promise((resolve3, reject) => {
+      return new Promise((resolve5, reject) => {
         const req = (0, import_http.request)({
           method: "GET",
           ...options,
@@ -18043,7 +18051,7 @@ var require_dist_cjs49 = __commonJS({
             chunks.push(chunk);
           });
           res.on("end", () => {
-            resolve3(import_buffer.Buffer.concat(chunks));
+            resolve5(import_buffer.Buffer.concat(chunks));
             req.destroy();
           });
         });
@@ -18478,7 +18486,7 @@ var require_retry_wrapper = __commonJS({
           try {
             return await toRetry();
           } catch (e3) {
-            await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+            await new Promise((resolve5) => setTimeout(resolve5, delayMs));
           }
         }
         return await toRetry();
@@ -18922,7 +18930,7 @@ var require_dist_cjs53 = __commonJS({
       calculateBodyLength: () => calculateBodyLength3
     });
     module.exports = __toCommonJS2(index_exports);
-    var import_fs8 = __require("fs");
+    var import_fs9 = __require("fs");
     var calculateBodyLength3 = /* @__PURE__ */ __name((body) => {
       if (!body) {
         return 0;
@@ -18936,9 +18944,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_fs8.lstatSync)(body.path).size;
+        return (0, import_fs9.lstatSync)(body.path).size;
       } else if (typeof body.fd === "number") {
-        return (0, import_fs8.fstatSync)(body.fd).size;
+        return (0, import_fs9.fstatSync)(body.fd).size;
       }
       throw new Error(`Body Length computation failed for ${body}`);
     }, "calculateBodyLength");
@@ -20976,8 +20984,8 @@ var require_dist_cjs57 = __commonJS({
       }
     }, "validateTokenKey");
     var import_shared_ini_file_loader = require_dist_cjs42();
-    var import_fs8 = __require("fs");
-    var { writeFile } = import_fs8.promises;
+    var import_fs9 = __require("fs");
+    var { writeFile } = import_fs9.promises;
     var writeSSOTokenToFile = /* @__PURE__ */ __name((id, ssoToken) => {
       const tokenFilepath = (0, import_shared_ini_file_loader.getSSOTokenFilepath)(id);
       const tokenString = JSON.stringify(ssoToken, null, 2);
@@ -22619,7 +22627,7 @@ var require_dist_cjs59 = __commonJS({
     module.exports = __toCommonJS2(index_exports);
     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) => {
@@ -22656,7 +22664,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;
@@ -23395,7 +23403,7 @@ var require_dist_cjs64 = __commonJS({
         streamEnded = true;
       });
       while (!generationEnded) {
-        const value = await new Promise((resolve3) => setTimeout(() => resolve3(records.shift()), 0));
+        const value = await new Promise((resolve5) => setTimeout(() => resolve5(records.shift()), 0));
         if (value) {
           yield value;
         }
@@ -26772,16 +26780,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
           }
         }
       });
@@ -28945,7 +28953,7 @@ function createMessagePreview(message, charsPerSide = 200) {
   const end = message.substring(message.length - charsPerSide);
   return `${start}...${end}`;
 }
-var searchSchema, querySchema, extractSchema, delegateSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, attemptCompletionToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
+var searchSchema, querySchema, extractSchema, delegateSchema, bashSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, attemptCompletionToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
 var init_common2 = __esm({
   "src/tools/common.js"() {
     "use strict";
@@ -28976,6 +28984,12 @@ var init_common2 = __esm({
     delegateSchema = z2.object({
       task: z2.string().describe("The task to delegate to a subagent. Be specific about what needs to be accomplished.")
     });
+    bashSchema = z2.object({
+      command: z2.string().describe("The bash command to execute"),
+      workingDirectory: z2.string().optional().describe("Directory to execute the command in (optional)"),
+      timeout: z2.number().optional().describe("Command timeout in milliseconds (optional)"),
+      env: z2.record(z2.string()).optional().describe("Additional environment variables (optional)")
+    });
     attemptCompletionSchema = {
       // Custom validation that requires result parameter but allows direct XML response
       safeParse: (params) => {
@@ -29238,7 +29252,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((resolve3, reject) => {
+    return new Promise((resolve5, reject) => {
       const delegationSpan = tracer ? tracer.createDelegationSpan(sessionId, task) : null;
       const process2 = spawn(binaryPath, args, {
         stdio: ["pipe", "pipe", "pipe"],
@@ -29303,7 +29317,7 @@ async function delegate({ task, timeout = 300, debug = false, currentIteration =
               delegationSpan.end();
             }
           }
-          resolve3(response);
+          resolve5(response);
         } else {
           const errorMessage = stderr.trim() || `Delegate process failed with exit code ${code}`;
           if (debug) {
@@ -29496,10 +29510,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: randomUUID7 } = await import("crypto");
-              tempFilePath = join2(tmpdir(), `probe-extract-${randomUUID7()}.txt`);
+              tempFilePath = join3(tmpdir(), `probe-extract-${randomUUID7()}.txt`);
               writeFileSync2(tempFilePath, input_content);
               if (debug) {
                 console.error(`Created temporary file for input content: ${tempFilePath}`);
@@ -29576,6 +29590,1247 @@ 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
+import { spawn as spawn2 } from "child_process";
+import { resolve, join } from "path";
+import { existsSync } from "fs";
+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 = resolve(cwd);
+    if (!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((resolve5, reject) => {
+    const processEnv = {
+      ...process.env,
+      ...env
+    };
+    const args = parseCommandForExecution(command);
+    if (!args || args.length === 0) {
+      resolve5({
+        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 = spawn2(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}`;
+      }
+      resolve5({
+        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);
+      }
+      resolve5({
+        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 (!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 init_bashExecutor = __esm({
+  "src/agent/bashExecutor.js"() {
+    "use strict";
+    init_bashCommandUtils();
+  }
+});
+
+// src/tools/bash.js
+import { tool as tool2 } from "ai";
+import { resolve as resolve2 } from "path";
+var bashTool;
+var init_bash = __esm({
+  "src/tools/bash.js"() {
+    "use strict";
+    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 tool2({
+        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 = resolve2(workingDir);
+              const isAllowed = allowedFolders.some((folder) => {
+                const resolvedFolder = resolve2(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
 var init_langchain = __esm({
   "src/tools/langchain.js"() {
@@ -29724,16 +30979,19 @@ var init_tools = __esm({
   "src/tools/index.js"() {
     "use strict";
     init_vercel();
+    init_bash();
     init_langchain();
     init_common2();
     init_system_message();
     init_vercel();
+    init_bash();
     init_system_message();
     tools = {
       searchTool: searchTool(),
       queryTool: queryTool(),
       extractTool: extractTool(),
       delegateTool: delegateTool(),
+      bashTool: bashTool(),
       DEFAULT_SYSTEM_MESSAGE
     };
   }
@@ -29840,7 +31098,7 @@ var init_file_lister = __esm({
 });
 
 // src/agent/simpleTelemetry.js
-import { existsSync, mkdirSync, createWriteStream } from "fs";
+import { existsSync as existsSync2, mkdirSync, createWriteStream } from "fs";
 import { dirname } from "path";
 function initializeSimpleTelemetryFromOptions(options) {
   const telemetry = new SimpleTelemetry({
@@ -29869,7 +31127,7 @@ var init_simpleTelemetry = __esm({
       initializeFileExporter() {
         try {
           const dir = dirname(this.filePath);
-          if (!existsSync(dir)) {
+          if (!existsSync2(dir)) {
             mkdirSync(dir, { recursive: true });
           }
           this.stream = createWriteStream(this.filePath, { flags: "a" });
@@ -29933,20 +31191,20 @@ var init_simpleTelemetry = __esm({
       }
       async flush() {
         if (this.stream) {
-          return new Promise((resolve3) => {
-            this.stream.once("drain", resolve3);
+          return new Promise((resolve5) => {
+            this.stream.once("drain", resolve5);
             if (!this.stream.writableNeedDrain) {
-              resolve3();
+              resolve5();
             }
           });
         }
       }
       async shutdown() {
         if (this.stream) {
-          return new Promise((resolve3) => {
+          return new Promise((resolve5) => {
             this.stream.end(() => {
               console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
-              resolve3();
+              resolve5();
             });
           });
         }
@@ -30078,25 +31336,21 @@ var init_index = __esm({
     init_system_message();
     init_common2();
     init_vercel();
+    init_bash();
     init_ProbeAgent();
     init_simpleTelemetry();
   }
 });
 
-// src/agent/tools.js
-import { randomUUID as randomUUID2 } from "crypto";
-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*$/,
@@ -30126,28 +31380,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
+import { randomUUID as randomUUID2 } from "crypto";
+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 implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition;
 var init_tools2 = __esm({
   "src/agent/tools.js"() {
     "use strict";
     init_index();
+    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.
@@ -30284,6 +31575,13 @@ function createWrappedTools(baseTools) {
       baseTools.delegateTool.execute
     );
   }
+  if (baseTools.bashTool) {
+    wrappedTools.bashToolInstance = wrapToolWithEmitter(
+      baseTools.bashTool,
+      "bash",
+      baseTools.bashTool.execute
+    );
+  }
   return wrappedTools;
 }
 var toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
@@ -30293,9 +31591,9 @@ var init_probeTool = __esm({
     init_index();
     toolCallEmitter = new 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";
@@ -30436,7 +31734,7 @@ function createMockProvider() {
       provider: "mock",
       // Mock the doGenerate method used by Vercel AI SDK
       doGenerate: async ({ messages, tools: tools2 }) => {
-        await new Promise((resolve3) => setTimeout(resolve3, 10));
+        await new Promise((resolve5) => setTimeout(resolve5, 10));
         return {
           text: "This is a mock response for testing",
           toolCalls: [],
@@ -31070,7 +32368,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;
@@ -31083,7 +32381,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;
@@ -31253,7 +32551,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;
@@ -31266,7 +32564,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;
@@ -31662,15 +32960,15 @@ Provide only the corrected Mermaid diagram within a mermaid code block. Do not a
 });
 
 // src/agent/mcp/config.js
-import { readFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { join, dirname as dirname2 } from "path";
+import { readFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
 import { homedir } from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
@@ -31689,17 +32987,17 @@ function loadMCPConfiguration() {
     // Environment variable path
     process.env.MCP_CONFIG_PATH,
     // Local project paths
-    join(process.cwd(), ".mcp", "config.json"),
-    join(process.cwd(), "mcp.config.json"),
+    join2(process.cwd(), ".mcp", "config.json"),
+    join2(process.cwd(), "mcp.config.json"),
     // Home directory paths
-    join(homedir(), ".config", "probe", "mcp.json"),
-    join(homedir(), ".mcp", "config.json"),
+    join2(homedir(), ".config", "probe", "mcp.json"),
+    join2(homedir(), ".mcp", "config.json"),
     // Claude-style config location
-    join(homedir(), "Library", "Application Support", "Claude", "mcp_config.json")
+    join2(homedir(), "Library", "Application Support", "Claude", "mcp_config.json")
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
-    if (existsSync2(configPath)) {
+    if (existsSync3(configPath)) {
       try {
         const content = readFileSync(configPath, "utf8");
         config = JSON.parse(content);
@@ -31808,7 +33106,7 @@ var init_config = __esm({
         // Example probe server configuration
         "probe-local": {
           command: "node",
-          args: [join(__dirname4, "../../../examples/chat/mcpServer.js")],
+          args: [join2(__dirname4, "../../../examples/chat/mcpServer.js")],
           transport: "stdio",
           enabled: false
         },
@@ -31965,12 +33263,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}`);
@@ -31992,20 +33290,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;
@@ -32020,11 +33318,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;
@@ -32035,10 +33333,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]) {
@@ -32075,9 +33373,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):";
@@ -32151,11 +33449,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());
@@ -32165,6 +33461,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}>`;
@@ -32194,6 +33503,7 @@ var init_xmlBridge = __esm({
     "use strict";
     init_client2();
     init_config();
+    init_xmlParsingUtils();
     MCPXmlBridge = class {
       constructor(options = {}) {
         this.debug = options.debug || false;
@@ -32225,8 +33535,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)`);
@@ -32263,12 +33573,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,
@@ -32326,9 +33636,9 @@ import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { streamText } from "ai";
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { readFile, stat } from "fs/promises";
-import { resolve, isAbsolute } from "path";
+import { resolve as resolve3, isAbsolute } from "path";
 var MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, SUPPORTED_IMAGE_EXTENSIONS, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
@@ -32377,6 +33687,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) {
@@ -32420,7 +33732,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);
@@ -32432,6 +33746,9 @@ var init_ProbeAgent = __esm({
           listFiles: listFilesToolInstance,
           searchFiles: searchFilesToolInstance
         };
+        if (this.enableBash && wrappedTools.bashToolInstance) {
+          this.toolImplementations.bash = wrappedTools.bashToolInstance;
+        }
         this.wrappedTools = wrappedTools;
       }
       /**
@@ -32620,11 +33937,11 @@ var init_ProbeAgent = __esm({
           let isPathAllowed = false;
           if (isAbsolute(imagePath)) {
             absolutePath = imagePath;
-            isPathAllowed = allowedDirs.some((dir) => absolutePath.startsWith(resolve(dir)));
+            isPathAllowed = allowedDirs.some((dir) => absolutePath.startsWith(resolve3(dir)));
           } else {
             for (const dir of allowedDirs) {
-              const resolvedPath3 = resolve(dir, imagePath);
-              if (resolvedPath3.startsWith(resolve(dir))) {
+              const resolvedPath3 = resolve3(dir, imagePath);
+              if (resolvedPath3.startsWith(resolve3(dir))) {
                 absolutePath = resolvedPath3;
                 isPathAllowed = true;
                 break;
@@ -33799,8 +35116,8 @@ import {
   ListToolsRequestSchema,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
-import { readFileSync as readFileSync2, existsSync as existsSync4 } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync5 } from "fs";
+import { resolve as resolve4 } from "path";
 
 // src/agent/acp/server.js
 import { randomUUID as randomUUID5 } from "crypto";
@@ -34059,8 +35376,8 @@ var ACPConnection = class extends EventEmitter3 {
     if (params !== null) {
       message.params = params;
     }
-    return new Promise((resolve3, reject) => {
-      this.pendingRequests.set(id, { resolve: resolve3, reject });
+    return new Promise((resolve5, reject) => {
+      this.pendingRequests.set(id, { resolve: resolve5, reject });
       this.sendMessage(message);
       setTimeout(() => {
         if (this.pendingRequests.has(id)) {
@@ -34468,8 +35785,8 @@ import { randomUUID as randomUUID6 } from "crypto";
 function readInputContent(input) {
   if (!input) return null;
   try {
-    const resolvedPath3 = resolve2(input);
-    if (existsSync4(resolvedPath3)) {
+    const resolvedPath3 = resolve4(input);
+    if (existsSync5(resolvedPath3)) {
       return readFileSync2(resolvedPath3, "utf-8").trim();
     }
   } catch (error2) {
@@ -34477,7 +35794,7 @@ function readInputContent(input) {
   return input;
 }
 function readFromStdin() {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve5, reject) => {
     let data2 = "";
     let hasReceivedData = false;
     let dataChunks = [];
@@ -34502,7 +35819,7 @@ function readFromStdin() {
       if (!trimmed && dataChunks.length === 0) {
         reject(new Error("No input received from stdin"));
       } else {
-        resolve3(trimmed);
+        resolve5(trimmed);
       }
     });
     process.stdin.on("error", (error2) => {
@@ -34545,8 +35862,16 @@ function parseArgs() {
     // New flag to indicate stdin should be used
     outline: false,
     // New flag to enable outline format
-    noMermaidValidation: false
+    noMermaidValidation: false,
     // New flag to disable mermaid validation
+    // Bash tool configuration
+    enableBash: false,
+    bashAllow: null,
+    bashDeny: null,
+    bashTimeout: null,
+    bashWorkingDir: null,
+    disableDefaultBashAllow: false,
+    disableDefaultBashDeny: false
   };
   for (let i3 = 0; i3 < args.length; i3++) {
     const arg = args[i3];
@@ -34588,6 +35913,20 @@ function parseArgs() {
       config.outline = true;
     } else if (arg === "--no-mermaid-validation") {
       config.noMermaidValidation = true;
+    } else if (arg === "--enable-bash") {
+      config.enableBash = true;
+    } else if (arg === "--bash-allow" && i3 + 1 < args.length) {
+      config.bashAllow = args[++i3];
+    } else if (arg === "--bash-deny" && i3 + 1 < args.length) {
+      config.bashDeny = args[++i3];
+    } else if (arg === "--bash-timeout" && i3 + 1 < args.length) {
+      config.bashTimeout = args[++i3];
+    } else if (arg === "--bash-working-dir" && i3 + 1 < args.length) {
+      config.bashWorkingDir = args[++i3];
+    } else if (arg === "--no-default-bash-allow") {
+      config.disableDefaultBashAllow = true;
+    } else if (arg === "--no-default-bash-deny") {
+      config.disableDefaultBashDeny = true;
     } else if (!arg.startsWith("--") && !config.question) {
       config.question = arg;
     }
@@ -34629,6 +35968,15 @@ Options:
   --no-mermaid-validation          Disable automatic mermaid diagram validation and fixing
   --help, -h                      Show this help message
 
+Bash Tool Options:
+  --enable-bash                    Enable bash command execution for system exploration
+  --bash-allow <patterns>          Additional bash command patterns to allow (comma-separated)
+  --bash-deny <patterns>           Additional bash command patterns to deny (comma-separated)
+  --no-default-bash-allow          Disable default bash allow list (use only custom patterns)
+  --no-default-bash-deny           Disable default bash deny list (use only custom patterns)  
+  --bash-timeout <ms>              Bash command timeout in milliseconds (default: 120000)
+  --bash-working-dir <path>        Default working directory for bash commands
+
 Environment Variables:
   ANTHROPIC_API_KEY               Anthropic Claude API key
   OPENAI_API_KEY                  OpenAI GPT API key
@@ -34965,6 +36313,40 @@ async function main() {
         process.exit(1);
       }
     }
+    let bashConfig = null;
+    if (config.enableBash) {
+      bashConfig = {};
+      if (config.bashAllow) {
+        bashConfig.allow = config.bashAllow.split(",").map((p3) => p3.trim()).filter((p3) => p3.length > 0);
+      }
+      if (config.bashDeny) {
+        bashConfig.deny = config.bashDeny.split(",").map((p3) => p3.trim()).filter((p3) => p3.length > 0);
+      }
+      if (config.disableDefaultBashAllow) {
+        bashConfig.disableDefaultAllow = true;
+      }
+      if (config.disableDefaultBashDeny) {
+        bashConfig.disableDefaultDeny = true;
+      }
+      if (config.bashTimeout) {
+        const timeout = parseInt(config.bashTimeout, 10);
+        if (isNaN(timeout) || timeout < 1e3) {
+          console.error("Error: Bash timeout must be a number >= 1000 milliseconds");
+          process.exit(1);
+        }
+        bashConfig.timeout = timeout;
+      }
+      if (config.bashWorkingDir) {
+        if (!existsSync5(config.bashWorkingDir)) {
+          console.error(`Error: Bash working directory does not exist: ${config.bashWorkingDir}`);
+          process.exit(1);
+        }
+        bashConfig.workingDirectory = config.bashWorkingDir;
+      }
+      if (config.verbose) {
+        console.log("Bash command execution enabled");
+      }
+    }
     const agentConfig2 = {
       path: config.path,
       allowedFolders: config.allowedFolders,
@@ -34975,7 +36357,9 @@ async function main() {
       tracer: appTracer,
       outline: config.outline,
       maxResponseTokens: config.maxResponseTokens,
-      disableMermaidValidation: config.noMermaidValidation
+      disableMermaidValidation: config.noMermaidValidation,
+      enableBash: config.enableBash,
+      bashConfig
     };
     const agent = new ProbeAgent(agentConfig2);
     let result;