@probelabs/probe 0.6.0-rc166 → 0.6.0-rc167

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}"`);
@@ -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 = `
 
@@ -57380,6 +57380,909 @@ var init_contextCompactor = __esm({
   }
 });
 
+// src/agent/mcp/built-in-server.js
+import { createServer } from "http";
+import { EventEmitter as EventEmitter3 } from "events";
+import { Server as MCPServer } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var BuiltInMCPServer;
+var init_built_in_server = __esm({
+  "src/agent/mcp/built-in-server.js"() {
+    "use strict";
+    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.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, () => {
+            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}`);
+            }
+            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;
+        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") {
+          this.handleSSE(req, res);
+          return;
+        }
+        if (url === "/rpc" && method === "POST") {
+          this.handleJSONRPC(req, res);
+          return;
+        }
+        if (url === "/mcp" && method === "POST") {
+          this.handleMCPProtocol(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 Server-Sent Events connection
+       */
+      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 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/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 ClaudeSession(
+    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 {
+        id: session.id,
+        conversationId: session.conversationId,
+        messageCount: session.messageCount
+      };
+    },
+    /**
+     * 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 ClaudeSession;
+var init_enhanced_claude_code = __esm({
+  "src/agent/engines/enhanced-claude-code.js"() {
+    "use strict";
+    init_built_in_server();
+    ClaudeSession = class {
+      constructor(id, debug = false) {
+        this.id = id;
+        this.conversationId = null;
+        this.messageCount = 0;
+        this.debug = debug;
+      }
+      /**
+       * Update session with Claude's conversation ID
+       */
+      setConversationId(convId) {
+        this.conversationId = convId;
+        if (this.debug) {
+          console.log(`[Session ${this.id}] Conversation ID: ${convId}`);
+        }
+      }
+      /**
+       * Get resume arguments for continuing conversation
+       */
+      getResumeArgs() {
+        if (this.conversationId && this.messageCount > 0) {
+          return ["--resume", this.conversationId];
+        }
+        return [];
+      }
+      incrementMessageCount() {
+        this.messageCount++;
+      }
+    };
+  }
+});
+
+// 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 +58293,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 { streamText as streamText2 } from "ai";
 import { randomUUID as randomUUID4 } from "crypto";
-import { EventEmitter as EventEmitter3 } from "events";
+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";
@@ -57517,7 +58420,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 +58431,7 @@ var init_ProbeAgent = __esm({
         this.retryManager = null;
         this.fallbackConfig = options.fallback || null;
         this.fallbackManager = null;
+        this.engine = null;
         this.initializeModel();
       }
       /**
@@ -57590,6 +58494,23 @@ 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") {
+          if (this.apiType === "uninitialized") {
+            const claudeAvailable = await this.isClaudeCommandAvailable();
+            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 {
+              throw new Error("No API key provided and claude command not 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");
+            }
+          }
+        }
         try {
           const history = await this.storageAdapter.loadHistory(this.sessionId);
           this.history = history;
@@ -57706,6 +58627,20 @@ var init_ProbeAgent = __esm({
           console.error("[DEBUG] ========================================\n");
         }
       }
+      /**
+       * Check if claude command is available on the system
+       * @returns {Promise<boolean>} True if claude command is available
+       * @private
+       */
+      async isClaudeCommandAvailable() {
+        try {
+          const { execSync } = await import("child_process");
+          execSync("claude --version", { stdio: "ignore" });
+          return true;
+        } catch (error) {
+          return false;
+        }
+      }
       /**
        * Initialize the AI model based on available API keys and forced provider setting
        */
@@ -57715,6 +58650,15 @@ 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;
+        }
         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 +58716,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 +58782,44 @@ 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.retryManager) {
           this.retryManager = new RetryManager({
             maxRetries: this.retryConfig.maxRetries ?? 3,
@@ -57847,7 +58832,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 +58854,7 @@ var init_ProbeAgent = __esm({
               debug: this.debug
             });
             return await providerRetryManager.executeWithRetry(
-              () => streamText(fallbackOptions),
+              () => streamText2(fallbackOptions),
               {
                 provider: config.provider,
                 model
@@ -57951,6 +58936,49 @@ 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;
+          }
+        }
+        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;
+      }
       /**
        * Process assistant response content and detect/load image references
        * @param {string} content - The assistant's response content
@@ -58237,6 +59265,55 @@ 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.predefinedPrompt) {
+          const personaPrompt = getPromptByType(this.predefinedPrompt);
+          if (personaPrompt?.system) {
+            systemPrompt += personaPrompt.system + "\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)
        */
@@ -58597,6 +59674,59 @@ 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";
+          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 (this.debug) {
             console.log(`[DEBUG] Starting agentic flow for question: ${message.substring(0, 100)}...`);
             if (options.schema) {
@@ -58655,7 +59785,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
@@ -59686,10 +60816,10 @@ 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";
@@ -59699,7 +60829,7 @@ import { resolve as resolve5 } from "path";
 import { randomUUID as randomUUID5 } 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 +60946,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;
@@ -60655,7 +61785,7 @@ var ProbeAgentMcpServer = class {
         }
       };
     });
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    this.server.setRequestHandler(ListToolsRequestSchema2, async () => ({
       tools: [
         {
           name: "search_code",
@@ -60690,7 +61820,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,