@probelabs/probe 0.6.0-rc165 → 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
@@ -17572,7 +17572,7 @@ function parseXmlToolCallWithThinking(xmlString, validTools) {
   }
   return parseXmlToolCall(cleanedXmlString, validTools);
 }
-var implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition;
+var implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition, readImageToolDefinition;
 var init_tools2 = __esm({
   "src/agent/tools.js"() {
     "use strict";
@@ -17650,6 +17650,29 @@ User: Find all markdown files in the docs directory, but only at the top level.
 <recursive>false</recursive>
 </searchFiles>
 
+</examples>
+`;
+    readImageToolDefinition = `
+## readImage
+Description: Read and load an image file so it can be viewed by the AI. Use this when you need to analyze, describe, or work with image content. Images from user messages are automatically loaded, but use this tool to explicitly read images mentioned in tool outputs or when you need to examine specific image files.
+
+Parameters:
+- path: (required) The path to the image file to read. Supports png, jpg, jpeg, webp, bmp, and svg formats.
+
+Usage Example:
+
+<examples>
+
+User: Can you describe what's in screenshot.png?
+<readImage>
+<path>screenshot.png</path>
+</readImage>
+
+User: Analyze the diagram in docs/architecture.svg
+<readImage>
+<path>docs/architecture.svg</path>
+</readImage>
+
 </examples>
 `;
   }
@@ -19444,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;
 }
@@ -19462,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;
@@ -20826,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;
     }
@@ -20856,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({
@@ -20869,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;
@@ -20908,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;
@@ -20922,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({
@@ -21542,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({
@@ -21749,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;
     }
@@ -21764,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);
@@ -21788,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;
@@ -21814,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;
@@ -24528,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);
     }
@@ -25703,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;
@@ -25750,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;
@@ -25993,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];
@@ -26299,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)) {
@@ -26311,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);
     });
@@ -38916,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;
     }
@@ -38932,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;
@@ -38959,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;
         }
@@ -38984,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;
   }
@@ -39003,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;
@@ -39032,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;
@@ -39048,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;
   }
@@ -39111,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;
   }
@@ -41386,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;
         }
@@ -41401,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);
@@ -41422,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;
@@ -41439,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;
@@ -42494,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) {
@@ -42510,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];
@@ -44686,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);
         }
@@ -51003,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;
@@ -51203,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;
       }
@@ -54547,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") {
@@ -54585,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  ");
@@ -54908,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;
@@ -54922,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);
@@ -55186,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)`);
@@ -55343,7 +55366,7 @@ ${maidResult.fixed}
     }
     const aiFixingStart = Date.now();
     const mermaidFixer = new MermaidFixingAgent({
-      path: path7,
+      path: path8,
       provider,
       model,
       debug,
@@ -55585,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 = `
 
@@ -57357,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, {
@@ -57367,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";
@@ -57494,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;
@@ -57505,6 +58431,7 @@ var init_ProbeAgent = __esm({
         this.retryManager = null;
         this.fallbackConfig = options.fallback || null;
         this.fallbackManager = null;
+        this.engine = null;
         this.initializeModel();
       }
       /**
@@ -57567,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;
@@ -57643,7 +58587,20 @@ var init_ProbeAgent = __esm({
           extract: wrappedTools.extractToolInstance,
           delegate: wrappedTools.delegateToolInstance,
           listFiles: listFilesToolInstance,
-          searchFiles: searchFilesToolInstance
+          searchFiles: searchFilesToolInstance,
+          readImage: {
+            execute: async (params) => {
+              const imagePath = params.path;
+              if (!imagePath) {
+                throw new Error("Image path is required");
+              }
+              const loaded = await this.loadImageIfValid(imagePath);
+              if (!loaded) {
+                throw new Error(`Failed to load image: ${imagePath}. The file may not exist, be too large, have an unsupported format, or be outside allowed directories.`);
+              }
+              return `Image loaded successfully: ${imagePath}. The image is now available for analysis in the conversation.`;
+            }
+          }
         };
         if (this.enableBash && wrappedTools.bashToolInstance) {
           this.toolImplementations.bash = wrappedTools.bashToolInstance;
@@ -57670,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
        */
@@ -57679,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;
@@ -57736,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()");
+          }
         }
       }
       /**
@@ -57799,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,
@@ -57811,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
@@ -57833,7 +58854,7 @@ var init_ProbeAgent = __esm({
               debug: this.debug
             });
             return await providerRetryManager.executeWithRetry(
-              () => streamText(fallbackOptions),
+              () => streamText2(fallbackOptions),
               {
                 provider: config.provider,
                 model
@@ -57915,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
@@ -58201,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)
        */
@@ -58246,6 +59359,10 @@ var init_ProbeAgent = __esm({
         }
         if (isToolAllowed("searchFiles")) {
           toolDefinitions += `${searchFilesToolDefinition}
+`;
+        }
+        if (isToolAllowed("readImage")) {
+          toolDefinitions += `${readImageToolDefinition}
 `;
         }
         if (this.allowEdit && isToolAllowed("implement")) {
@@ -58333,6 +59450,7 @@ Available Tools:
 - extract: Extract specific code blocks or lines from files.
 - listFiles: List files and directories in a specified location.
 - searchFiles: Find files matching a glob pattern with recursive search capability.
+- readImage: Read and load an image file for AI analysis.
 ${this.allowEdit ? "- implement: Implement a feature or fix a bug using aider.\n- edit: Edit files using exact string replacement.\n- create: Create new files with specified content.\n" : ""}${this.enableDelegate ? "- delegate: Delegate big distinct tasks to specialized probe subagents.\n" : ""}${this.enableBash ? "- bash: Execute bash commands for system operations.\n" : ""}
 - attempt_completion: Finalize the task and provide the result to the user.
 - attempt_complete: Quick completion using previous response (shorthand).
@@ -58556,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) {
@@ -58614,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
@@ -58690,15 +59861,13 @@ You are working with a repository located at: ${searchDirectory}
               const assistantPreview = createMessagePreview(assistantResponseContent);
               console.log(`[DEBUG] Assistant response (${assistantResponseContent.length} chars): ${assistantPreview}`);
             }
-            if (assistantResponseContent) {
-              await this.processImageReferences(assistantResponseContent);
-            }
             const validTools = [];
             if (this.allowedTools.isEnabled("search")) validTools.push("search");
             if (this.allowedTools.isEnabled("query")) validTools.push("query");
             if (this.allowedTools.isEnabled("extract")) validTools.push("extract");
             if (this.allowedTools.isEnabled("listFiles")) validTools.push("listFiles");
             if (this.allowedTools.isEnabled("searchFiles")) validTools.push("searchFiles");
+            if (this.allowedTools.isEnabled("readImage")) validTools.push("readImage");
             if (this.allowedTools.isEnabled("attempt_completion")) validTools.push("attempt_completion");
             if (this.allowEdit && this.allowedTools.isEnabled("implement")) {
               validTools.push("implement", "edit", "create");
@@ -59647,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";
@@ -59660,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";
@@ -59777,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;
@@ -60616,7 +61785,7 @@ var ProbeAgentMcpServer = class {
         }
       };
     });
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    this.server.setRequestHandler(ListToolsRequestSchema2, async () => ({
       tools: [
         {
           name: "search_code",
@@ -60651,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,