@probelabs/probe 0.6.0-rc166 → 0.6.0-rc168

package/build/agent/index.js

@@ -3404,7 +3404,7 @@ async function delegate({
   maxIterations = 30,
   tracer = null,
   parentSessionId = null,
-  path: path7 = null,
+  path: path8 = null,
   provider = null,
   model = null
 }) {
@@ -3444,7 +3444,7 @@ async function delegate({
       maxIterations: remainingIterations,
       debug,
       tracer,
-      path: path7,
+      path: path8,
       // Inherit from parent
       provider,
       // Inherit from parent
@@ -4062,8 +4062,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path7, errorMaps, issueData } = params;
-      const fullPath = [...path7, ...issueData.path || []];
+      const { data, path: path8, errorMaps, issueData } = params;
+      const fullPath = [...path8, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4371,11 +4371,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util2();
     ParseInputLazyPath = class {
-      constructor(parent, value, path7, key) {
+      constructor(parent, value, path8, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path7;
+        this._path = path8;
         this._key = key;
       }
       get path() {
@@ -8198,10 +8198,10 @@ var init_vercel = __esm({
         name: "search",
         description: searchDescription,
         inputSchema: searchSchema,
-        execute: async ({ query: searchQuery, path: path7, allow_tests, exact, maxTokens: paramMaxTokens, language }) => {
+        execute: async ({ query: searchQuery, path: path8, allow_tests, exact, maxTokens: paramMaxTokens, language }) => {
           try {
             const effectiveMaxTokens = paramMaxTokens || maxTokens;
-            let searchPath = path7 || options.defaultPath || ".";
+            let searchPath = path8 || options.defaultPath || ".";
             if ((searchPath === "." || searchPath === "./") && options.defaultPath) {
               if (debug) {
                 console.error(`Using default path "${options.defaultPath}" instead of "${searchPath}"`);
@@ -8241,9 +8241,9 @@ var init_vercel = __esm({
         name: "query",
         description: queryDescription,
         inputSchema: querySchema,
-        execute: async ({ pattern, path: path7, language, allow_tests }) => {
+        execute: async ({ pattern, path: path8, language, allow_tests }) => {
           try {
-            let queryPath = path7 || options.defaultPath || ".";
+            let queryPath = path8 || options.defaultPath || ".";
             if ((queryPath === "." || queryPath === "./") && options.defaultPath) {
               if (debug) {
                 console.error(`Using default path "${options.defaultPath}" instead of "${queryPath}"`);
@@ -8296,8 +8296,8 @@ var init_vercel = __esm({
               const { writeFileSync: writeFileSync2, unlinkSync } = await import("fs");
               const { join: join3 } = await import("path");
               const { tmpdir } = await import("os");
-              const { randomUUID: randomUUID7 } = await import("crypto");
-              tempFilePath = join3(tmpdir(), `probe-extract-${randomUUID7()}.txt`);
+              const { randomUUID: randomUUID8 } = await import("crypto");
+              tempFilePath = join3(tmpdir(), `probe-extract-${randomUUID8()}.txt`);
               writeFileSync2(tempFilePath, input_content);
               if (debug) {
                 console.error(`Created temporary file for input content: ${tempFilePath}`);
@@ -8353,7 +8353,7 @@ var init_vercel = __esm({
         name: "delegate",
         description: delegateDescription,
         inputSchema: delegateSchema,
-        execute: async ({ task, currentIteration, maxIterations, parentSessionId, path: path7, provider, model, tracer }) => {
+        execute: async ({ task, currentIteration, maxIterations, parentSessionId, path: path8, provider, model, tracer }) => {
           if (!task || typeof task !== "string") {
             throw new Error("Task parameter is required and must be a non-empty string");
           }
@@ -8369,7 +8369,7 @@ var init_vercel = __esm({
           if (parentSessionId !== void 0 && parentSessionId !== null && typeof parentSessionId !== "string") {
             throw new TypeError("parentSessionId must be a string, null, or undefined");
           }
-          if (path7 !== void 0 && path7 !== null && typeof path7 !== "string") {
+          if (path8 !== void 0 && path8 !== null && typeof path8 !== "string") {
             throw new TypeError("path must be a string, null, or undefined");
           }
           if (provider !== void 0 && provider !== null && typeof provider !== "string") {
@@ -8391,7 +8391,7 @@ var init_vercel = __esm({
             currentIteration: currentIteration || 0,
             maxIterations: maxIterations || 30,
             parentSessionId,
-            path: path7,
+            path: path8,
             provider,
             model,
             tracer
@@ -14519,12 +14519,12 @@ var init_esm4 = __esm({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path7) {
-        if (!path7) {
+      resolve(path8) {
+        if (!path8) {
           return this;
         }
-        const rootPath = this.getRootString(path7);
-        const dir = path7.substring(rootPath.length);
+        const rootPath = this.getRootString(path8);
+        const dir = path8.substring(rootPath.length);
         const dirParts = dir.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -15276,8 +15276,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path7) {
-        return win32.parse(path7).root;
+      getRootString(path8) {
+        return win32.parse(path8).root;
       }
       /**
        * @internal
@@ -15323,8 +15323,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path7) {
-        return path7.startsWith("/") ? "/" : "";
+      getRootString(path8) {
+        return path8.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -15373,8 +15373,8 @@ var init_esm4 = __esm({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs7);
+      constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs: fs8 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs8);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = fileURLToPath4(cwd);
         }
@@ -15413,11 +15413,11 @@ var init_esm4 = __esm({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path7 = this.cwd) {
-        if (typeof path7 === "string") {
-          path7 = this.cwd.resolve(path7);
+      depth(path8 = this.cwd) {
+        if (typeof path8 === "string") {
+          path8 = this.cwd.resolve(path8);
         }
-        return path7.depth();
+        return path8.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -15904,9 +15904,9 @@ var init_esm4 = __esm({
         process2();
         return results;
       }
-      chdir(path7 = this.cwd) {
+      chdir(path8 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path7 === "string" ? this.cwd.resolve(path7) : path7;
+        this.cwd = typeof path8 === "string" ? this.cwd.resolve(path8) : path8;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -15932,8 +15932,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs7) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
+      newRoot(fs8) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs8 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -15961,8 +15961,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs7) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
+      newRoot(fs8) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs8 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -16281,8 +16281,8 @@ var init_processor = __esm({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path7, n]) => [
-          path7,
+        return [...this.store.entries()].map(([path8, n]) => [
+          path8,
           !!(n & 2),
           !!(n & 1)
         ]);
@@ -16495,9 +16495,9 @@ var init_walker = __esm({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path7, opts) {
+      constructor(patterns, path8, opts) {
         this.patterns = patterns;
-        this.path = path7;
+        this.path = path8;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -16516,11 +16516,11 @@ var init_walker = __esm({
           });
         }
       }
-      #ignored(path7) {
-        return this.seen.has(path7) || !!this.#ignore?.ignored?.(path7);
+      #ignored(path8) {
+        return this.seen.has(path8) || !!this.#ignore?.ignored?.(path8);
       }
-      #childrenIgnored(path7) {
-        return !!this.#ignore?.childrenIgnored?.(path7);
+      #childrenIgnored(path8) {
+        return !!this.#ignore?.childrenIgnored?.(path8);
       }
       // backpressure mechanism
       pause() {
@@ -16735,8 +16735,8 @@ var init_walker = __esm({
     };
     GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path7, opts) {
-        super(patterns, path7, opts);
+      constructor(patterns, path8, opts) {
+        super(patterns, path8, opts);
       }
       matchEmit(e) {
         this.matches.add(e);
@@ -16773,8 +16773,8 @@ var init_walker = __esm({
     };
     GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path7, opts) {
-        super(patterns, path7, opts);
+      constructor(patterns, path8, opts) {
+        super(patterns, path8, opts);
         this.results = new Minipass({
           signal: this.signal,
           objectMode: true
@@ -19467,11 +19467,11 @@ var init_toKey = __esm({
 });
 
 // node_modules/lodash-es/_baseGet.js
-function baseGet(object, path7) {
-  path7 = castPath_default(path7, object);
-  var index = 0, length = path7.length;
+function baseGet(object, path8) {
+  path8 = castPath_default(path8, object);
+  var index = 0, length = path8.length;
   while (object != null && index < length) {
-    object = object[toKey_default(path7[index++])];
+    object = object[toKey_default(path8[index++])];
   }
   return index && index == length ? object : void 0;
 }
@@ -19485,8 +19485,8 @@ var init_baseGet = __esm({
 });
 
 // node_modules/lodash-es/get.js
-function get(object, path7, defaultValue) {
-  var result = object == null ? void 0 : baseGet_default(object, path7);
+function get(object, path8, defaultValue) {
+  var result = object == null ? void 0 : baseGet_default(object, path8);
   return result === void 0 ? defaultValue : result;
 }
 var get_default;
@@ -20849,11 +20849,11 @@ var init_baseHasIn = __esm({
 });
 
 // node_modules/lodash-es/_hasPath.js
-function hasPath(object, path7, hasFunc) {
-  path7 = castPath_default(path7, object);
-  var index = -1, length = path7.length, result = false;
+function hasPath(object, path8, hasFunc) {
+  path8 = castPath_default(path8, object);
+  var index = -1, length = path8.length, result = false;
   while (++index < length) {
-    var key = toKey_default(path7[index]);
+    var key = toKey_default(path8[index]);
     if (!(result = object != null && hasFunc(object, key))) {
       break;
     }
@@ -20879,8 +20879,8 @@ var init_hasPath = __esm({
 });
 
 // node_modules/lodash-es/hasIn.js
-function hasIn(object, path7) {
-  return object != null && hasPath_default(object, path7, baseHasIn_default);
+function hasIn(object, path8) {
+  return object != null && hasPath_default(object, path8, baseHasIn_default);
 }
 var hasIn_default;
 var init_hasIn = __esm({
@@ -20892,13 +20892,13 @@ var init_hasIn = __esm({
 });
 
 // node_modules/lodash-es/_baseMatchesProperty.js
-function baseMatchesProperty(path7, srcValue) {
-  if (isKey_default(path7) && isStrictComparable_default(srcValue)) {
-    return matchesStrictComparable_default(toKey_default(path7), srcValue);
+function baseMatchesProperty(path8, srcValue) {
+  if (isKey_default(path8) && isStrictComparable_default(srcValue)) {
+    return matchesStrictComparable_default(toKey_default(path8), srcValue);
   }
   return function(object) {
-    var objValue = get_default(object, path7);
-    return objValue === void 0 && objValue === srcValue ? hasIn_default(object, path7) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
+    var objValue = get_default(object, path8);
+    return objValue === void 0 && objValue === srcValue ? hasIn_default(object, path8) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
   };
 }
 var COMPARE_PARTIAL_FLAG6, COMPARE_UNORDERED_FLAG4, baseMatchesProperty_default;
@@ -20931,9 +20931,9 @@ var init_baseProperty = __esm({
 });
 
 // node_modules/lodash-es/_basePropertyDeep.js
-function basePropertyDeep(path7) {
+function basePropertyDeep(path8) {
   return function(object) {
-    return baseGet_default(object, path7);
+    return baseGet_default(object, path8);
   };
 }
 var basePropertyDeep_default;
@@ -20945,8 +20945,8 @@ var init_basePropertyDeep = __esm({
 });
 
 // node_modules/lodash-es/property.js
-function property(path7) {
-  return isKey_default(path7) ? baseProperty_default(toKey_default(path7)) : basePropertyDeep_default(path7);
+function property(path8) {
+  return isKey_default(path8) ? baseProperty_default(toKey_default(path8)) : basePropertyDeep_default(path8);
 }
 var property_default;
 var init_property = __esm({
@@ -21565,8 +21565,8 @@ var init_baseHas = __esm({
 });
 
 // node_modules/lodash-es/has.js
-function has(object, path7) {
-  return object != null && hasPath_default(object, path7, baseHas_default);
+function has(object, path8) {
+  return object != null && hasPath_default(object, path8, baseHas_default);
 }
 var has_default;
 var init_has = __esm({
@@ -21772,14 +21772,14 @@ var init_negate = __esm({
 });
 
 // node_modules/lodash-es/_baseSet.js
-function baseSet(object, path7, value, customizer) {
+function baseSet(object, path8, value, customizer) {
   if (!isObject_default(object)) {
     return object;
   }
-  path7 = castPath_default(path7, object);
-  var index = -1, length = path7.length, lastIndex = length - 1, nested = object;
+  path8 = castPath_default(path8, object);
+  var index = -1, length = path8.length, lastIndex = length - 1, nested = object;
   while (nested != null && ++index < length) {
-    var key = toKey_default(path7[index]), newValue = value;
+    var key = toKey_default(path8[index]), newValue = value;
     if (key === "__proto__" || key === "constructor" || key === "prototype") {
       return object;
     }
@@ -21787,7 +21787,7 @@ function baseSet(object, path7, value, customizer) {
       var objValue = nested[key];
       newValue = customizer ? customizer(objValue, key, nested) : void 0;
       if (newValue === void 0) {
-        newValue = isObject_default(objValue) ? objValue : isIndex_default(path7[index + 1]) ? [] : {};
+        newValue = isObject_default(objValue) ? objValue : isIndex_default(path8[index + 1]) ? [] : {};
       }
     }
     assignValue_default(nested, key, newValue);
@@ -21811,9 +21811,9 @@ var init_baseSet = __esm({
 function basePickBy(object, paths, predicate) {
   var index = -1, length = paths.length, result = {};
   while (++index < length) {
-    var path7 = paths[index], value = baseGet_default(object, path7);
-    if (predicate(value, path7)) {
-      baseSet_default(result, castPath_default(path7, object), value);
+    var path8 = paths[index], value = baseGet_default(object, path8);
+    if (predicate(value, path8)) {
+      baseSet_default(result, castPath_default(path8, object), value);
     }
   }
   return result;
@@ -21837,8 +21837,8 @@ function pickBy(object, predicate) {
     return [prop];
   });
   predicate = baseIteratee_default(predicate);
-  return basePickBy_default(object, props, function(value, path7) {
-    return predicate(value, path7[0]);
+  return basePickBy_default(object, props, function(value, path8) {
+    return predicate(value, path8[0]);
   });
 }
 var pickBy_default;
@@ -24551,12 +24551,12 @@ function assignCategoriesMapProp(tokenTypes) {
     singleAssignCategoriesToksMap([], currTokType);
   });
 }
-function singleAssignCategoriesToksMap(path7, nextNode) {
-  forEach_default(path7, (pathNode) => {
+function singleAssignCategoriesToksMap(path8, nextNode) {
+  forEach_default(path8, (pathNode) => {
     nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;
   });
   forEach_default(nextNode.CATEGORIES, (nextCategory) => {
-    const newPath = path7.concat(nextNode);
+    const newPath = path8.concat(nextNode);
     if (!includes_default(newPath, nextCategory)) {
       singleAssignCategoriesToksMap(newPath, nextCategory);
     }
@@ -25726,10 +25726,10 @@ var init_interpreter = __esm({
     init_rest();
     init_api2();
     AbstractNextPossibleTokensWalker = class extends RestWalker {
-      constructor(topProd, path7) {
+      constructor(topProd, path8) {
         super();
         this.topProd = topProd;
-        this.path = path7;
+        this.path = path8;
         this.possibleTokTypes = [];
         this.nextProductionName = "";
         this.nextProductionOccurrence = 0;
@@ -25773,9 +25773,9 @@ var init_interpreter = __esm({
       }
     };
     NextAfterTokenWalker = class extends AbstractNextPossibleTokensWalker {
-      constructor(topProd, path7) {
-        super(topProd, path7);
-        this.path = path7;
+      constructor(topProd, path8) {
+        super(topProd, path8);
+        this.path = path8;
         this.nextTerminalName = "";
         this.nextTerminalOccurrence = 0;
         this.nextTerminalName = this.path.lastTok.name;
@@ -26016,10 +26016,10 @@ function initializeArrayOfArrays(size) {
   }
   return result;
 }
-function pathToHashKeys(path7) {
+function pathToHashKeys(path8) {
   let keys2 = [""];
-  for (let i = 0; i < path7.length; i++) {
-    const tokType = path7[i];
+  for (let i = 0; i < path8.length; i++) {
+    const tokType = path8[i];
     const longerKeys = [];
     for (let j = 0; j < keys2.length; j++) {
       const currShorterKey = keys2[j];
@@ -26322,7 +26322,7 @@ function validateRuleIsOverridden(ruleName, definedRulesNames, className) {
   }
   return errors;
 }
-function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path7 = []) {
+function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path8 = []) {
   const errors = [];
   const nextNonTerminals = getFirstNoneTerminal(currRule.definition);
   if (isEmpty_default(nextNonTerminals)) {
@@ -26334,15 +26334,15 @@ function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path7 = [])
       errors.push({
         message: errMsgProvider.buildLeftRecursionError({
           topLevelRule: topRule,
-          leftRecursionPath: path7
+          leftRecursionPath: path8
         }),
         type: ParserDefinitionErrorType.LEFT_RECURSION,
         ruleName
       });
     }
-    const validNextSteps = difference_default(nextNonTerminals, path7.concat([topRule]));
+    const validNextSteps = difference_default(nextNonTerminals, path8.concat([topRule]));
     const errorsFromNextSteps = flatMap_default(validNextSteps, (currRefRule) => {
-      const newPath = clone_default(path7);
+      const newPath = clone_default(path8);
       newPath.push(currRefRule);
       return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);
     });
@@ -38939,11 +38939,11 @@ var require_baseGet = __commonJS({
   "node_modules/lodash/_baseGet.js"(exports2, module2) {
     var castPath2 = require_castPath();
     var toKey2 = require_toKey();
-    function baseGet2(object, path7) {
-      path7 = castPath2(path7, object);
-      var index = 0, length = path7.length;
+    function baseGet2(object, path8) {
+      path8 = castPath2(path8, object);
+      var index = 0, length = path8.length;
       while (object != null && index < length) {
-        object = object[toKey2(path7[index++])];
+        object = object[toKey2(path8[index++])];
       }
       return index && index == length ? object : void 0;
     }
@@ -38955,8 +38955,8 @@ var require_baseGet = __commonJS({
 var require_get = __commonJS({
   "node_modules/lodash/get.js"(exports2, module2) {
     var baseGet2 = require_baseGet();
-    function get2(object, path7, defaultValue) {
-      var result = object == null ? void 0 : baseGet2(object, path7);
+    function get2(object, path8, defaultValue) {
+      var result = object == null ? void 0 : baseGet2(object, path8);
       return result === void 0 ? defaultValue : result;
     }
     module2.exports = get2;
@@ -38982,11 +38982,11 @@ var require_hasPath = __commonJS({
     var isIndex2 = require_isIndex();
     var isLength2 = require_isLength();
     var toKey2 = require_toKey();
-    function hasPath2(object, path7, hasFunc) {
-      path7 = castPath2(path7, object);
-      var index = -1, length = path7.length, result = false;
+    function hasPath2(object, path8, hasFunc) {
+      path8 = castPath2(path8, object);
+      var index = -1, length = path8.length, result = false;
       while (++index < length) {
-        var key = toKey2(path7[index]);
+        var key = toKey2(path8[index]);
         if (!(result = object != null && hasFunc(object, key))) {
           break;
         }
@@ -39007,8 +39007,8 @@ var require_hasIn = __commonJS({
   "node_modules/lodash/hasIn.js"(exports2, module2) {
     var baseHasIn2 = require_baseHasIn();
     var hasPath2 = require_hasPath();
-    function hasIn2(object, path7) {
-      return object != null && hasPath2(object, path7, baseHasIn2);
+    function hasIn2(object, path8) {
+      return object != null && hasPath2(object, path8, baseHasIn2);
     }
     module2.exports = hasIn2;
   }
@@ -39026,13 +39026,13 @@ var require_baseMatchesProperty = __commonJS({
     var toKey2 = require_toKey();
     var COMPARE_PARTIAL_FLAG7 = 1;
     var COMPARE_UNORDERED_FLAG5 = 2;
-    function baseMatchesProperty2(path7, srcValue) {
-      if (isKey2(path7) && isStrictComparable2(srcValue)) {
-        return matchesStrictComparable2(toKey2(path7), srcValue);
+    function baseMatchesProperty2(path8, srcValue) {
+      if (isKey2(path8) && isStrictComparable2(srcValue)) {
+        return matchesStrictComparable2(toKey2(path8), srcValue);
       }
       return function(object) {
-        var objValue = get2(object, path7);
-        return objValue === void 0 && objValue === srcValue ? hasIn2(object, path7) : baseIsEqual2(srcValue, objValue, COMPARE_PARTIAL_FLAG7 | COMPARE_UNORDERED_FLAG5);
+        var objValue = get2(object, path8);
+        return objValue === void 0 && objValue === srcValue ? hasIn2(object, path8) : baseIsEqual2(srcValue, objValue, COMPARE_PARTIAL_FLAG7 | COMPARE_UNORDERED_FLAG5);
       };
     }
     module2.exports = baseMatchesProperty2;
@@ -39055,9 +39055,9 @@ var require_baseProperty = __commonJS({
 var require_basePropertyDeep = __commonJS({
   "node_modules/lodash/_basePropertyDeep.js"(exports2, module2) {
     var baseGet2 = require_baseGet();
-    function basePropertyDeep2(path7) {
+    function basePropertyDeep2(path8) {
       return function(object) {
-        return baseGet2(object, path7);
+        return baseGet2(object, path8);
       };
     }
     module2.exports = basePropertyDeep2;
@@ -39071,8 +39071,8 @@ var require_property = __commonJS({
     var basePropertyDeep2 = require_basePropertyDeep();
     var isKey2 = require_isKey();
     var toKey2 = require_toKey();
-    function property2(path7) {
-      return isKey2(path7) ? baseProperty2(toKey2(path7)) : basePropertyDeep2(path7);
+    function property2(path8) {
+      return isKey2(path8) ? baseProperty2(toKey2(path8)) : basePropertyDeep2(path8);
     }
     module2.exports = property2;
   }
@@ -39134,8 +39134,8 @@ var require_has = __commonJS({
   "node_modules/lodash/has.js"(exports2, module2) {
     var baseHas2 = require_baseHas();
     var hasPath2 = require_hasPath();
-    function has2(object, path7) {
-      return object != null && hasPath2(object, path7, baseHas2);
+    function has2(object, path8) {
+      return object != null && hasPath2(object, path8, baseHas2);
     }
     module2.exports = has2;
   }
@@ -41409,14 +41409,14 @@ var require_baseSet = __commonJS({
     var isIndex2 = require_isIndex();
     var isObject2 = require_isObject();
     var toKey2 = require_toKey();
-    function baseSet2(object, path7, value, customizer) {
+    function baseSet2(object, path8, value, customizer) {
       if (!isObject2(object)) {
         return object;
       }
-      path7 = castPath2(path7, object);
-      var index = -1, length = path7.length, lastIndex = length - 1, nested = object;
+      path8 = castPath2(path8, object);
+      var index = -1, length = path8.length, lastIndex = length - 1, nested = object;
       while (nested != null && ++index < length) {
-        var key = toKey2(path7[index]), newValue = value;
+        var key = toKey2(path8[index]), newValue = value;
         if (key === "__proto__" || key === "constructor" || key === "prototype") {
           return object;
         }
@@ -41424,7 +41424,7 @@ var require_baseSet = __commonJS({
           var objValue = nested[key];
           newValue = customizer ? customizer(objValue, key, nested) : void 0;
           if (newValue === void 0) {
-            newValue = isObject2(objValue) ? objValue : isIndex2(path7[index + 1]) ? [] : {};
+            newValue = isObject2(objValue) ? objValue : isIndex2(path8[index + 1]) ? [] : {};
           }
         }
         assignValue2(nested, key, newValue);
@@ -41445,9 +41445,9 @@ var require_basePickBy = __commonJS({
     function basePickBy2(object, paths, predicate) {
       var index = -1, length = paths.length, result = {};
       while (++index < length) {
-        var path7 = paths[index], value = baseGet2(object, path7);
-        if (predicate(value, path7)) {
-          baseSet2(result, castPath2(path7, object), value);
+        var path8 = paths[index], value = baseGet2(object, path8);
+        if (predicate(value, path8)) {
+          baseSet2(result, castPath2(path8, object), value);
         }
       }
       return result;
@@ -41462,8 +41462,8 @@ var require_basePick = __commonJS({
     var basePickBy2 = require_basePickBy();
     var hasIn2 = require_hasIn();
     function basePick(object, paths) {
-      return basePickBy2(object, paths, function(value, path7) {
-        return hasIn2(object, path7);
+      return basePickBy2(object, paths, function(value, path8) {
+        return hasIn2(object, path8);
       });
     }
     module2.exports = basePick;
@@ -42517,15 +42517,15 @@ var require_parent_dummy_chains = __commonJS({
         var node = g.node(v);
         var edgeObj = node.edgeObj;
         var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
-        var path7 = pathData.path;
+        var path8 = pathData.path;
         var lca = pathData.lca;
         var pathIdx = 0;
-        var pathV = path7[pathIdx];
+        var pathV = path8[pathIdx];
         var ascending = true;
         while (v !== edgeObj.w) {
           node = g.node(v);
           if (ascending) {
-            while ((pathV = path7[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) {
+            while ((pathV = path8[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) {
               pathIdx++;
             }
             if (pathV === lca) {
@@ -42533,10 +42533,10 @@ var require_parent_dummy_chains = __commonJS({
             }
           }
           if (!ascending) {
-            while (pathIdx < path7.length - 1 && g.node(pathV = path7[pathIdx + 1]).minRank <= node.rank) {
+            while (pathIdx < path8.length - 1 && g.node(pathV = path8[pathIdx + 1]).minRank <= node.rank) {
               pathIdx++;
             }
-            pathV = path7[pathIdx];
+            pathV = path8[pathIdx];
           }
           g.setParent(v, pathV);
           v = g.successors(v)[0];
@@ -44709,8 +44709,8 @@ var init_svg_generator = __esm({
           elements.push(this.generateNodeWithPad(node, padX, padY));
         }
         for (const edge of layout.edges) {
-          const { path: path7, overlay } = this.generateEdge(edge, padX, padY, nodeMap);
-          elements.push(path7);
+          const { path: path8, overlay } = this.generateEdge(edge, padX, padY, nodeMap);
+          elements.push(path8);
           if (overlay)
             overlays.push(overlay);
         }
@@ -51026,8 +51026,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path7) {
-      let input = path7;
+    function removeDotSegments(path8) {
+      let input = path8;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -51226,8 +51226,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path7, query2] = wsComponent.resourceName.split("?");
-        wsComponent.path = path7 && path7 !== "/" ? path7 : void 0;
+        const [path8, query2] = wsComponent.resourceName.split("?");
+        wsComponent.path = path8 && path8 !== "/" ? path8 : void 0;
         wsComponent.query = query2;
         wsComponent.resourceName = void 0;
       }
@@ -54570,7 +54570,7 @@ function validateJsonResponse(response, options = {}) {
       }
       if (!valid) {
         const formattedErrors = validate2.errors.map((err) => {
-          const path7 = err.instancePath ? err.instancePath.substring(1).replace(/\//g, ".") : "<root>";
+          const path8 = err.instancePath ? err.instancePath.substring(1).replace(/\//g, ".") : "<root>";
           let message = "";
           let suggestion = "";
           if (err.keyword === "additionalProperties") {
@@ -54608,7 +54608,7 @@ function validateJsonResponse(response, options = {}) {
             message = err.message;
             suggestion = "";
           }
-          const location = path7 ? `at '${path7}'` : "at root";
+          const location = path8 ? `at '${path8}'` : "at root";
           return suggestion ? `${location}: ${message} \u2192 ${suggestion}` : `${location}: ${message}`;
         });
         const errorSummary = formattedErrors.join("\n  ");
@@ -54931,7 +54931,7 @@ function extractMermaidFromJson(response) {
   }
   const diagrams = [];
   const jsonPaths = [];
-  function searchObject(obj, path7 = []) {
+  function searchObject(obj, path8 = []) {
     if (typeof obj === "string") {
       const mermaidPattern = /```mermaid([^\n`]*?)(?:\n|\\n)([\s\S]*?)```/gi;
       let match2;
@@ -54945,14 +54945,14 @@ function extractMermaidFromJson(response) {
           endIndex: match2.index + match2[0].length,
           attributes,
           isInJson: true,
-          jsonPath: path7.join(".")
+          jsonPath: path8.join(".")
         });
-        jsonPaths.push(path7.join("."));
+        jsonPaths.push(path8.join("."));
       }
     } else if (Array.isArray(obj)) {
-      obj.forEach((item, index) => searchObject(item, [...path7, `[${index}]`]));
+      obj.forEach((item, index) => searchObject(item, [...path8, `[${index}]`]));
     } else if (obj && typeof obj === "object") {
-      Object.entries(obj).forEach(([key, value]) => searchObject(value, [...path7, key]));
+      Object.entries(obj).forEach(([key, value]) => searchObject(value, [...path8, key]));
     }
   }
   searchObject(parsedJson);
@@ -55209,7 +55209,7 @@ async function tryMaidAutoFix(diagramContent, options = {}) {
   }
 }
 async function validateAndFixMermaidResponse(response, options = {}) {
-  const { schema, debug, path: path7, provider, model, tracer } = options;
+  const { schema, debug, path: path8, provider, model, tracer } = options;
   const startTime = Date.now();
   if (debug) {
     console.log(`[DEBUG] Mermaid validation: Starting maid-based validation for response (${response.length} chars)`);
@@ -55366,7 +55366,7 @@ ${maidResult.fixed}
     }
     const aiFixingStart = Date.now();
     const mermaidFixer = new MermaidFixingAgent({
-      path: path7,
+      path: path8,
       provider,
       model,
       debug,
@@ -55608,8 +55608,8 @@ Schema Validation Errors:
 ${validationResult.errorSummary}`;
         } else if (validationResult.schemaErrors && validationResult.schemaErrors.length > 0) {
           const errors = validationResult.schemaErrors.map((err) => {
-            const path7 = err.instancePath || "(root)";
-            return `  ${path7}: ${err.message}`;
+            const path8 = err.instancePath || "(root)";
+            return `  ${path8}: ${err.message}`;
           }).join("\n");
           schemaErrorDetails = `
 
@@ -55844,6 +55844,126 @@ Provide only the corrected Mermaid diagram within a mermaid code block. Do not a
   }
 });
 
+// src/agent/shared/prompts.js
+var predefinedPrompts;
+var init_prompts = __esm({
+  "src/agent/shared/prompts.js"() {
+    "use strict";
+    predefinedPrompts = {
+      "code-explorer": `You are ProbeChat Code Explorer - an AI assistant focused on reading and explaining code using Probe's semantic search capabilities.
+
+Your primary role is to explore codebases, understand code structure, and provide clear explanations. You should:
+
+1. Use the 'search' tool to find relevant code snippets across the codebase
+2. Use the 'query' tool to locate specific symbols, functions, or classes
+3. Use the 'extract' tool to get full context for files or specific code blocks
+4. Explain code behavior, architecture patterns, and relationships between components
+5. Provide concise summaries with key insights highlighted
+
+When exploring code:
+- Start with targeted searches to find relevant areas
+- Extract full context when you need to understand implementation details
+- Trace function calls and data flow to understand how components interact
+- Focus on "why" and "how" rather than just describing what the code does
+
+You should NOT:
+- Make changes to the codebase (read-only access)
+- Execute or run code
+- Make assumptions without verifying through search/query/extract`,
+      "architect": `You are ProbeChat Architect - a senior software architect specialized in analyzing and designing software systems.
+
+Your role is to:
+
+1. Analyze existing codebases to understand architecture patterns and design decisions
+2. Identify architectural issues, technical debt, and improvement opportunities
+3. Propose refactoring strategies and architectural changes
+4. Design new features that fit well with existing architecture
+5. Create high-level architecture diagrams and documentation
+
+When analyzing architecture:
+- Use search/query/extract to understand component boundaries and dependencies
+- Identify layers, modules, and their responsibilities
+- Look for patterns like MVC, microservices, event-driven, etc.
+- Assess coupling, cohesion, and separation of concerns
+- Consider scalability, maintainability, and testability
+
+When proposing changes:
+- Provide clear rationale backed by architectural principles
+- Consider migration paths and backwards compatibility
+- Identify risks and tradeoffs
+- Suggest incremental implementation steps`,
+      "code-review": `You are ProbeChat Code Reviewer - a meticulous code reviewer focused on quality, best practices, and maintainability.
+
+Your role is to:
+
+1. Review code changes for correctness, clarity, and best practices
+2. Identify bugs, security issues, and performance problems
+3. Suggest improvements for readability and maintainability
+4. Ensure consistency with project conventions and patterns
+5. Verify test coverage and edge case handling
+
+When reviewing code:
+- Use search to find similar patterns in the codebase for consistency
+- Look for common issues: null checks, error handling, resource leaks
+- Check for security vulnerabilities: injection, XSS, etc.
+- Assess complexity and suggest simplifications
+- Verify naming conventions and code organization
+
+Provide constructive feedback:
+- Start with what's good about the code
+- Be specific about issues with examples
+- Suggest concrete improvements with code snippets
+- Prioritize critical issues over style preferences
+- Explain the "why" behind your suggestions`,
+      "engineer": `You are a senior engineer who helps implement features and fix bugs.
+
+Your role is to:
+
+1. Implement new features following project conventions
+2. Fix bugs by understanding root causes
+3. Refactor code to improve quality
+4. Write clear, maintainable code
+5. Add appropriate tests and documentation
+
+When implementing:
+- Use search/query to understand existing patterns
+- Follow the project's coding style and conventions
+- Consider edge cases and error handling
+- Write self-documenting code with clear names
+- Add comments for complex logic
+
+You have access to:
+- search: Find relevant code patterns
+- query: Locate specific symbols/functions
+- extract: Get full file context
+- implement: Create or modify files (use carefully)
+- delegate: Break down complex tasks`,
+      "support": `You are ProbeChat Support - a helpful assistant focused on answering questions about codebases.
+
+Your role is to:
+
+1. Answer questions about how code works
+2. Help users locate specific functionality
+3. Explain error messages and debugging approaches
+4. Guide users to relevant documentation
+5. Provide examples and usage patterns
+
+When helping users:
+- Ask clarifying questions if the request is ambiguous
+- Use search/query to find relevant code quickly
+- Provide clear, step-by-step explanations
+- Include code examples when helpful
+- Point to relevant files and line numbers
+
+You should be:
+- Patient and encouraging
+- Clear and concise
+- Thorough but not overwhelming
+- Honest about limitations (say "I don't know" when appropriate)`
+    };
+  }
+});
+
 // src/agent/mcp/config.js
 import { readFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync } from "fs";
 import { join as join2, dirname as dirname3 } from "path";
@@ -57380,6 +57500,1471 @@ var init_contextCompactor = __esm({
   }
 });
 
+// src/agent/mcp/built-in-server.js
+import { createServer } from "http";
+import { EventEmitter as EventEmitter3 } from "events";
+import { randomUUID as randomUUID4 } from "crypto";
+import { Server as MCPServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  isInitializeRequest
+} from "@modelcontextprotocol/sdk/types.js";
+var InMemoryEventStore, BuiltInMCPServer;
+var init_built_in_server = __esm({
+  "src/agent/mcp/built-in-server.js"() {
+    "use strict";
+    InMemoryEventStore = class {
+      constructor() {
+        this.events = /* @__PURE__ */ new Map();
+      }
+      generateEventId(streamId) {
+        return `${streamId}_${Date.now()}_${Math.random().toString(36).substring(2, 10)}`;
+      }
+      getStreamIdFromEventId(eventId) {
+        const parts = eventId.split("_");
+        return parts.length > 0 ? parts[0] : "";
+      }
+      async storeEvent(streamId, message) {
+        const eventId = this.generateEventId(streamId);
+        this.events.set(eventId, { streamId, message });
+        return eventId;
+      }
+      async replayEventsAfter(lastEventId, { send }) {
+        if (!lastEventId || !this.events.has(lastEventId)) {
+          return "";
+        }
+        const streamId = this.getStreamIdFromEventId(lastEventId);
+        if (!streamId) {
+          return "";
+        }
+        let foundLastEvent = false;
+        const sortedEvents = [...this.events.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+        for (const [eventId, { streamId: eventStreamId, message }] of sortedEvents) {
+          if (eventStreamId !== streamId) {
+            continue;
+          }
+          if (eventId === lastEventId) {
+            foundLastEvent = true;
+            continue;
+          }
+          if (foundLastEvent) {
+            await send(eventId, message);
+          }
+        }
+        return streamId;
+      }
+    };
+    BuiltInMCPServer = class extends EventEmitter3 {
+      constructor(agent, options = {}) {
+        super();
+        this.agent = agent;
+        this.port = options.port || 0;
+        this.host = options.host || "127.0.0.1";
+        this.httpServer = null;
+        this.mcpServer = null;
+        this.sseTransports = /* @__PURE__ */ new Map();
+        this.streamableTransports = /* @__PURE__ */ new Map();
+        this.connections = /* @__PURE__ */ new Set();
+        this.debug = options.debug || false;
+      }
+      /**
+       * Start the built-in MCP server
+       */
+      async start() {
+        this.httpServer = createServer();
+        this.httpServer.on("request", (req, res) => {
+          this.handleRequest(req, res);
+        });
+        this.mcpServer = new MCPServer({
+          name: "probe-builtin",
+          version: "1.0.0"
+        }, {
+          capabilities: {
+            tools: {}
+          }
+        });
+        this.registerHandlers();
+        return new Promise((resolve6, reject2) => {
+          this.httpServer.listen(this.port, this.host, async () => {
+            const address = this.httpServer.address();
+            this.port = address.port;
+            if (this.debug) {
+              console.log(`[MCP] Built-in server started at http://${this.host}:${this.port}`);
+              console.log(`[MCP] SSE endpoint: http://${this.host}:${this.port}/sse`);
+              console.log(`[MCP] Messages endpoint: http://${this.host}:${this.port}/messages`);
+            }
+            this.emit("ready", { host: this.host, port: this.port });
+            resolve6({ host: this.host, port: this.port });
+          });
+          this.httpServer.on("error", reject2);
+        });
+      }
+      /**
+       * Handle HTTP requests (SSE and JSON-RPC)
+       */
+      handleRequest(req, res) {
+        const { method, url } = req;
+        if (this.debug) {
+          console.log(`[MCP] Request: ${method} ${url}`);
+        }
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (method === "OPTIONS") {
+          res.writeHead(204);
+          res.end();
+          return;
+        }
+        if (url === "/sse" && method === "GET") {
+          if (this.debug) {
+            console.log("[MCP] Routing to handleSSEConnection");
+          }
+          this.handleSSEConnection(req, res);
+          return;
+        }
+        if (url.startsWith("/messages") && method === "POST") {
+          this.handleSSEMessage(req, res);
+          return;
+        }
+        if (url === "/rpc" && method === "POST") {
+          this.handleJSONRPC(req, res);
+          return;
+        }
+        if (url === "/mcp") {
+          this.handleStreamableHTTP(req, res);
+          return;
+        }
+        if (url === "/health") {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            status: "ok",
+            server: "probe-builtin-mcp",
+            tools: this.getToolCount()
+          }));
+          return;
+        }
+        res.writeHead(404);
+        res.end("Not Found");
+      }
+      /**
+       * Handle SSE connection (GET /sse) - creates new transport
+       */
+      async handleSSEConnection(req, res) {
+        if (this.debug) {
+          console.log("[MCP] New SSE connection request");
+        }
+        const transport = new SSEServerTransport("/messages", res);
+        this.sseTransports.set(transport.sessionId, transport);
+        res.on("close", () => {
+          if (this.debug) {
+            console.log("[MCP] SSE connection closed, sessionId:", transport.sessionId);
+          }
+          this.sseTransports.delete(transport.sessionId);
+        });
+        try {
+          await this.mcpServer.connect(transport);
+          if (this.debug) {
+            console.log("[MCP] MCP server connected to SSE transport, sessionId:", transport.sessionId);
+          }
+        } catch (error) {
+          if (this.debug) {
+            console.error("[MCP] Error connecting MCP server to transport:", error);
+          }
+          this.sseTransports.delete(transport.sessionId);
+        }
+      }
+      /**
+       * Handle SSE message (POST /messages?sessionId=...) - routes to existing transport
+       */
+      async handleSSEMessage(req, res) {
+        const url = new URL(req.url, `http://${req.headers.host}`);
+        const sessionId = url.searchParams.get("sessionId");
+        if (!sessionId) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Bad Request: sessionId query parameter is required"
+            },
+            id: null
+          }));
+          return;
+        }
+        const transport = this.sseTransports.get(sessionId);
+        if (!transport) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: `Bad Request: No transport found for sessionId: ${sessionId}`
+            },
+            id: null
+          }));
+          return;
+        }
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", async () => {
+          try {
+            const message = JSON.parse(body);
+            await transport.handlePostMessage(req, res, message);
+          } catch (error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              jsonrpc: "2.0",
+              error: {
+                code: -32603,
+                message: "Internal error",
+                data: error.message
+              },
+              id: null
+            }));
+          }
+        });
+      }
+      /**
+       * Handle Streamable HTTP protocol (GET/POST/DELETE on /mcp)
+       */
+      async handleStreamableHTTP(req, res) {
+        const { method } = req;
+        if (this.debug) {
+          console.log(`[MCP] Streamable HTTP ${method} request`);
+        }
+        try {
+          let body = null;
+          if (method === "POST") {
+            body = await this.parseRequestBody(req);
+          }
+          const sessionId = req.headers["mcp-session-id"];
+          let transport;
+          if (sessionId && this.streamableTransports.has(sessionId)) {
+            transport = this.streamableTransports.get(sessionId);
+            if (this.debug) {
+              console.log(`[MCP] Reusing existing transport for session: ${sessionId}`);
+            }
+          } else if (!sessionId && method === "POST" && body && isInitializeRequest(body)) {
+            if (this.debug) {
+              console.log("[MCP] Creating new Streamable HTTP transport for initialization");
+            }
+            const eventStore = new InMemoryEventStore();
+            transport = new StreamableHTTPServerTransport({
+              sessionIdGenerator: () => randomUUID4(),
+              eventStore,
+              // Enable resumability
+              onsessioninitialized: (newSessionId) => {
+                if (this.debug) {
+                  console.log(`[MCP] Streamable HTTP session initialized: ${newSessionId}`);
+                }
+                this.streamableTransports.set(newSessionId, transport);
+              },
+              onsessionclosed: (closedSessionId) => {
+                if (this.debug) {
+                  console.log(`[MCP] Streamable HTTP session closed: ${closedSessionId}`);
+                }
+                this.streamableTransports.delete(closedSessionId);
+              }
+            });
+            transport.onclose = () => {
+              const sid = transport.sessionId;
+              if (sid && this.streamableTransports.has(sid)) {
+                if (this.debug) {
+                  console.log(`[MCP] Transport closed for session ${sid}`);
+                }
+                this.streamableTransports.delete(sid);
+              }
+            };
+            await this.mcpServer.connect(transport);
+          } else {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              jsonrpc: "2.0",
+              error: {
+                code: -32e3,
+                message: "Bad Request: No valid session ID provided or not an initialization request"
+              },
+              id: null
+            }));
+            return;
+          }
+          await transport.handleRequest(req, res, body);
+        } catch (error) {
+          if (this.debug) {
+            console.error("[MCP] Error handling Streamable HTTP request:", error);
+          }
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              jsonrpc: "2.0",
+              error: {
+                code: -32603,
+                message: "Internal server error",
+                data: error.message
+              },
+              id: null
+            }));
+          }
+        }
+      }
+      /**
+       * Parse request body as JSON
+       */
+      async parseRequestBody(req) {
+        return new Promise((resolve6, reject2) => {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", () => {
+            try {
+              const parsed = body ? JSON.parse(body) : null;
+              resolve6(parsed);
+            } catch (error) {
+              reject2(error);
+            }
+          });
+          req.on("error", reject2);
+        });
+      }
+      /**
+       * Handle Server-Sent Events connection (DEPRECATED - use handleSSEConnection instead)
+       */
+      handleSSE(req, res) {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive"
+        });
+        res.write("event: connected\n");
+        res.write(`data: ${JSON.stringify({ type: "connected", server: "probe-builtin" })}
+
+`);
+        this.connections.add(res);
+        req.on("close", () => {
+          this.connections.delete(res);
+        });
+      }
+      /**
+       * Handle JSON-RPC requests
+       */
+      async handleJSONRPC(req, res) {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", async () => {
+          try {
+            const request = JSON.parse(body);
+            const response = await this.processRequest(request);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(response));
+          } catch (error) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              jsonrpc: "2.0",
+              error: {
+                code: -32700,
+                message: "Parse error",
+                data: error.message
+              },
+              id: null
+            }));
+          }
+        });
+      }
+      /**
+       * Handle MCP protocol messages
+       */
+      async handleMCPProtocol(req, res) {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", async () => {
+          try {
+            const message = JSON.parse(body);
+            let response;
+            if (message.method === "tools/list") {
+              response = await this.handleListTools();
+            } else if (message.method === "tools/call") {
+              response = await this.handleCallTool(message.params);
+            } else {
+              response = {
+                error: {
+                  code: -32601,
+                  message: "Method not found"
+                }
+              };
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(response));
+          } catch (error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              error: {
+                code: -32603,
+                message: "Internal error",
+                data: error.message
+              }
+            }));
+          }
+        });
+      }
+      /**
+       * Process JSON-RPC request
+       */
+      async processRequest(request) {
+        const { jsonrpc, method, params, id } = request;
+        try {
+          let result;
+          switch (method) {
+            case "tools/list":
+              result = await this.handleListTools();
+              break;
+            case "tools/call":
+              result = await this.handleCallTool(params);
+              break;
+            default:
+              return {
+                jsonrpc: "2.0",
+                error: {
+                  code: -32601,
+                  message: "Method not found"
+                },
+                id
+              };
+          }
+          return {
+            jsonrpc: "2.0",
+            result,
+            id
+          };
+        } catch (error) {
+          return {
+            jsonrpc: "2.0",
+            error: {
+              code: -32603,
+              message: "Internal error",
+              data: error.message
+            },
+            id
+          };
+        }
+      }
+      /**
+       * Register MCP protocol handlers
+       */
+      registerHandlers() {
+        this.mcpServer.setRequestHandler(ListToolsRequestSchema, async () => {
+          return this.handleListTools();
+        });
+        this.mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+          return this.handleCallTool(request.params);
+        });
+      }
+      /**
+       * Handle list tools request
+       */
+      async handleListTools() {
+        const tools2 = [];
+        if (this.agent && this.agent.allowedTools) {
+          const toolDefs = {
+            search: {
+              description: "Search for code patterns using semantic search",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  query: { type: "string", description: "Search query" },
+                  path: { type: "string", description: "Directory to search", default: "." },
+                  maxResults: { type: "integer", default: 10 }
+                },
+                required: ["query"]
+              }
+            },
+            extract: {
+              description: "Extract code from specific file location",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  path: { type: "string", description: "File path with optional line number" }
+                },
+                required: ["path"]
+              }
+            },
+            listFiles: {
+              description: "List files in a directory",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  path: { type: "string", description: "Directory path" },
+                  pattern: { type: "string", description: "File pattern" }
+                },
+                required: ["path"]
+              }
+            },
+            searchFiles: {
+              description: "Search for files by name pattern",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  pattern: { type: "string", description: "File name pattern" },
+                  path: { type: "string", description: "Directory to search" }
+                },
+                required: ["pattern"]
+              }
+            },
+            query: {
+              description: "Query code using AST patterns",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  query: { type: "string", description: "AST query" },
+                  path: { type: "string", description: "Directory to search" }
+                },
+                required: ["query"]
+              }
+            }
+          };
+          for (const [name, def] of Object.entries(toolDefs)) {
+            if (this.agent.allowedTools.isEnabled(name)) {
+              tools2.push({
+                name: `mcp__probe__${name}`,
+                description: def.description,
+                inputSchema: def.inputSchema
+              });
+            }
+          }
+        }
+        return { tools: tools2 };
+      }
+      /**
+       * Handle tool execution
+       */
+      async handleCallTool(params) {
+        const { name, arguments: args } = params;
+        const toolName = name.replace("mcp__probe__", "");
+        if (!this.agent.allowedTools.isEnabled(toolName)) {
+          throw new Error(`Tool ${name} is not enabled`);
+        }
+        const tool4 = this.agent.toolImplementations[toolName];
+        if (!tool4) {
+          throw new Error(`Tool ${name} not found`);
+        }
+        try {
+          const result = await tool4.execute(args);
+          return {
+            content: [{
+              type: "text",
+              text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+            }]
+          };
+        } catch (error) {
+          return {
+            content: [{
+              type: "text",
+              text: `Error executing ${name}: ${error.message}`
+            }],
+            isError: true
+          };
+        }
+      }
+      /**
+       * Get the number of available tools
+       */
+      getToolCount() {
+        if (!this.agent || !this.agent.allowedTools) {
+          return 0;
+        }
+        const tools2 = ["search", "extract", "listFiles", "searchFiles", "query"];
+        return tools2.filter((name) => this.agent.allowedTools.isEnabled(name)).length;
+      }
+      /**
+       * Broadcast message to all SSE connections
+       */
+      broadcast(event, data) {
+        const message = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+        for (const connection of this.connections) {
+          connection.write(message);
+        }
+      }
+      /**
+       * Stop the server
+       */
+      async stop() {
+        for (const [sessionId, transport] of this.streamableTransports.entries()) {
+          try {
+            await transport.close();
+            if (this.debug) {
+              console.log(`[MCP] Closed Streamable HTTP transport for session: ${sessionId}`);
+            }
+          } catch (error) {
+            if (this.debug) {
+              console.error(`[MCP] Error closing Streamable HTTP transport ${sessionId}:`, error);
+            }
+          }
+        }
+        this.streamableTransports.clear();
+        for (const [sessionId, transport] of this.sseTransports.entries()) {
+          try {
+            await transport.close();
+            if (this.debug) {
+              console.log(`[MCP] Closed SSE transport for session: ${sessionId}`);
+            }
+          } catch (error) {
+            if (this.debug) {
+              console.error(`[MCP] Error closing SSE transport ${sessionId}:`, error);
+            }
+          }
+        }
+        this.sseTransports.clear();
+        for (const connection of this.connections) {
+          connection.end();
+        }
+        this.connections.clear();
+        if (this.httpServer) {
+          return new Promise((resolve6) => {
+            this.httpServer.close(() => {
+              if (this.debug) {
+                console.log("[MCP] Built-in server stopped");
+              }
+              resolve6();
+            });
+          });
+        }
+      }
+      /**
+       * Get server configuration for MCP clients
+       */
+      getConfig() {
+        return {
+          transport: "http",
+          url: `http://${this.host}:${this.port}/mcp`
+          // Alternative transports:
+          // sse: `http://${this.host}:${this.port}/sse`,
+          // rpc: `http://${this.host}:${this.port}/rpc`
+        };
+      }
+    };
+  }
+});
+
+// src/agent/shared/Session.js
+var Session;
+var init_Session = __esm({
+  "src/agent/shared/Session.js"() {
+    "use strict";
+    Session = class {
+      constructor(id, debug = false) {
+        this.id = id;
+        this.conversationId = null;
+        this.messageCount = 0;
+        this.debug = debug;
+      }
+      /**
+       * Set the conversation ID for session resumption
+       * @param {string} conversationId - Provider's conversation/thread ID
+       */
+      setConversationId(conversationId) {
+        this.conversationId = conversationId;
+        if (this.debug) {
+          console.log(`[Session ${this.id}] Conversation ID: ${conversationId}`);
+        }
+      }
+      /**
+       * Increment the message count
+       */
+      incrementMessageCount() {
+        this.messageCount++;
+      }
+      /**
+       * Get session info as plain object
+       * @returns {Object} Session information
+       */
+      getInfo() {
+        return {
+          id: this.id,
+          conversationId: this.conversationId,
+          messageCount: this.messageCount
+        };
+      }
+      /**
+       * Get resume arguments for CLI commands (used by Claude Code)
+       * @returns {Array<string>} CLI arguments for resuming conversation
+       */
+      getResumeArgs() {
+        if (this.conversationId && this.messageCount > 0) {
+          return ["--resume", this.conversationId];
+        }
+        return [];
+      }
+    };
+  }
+});
+
+// src/agent/engines/enhanced-claude-code.js
+var enhanced_claude_code_exports = {};
+__export(enhanced_claude_code_exports, {
+  createEnhancedClaudeCLIEngine: () => createEnhancedClaudeCLIEngine
+});
+import { spawn as spawn3 } from "child_process";
+import { randomBytes } from "crypto";
+import fs7 from "fs/promises";
+import path7 from "path";
+import os3 from "os";
+import { EventEmitter as EventEmitter4 } from "events";
+async function createEnhancedClaudeCLIEngine(options = {}) {
+  const { agent, systemPrompt, customPrompt, debug, sessionId, allowedTools } = options;
+  const session = new Session(
+    sessionId || randomBytes(8).toString("hex"),
+    debug
+  );
+  let mcpServer = null;
+  let mcpConfigPath = null;
+  if (agent) {
+    mcpServer = new BuiltInMCPServer(agent, {
+      port: 0,
+      // Ephemeral port
+      host: "127.0.0.1",
+      debug
+    });
+    const { host, port } = await mcpServer.start();
+    if (debug) {
+      console.log("[DEBUG] Built-in MCP server started");
+      console.log("[DEBUG] MCP URL:", `http://${host}:${port}/mcp`);
+    }
+    mcpConfigPath = path7.join(os3.tmpdir(), `probe-mcp-${session.id}.json`);
+    const mcpConfig = {
+      mcpServers: {
+        probe: {
+          command: "node",
+          args: [path7.join(process.cwd(), "mcp-probe-server.js")],
+          env: {
+            PROBE_WORKSPACE: process.cwd(),
+            DEBUG: debug ? "true" : "false"
+          }
+        }
+      }
+    };
+    await fs7.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+  }
+  if (debug) {
+    console.log("[DEBUG] Enhanced Claude Code Engine");
+    console.log("[DEBUG] Session:", session.id);
+    console.log("[DEBUG] MCP Config:", mcpConfigPath);
+  }
+  const fullSystemPrompt = combinePrompts(systemPrompt, customPrompt, agent);
+  return {
+    sessionId: session.id,
+    session,
+    /**
+     * Query Claude with advanced streaming
+     */
+    async *query(prompt, opts = {}) {
+      const emitter = new EventEmitter4();
+      let buffer = "";
+      let processEnded = false;
+      let currentToolCall = null;
+      let isSchemaMode = false;
+      if (opts.schema || prompt.includes("JSON schema") || prompt.includes("mermaid diagram")) {
+        isSchemaMode = true;
+        if (debug) {
+          console.log("[DEBUG] Schema/validation mode - treating as black box");
+        }
+      }
+      let finalPrompt = prompt;
+      if (opts.schema && isSchemaMode) {
+        finalPrompt = `${prompt}
+
+Please provide your response in the following JSON format:
+${opts.schema}`;
+      }
+      const args = buildClaudeArgs({
+        systemPrompt: fullSystemPrompt,
+        mcpConfigPath,
+        session,
+        debug,
+        prompt: finalPrompt,
+        // Use finalPrompt which may include schema
+        allowedTools: allowedTools || opts.allowedTools
+        // Support tool filtering
+      });
+      if (debug) {
+        console.log("[DEBUG] Executing: claude", args.join(" "));
+      }
+      const shellCmd = `echo "" | claude ${args.map((arg) => {
+        if (typeof arg !== "string") {
+          throw new TypeError(`Invalid argument type: expected string, got ${typeof arg}`);
+        }
+        const escaped = arg.replace(/'/g, "'\\''");
+        return `'${escaped}'`;
+      }).join(" ")}`;
+      if (debug) {
+        console.log("[DEBUG] Shell command length:", shellCmd.length);
+        if (shellCmd.length < 500) {
+          console.log("[DEBUG] Shell command:", shellCmd);
+        } else {
+          console.log("[DEBUG] Shell command (truncated):", shellCmd.substring(0, 200) + "...");
+        }
+      }
+      const toolCollector = [];
+      const proc2 = spawn3("sh", ["-c", shellCmd], {
+        env: { ...process.env, FORCE_COLOR: "0" },
+        stdio: ["ignore", "pipe", "pipe"]
+        // Ignore stdin since echo handles it
+      });
+      proc2.stdout.on("data", (data) => {
+        buffer += data.toString();
+        processJsonBuffer(buffer, emitter, session, debug, toolCollector);
+        const lines = buffer.split("\n");
+        buffer = lines[lines.length - 1] || "";
+      });
+      proc2.stderr.on("data", (data) => {
+        const stderr = data.toString();
+        if (debug) {
+          console.error("[STDERR]", stderr);
+        }
+        if (stderr.includes("command not found")) {
+          emitter.emit("error", new Error("Claude Code not found. Please install it first."));
+        }
+      });
+      proc2.on("close", (code) => {
+        processEnded = true;
+        if (code !== 0 && debug) {
+          console.log(`[DEBUG] Process exited with code ${code}`);
+        }
+        if (buffer.trim()) {
+          processJsonBuffer(buffer, emitter, session, debug, toolCollector);
+        }
+        if (toolCollector.length > 0) {
+          emitter.emit("toolBatch", {
+            tools: toolCollector,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          if (debug) {
+            console.log(`[DEBUG] Emitting batch of ${toolCollector.length} tool events`);
+          }
+        }
+        emitter.emit("end");
+      });
+      proc2.on("error", (error) => {
+        emitter.emit("error", error);
+      });
+      const messageQueue = [];
+      let resolver = null;
+      emitter.on("message", (msg) => {
+        messageQueue.push(msg);
+        if (resolver) {
+          resolver();
+          resolver = null;
+        }
+      });
+      emitter.on("toolBatch", (batch) => {
+        messageQueue.push({ type: "toolBatch", ...batch });
+        if (resolver) {
+          resolver();
+          resolver = null;
+        }
+      });
+      emitter.on("end", () => {
+        processEnded = true;
+        if (resolver) {
+          resolver();
+          resolver = null;
+        }
+      });
+      emitter.on("error", (error) => {
+        messageQueue.push({ type: "error", error });
+        if (resolver) {
+          resolver();
+          resolver = null;
+        }
+      });
+      while (!processEnded || messageQueue.length > 0) {
+        if (messageQueue.length > 0) {
+          const msg = messageQueue.shift();
+          if (msg.type === "text") {
+            yield { type: "text", content: msg.content };
+          } else if (msg.type === "tool_use") {
+            currentToolCall = msg;
+            yield {
+              type: "text",
+              content: `
+\u{1F527} Using ${msg.name}: ${JSON.stringify(msg.input)}
+`
+            };
+            const result = await executeProbleTool(agent, msg.name, msg.input);
+            yield { type: "text", content: `${result}
+` };
+          } else if (msg.type === "toolBatch") {
+            yield { type: "toolBatch", tools: msg.tools, timestamp: msg.timestamp };
+          } else if (msg.type === "session_update") {
+            if (debug) {
+              console.log("[DEBUG] Session updated:", msg.conversationId);
+            }
+          } else if (msg.type === "error") {
+            yield { type: "error", error: msg.error };
+            break;
+          }
+        } else if (!processEnded) {
+          await new Promise((resolve6) => {
+            resolver = resolve6;
+          });
+        }
+      }
+      session.incrementMessageCount();
+      yield {
+        type: "metadata",
+        data: {
+          sessionId: session.id,
+          conversationId: session.conversationId,
+          messageCount: session.messageCount
+        }
+      };
+    },
+    /**
+     * Get session info
+     */
+    getSession() {
+      return session.getInfo();
+    },
+    /**
+     * Clean up - MUST be called to stop MCP server and clean resources
+     */
+    async close() {
+      try {
+        if (mcpServer) {
+          await mcpServer.stop();
+          if (debug) {
+            console.log("[DEBUG] Built-in MCP server stopped");
+          }
+        }
+        if (mcpConfigPath) {
+          await fs7.unlink(mcpConfigPath).catch(() => {
+          });
+          if (debug) {
+            console.log("[DEBUG] MCP config file removed");
+          }
+        }
+        if (debug) {
+          console.log("[DEBUG] Engine closed, session:", session.id);
+        }
+      } catch (error) {
+        if (debug) {
+          console.error("[DEBUG] Error during cleanup:", error.message);
+        }
+      }
+    }
+  };
+}
+function processJsonBuffer(buffer, emitter, session, debug, toolCollector = null) {
+  const lines = buffer.split("\n");
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      const messages = Array.isArray(parsed) ? parsed : [parsed];
+      for (const msg of messages) {
+        switch (msg.type) {
+          case "result":
+            if (msg.result) {
+              emitter.emit("message", { type: "text", content: msg.result });
+            }
+            if (msg.session_id) {
+              session.setConversationId(msg.session_id);
+              emitter.emit("message", { type: "session_update", conversationId: msg.session_id });
+            }
+            break;
+          case "conversation":
+            session.setConversationId(msg.id);
+            emitter.emit("message", { type: "session_update", conversationId: msg.id });
+            break;
+          case "text":
+            if (msg.text) {
+              emitter.emit("message", { type: "text", content: msg.text });
+            }
+            break;
+          case "assistant":
+            if (msg.message && msg.message.content) {
+              for (const content of msg.message.content) {
+                if (content.type === "text" && content.text) {
+                  emitter.emit("message", { type: "text", content: content.text });
+                } else if (content.type === "tool_use") {
+                  if (toolCollector) {
+                    toolCollector.push({
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                      name: content.name,
+                      args: content.input || {},
+                      id: content.id,
+                      status: "started"
+                    });
+                  }
+                  if (debug) {
+                    console.log("[DEBUG] Assistant internal tool use:", content.name);
+                  }
+                }
+              }
+            }
+            break;
+          case "tool_use":
+            if (toolCollector) {
+              toolCollector.push({
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                name: msg.name,
+                args: msg.input || {},
+                id: msg.id,
+                status: "started"
+              });
+            }
+            emitter.emit("message", {
+              type: "tool_use",
+              id: msg.id,
+              name: msg.name,
+              input: msg.input
+            });
+            break;
+          case "tool_result":
+            if (toolCollector && msg.tool_use_id) {
+              const toolCall = toolCollector.find((t) => t.id === msg.tool_use_id);
+              if (toolCall) {
+                toolCall.status = "completed";
+                toolCall.resultPreview = msg.content ? (typeof msg.content === "string" ? msg.content.substring(0, 200) : JSON.stringify(msg.content).substring(0, 200)) + "..." : "No Result";
+              }
+            }
+            if (debug) {
+              console.log("[DEBUG] Tool result:", msg);
+            }
+            break;
+          case "error":
+            emitter.emit("error", new Error(msg.message || "Unknown error"));
+            break;
+          default:
+            if (debug) {
+              console.log("[DEBUG] Unknown message type:", msg.type);
+              console.log("[DEBUG] Full message:", JSON.stringify(msg).substring(0, 200));
+            }
+        }
+      }
+    } catch (e) {
+      if (debug && line.trim()) {
+        console.log("[DEBUG] Non-JSON output:", line);
+      }
+    }
+  }
+}
+function buildClaudeArgs({ systemPrompt, mcpConfigPath, session, debug, prompt, allowedTools }) {
+  const args = [
+    "-p",
+    // Short form of --print
+    prompt,
+    // The prompt text goes right after -p
+    "--output-format",
+    "json"
+  ];
+  const resumeArgs = session.getResumeArgs();
+  if (resumeArgs.length > 0) {
+    args.push(...resumeArgs);
+  }
+  if (systemPrompt) {
+    args.push("--system-prompt", systemPrompt);
+  }
+  args.push("--mcp-config", mcpConfigPath);
+  if (allowedTools && Array.isArray(allowedTools) && allowedTools.length > 0) {
+    const mcpTools = allowedTools.map(
+      (tool4) => tool4.startsWith("mcp__") ? tool4 : `mcp__probe__${tool4}`
+    ).join(",");
+    args.push("--allowedTools", mcpTools);
+  } else {
+    args.push("--allowedTools", "mcp__probe__*");
+  }
+  if (debug) {
+    args.push("--verbose");
+  }
+  return args;
+}
+async function executeProbleTool(agent, toolName, params) {
+  if (!agent || !agent.toolImplementations) {
+    return "Tool execution not available";
+  }
+  const name = toolName.replace(/^mcp__probe__/, "");
+  const tool4 = agent.toolImplementations[name];
+  if (!tool4) {
+    return `Unknown tool: ${name}`;
+  }
+  try {
+    const result = await tool4.execute(params);
+    return typeof result === "string" ? result : JSON.stringify(result, null, 2);
+  } catch (error) {
+    return `Tool error: ${error.message}`;
+  }
+}
+function combinePrompts(systemPrompt, customPrompt, agent) {
+  if (!systemPrompt && customPrompt) {
+    return customPrompt;
+  }
+  if (systemPrompt && customPrompt) {
+    return systemPrompt + "\n\n## Additional Instructions\n" + customPrompt;
+  }
+  return systemPrompt || "";
+}
+var init_enhanced_claude_code = __esm({
+  "src/agent/engines/enhanced-claude-code.js"() {
+    "use strict";
+    init_built_in_server();
+    init_Session();
+  }
+});
+
+// src/agent/engines/codex.js
+var codex_exports = {};
+__export(codex_exports, {
+  createCodexEngine: () => createCodexEngine
+});
+import { spawn as spawn4 } from "child_process";
+import { randomBytes as randomBytes2 } from "crypto";
+import { createInterface } from "readline";
+async function createCodexEngine(options = {}) {
+  const { agent, systemPrompt, customPrompt, debug, sessionId, allowedTools, model } = options;
+  const session = new Session(
+    sessionId || randomBytes2(8).toString("hex"),
+    debug
+  );
+  let mcpServer = null;
+  let mcpServerUrl = null;
+  let mcpServerName = null;
+  if (agent) {
+    mcpServer = new BuiltInMCPServer(agent, {
+      port: 0,
+      host: "127.0.0.1",
+      debug
+    });
+    const { host, port } = await mcpServer.start();
+    mcpServerUrl = `http://${host}:${port}/mcp`;
+    mcpServerName = `probe_${session.id}`;
+    if (debug) {
+      console.log("[DEBUG] Built-in Probe MCP server started");
+      console.log("[DEBUG] Probe MCP URL:", mcpServerUrl);
+    }
+  }
+  if (debug) {
+    console.log("[DEBUG] Starting Codex MCP server...");
+  }
+  const codexProcess = spawn4("codex", ["mcp-server"], {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  let requestId = 0;
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const eventHandlers = /* @__PURE__ */ new Map();
+  const stdoutReader = createInterface({
+    input: codexProcess.stdout,
+    crlfDelay: Infinity
+  });
+  stdoutReader.on("line", (line) => {
+    try {
+      const message = JSON.parse(line);
+      if (debug) {
+        if (message.method === "codex/event") {
+          console.log(`[DEBUG] Codex event: ${message.params?.msg?.type}`);
+        }
+      }
+      if (message.id !== void 0 && pendingRequests.has(message.id)) {
+        const { resolve: resolve6, reject: reject2 } = pendingRequests.get(message.id);
+        pendingRequests.delete(message.id);
+        if (message.error) {
+          reject2(new Error(message.error.message || JSON.stringify(message.error)));
+        } else {
+          resolve6(message.result);
+        }
+      }
+      if (message.method === "codex/event" && message.params) {
+        const requestId2 = message.params._meta?.requestId;
+        if (requestId2 !== void 0 && eventHandlers.has(requestId2)) {
+          eventHandlers.get(requestId2)(message.params);
+        }
+      }
+    } catch (e) {
+      if (debug) {
+        console.error("[DEBUG] Failed to parse message:", line);
+      }
+    }
+  });
+  if (debug) {
+    codexProcess.stderr.on("data", (data) => {
+      console.error("[CODEX STDERR]", data.toString());
+    });
+  }
+  function sendRequest(method, params = {}) {
+    return new Promise((resolve6, reject2) => {
+      const id = ++requestId;
+      const request = {
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      };
+      pendingRequests.set(id, { resolve: resolve6, reject: reject2 });
+      setTimeout(() => {
+        if (pendingRequests.has(id)) {
+          pendingRequests.delete(id);
+          reject2(new Error(`Request ${method} timed out after 10 minutes`));
+        }
+      }, 6e5);
+      codexProcess.stdin.write(JSON.stringify(request) + "\n");
+    });
+  }
+  await sendRequest("initialize", {
+    protocolVersion: "2024-11-05",
+    capabilities: { tools: {} },
+    clientInfo: {
+      name: "probe-codex-client",
+      version: "1.0.0"
+    }
+  });
+  if (debug) {
+    console.log("[DEBUG] Connected to Codex MCP server");
+    console.log("[DEBUG] Session:", session.id);
+  }
+  const fullPrompt = combinePrompts2(systemPrompt, customPrompt, agent);
+  return {
+    sessionId: session.id,
+    session,
+    /**
+     * Query Codex via MCP protocol with event streaming
+     */
+    async *query(prompt, opts = {}) {
+      let finalPrompt = prompt;
+      if (!session.conversationId && fullPrompt) {
+        finalPrompt = `${fullPrompt}
+
+${prompt}`;
+      }
+      const isFollowUp = session.conversationId !== null;
+      const toolName = isFollowUp ? "codex-reply" : "codex";
+      const toolArgs = { prompt: finalPrompt };
+      if (isFollowUp) {
+        toolArgs.conversationId = session.conversationId;
+        if (debug) {
+          console.log(`[DEBUG] Follow-up with conversationId: ${session.conversationId}`);
+        }
+      } else {
+        if (model) {
+          toolArgs.model = model;
+        }
+        if (mcpServerUrl && mcpServerName) {
+          toolArgs.config = {
+            mcp_servers: {
+              [mcpServerName]: { url: mcpServerUrl }
+            }
+          };
+        }
+        if (debug) {
+          console.log(`[DEBUG] Initial query with tool: ${toolName}`);
+        }
+      }
+      try {
+        const reqId = requestId + 1;
+        let fullResponse = "";
+        let gotSessionId = false;
+        const eventPromise = new Promise((resolve6) => {
+          eventHandlers.set(reqId, (eventParams) => {
+            const msg = eventParams.msg;
+            if (msg.type === "session_configured" && msg.session_id && !gotSessionId) {
+              session.setConversationId(msg.session_id);
+              gotSessionId = true;
+            }
+            if (msg.type === "raw_response_item" && msg.item?.role === "assistant") {
+              const content = msg.item.content;
+              if (Array.isArray(content)) {
+                for (const part of content) {
+                  if (part.type === "text" && part.text) {
+                    fullResponse += part.text;
+                  }
+                }
+              }
+            }
+          });
+          setTimeout(() => {
+            eventHandlers.delete(reqId);
+            resolve6();
+          }, 6e5);
+        });
+        const resultPromise = sendRequest("tools/call", {
+          name: toolName,
+          arguments: toolArgs
+        });
+        const result = await resultPromise;
+        eventHandlers.delete(reqId);
+        if (result && result.content && Array.isArray(result.content)) {
+          for (const item of result.content) {
+            if (item.type === "text" && item.text) {
+              yield {
+                type: "text",
+                content: item.text
+              };
+              fullResponse = item.text;
+            }
+          }
+        }
+        if (fullResponse && (!result.content || result.content.length === 0)) {
+          yield {
+            type: "text",
+            content: fullResponse
+          };
+        }
+        session.incrementMessageCount();
+        yield {
+          type: "metadata",
+          data: {
+            sessionId: session.id,
+            conversationId: session.conversationId,
+            messageCount: session.messageCount
+          }
+        };
+      } catch (error) {
+        if (debug) {
+          console.error("[DEBUG] Codex query error:", error);
+        }
+        yield {
+          type: "error",
+          error
+        };
+      }
+    },
+    /**
+     * Get session info
+     */
+    getSession() {
+      return session.getInfo();
+    },
+    /**
+     * Clean up resources
+     */
+    async close() {
+      try {
+        if (stdoutReader) {
+          stdoutReader.close();
+          if (debug) {
+            console.log("[DEBUG] Closed stdout reader");
+          }
+        }
+        pendingRequests.clear();
+        eventHandlers.clear();
+        if (codexProcess && !codexProcess.killed) {
+          codexProcess.kill();
+          if (debug) {
+            console.log("[DEBUG] Killed Codex MCP server process");
+          }
+        }
+        if (mcpServer) {
+          await mcpServer.stop();
+          if (debug) {
+            console.log("[DEBUG] Stopped Probe MCP server");
+          }
+        }
+        if (debug) {
+          console.log("[DEBUG] Engine closed, session:", session.id);
+        }
+      } catch (error) {
+        if (debug) {
+          console.error("[DEBUG] Error during cleanup:", error.message);
+        }
+      }
+    }
+  };
+}
+function combinePrompts2(systemPrompt, customPrompt, agent) {
+  if (!systemPrompt && customPrompt) {
+    return customPrompt;
+  }
+  if (systemPrompt && customPrompt) {
+    return systemPrompt + "\n\n## Additional Instructions\n" + customPrompt;
+  }
+  return systemPrompt || "";
+}
+var init_codex = __esm({
+  "src/agent/engines/codex.js"() {
+    "use strict";
+    init_built_in_server();
+    init_Session();
+  }
+});
+
+// src/agent/engines/enhanced-vercel.js
+var enhanced_vercel_exports = {};
+__export(enhanced_vercel_exports, {
+  createEnhancedVercelEngine: () => createEnhancedVercelEngine
+});
+import { streamText } from "ai";
+function createEnhancedVercelEngine(agent) {
+  return {
+    /**
+     * Query the model using existing Vercel AI SDK implementation
+     * @param {string} prompt - The prompt to send
+     * @param {Object} options - Additional options
+     * @returns {AsyncIterable} Response stream
+     */
+    async *query(prompt, options = {}) {
+      const systemMessage = await agent.getSystemMessage();
+      const messages = [
+        { role: "system", content: systemMessage },
+        ...agent.history,
+        { role: "user", content: prompt }
+      ];
+      const result = await agent.streamTextWithRetryAndFallback({
+        model: agent.provider(agent.model),
+        messages,
+        maxTokens: options.maxTokens || agent.maxResponseTokens,
+        temperature: options.temperature || 0.3,
+        // Note: Vercel AI SDK doesn't use structured tools for XML format
+        // The tools are embedded in the system prompt
+        experimental_telemetry: options.telemetry
+      });
+      let fullContent = "";
+      for await (const chunk of result.textStream) {
+        fullContent += chunk;
+        yield { type: "text", content: chunk };
+      }
+      const toolCalls = agent.parseXmlToolCalls ? agent.parseXmlToolCalls(fullContent) : null;
+      if (toolCalls && toolCalls.length > 0) {
+        yield { type: "tool_calls", toolCalls };
+      }
+      if (result.finishReason) {
+        yield { type: "finish", reason: result.finishReason };
+      }
+    },
+    /**
+     * Get available tools for this engine
+     */
+    getTools() {
+      return agent.toolImplementations || {};
+    },
+    /**
+     * Get system prompt for this engine
+     */
+    async getSystemPrompt() {
+      return agent.getSystemMessage();
+    },
+    /**
+     * Optional cleanup
+     */
+    async close() {
+    }
+  };
+}
+var init_enhanced_vercel = __esm({
+  "src/agent/engines/enhanced-vercel.js"() {
+    "use strict";
+  }
+});
+
 // src/agent/ProbeAgent.js
 var ProbeAgent_exports = {};
 __export(ProbeAgent_exports, {
@@ -57390,9 +58975,9 @@ import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
 import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
 import { createGoogleGenerativeAI as createGoogleGenerativeAI2 } from "@ai-sdk/google";
 import { createAmazonBedrock as createAmazonBedrock2 } from "@ai-sdk/amazon-bedrock";
-import { streamText } from "ai";
-import { randomUUID as randomUUID4 } from "crypto";
-import { EventEmitter as EventEmitter3 } from "events";
+import { streamText as streamText2 } from "ai";
+import { randomUUID as randomUUID5 } from "crypto";
+import { EventEmitter as EventEmitter5 } from "events";
 import { existsSync as existsSync5 } from "fs";
 import { readFile, stat } from "fs/promises";
 import { resolve as resolve4, isAbsolute as isAbsolute2, dirname as dirname4 } from "path";
@@ -57411,6 +58996,7 @@ var init_ProbeAgent = __esm({
     init_index();
     init_schemaUtils();
     init_xmlParsingUtils();
+    init_prompts();
     init_mcp();
     init_RetryManager();
     init_FallbackManager();
@@ -57432,6 +59018,7 @@ var init_ProbeAgent = __esm({
        * @param {Object} options - Configuration options
        * @param {string} [options.sessionId] - Optional session ID
        * @param {string} [options.customPrompt] - Custom prompt to replace the default system message
+       * @param {string} [options.systemPrompt] - Alias for customPrompt; takes precedence when both are provided
        * @param {string} [options.promptType] - Predefined prompt type (architect, code-review, support)
        * @param {boolean} [options.allowEdit=false] - Allow the use of the 'implement' tool
        * @param {boolean} [options.enableDelegate=false] - Enable the delegate tool for task distribution to subagents
@@ -57466,8 +59053,8 @@ var init_ProbeAgent = __esm({
        * @param {number} [options.fallback.maxTotalAttempts=10] - Maximum total attempts across all providers
        */
       constructor(options = {}) {
-        this.sessionId = options.sessionId || randomUUID4();
-        this.customPrompt = options.customPrompt || null;
+        this.sessionId = options.sessionId || randomUUID5();
+        this.customPrompt = options.systemPrompt || options.customPrompt || null;
         this.promptType = options.promptType || "code-explorer";
         this.allowEdit = !!options.allowEdit;
         this.enableDelegate = !!options.enableDelegate;
@@ -57517,7 +59104,7 @@ var init_ProbeAgent = __esm({
         this.history = [];
         this.pendingImages = /* @__PURE__ */ new Map();
         this.currentImages = [];
-        this.events = new EventEmitter3();
+        this.events = new EventEmitter5();
         this.enableMcp = !!options.enableMcp || process.env.ENABLE_MCP === "1";
         this.mcpConfigPath = options.mcpConfigPath || null;
         this.mcpConfig = options.mcpConfig || null;
@@ -57528,6 +59115,7 @@ var init_ProbeAgent = __esm({
         this.retryManager = null;
         this.fallbackConfig = options.fallback || null;
         this.fallbackManager = null;
+        this.engine = null;
         this.initializeModel();
       }
       /**
@@ -57590,6 +59178,33 @@ var init_ProbeAgent = __esm({
        * This method initializes MCP and merges MCP tools into the tool list, and loads history from storage
        */
       async initialize() {
+        if (!this.provider && !this.clientApiProvider && this.apiType !== "claude-code" && this.apiType !== "codex") {
+          if (this.apiType === "uninitialized") {
+            const claudeAvailable = await this.isClaudeCommandAvailable();
+            const codexAvailable = await this.isCodexCommandAvailable();
+            if (claudeAvailable) {
+              if (this.debug) {
+                console.log("[DEBUG] No API keys found, but claude command detected");
+                console.log("[DEBUG] Auto-switching to claude-code provider");
+              }
+              this.clientApiProvider = "claude-code";
+              this.provider = null;
+              this.model = this.clientApiModel || "claude-3-5-sonnet-20241022";
+              this.apiType = "claude-code";
+            } else if (codexAvailable) {
+              if (this.debug) {
+                console.log("[DEBUG] No API keys found, but codex command detected");
+                console.log("[DEBUG] Auto-switching to codex provider");
+              }
+              this.clientApiProvider = "codex";
+              this.provider = null;
+              this.model = this.clientApiModel || "gpt-4o";
+              this.apiType = "codex";
+            } else {
+              throw new Error("No API key provided and neither claude nor codex command found. Please either:\n1. Set an API key: ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, or AWS credentials\n2. Install claude command from https://docs.claude.com/en/docs/claude-code\n3. Install codex command from https://openai.com/codex");
+            }
+          }
+        }
         try {
           const history = await this.storageAdapter.loadHistory(this.sessionId);
           this.history = history;
@@ -57706,6 +59321,40 @@ var init_ProbeAgent = __esm({
           console.error("[DEBUG] ========================================\n");
         }
       }
+      /**
+       * Check if claude command is available on the system
+       * Uses execFile instead of exec to avoid shell injection risks
+       * @returns {Promise<boolean>} True if claude command is available
+       * @private
+       */
+      async isClaudeCommandAvailable() {
+        try {
+          const { execFile: execFile3 } = await import("child_process");
+          const { promisify: promisify8 } = await import("util");
+          const execFileAsync3 = promisify8(execFile3);
+          await execFileAsync3("claude", ["--version"], { timeout: 5e3 });
+          return true;
+        } catch (error) {
+          return false;
+        }
+      }
+      /**
+       * Check if codex command is available on the system
+       * Uses execFile instead of exec to avoid shell injection risks
+       * @returns {Promise<boolean>} True if codex command is available
+       * @private
+       */
+      async isCodexCommandAvailable() {
+        try {
+          const { execFile: execFile3 } = await import("child_process");
+          const { promisify: promisify8 } = await import("util");
+          const execFileAsync3 = promisify8(execFile3);
+          await execFileAsync3("codex", ["--version"], { timeout: 5e3 });
+          return true;
+        } catch (error) {
+          return false;
+        }
+      }
       /**
        * Initialize the AI model based on available API keys and forced provider setting
        */
@@ -57715,6 +59364,29 @@ var init_ProbeAgent = __esm({
           this.initializeMockModel(modelName);
           return;
         }
+        if (this.clientApiProvider === "claude-code" || process.env.USE_CLAUDE_CODE === "true") {
+          this.provider = null;
+          this.model = modelName || "claude-3-5-sonnet-20241022";
+          this.apiType = "claude-code";
+          if (this.debug) {
+            console.log("[DEBUG] Claude Code engine selected - will use built-in access if available");
+          }
+          return;
+        }
+        if (this.clientApiProvider === "codex" || process.env.USE_CODEX === "true") {
+          this.provider = null;
+          this.model = modelName || null;
+          this.apiType = "codex";
+          if (this.debug) {
+            console.log("[DEBUG] Codex CLI engine selected - will use built-in access if available");
+            if (this.model) {
+              console.log(`[DEBUG] Using model: ${this.model}`);
+            } else {
+              console.log("[DEBUG] Using Codex account default model");
+            }
+          }
+          return;
+        }
         const anthropicApiKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN;
         const openaiApiKey = process.env.OPENAI_API_KEY;
         const googleApiKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GOOGLE_API_KEY;
@@ -57772,7 +59444,10 @@ var init_ProbeAgent = __esm({
           this.initializeBedrockModel(awsAccessKeyId, awsSecretAccessKey, awsRegion, awsSessionToken, awsApiKey, awsBedrockBaseUrl, modelName);
           this.initializeFallbackManager("bedrock", modelName);
         } else {
-          throw new Error("No API key provided. Please set ANTHROPIC_API_KEY (or ANTHROPIC_AUTH_TOKEN), OPENAI_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY (or GOOGLE_API_KEY), AWS credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION), or AWS_BEDROCK_API_KEY environment variables.");
+          this.apiType = "uninitialized";
+          if (this.debug) {
+            console.log("[DEBUG] No API keys found - will check for claude command in initialize()");
+          }
         }
       }
       /**
@@ -57835,6 +59510,82 @@ var init_ProbeAgent = __esm({
        * @private
        */
       async streamTextWithRetryAndFallback(options) {
+        if (this.clientApiProvider === "claude-code" || process.env.USE_CLAUDE_CODE === "true") {
+          try {
+            const engine = await this.getEngine();
+            if (engine && engine.query) {
+              const userMessages = options.messages.filter(
+                (m) => m.role === "user" && !m.content.includes("WARNING: You have reached the maximum tool iterations limit")
+              );
+              const lastUserMessage = userMessages[userMessages.length - 1];
+              const prompt = lastUserMessage ? lastUserMessage.content : "";
+              const engineOptions = {
+                maxTokens: options.maxTokens,
+                temperature: options.temperature,
+                messages: options.messages,
+                systemPrompt: options.messages.find((m) => m.role === "system")?.content
+              };
+              const engineStream = engine.query(prompt, engineOptions);
+              async function* createTextStream() {
+                for await (const message of engineStream) {
+                  if (message.type === "text" && message.content) {
+                    yield message.content;
+                  } else if (typeof message === "string") {
+                    yield message;
+                  }
+                }
+              }
+              return {
+                textStream: createTextStream(),
+                usage: Promise.resolve({})
+                // Engine should handle its own usage tracking
+                // Add other streamText-compatible properties as needed
+              };
+            }
+          } catch (error) {
+            if (this.debug) {
+              console.log(`[DEBUG] Failed to use Claude Code engine, falling back to Vercel:`, error.message);
+            }
+          }
+        }
+        if (this.clientApiProvider === "codex" || process.env.USE_CODEX === "true") {
+          try {
+            const engine = await this.getEngine();
+            if (engine && engine.query) {
+              const userMessages = options.messages.filter(
+                (m) => m.role === "user" && !m.content.includes("WARNING: You have reached the maximum tool iterations limit")
+              );
+              const lastUserMessage = userMessages[userMessages.length - 1];
+              const prompt = lastUserMessage ? lastUserMessage.content : "";
+              const engineOptions = {
+                maxTokens: options.maxTokens,
+                temperature: options.temperature,
+                messages: options.messages,
+                systemPrompt: options.messages.find((m) => m.role === "system")?.content
+              };
+              const engineStream = engine.query(prompt, engineOptions);
+              async function* createTextStream() {
+                for await (const message of engineStream) {
+                  if (message.type === "text" && message.content) {
+                    yield message.content;
+                  } else if (typeof message === "string") {
+                    yield message;
+                  }
+                }
+              }
+              return {
+                textStream: createTextStream(),
+                usage: Promise.resolve({})
+                // Engine should handle its own usage tracking
+                // Add other streamText-compatible properties as needed
+              };
+            }
+          } catch (error) {
+            if (this.debug) {
+              console.log(`[DEBUG] Failed to use Codex engine, falling back to Vercel:`, error.message);
+            }
+          }
+        }
         if (!this.retryManager) {
           this.retryManager = new RetryManager({
             maxRetries: this.retryConfig.maxRetries ?? 3,
@@ -57847,7 +59598,7 @@ var init_ProbeAgent = __esm({
         }
         if (!this.fallbackManager) {
           return await this.retryManager.executeWithRetry(
-            () => streamText(options),
+            () => streamText2(options),
             {
               provider: this.apiType,
               model: this.model
@@ -57869,7 +59620,7 @@ var init_ProbeAgent = __esm({
               debug: this.debug
             });
             return await providerRetryManager.executeWithRetry(
-              () => streamText(fallbackOptions),
+              () => streamText2(fallbackOptions),
               {
                 provider: config.provider,
                 model
@@ -57951,6 +59702,104 @@ var init_ProbeAgent = __esm({
           console.log(`Using AWS Bedrock API with model: ${this.model}${regionInfo} [Auth: ${authMethod}]${baseUrlInfo}`);
         }
       }
+      /**
+       * Get or create the AI engine based on configuration
+       * @returns {Promise<Object>} Engine interface
+       * @private
+       */
+      async getEngine() {
+        if (this.engine) {
+          return this.engine;
+        }
+        if (this.clientApiProvider === "claude-code" || process.env.USE_CLAUDE_CODE === "true") {
+          try {
+            const { createEnhancedClaudeCLIEngine: createEnhancedClaudeCLIEngine2 } = await Promise.resolve().then(() => (init_enhanced_claude_code(), enhanced_claude_code_exports));
+            const systemPrompt = this.customPrompt || this.getClaudeNativeSystemPrompt();
+            this.engine = await createEnhancedClaudeCLIEngine2({
+              agent: this,
+              // Pass reference to ProbeAgent for tool access
+              systemPrompt,
+              customPrompt: this.customPrompt,
+              sessionId: this.options?.sessionId,
+              debug: this.debug,
+              allowedTools: this.allowedTools
+              // Pass tool filtering configuration
+            });
+            if (this.debug) {
+              console.log("[DEBUG] Using Claude Code engine with Probe tools");
+              if (this.customPrompt) {
+                console.log("[DEBUG] Using custom prompt/persona");
+              }
+            }
+            return this.engine;
+          } catch (error) {
+            console.warn("[WARNING] Failed to load Claude Code engine:", error.message);
+            console.warn("[WARNING] Falling back to Vercel AI SDK");
+            this.clientApiProvider = null;
+          }
+        }
+        if (this.clientApiProvider === "codex" || process.env.USE_CODEX === "true") {
+          try {
+            const { createCodexEngine: createCodexEngine2 } = await Promise.resolve().then(() => (init_codex(), codex_exports));
+            const systemPrompt = this.customPrompt || this.getCodexNativeSystemPrompt();
+            this.engine = await createCodexEngine2({
+              agent: this,
+              // Pass reference to ProbeAgent for tool access
+              systemPrompt,
+              customPrompt: this.customPrompt,
+              sessionId: this.options?.sessionId,
+              debug: this.debug,
+              allowedTools: this.allowedTools,
+              // Pass tool filtering configuration
+              model: this.model
+              // Pass model name (e.g., gpt-4o, o3, etc.)
+            });
+            if (this.debug) {
+              console.log("[DEBUG] Using Codex CLI engine with Probe tools");
+              if (this.customPrompt) {
+                console.log("[DEBUG] Using custom prompt/persona");
+              }
+            }
+            return this.engine;
+          } catch (error) {
+            console.warn("[WARNING] Failed to load Codex CLI engine:", error.message);
+            console.warn("[WARNING] Falling back to Vercel AI SDK");
+            this.clientApiProvider = null;
+          }
+        }
+        const { createEnhancedVercelEngine: createEnhancedVercelEngine2 } = await Promise.resolve().then(() => (init_enhanced_vercel(), enhanced_vercel_exports));
+        this.engine = createEnhancedVercelEngine2(this);
+        if (this.debug) {
+          console.log("[DEBUG] Using Vercel AI SDK engine");
+        }
+        return this.engine;
+      }
+      /**
+       * Get session information including thread ID for resumability
+       * @returns {Object} Session info with sessionId, threadId, messageCount
+       */
+      getSessionInfo() {
+        if (this.engine && this.engine.getSession) {
+          return this.engine.getSession();
+        }
+        return {
+          id: this.sessionId,
+          threadId: null,
+          messageCount: 0
+        };
+      }
+      /**
+       * Close the agent and clean up resources (e.g., MCP servers)
+       * @returns {Promise<void>}
+       */
+      async close() {
+        if (this.engine && this.engine.close) {
+          await this.engine.close();
+        }
+        if (this.mcpBridge) {
+          this.mcpBridge = null;
+        }
+      }
       /**
        * Process assistant response content and detect/load image references
        * @param {string} content - The assistant's response content
@@ -58237,6 +60086,105 @@ var init_ProbeAgent = __esm({
           this.mcpBridge = null;
         }
       }
+      /**
+       * Get system prompt for Claude native engines (CLI/SDK) without XML formatting
+       * These engines have native MCP support and don't need XML instructions
+       */
+      getClaudeNativeSystemPrompt() {
+        let systemPrompt = "";
+        if (this.customPrompt) {
+          systemPrompt += this.customPrompt + "\n\n";
+        } else if (this.promptType && predefinedPrompts[this.promptType]) {
+          systemPrompt += predefinedPrompts[this.promptType] + "\n\n";
+        } else {
+          systemPrompt += predefinedPrompts["code-explorer"] + "\n\n";
+        }
+        systemPrompt += `You have access to powerful code search and analysis tools through MCP:
+- search: Find code patterns using semantic search
+- extract: Extract specific code sections with context
+- query: Use AST patterns for structural code matching
+- listFiles: Browse directory contents
+- searchFiles: Find files by name patterns`;
+        if (this.enableBash) {
+          systemPrompt += `
+- bash: Execute bash commands for system operations`;
+        }
+        systemPrompt += `
+
+When exploring code:
+1. Start with search to find relevant code patterns
+2. Use extract to get detailed context when needed
+3. Prefer focused, specific searches over broad queries
+4. Combine multiple tools to build complete understanding`;
+        if (this.allowedFolders && this.allowedFolders.length > 0) {
+          systemPrompt += `
+
+Workspace: ${this.allowedFolders.join(", ")}`;
+        }
+        if (this.fileList) {
+          systemPrompt += `
+
+# Repository Structure
+`;
+          systemPrompt += `You are working with a repository located at: ${this.allowedFolders[0]}
+
+`;
+          systemPrompt += `Here's an overview of the repository structure (showing up to 100 most relevant files):
+
+`;
+          systemPrompt += "```\n" + this.fileList + "\n```\n";
+        }
+        return systemPrompt;
+      }
+      /**
+       * Get system prompt for Codex CLI (similar to Claude but optimized for Codex)
+       */
+      getCodexNativeSystemPrompt() {
+        let systemPrompt = "";
+        if (this.customPrompt) {
+          systemPrompt += this.customPrompt + "\n\n";
+        } else if (this.promptType && predefinedPrompts[this.promptType]) {
+          systemPrompt += predefinedPrompts[this.promptType] + "\n\n";
+        } else {
+          systemPrompt += predefinedPrompts["code-explorer"] + "\n\n";
+        }
+        systemPrompt += `You have access to powerful code search and analysis tools through MCP:
+- search: Find code patterns using semantic search
+- extract: Extract specific code sections with context
+- query: Use AST patterns for structural code matching
+- listFiles: Browse directory contents
+- searchFiles: Find files by name patterns`;
+        if (this.enableBash) {
+          systemPrompt += `
+- bash: Execute bash commands for system operations`;
+        }
+        systemPrompt += `
+
+When exploring code:
+1. Start with search to find relevant code patterns
+2. Use extract to get detailed context when needed
+3. Prefer focused, specific searches over broad queries
+4. Combine multiple tools to build complete understanding`;
+        if (this.allowedFolders && this.allowedFolders.length > 0) {
+          systemPrompt += `
+
+Workspace: ${this.allowedFolders.join(", ")}`;
+        }
+        if (this.fileList) {
+          systemPrompt += `
+
+# Repository Structure
+`;
+          systemPrompt += `You are working with a repository located at: ${this.allowedFolders[0]}
+
+`;
+          systemPrompt += `Here's an overview of the repository structure (showing up to 100 most relevant files):
+
+`;
+          systemPrompt += "```\n" + this.fileList + "\n```\n";
+        }
+        return systemPrompt;
+      }
       /**
        * Get the system message with instructions for the AI (XML Tool Format)
        */
@@ -58394,7 +60342,7 @@ Follow these instructions carefully:
     - Use 'create' for new files or complete file rewrites` : ""}
 </instructions>
 `;
-        const predefinedPrompts = {
+        const predefinedPrompts2 = {
           "code-explorer": `You are ProbeChat Code Explorer, a specialized AI assistant focused on helping developers, product managers, and QAs understand and navigate codebases. Your primary function is to answer questions based on code, explain how systems work, and provide insights into code functionality using the provided code analysis tools.
 
 When exploring code:
@@ -58450,14 +60398,14 @@ When troubleshooting:
           if (this.debug) {
             console.log(`[DEBUG] Using custom prompt`);
           }
-        } else if (this.promptType && predefinedPrompts[this.promptType]) {
-          systemMessage = "<role>" + predefinedPrompts[this.promptType] + "</role>";
+        } else if (this.promptType && predefinedPrompts2[this.promptType]) {
+          systemMessage = "<role>" + predefinedPrompts2[this.promptType] + "</role>";
           if (this.debug) {
             console.log(`[DEBUG] Using predefined prompt: ${this.promptType}`);
           }
           systemMessage += commonInstructions;
         } else {
-          systemMessage = "<role>" + predefinedPrompts["code-explorer"] + "</role>";
+          systemMessage = "<role>" + predefinedPrompts2["code-explorer"] + "</role>";
           if (this.debug) {
             console.log(`[DEBUG] Using default prompt: code explorer`);
           }
@@ -58597,6 +60545,112 @@ You are working with a repository located at: ${searchDirectory}
           let finalResult = "I was unable to complete your request due to reaching the maximum number of tool iterations.";
           const baseMaxIterations = this.maxIterations || MAX_TOOL_ITERATIONS;
           const maxIterations = options.schema ? baseMaxIterations + 4 : baseMaxIterations;
+          const isClaudeCode = this.clientApiProvider === "claude-code" || process.env.USE_CLAUDE_CODE === "true";
+          const isCodex = this.clientApiProvider === "codex" || process.env.USE_CODEX === "true";
+          if (isClaudeCode) {
+            if (this.debug) {
+              console.log(`[DEBUG] Using Claude Code engine - bypassing tool loop (black box mode)`);
+              console.log(`[DEBUG] Sending question directly to Claude Code: ${message.substring(0, 100)}...`);
+            }
+            try {
+              const engine = await this.getEngine();
+              if (engine && engine.query) {
+                let assistantResponseContent = "";
+                let toolBatch = null;
+                for await (const chunk of engine.query(message, options)) {
+                  if (chunk.type === "text" && chunk.content) {
+                    assistantResponseContent += chunk.content;
+                    if (options.onStream) {
+                      options.onStream(chunk.content);
+                    }
+                  } else if (chunk.type === "toolBatch" && chunk.tools) {
+                    toolBatch = chunk.tools;
+                    if (this.debug) {
+                      console.log(`[DEBUG] Received batch of ${chunk.tools.length} tool events from Claude Code`);
+                    }
+                  } else if (chunk.type === "error") {
+                    throw chunk.error;
+                  }
+                }
+                if (toolBatch && toolBatch.length > 0 && this.events) {
+                  if (this.debug) {
+                    console.log(`[DEBUG] Emitting ${toolBatch.length} tool events from Claude Code batch`);
+                  }
+                  for (const toolEvent of toolBatch) {
+                    this.events.emit("toolCall", toolEvent);
+                  }
+                }
+                this.history.push(userMessage);
+                this.history.push({
+                  role: "assistant",
+                  content: assistantResponseContent
+                });
+                await this.hooks.emit(HOOK_TYPES.COMPLETION, {
+                  sessionId: this.sessionId,
+                  prompt: message,
+                  response: assistantResponseContent
+                });
+                return assistantResponseContent;
+              }
+            } catch (error) {
+              if (this.debug) {
+                console.error("[DEBUG] Claude Code error:", error);
+              }
+              throw error;
+            }
+          }
+          if (isCodex) {
+            if (this.debug) {
+              console.log(`[DEBUG] Using Codex engine - bypassing tool loop (black box mode)`);
+              console.log(`[DEBUG] Sending question directly to Codex: ${message.substring(0, 100)}...`);
+            }
+            try {
+              const engine = await this.getEngine();
+              if (engine && engine.query) {
+                let assistantResponseContent = "";
+                let toolBatch = null;
+                for await (const chunk of engine.query(message, options)) {
+                  if (chunk.type === "text" && chunk.content) {
+                    assistantResponseContent += chunk.content;
+                    if (options.onStream) {
+                      options.onStream(chunk.content);
+                    }
+                  } else if (chunk.type === "toolBatch" && chunk.tools) {
+                    toolBatch = chunk.tools;
+                    if (this.debug) {
+                      console.log(`[DEBUG] Received batch of ${chunk.tools.length} tool events from Codex`);
+                    }
+                  } else if (chunk.type === "error") {
+                    throw chunk.error;
+                  }
+                }
+                if (toolBatch && toolBatch.length > 0 && this.events) {
+                  if (this.debug) {
+                    console.log(`[DEBUG] Emitting ${toolBatch.length} tool events from Codex batch`);
+                  }
+                  for (const toolEvent of toolBatch) {
+                    this.events.emit("toolCall", toolEvent);
+                  }
+                }
+                this.history.push(userMessage);
+                this.history.push({
+                  role: "assistant",
+                  content: assistantResponseContent
+                });
+                await this.hooks.emit(HOOK_TYPES.COMPLETION, {
+                  sessionId: this.sessionId,
+                  prompt: message,
+                  response: assistantResponseContent
+                });
+                return assistantResponseContent;
+              }
+            } catch (error) {
+              if (this.debug) {
+                console.error("[DEBUG] Codex error:", error);
+              }
+              throw error;
+            }
+          }
           if (this.debug) {
             console.log(`[DEBUG] Starting agentic flow for question: ${message.substring(0, 100)}...`);
             if (options.schema) {
@@ -58655,7 +60709,7 @@ You are working with a repository located at: ${searchDirectory}
                 const executeAIRequest = async () => {
                   const messagesForAI = this.prepareMessagesWithImages(currentMessages);
                   const result = await this.streamTextWithRetryAndFallback({
-                    model: this.provider(this.model),
+                    model: this.provider ? this.provider(this.model) : this.model,
                     messages: messagesForAI,
                     maxTokens: maxResponseTokens,
                     temperature: 0.3
@@ -59477,7 +61531,7 @@ Convert your previous response content into actual JSON data that follows this s
        */
       clone(options = {}) {
         const {
-          sessionId = randomUUID4(),
+          sessionId = randomUUID5(),
           stripInternalMessages = true,
           keepSystemMessage = true,
           deepCopy = true,
@@ -59686,20 +61740,20 @@ import dotenv3 from "dotenv";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
-  CallToolRequestSchema,
+  CallToolRequestSchema as CallToolRequestSchema2,
   ErrorCode as ErrorCode2,
   InitializeRequestSchema,
-  ListToolsRequestSchema,
+  ListToolsRequestSchema as ListToolsRequestSchema2,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
 import { readFileSync as readFileSync2, existsSync as existsSync6 } from "fs";
 import { resolve as resolve5 } from "path";
 
 // src/agent/acp/server.js
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // src/agent/acp/connection.js
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
 
 // src/agent/acp/types.js
 var ACP_PROTOCOL_VERSION = "1";
@@ -59816,7 +61870,7 @@ function validateMessage(message) {
 }
 
 // src/agent/acp/connection.js
-var ACPConnection = class extends EventEmitter4 {
+var ACPConnection = class extends EventEmitter6 {
   constructor(inputStream = process.stdin, outputStream = process.stdout) {
     super();
     this.inputStream = inputStream;
@@ -60188,7 +62242,7 @@ var ACPServer = class {
    * Handle new session request
    */
   async handleNewSession(params) {
-    const sessionId = params?.sessionId || randomUUID5();
+    const sessionId = params?.sessionId || randomUUID6();
     const mode = params?.mode || SessionMode.NORMAL;
     const session = new ACPSession(sessionId, mode);
     this.sessions.set(sessionId, session);
@@ -60360,7 +62414,7 @@ var ACPServer = class {
 };
 
 // src/agent/acp/tools.js
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/agent/index.js
 dotenv3.config();
@@ -60655,7 +62709,7 @@ var ProbeAgentMcpServer = class {
         }
       };
     });
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    this.server.setRequestHandler(ListToolsRequestSchema2, async () => ({
       tools: [
         {
           name: "search_code",
@@ -60690,7 +62744,7 @@ var ProbeAgentMcpServer = class {
         }
       ]
     }));
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    this.server.setRequestHandler(CallToolRequestSchema2, async (request) => {
       if (request.params.name !== "search_code") {
         throw new McpError(
           ErrorCode2.MethodNotFound,