@probelabs/probe 0.6.0-rc159 → 0.6.0-rc162

package/build/agent/index.js

@@ -552,6 +552,162 @@ var init_BytePairEncodingCore = __esm({
   }
 });
 
+// node_modules/gpt-tokenizer/esm/functionCalling.js
+function countMessageTokens(message, countStringTokens) {
+  let tokens = 0;
+  if (message.role) {
+    tokens += countStringTokens(message.role);
+  }
+  if (message.content) {
+    tokens += countStringTokens(message.content);
+  }
+  if (message.name) {
+    tokens += countStringTokens(message.name) + MESSAGE_NAME_TOKEN_OVERHEAD;
+  }
+  if (message.function_call) {
+    const { name, arguments: args } = message.function_call;
+    if (name) {
+      tokens += countStringTokens(name);
+    }
+    if (args) {
+      tokens += countStringTokens(args);
+    }
+    tokens += FUNCTION_CALL_METADATA_TOKEN_OVERHEAD;
+  }
+  tokens += MESSAGE_TOKEN_OVERHEAD;
+  if (message.role === "function") {
+    tokens -= FUNCTION_ROLE_TOKEN_DISCOUNT;
+  }
+  return tokens;
+}
+function formatObjectProperties(obj, indent, formatType) {
+  if (!obj.properties) {
+    return "";
+  }
+  const lines = [];
+  const requiredParams = new Set(obj.required ?? []);
+  const indentString = " ".repeat(indent);
+  for (const [name, param] of Object.entries(obj.properties)) {
+    if (param.description && indent < 2) {
+      lines.push(`${indentString}// ${param.description}`);
+    }
+    const isRequired = requiredParams.has(name);
+    const formattedType = formatType(param, indent);
+    lines.push(`${indentString}${name}${isRequired ? "" : "?"}: ${formattedType},`);
+  }
+  return lines.join("\n");
+}
+function formatFunctionType(param, indent) {
+  switch (param.type) {
+    case "string":
+      return param.enum?.map((value) => JSON.stringify(value)).join(" | ") ?? "string";
+    case "integer":
+    case "number":
+      return param.enum?.map((value) => `${value}`).join(" | ") ?? "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "array":
+      return param.items ? `${formatFunctionType(param.items, indent)}[]` : "any[]";
+    case "object": {
+      const inner = formatObjectProperties(param, indent + 2, formatFunctionType);
+      const closingIndent = " ".repeat(indent);
+      return `{
+${inner}
+${closingIndent}}`;
+    }
+    default:
+      return "any";
+  }
+}
+function formatFunctionDefinitions(functions) {
+  const lines = ["namespace functions {", ""];
+  for (const fn of functions) {
+    if (fn.description) {
+      lines.push(`// ${fn.description}`);
+    }
+    const { parameters } = fn;
+    const properties = parameters?.properties;
+    if (!parameters || !properties || Object.keys(properties).length === 0) {
+      lines.push(`type ${fn.name} = () => any;`);
+    } else {
+      lines.push(`type ${fn.name} = (_: {`);
+      const formattedProperties = formatObjectProperties(parameters, 0, formatFunctionType);
+      if (formattedProperties.length > 0) {
+        lines.push(formattedProperties);
+      }
+      lines.push("}) => any;");
+    }
+    lines.push("");
+  }
+  lines.push("} // namespace functions");
+  return lines.join("\n");
+}
+function estimateTokensInFunctions(functions, countStringTokens) {
+  const formatted = formatFunctionDefinitions(functions);
+  let tokens = countStringTokens(formatted);
+  tokens += FUNCTION_DEFINITION_TOKEN_OVERHEAD;
+  return tokens;
+}
+function padSystemMessage(message, hasFunctions, isSystemPadded) {
+  if (!hasFunctions || isSystemPadded || message.role !== "system") {
+    return message;
+  }
+  if (!message.content || message.content.endsWith(NEWLINE)) {
+    return message;
+  }
+  return {
+    ...message,
+    content: `${message.content}${NEWLINE}`
+  };
+}
+function computeChatCompletionTokenCount(request, countStringTokens) {
+  const { messages, functions, function_call: functionCall } = request;
+  const hasFunctions = Boolean(functions && functions.length > 0);
+  let paddedSystem = false;
+  let total = 0;
+  for (const message of messages) {
+    const messageToCount = padSystemMessage(message, hasFunctions, paddedSystem);
+    if (messageToCount !== message && message.role === "system") {
+      paddedSystem = true;
+    } else if (message.role === "system" && hasFunctions && !paddedSystem) {
+      paddedSystem = true;
+    }
+    total += countMessageTokens(messageToCount, countStringTokens);
+  }
+  total += COMPLETION_REQUEST_TOKEN_OVERHEAD;
+  if (hasFunctions && functions) {
+    total += estimateTokensInFunctions(functions, countStringTokens);
+    if (messages.some((message) => message.role === "system")) {
+      total -= SYSTEM_FUNCTION_TOKEN_DEDUCTION;
+    }
+  }
+  if (functionCall && functionCall !== "auto") {
+    if (functionCall === "none") {
+      total += FUNCTION_CALL_NONE_TOKEN_OVERHEAD;
+    } else if (typeof functionCall === "object" && functionCall.name) {
+      total += countStringTokens(functionCall.name) + FUNCTION_CALL_NAME_TOKEN_OVERHEAD;
+    }
+  }
+  return total;
+}
+var MESSAGE_TOKEN_OVERHEAD, MESSAGE_NAME_TOKEN_OVERHEAD, FUNCTION_ROLE_TOKEN_DISCOUNT, FUNCTION_CALL_METADATA_TOKEN_OVERHEAD, FUNCTION_DEFINITION_TOKEN_OVERHEAD, COMPLETION_REQUEST_TOKEN_OVERHEAD, FUNCTION_CALL_NAME_TOKEN_OVERHEAD, FUNCTION_CALL_NONE_TOKEN_OVERHEAD, SYSTEM_FUNCTION_TOKEN_DEDUCTION, NEWLINE;
+var init_functionCalling = __esm({
+  "node_modules/gpt-tokenizer/esm/functionCalling.js"() {
+    MESSAGE_TOKEN_OVERHEAD = 3;
+    MESSAGE_NAME_TOKEN_OVERHEAD = 1;
+    FUNCTION_ROLE_TOKEN_DISCOUNT = 2;
+    FUNCTION_CALL_METADATA_TOKEN_OVERHEAD = 3;
+    FUNCTION_DEFINITION_TOKEN_OVERHEAD = 9;
+    COMPLETION_REQUEST_TOKEN_OVERHEAD = 3;
+    FUNCTION_CALL_NAME_TOKEN_OVERHEAD = 4;
+    FUNCTION_CALL_NONE_TOKEN_OVERHEAD = 1;
+    SYSTEM_FUNCTION_TOKEN_DEDUCTION = 4;
+    NEWLINE = "\n";
+  }
+});
+
 // node_modules/gpt-tokenizer/esm/modelsChatEnabled.gen.js
 var chatEnabledModels;
 var init_modelsChatEnabled_gen = __esm({
@@ -565,11 +721,12 @@ var modelsMap_exports = {};
 __export(modelsMap_exports, {
   cl100k_base: () => cl100k_base,
   o200k_base: () => o200k_base,
+  o200k_harmony: () => o200k_harmony,
   p50k_base: () => p50k_base,
   p50k_edit: () => p50k_edit,
   r50k_base: () => r50k_base
 });
-var p50k_base, r50k_base, p50k_edit, cl100k_base, o200k_base;
+var p50k_base, r50k_base, p50k_edit, cl100k_base, o200k_base, o200k_harmony;
 var init_modelsMap = __esm({
   "node_modules/gpt-tokenizer/esm/modelsMap.js"() {
     p50k_base = [
@@ -644,11 +801,15 @@ var init_modelsMap = __esm({
       "davinci-002"
     ];
     o200k_base = [];
+    o200k_harmony = [
+      "gpt-oss-20b",
+      "gpt-oss-120b"
+    ];
   }
 });
 
 // node_modules/gpt-tokenizer/esm/specialTokens.js
-var EndOfText, FimPrefix, FimMiddle, FimSuffix, ImStart, ImEnd, ImSep, EndOfPrompt;
+var EndOfText, FimPrefix, FimMiddle, FimSuffix, ImStart, ImEnd, ImSep, EndOfPrompt, HarmonyStartOfText, HarmonyStart, HarmonyEnd, HarmonyMessage, HarmonyChannel, HarmonyReturn, HarmonyConstrain, HarmonyCall;
 var init_specialTokens = __esm({
   "node_modules/gpt-tokenizer/esm/specialTokens.js"() {
     EndOfText = "<|endoftext|>";
@@ -659,6 +820,14 @@ var init_specialTokens = __esm({
     ImEnd = "<|im_end|>";
     ImSep = "<|im_sep|>";
     EndOfPrompt = "<|endofprompt|>";
+    HarmonyStartOfText = "<|startoftext|>";
+    HarmonyStart = "<|start|>";
+    HarmonyEnd = "<|end|>";
+    HarmonyMessage = "<|message|>";
+    HarmonyChannel = "<|channel|>";
+    HarmonyReturn = "<|return|>";
+    HarmonyConstrain = "<|constrain|>";
+    HarmonyCall = "<|call|>";
   }
 });
 
@@ -685,11 +854,16 @@ var init_mapping = __esm({
 });
 
 // node_modules/gpt-tokenizer/esm/encodingParams/constants.js
-var R50K_TOKEN_SPLIT_REGEX, CL_AND_O_TOKEN_SPLIT_PATTERN;
+var R50K_TOKEN_SPLIT_REGEX, CONTRACTION_SUFFIX_PATTERN, OPTIONAL_CONTRACTION_SUFFIX, CL100K_TOKEN_SPLIT_PATTERN, CL100K_TOKEN_SPLIT_REGEX, O200K_TOKEN_SPLIT_PATTERN, O200K_TOKEN_SPLIT_REGEX;
 var init_constants2 = __esm({
   "node_modules/gpt-tokenizer/esm/encodingParams/constants.js"() {
     R50K_TOKEN_SPLIT_REGEX = new RegExp("'s|'t|'re|'ve|'m|'ll|'d| ?\\p{L}+| ?\\p{N}+| ?[^\\s\\p{L}\\p{N}]+|\\s+(?!\\S)|\\s+", "gu");
-    CL_AND_O_TOKEN_SPLIT_PATTERN = new RegExp("(?:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?\\p{L}+|\\p{N}{1,3}| ?[^\\s\\p{L}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+", "giu");
+    CONTRACTION_SUFFIX_PATTERN = String.raw`'(?:[sS]|[dD]|[mM]|[tT]|[lL][lL]|[vV][eE]|[rR][eE])`;
+    OPTIONAL_CONTRACTION_SUFFIX = String.raw`(?:${CONTRACTION_SUFFIX_PATTERN})?`;
+    CL100K_TOKEN_SPLIT_PATTERN = String.raw`${CONTRACTION_SUFFIX_PATTERN}|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s+$|\s*[\r\n]|\s+(?!\S)|\s`;
+    CL100K_TOKEN_SPLIT_REGEX = new RegExp(CL100K_TOKEN_SPLIT_PATTERN, "gu");
+    O200K_TOKEN_SPLIT_PATTERN = String.raw`[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]*[\p{Ll}\p{Lm}\p{Lo}\p{M}]+${OPTIONAL_CONTRACTION_SUFFIX}|[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]+[\p{Ll}\p{Lm}\p{Lo}\p{M}]*${OPTIONAL_CONTRACTION_SUFFIX}|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n/]*|\s*[\r\n]+|\s+(?!\S)|\s+`;
+    O200K_TOKEN_SPLIT_REGEX = new RegExp(O200K_TOKEN_SPLIT_PATTERN, "gu");
   }
 });
 
@@ -706,7 +880,7 @@ function Cl100KBase(bytePairRankDecoder) {
     [EndOfPrompt, 100276]
   ]);
   return {
-    tokenSplitRegex: CL_AND_O_TOKEN_SPLIT_PATTERN,
+    tokenSplitRegex: CL100K_TOKEN_SPLIT_REGEX,
     bytePairRankDecoder,
     specialTokensEncoder: specialTokenMapping
   };
@@ -720,26 +894,69 @@ var init_cl100k_base = __esm({
 
 // node_modules/gpt-tokenizer/esm/encodingParams/o200k_base.js
 function O200KBase(bytePairRankDecoder) {
-  const specialTokenMapping = /* @__PURE__ */ new Map([
-    [EndOfText, 199999],
-    [FimPrefix, 2e5],
-    [FimMiddle, 200001],
-    [FimSuffix, 200002],
-    [ImStart, 200003],
-    [ImEnd, 200004],
-    [ImSep, 200005],
-    [EndOfPrompt, 200006]
-  ]);
   return {
-    tokenSplitRegex: CL_AND_O_TOKEN_SPLIT_PATTERN,
+    tokenSplitRegex: O200K_TOKEN_SPLIT_REGEX,
     bytePairRankDecoder,
-    specialTokensEncoder: specialTokenMapping
+    specialTokensEncoder: createO200KSpecialTokenMap()
   };
 }
+var O200K_BASE_SPECIAL_TOKEN_ENTRIES, createO200KSpecialTokenMap;
 var init_o200k_base2 = __esm({
   "node_modules/gpt-tokenizer/esm/encodingParams/o200k_base.js"() {
     init_specialTokens();
     init_constants2();
+    O200K_BASE_SPECIAL_TOKEN_ENTRIES = [
+      [EndOfText, 199999],
+      [FimPrefix, 2e5],
+      [FimMiddle, 200001],
+      [FimSuffix, 200002],
+      [ImStart, 200003],
+      [ImEnd, 200004],
+      [ImSep, 200005],
+      [EndOfPrompt, 200006]
+    ];
+    createO200KSpecialTokenMap = () => new Map(O200K_BASE_SPECIAL_TOKEN_ENTRIES);
+  }
+});
+
+// node_modules/gpt-tokenizer/esm/encodingParams/o200k_harmony.js
+function O200KHarmony(bytePairRankDecoder) {
+  const specialTokensEncoder = new Map(STATIC_SPECIAL_TOKEN_ENTRIES);
+  for (let tokenId = RESERVED_TOKEN_RANGE_START; tokenId < RESERVED_TOKEN_RANGE_END; tokenId += 1) {
+    specialTokensEncoder.set(`<|reserved_${tokenId}|>`, tokenId);
+  }
+  specialTokensEncoder.set(EndOfPrompt, 200018);
+  return {
+    tokenSplitRegex: O200K_TOKEN_SPLIT_REGEX,
+    bytePairRankDecoder,
+    specialTokensEncoder,
+    chatFormatter: "harmony"
+  };
+}
+var RESERVED_TOKEN_RANGE_START, RESERVED_TOKEN_RANGE_END, STATIC_SPECIAL_TOKEN_ENTRIES;
+var init_o200k_harmony = __esm({
+  "node_modules/gpt-tokenizer/esm/encodingParams/o200k_harmony.js"() {
+    init_specialTokens();
+    init_constants2();
+    RESERVED_TOKEN_RANGE_START = 200013;
+    RESERVED_TOKEN_RANGE_END = 201088;
+    STATIC_SPECIAL_TOKEN_ENTRIES = [
+      [HarmonyStartOfText, 199998],
+      [EndOfText, 199999],
+      ["<|reserved_200000|>", 2e5],
+      ["<|reserved_200001|>", 200001],
+      [HarmonyReturn, 200002],
+      [HarmonyConstrain, 200003],
+      ["<|reserved_200004|>", 200004],
+      [HarmonyChannel, 200005],
+      [HarmonyStart, 200006],
+      [HarmonyEnd, 200007],
+      [HarmonyMessage, 200008],
+      ["<|reserved_200009|>", 200009],
+      ["<|reserved_200010|>", 200010],
+      ["<|reserved_200011|>", 200011],
+      [HarmonyCall, 200012]
+    ];
   }
 });
 
@@ -813,6 +1030,8 @@ function getEncodingParams(encodingName, getMergeableRanks) {
       return Cl100KBase(mergeableBytePairRanks);
     case "o200k_base":
       return O200KBase(mergeableBytePairRanks);
+    case "o200k_harmony":
+      return O200KHarmony(mergeableBytePairRanks);
     default:
       throw new Error(`Unknown encoding name: ${encodingName}`);
   }
@@ -821,6 +1040,7 @@ var init_modelParams = __esm({
   "node_modules/gpt-tokenizer/esm/modelParams.js"() {
     init_cl100k_base();
     init_o200k_base2();
+    init_o200k_harmony();
     init_p50k_base();
     init_p50k_edit();
     init_r50k_base();
@@ -833,6 +1053,7 @@ var init_GptEncoding = __esm({
   "node_modules/gpt-tokenizer/esm/GptEncoding.js"() {
     init_BytePairEncodingCore();
     init_constants();
+    init_functionCalling();
     init_mapping();
     init_modelParams();
     init_specialTokens();
@@ -851,8 +1072,10 @@ var init_GptEncoding = __esm({
       specialTokensSet;
       allSpecialTokenRegex;
       defaultSpecialTokenConfig;
+      chatFormatter;
+      countChatCompletionTokens;
       vocabularySize;
-      constructor({ bytePairRankDecoder: mergeableBytePairRanks, specialTokensEncoder, expectedVocabularySize, modelName, modelSpec, ...rest }) {
+      constructor({ bytePairRankDecoder: mergeableBytePairRanks, specialTokensEncoder, expectedVocabularySize, modelName, modelSpec, chatFormatter, ...rest }) {
         this.specialTokensEncoder = specialTokensEncoder;
         this.specialTokensSet = new Set(this.specialTokensEncoder.keys());
         this.allSpecialTokenRegex = getSpecialTokenRegex(this.specialTokensSet);
@@ -885,8 +1108,69 @@ var init_GptEncoding = __esm({
         this.setMergeCacheSize = this.setMergeCacheSize.bind(this);
         this.clearMergeCache = this.clearMergeCache.bind(this);
         this.estimateCost = this.estimateCost.bind(this);
+        if (modelSpec?.supported_features?.includes("function_calling")) {
+          this.countChatCompletionTokens = this.countChatCompletionTokensInternal.bind(this);
+        }
         this.modelName = modelName;
         this.modelSpec = modelSpec;
+        this.chatFormatter = chatFormatter ?? "chatml";
+      }
+      *encodeHarmonyChatGenerator(chat, encodeOptions) {
+        const harmonyStart = this.specialTokensEncoder.get(HarmonyStart);
+        const harmonyMessage = this.specialTokensEncoder.get(HarmonyMessage);
+        const harmonyEnd = this.specialTokensEncoder.get(HarmonyEnd);
+        const harmonyReturn = this.specialTokensEncoder.get(HarmonyReturn);
+        const harmonyCall = this.specialTokensEncoder.get(HarmonyCall);
+        const harmonyChannel = this.specialTokensEncoder.get(HarmonyChannel);
+        const harmonyConstrain = this.specialTokensEncoder.get(HarmonyConstrain);
+        if (harmonyStart === void 0 || harmonyMessage === void 0 || harmonyEnd === void 0 || harmonyReturn === void 0 || harmonyCall === void 0 || harmonyChannel === void 0 || harmonyConstrain === void 0) {
+          throw new Error("Harmony chat format requires dedicated special tokens.");
+        }
+        const encodeHeaderText = (text) => text.length > 0 ? this.encode(text) : [];
+        const resolveTerminatorToken = (terminator) => {
+          switch (terminator) {
+            case "<|return|>":
+              return harmonyReturn;
+            case "<|call|>":
+              return harmonyCall;
+            // eslint-disable-next-line unicorn/no-useless-switch-case
+            case "<|end|>":
+            default:
+              return harmonyEnd;
+          }
+        };
+        for (const message of chat) {
+          if (message.content === void 0) {
+            throw new Error("Content must be defined for all messages.");
+          }
+          const roleOrName = message.name ?? message.role ?? "user";
+          yield [harmonyStart];
+          yield encodeHeaderText(roleOrName);
+          const recipientInRole = message.recipient && (message.recipientPlacement === "role" || !message.channel);
+          const recipientInChannel = message.recipient && !recipientInRole;
+          if (recipientInRole) {
+            yield encodeHeaderText(` to=${message.recipient}`);
+          }
+          if (message.channel) {
+            yield [harmonyChannel];
+            yield encodeHeaderText(message.channel);
+            if (recipientInChannel) {
+              yield encodeHeaderText(` to=${message.recipient}`);
+            }
+          }
+          if (message.constraint) {
+            yield [harmonyConstrain];
+            yield encodeHeaderText(message.constraint);
+          }
+          yield [harmonyMessage];
+          yield* this.encodeGenerator(message.content, encodeOptions);
+          yield [resolveTerminatorToken(message.terminator)];
+        }
+        const assistantPrime = encodeOptions?.primeWithAssistantResponse ?? "assistant";
+        if (assistantPrime.length > 0) {
+          yield [harmonyStart];
+          yield encodeHeaderText(assistantPrime);
+        }
       }
       static getEncodingApi(encodingName, getMergeableRanks) {
         const modelParams = getEncodingParams(encodingName, getMergeableRanks);
@@ -959,9 +1243,16 @@ var init_GptEncoding = __esm({
           throw new Error("Model name must be provided either during initialization or passed in to the method.");
         }
         const params = chatModelParams[model];
+        if (!params) {
+          throw new Error(`Model '${model}' does not support chat.`);
+        }
+        if (this.chatFormatter === "harmony") {
+          yield* this.encodeHarmonyChatGenerator(chat, encodeOptions);
+          return;
+        }
         const chatStartToken = this.specialTokensEncoder.get(ImStart);
         const chatEndToken = this.specialTokensEncoder.get(ImEnd);
-        if (!params || chatStartToken === void 0 || chatEndToken === void 0) {
+        if (chatStartToken === void 0 || chatEndToken === void 0) {
           throw new Error(`Model '${model}' does not support chat.`);
         }
         const allowedSpecial = /* @__PURE__ */ new Set([ImSep]);
@@ -984,8 +1275,11 @@ var init_GptEncoding = __esm({
           yield [chatEndToken];
           yield encodedMessageSeparator;
         }
-        yield [chatStartToken];
-        yield* this.encodeGenerator("assistant", encodeOptions);
+        const assistantPrime = encodeOptions?.primeWithAssistantResponse ?? "assistant";
+        if (assistantPrime.length > 0) {
+          yield [chatStartToken];
+          yield* this.encodeGenerator(assistantPrime, encodeOptions);
+        }
         if (encodedRoleSeparator.length > 0) {
           yield encodedRoleSeparator;
         }
@@ -1043,6 +1337,15 @@ var init_GptEncoding = __esm({
         }
         return count;
       }
+      countStringTokens(text) {
+        if (!text) {
+          return 0;
+        }
+        return this.bytePairEncodingCoreProcessor.countNative(text);
+      }
+      countChatCompletionTokensInternal(request) {
+        return computeChatCompletionTokenCount(request, (text) => this.countStringTokens(text));
+      }
       setMergeCacheSize(size) {
         this.bytePairEncodingCoreProcessor.setMergeCacheSize(size);
       }
@@ -2007,7 +2310,7 @@ async function waitForFileLock(lockPath, binaryPath) {
       }
     } catch {
     }
-    await new Promise((resolve5) => setTimeout(resolve5, LOCK_POLL_INTERVAL_MS));
+    await new Promise((resolve6) => setTimeout(resolve6, LOCK_POLL_INTERVAL_MS));
   }
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Timeout waiting for file lock`);
@@ -2978,7 +3281,7 @@ Command: ${command}`;
   }
 }
 function extractWithStdin(binaryPath, cliArgs, content, options) {
-  return new Promise((resolve5, reject2) => {
+  return new Promise((resolve6, reject2) => {
     const childProcess = spawn(binaryPath, ["extract", ...cliArgs], {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -3000,7 +3303,7 @@ function extractWithStdin(binaryPath, cliArgs, content, options) {
       }
       try {
         const result = processExtractOutput(stdout, options);
-        resolve5(result);
+        resolve6(result);
       } catch (error) {
         reject2(error);
       }
@@ -7483,7 +7786,15 @@ function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
     if (openIndex === -1) {
       continue;
     }
-    let closeIndex = xmlString.indexOf(closeTag, openIndex + openTag.length);
+    let closeIndex;
+    if (toolName === "attempt_completion") {
+      closeIndex = xmlString.lastIndexOf(closeTag);
+      if (closeIndex !== -1 && closeIndex <= openIndex + openTag.length) {
+        closeIndex = -1;
+      }
+    } else {
+      closeIndex = xmlString.indexOf(closeTag, openIndex + openTag.length);
+    }
     let hasClosingTag = closeIndex !== -1;
     if (closeIndex === -1) {
       closeIndex = xmlString.length;
@@ -7560,7 +7871,7 @@ function parseTargets(targets) {
   }
   return targets.split(/\s+/).filter((f) => f.length > 0);
 }
-var searchSchema, querySchema, extractSchema, delegateSchema, bashSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
+var searchSchema, querySchema, extractSchema, delegateSchema, bashSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, bashToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
 var init_common = __esm({
   "src/tools/common.js"() {
     "use strict";
@@ -7573,11 +7884,12 @@ var init_common = __esm({
       pattern: external_exports.string().describe("AST pattern to search for. Use $NAME for variable names, $$$PARAMS for parameter lists, etc."),
       path: external_exports.string().optional().default(".").describe("Path to search in"),
       language: external_exports.string().optional().default("rust").describe("Programming language to use for parsing"),
-      allow_tests: external_exports.boolean().optional().default(false).describe("Allow test files in search results")
+      allow_tests: external_exports.boolean().optional().default(true).describe("Allow test files in search results")
     });
     extractSchema = external_exports.object({
       targets: external_exports.string().optional().describe('File paths or symbols to extract from. Formats: "file.js" (whole file), "file.js:42" (line 42), "file.js:10-20" (lines 10-20), "file.js#funcName" (symbol). Multiple targets separated by spaces.'),
-      input_content: external_exports.string().optional().describe("Text content to extract file paths from (alternative to targets)")
+      input_content: external_exports.string().optional().describe("Text content to extract file paths from (alternative to targets)"),
+      allow_tests: external_exports.boolean().optional().default(true).describe("Include test files in extraction results")
     });
     delegateSchema = external_exports.object({
       task: external_exports.string().describe("The task to delegate to a subagent. Be specific about what needs to be accomplished.")
@@ -7704,7 +8016,7 @@ Parameters:
 - pattern: (required) AST pattern to search for. Use $NAME for variable names, $$$PARAMS for parameter lists, etc.
 - path: (optional, default: '.') Path to search in.
 - language: (optional, default: 'rust') Programming language to use for parsing.
-- allow_tests: (optional, default: false) Allow test files in search results (true/false).
+- allow_tests: (optional, default: true) Allow test files in search results (true/false).
 Usage Example:
 
 <examples>
@@ -7729,6 +8041,7 @@ Full file extraction should be the LAST RESORT! Always prefer search.
 Parameters:
 - targets: (required) File paths or symbols to extract from. Formats: "file.js" (whole file), "file.js:42" (code block at line 42), "file.js:10-20" (lines 10-20), "file.js#funcName" (specific symbol). Multiple targets separated by spaces.
 - input_content: (optional) Text content to extract file paths from (alternative to targets for processing diffs/logs).
+- allow_tests: (optional, default: true) Include test files in extraction results.
 
 Usage Example:
 
@@ -7795,6 +8108,61 @@ Usage Example:
 <attempt_completion>
 I have refactored the search module according to the requirements and verified the tests pass. The module now uses the new BM25 ranking algorithm and has improved error handling.
 </attempt_completion>
+`;
+    bashToolDefinition = `
+## bash
+Description: Execute bash commands for system exploration and development tasks. This tool has built-in security with allow/deny lists. By default, only safe read-only commands are allowed for code exploration.
+
+Parameters:
+- command: (required) The bash command to execute
+- workingDirectory: (optional) Directory to execute the command in
+- timeout: (optional) Command timeout in milliseconds
+- env: (optional) Additional environment variables as an object
+
+Security: Commands are filtered through allow/deny lists for safety:
+- Allowed by default: ls, cat, git status, npm list, find, grep, etc.
+- Denied by default: rm -rf, sudo, npm install, dangerous system commands
+
+Usage Examples:
+
+<examples>
+
+User: What files are in the src directory?
+<bash>
+<command>ls -la src/</command>
+</bash>
+
+User: Show me the git status
+<bash>
+<command>git status</command>
+</bash>
+
+User: Find all TypeScript files
+<bash>
+<command>find . -name "*.ts" -type f</command>
+</bash>
+
+User: Check installed npm packages
+<bash>
+<command>npm list --depth=0</command>
+</bash>
+
+User: Search for TODO comments in code
+<bash>
+<command>grep -r "TODO" src/</command>
+</bash>
+
+User: Show recent git commits
+<bash>
+<command>git log --oneline -10</command>
+</bash>
+
+User: Check system info
+<bash>
+<command>uname -a</command>
+</bash>
+
+</examples>
 `;
     searchDescription = "Search code in the repository using Elasticsearch-like query syntax. Use this tool first for any code-related questions.";
     queryDescription = "Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.";
@@ -8894,14 +9262,14 @@ async function executeBashCommand(command, options = {}) {
     console.log(`[BashExecutor] Working directory: "${cwd}"`);
     console.log(`[BashExecutor] Timeout: ${timeout}ms`);
   }
-  return new Promise((resolve5, reject2) => {
+  return new Promise((resolve6, reject2) => {
     const processEnv = {
       ...process.env,
       ...env
     };
     const args = parseCommandForExecution(command);
     if (!args || args.length === 0) {
-      resolve5({
+      resolve6({
         success: false,
         error: "Failed to parse command",
         stdout: "",
@@ -8984,7 +9352,7 @@ async function executeBashCommand(command, options = {}) {
         success = false;
         error = `Command exited with code ${code}`;
       }
-      resolve5({
+      resolve6({
         success,
         error,
         stdout: stdout.trim(),
@@ -9004,7 +9372,7 @@ async function executeBashCommand(command, options = {}) {
       if (debug) {
         console.log(`[BashExecutor] Spawn error:`, error);
       }
-      resolve5({
+      resolve6({
         success: false,
         error: `Failed to execute command: ${error.message}`,
         stdout: "",
@@ -9276,6 +9644,283 @@ Command failed with exit code ${result.exitCode}`;
   }
 });
 
+// src/tools/edit.js
+import { tool as tool3 } from "ai";
+import { promises as fs4 } from "fs";
+import { dirname, resolve as resolve3, isAbsolute, sep } from "path";
+import { existsSync as existsSync2 } from "fs";
+function isPathAllowed(filePath, allowedFolders) {
+  if (!allowedFolders || allowedFolders.length === 0) {
+    const resolvedPath2 = resolve3(filePath);
+    const cwd = resolve3(process.cwd());
+    return resolvedPath2 === cwd || resolvedPath2.startsWith(cwd + sep);
+  }
+  const resolvedPath = resolve3(filePath);
+  return allowedFolders.some((folder) => {
+    const allowedPath = resolve3(folder);
+    return resolvedPath === allowedPath || resolvedPath.startsWith(allowedPath + sep);
+  });
+}
+function parseFileToolOptions(options = {}) {
+  return {
+    debug: options.debug || false,
+    allowedFolders: options.allowedFolders || [],
+    defaultPath: options.defaultPath
+  };
+}
+var editTool, createTool, editDescription, createDescription, editToolDefinition, createToolDefinition;
+var init_edit = __esm({
+  "src/tools/edit.js"() {
+    "use strict";
+    editTool = (options = {}) => {
+      const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+      return tool3({
+        name: "edit",
+        description: `Edit files using exact string replacement (Claude Code style).
+
+This tool performs exact string replacements in files. It requires the old_string to match exactly what's in the file, including all whitespace and indentation.
+
+Parameters:
+- file_path: Path to the file to edit (absolute or relative)
+- old_string: Exact text to find and replace (must be unique in the file unless replace_all is true)
+- new_string: Text to replace with
+- replace_all: (optional) Replace all occurrences instead of requiring uniqueness
+
+Important:
+- The old_string must match EXACTLY including whitespace
+- If old_string appears multiple times and replace_all is false, the edit will fail
+- Use larger context around the string to ensure uniqueness when needed`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_path: {
+              type: "string",
+              description: "Path to the file to edit"
+            },
+            old_string: {
+              type: "string",
+              description: "Exact text to find and replace"
+            },
+            new_string: {
+              type: "string",
+              description: "Text to replace with"
+            },
+            replace_all: {
+              type: "boolean",
+              description: "Replace all occurrences (default: false)",
+              default: false
+            }
+          },
+          required: ["file_path", "old_string", "new_string"]
+        },
+        execute: async ({ file_path, old_string, new_string, replace_all = false }) => {
+          try {
+            if (!file_path || typeof file_path !== "string" || file_path.trim() === "") {
+              return `Error editing file: Invalid file_path - must be a non-empty string`;
+            }
+            if (old_string === void 0 || old_string === null || typeof old_string !== "string") {
+              return `Error editing file: Invalid old_string - must be a string`;
+            }
+            if (new_string === void 0 || new_string === null || typeof new_string !== "string") {
+              return `Error editing file: Invalid new_string - must be a string`;
+            }
+            const resolvedPath = isAbsolute(file_path) ? file_path : resolve3(defaultPath || process.cwd(), file_path);
+            if (debug) {
+              console.error(`[Edit] Attempting to edit file: ${resolvedPath}`);
+            }
+            if (!isPathAllowed(resolvedPath, allowedFolders)) {
+              return `Error editing file: Permission denied - ${file_path} is outside allowed directories`;
+            }
+            if (!existsSync2(resolvedPath)) {
+              return `Error editing file: File not found - ${file_path}`;
+            }
+            const content = await fs4.readFile(resolvedPath, "utf-8");
+            if (!content.includes(old_string)) {
+              return `Error editing file: String not found - the specified old_string was not found in ${file_path}`;
+            }
+            const occurrences = content.split(old_string).length - 1;
+            if (!replace_all && occurrences > 1) {
+              return `Error editing file: Multiple occurrences found - the old_string appears ${occurrences} times. Use replace_all: true to replace all occurrences, or provide more context to make the string unique.`;
+            }
+            let newContent;
+            if (replace_all) {
+              newContent = content.replaceAll(old_string, new_string);
+            } else {
+              newContent = content.replace(old_string, new_string);
+            }
+            if (newContent === content) {
+              return `Error editing file: No changes made - old_string and new_string might be the same`;
+            }
+            await fs4.writeFile(resolvedPath, newContent, "utf-8");
+            const replacedCount = replace_all ? occurrences : 1;
+            if (debug) {
+              console.error(`[Edit] Successfully edited ${resolvedPath}, replaced ${replacedCount} occurrence(s)`);
+            }
+            return `Successfully edited ${file_path} (${replacedCount} replacement${replacedCount !== 1 ? "s" : ""})`;
+          } catch (error) {
+            console.error("[Edit] Error:", error);
+            return `Error editing file: ${error.message}`;
+          }
+        }
+      });
+    };
+    createTool = (options = {}) => {
+      const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+      return tool3({
+        name: "create",
+        description: `Create new files with specified content.
+
+This tool creates new files in the filesystem. It will create parent directories if they don't exist.
+
+Parameters:
+- file_path: Path where the file should be created (absolute or relative)
+- content: Content to write to the file
+- overwrite: (optional) Whether to overwrite if file exists (default: false)
+
+Important:
+- By default, will fail if the file already exists
+- Set overwrite: true to replace existing files
+- Parent directories will be created automatically if needed`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_path: {
+              type: "string",
+              description: "Path where the file should be created"
+            },
+            content: {
+              type: "string",
+              description: "Content to write to the file"
+            },
+            overwrite: {
+              type: "boolean",
+              description: "Overwrite if file exists (default: false)",
+              default: false
+            }
+          },
+          required: ["file_path", "content"]
+        },
+        execute: async ({ file_path, content, overwrite = false }) => {
+          try {
+            if (!file_path || typeof file_path !== "string" || file_path.trim() === "") {
+              return `Error creating file: Invalid file_path - must be a non-empty string`;
+            }
+            if (content === void 0 || content === null || typeof content !== "string") {
+              return `Error creating file: Invalid content - must be a string`;
+            }
+            const resolvedPath = isAbsolute(file_path) ? file_path : resolve3(defaultPath || process.cwd(), file_path);
+            if (debug) {
+              console.error(`[Create] Attempting to create file: ${resolvedPath}`);
+            }
+            if (!isPathAllowed(resolvedPath, allowedFolders)) {
+              return `Error creating file: Permission denied - ${file_path} is outside allowed directories`;
+            }
+            if (existsSync2(resolvedPath) && !overwrite) {
+              return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
+            }
+            const dir = dirname(resolvedPath);
+            await fs4.mkdir(dir, { recursive: true });
+            await fs4.writeFile(resolvedPath, content, "utf-8");
+            const action = existsSync2(resolvedPath) && overwrite ? "overwrote" : "created";
+            const bytes = Buffer.byteLength(content, "utf-8");
+            if (debug) {
+              console.error(`[Create] Successfully ${action} ${resolvedPath}`);
+            }
+            return `Successfully ${action} ${file_path} (${bytes} bytes)`;
+          } catch (error) {
+            console.error("[Create] Error:", error);
+            return `Error creating file: ${error.message}`;
+          }
+        }
+      });
+    };
+    editDescription = "Edit files using exact string replacement. Requires exact match including whitespace.";
+    createDescription = "Create new files with specified content. Will create parent directories if needed.";
+    editToolDefinition = `
+## edit
+Description: ${editDescription}
+
+When to use:
+- For precise, surgical edits to existing files
+- When you need to change specific lines or blocks of code
+- For renaming functions, variables, or updating configuration values
+- When the exact text to replace is known and unique (or use replace_all for multiple occurrences)
+
+When NOT to use:
+- For creating new files (use 'create' tool instead)
+- When you cannot determine the exact text to replace
+- When changes span multiple locations that would be better handled together
+
+Parameters:
+- file_path: (required) Path to the file to edit
+- old_string: (required) Exact text to find and replace (must match including whitespace, newlines, and indentation)
+- new_string: (required) Text to replace with
+- replace_all: (optional, default: false) Replace all occurrences if the string appears multiple times
+
+Important notes:
+- The old_string MUST match EXACTLY, including all whitespace, indentation, and line breaks
+- If old_string appears multiple times and replace_all is false, the tool will fail
+- Always verify the exact formatting of the text you want to replace
+
+Examples:
+<edit>
+<file_path>src/main.js</file_path>
+<old_string>function oldName() {
+  return 42;
+}</old_string>
+<new_string>function newName() {
+  return 42;
+}</new_string>
+</edit>
+
+<edit>
+<file_path>config.json</file_path>
+<old_string>"debug": false</old_string>
+<new_string>"debug": true</new_string>
+<replace_all>true</replace_all>
+</edit>`;
+    createToolDefinition = `
+## create
+Description: ${createDescription}
+
+When to use:
+- For creating brand new files from scratch
+- When you need to add configuration files, documentation, or new modules
+- For generating boilerplate code or templates
+- When you have the complete content ready to write
+
+When NOT to use:
+- For editing existing files (use 'edit' tool instead)
+- When a file already exists unless you explicitly want to overwrite it
+
+Parameters:
+- file_path: (required) Path where the file should be created
+- content: (required) Complete content to write to the file
+- overwrite: (optional, default: false) Whether to overwrite if file already exists
+
+Important notes:
+- Parent directories will be created automatically if they don't exist
+- The tool will fail if the file already exists and overwrite is false
+- Be careful with the overwrite option as it completely replaces existing files
+
+Examples:
+<create>
+<file_path>src/newFile.js</file_path>
+<content>export function hello() {
+  return "Hello, world!";
+}</content>
+</create>
+
+<create>
+<file_path>README.md</file_path>
+<content># My Project
+
+This is a new project.</content>
+<overwrite>true</overwrite>
+</create>`;
+  }
+});
+
 // src/tools/langchain.js
 var init_langchain = __esm({
   "src/tools/langchain.js"() {
@@ -9425,8 +10070,10 @@ var init_tools = __esm({
     "use strict";
     init_vercel();
     init_bash();
+    init_edit();
     init_langchain();
     init_common();
+    init_edit();
     init_system_message();
     init_vercel();
     init_bash();
@@ -9443,7 +10090,7 @@ var init_tools = __esm({
 });
 
 // src/utils/file-lister.js
-import fs4 from "fs";
+import fs5 from "fs";
 import path4 from "path";
 import { promisify as promisify6 } from "util";
 import { exec as exec4 } from "child_process";
@@ -9453,10 +10100,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!fs4.existsSync(directory)) {
+  if (!fs5.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = fs4.existsSync(path4.join(directory, ".git"));
+  const gitDirExists = fs5.existsSync(path4.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -9487,7 +10134,7 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = fs4.readdirSync(dir, { withFileTypes: true });
+      const entries = fs5.readdirSync(dir, { withFileTypes: true });
       const files = entries.filter((entry) => entry.isFile());
       for (const file of files) {
         if (result.length >= maxFiles) break;
@@ -9512,11 +10159,11 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 }
 function loadGitignorePatterns(directory) {
   const gitignorePath = path4.join(directory, ".gitignore");
-  if (!fs4.existsSync(gitignorePath)) {
+  if (!fs5.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = fs4.readFileSync(gitignorePath, "utf8");
+    const content = fs5.readFileSync(gitignorePath, "utf8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error) {
     console.error(`Warning: Could not read .gitignore: ${error.message}`);
@@ -9543,8 +10190,8 @@ var init_file_lister = __esm({
 });
 
 // src/agent/simpleTelemetry.js
-import { existsSync as existsSync2, mkdirSync, createWriteStream } from "fs";
-import { dirname } from "path";
+import { existsSync as existsSync3, mkdirSync, createWriteStream } from "fs";
+import { dirname as dirname2 } from "path";
 function initializeSimpleTelemetryFromOptions(options) {
   const telemetry = new SimpleTelemetry({
     serviceName: "probe-agent",
@@ -9571,8 +10218,8 @@ var init_simpleTelemetry = __esm({
       }
       initializeFileExporter() {
         try {
-          const dir = dirname(this.filePath);
-          if (!existsSync2(dir)) {
+          const dir = dirname2(this.filePath);
+          if (!existsSync3(dir)) {
             mkdirSync(dir, { recursive: true });
           }
           this.stream = createWriteStream(this.filePath, { flags: "a" });
@@ -9636,20 +10283,20 @@ var init_simpleTelemetry = __esm({
       }
       async flush() {
         if (this.stream) {
-          return new Promise((resolve5) => {
-            this.stream.once("drain", resolve5);
+          return new Promise((resolve6) => {
+            this.stream.once("drain", resolve6);
             if (!this.stream.writableNeedDrain) {
-              resolve5();
+              resolve6();
             }
           });
         }
       }
       async shutdown() {
         if (this.stream) {
-          return new Promise((resolve5) => {
+          return new Promise((resolve6) => {
             this.stream.end(() => {
               console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
-              resolve5();
+              resolve6();
             });
           });
         }
@@ -10612,7 +11259,7 @@ var init_escape = __esm({
 });
 
 // node_modules/minimatch/dist/esm/index.js
-var import_brace_expansion, minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
+var import_brace_expansion, minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep2, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
 var init_esm = __esm({
   "node_modules/minimatch/dist/esm/index.js"() {
     import_brace_expansion = __toESM(require_brace_expansion(), 1);
@@ -10685,8 +11332,8 @@ var init_esm = __esm({
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    sep = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
-    minimatch.sep = sep;
+    sep2 = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
+    minimatch.sep = sep2;
     GLOBSTAR = Symbol("globstar **");
     minimatch.GLOBSTAR = GLOBSTAR;
     qmark2 = "[^/]";
@@ -13448,10 +14095,10 @@ var init_esm3 = __esm({
        * Return a void Promise that resolves once the stream ends.
        */
       async promise() {
-        return new Promise((resolve5, reject2) => {
+        return new Promise((resolve6, reject2) => {
           this.on(DESTROYED, () => reject2(new Error("stream destroyed")));
           this.on("error", (er) => reject2(er));
-          this.on("end", () => resolve5());
+          this.on("end", () => resolve6());
         });
       }
       /**
@@ -13475,7 +14122,7 @@ var init_esm3 = __esm({
             return Promise.resolve({ done: false, value: res });
           if (this[EOF])
             return stop();
-          let resolve5;
+          let resolve6;
           let reject2;
           const onerr = (er) => {
             this.off("data", ondata);
@@ -13489,19 +14136,19 @@ var init_esm3 = __esm({
             this.off("end", onend);
             this.off(DESTROYED, ondestroy);
             this.pause();
-            resolve5({ value, done: !!this[EOF] });
+            resolve6({ value, done: !!this[EOF] });
           };
           const onend = () => {
             this.off("error", onerr);
             this.off("data", ondata);
             this.off(DESTROYED, ondestroy);
             stop();
-            resolve5({ done: true, value: void 0 });
+            resolve6({ done: true, value: void 0 });
           };
           const ondestroy = () => onerr(new Error("stream destroyed"));
           return new Promise((res2, rej) => {
             reject2 = rej;
-            resolve5 = res2;
+            resolve6 = res2;
             this.once(DESTROYED, ondestroy);
             this.once("error", onerr);
             this.once("end", onend);
@@ -14481,9 +15128,9 @@ var init_esm4 = __esm({
         if (this.#asyncReaddirInFlight) {
           await this.#asyncReaddirInFlight;
         } else {
-          let resolve5 = () => {
+          let resolve6 = () => {
           };
-          this.#asyncReaddirInFlight = new Promise((res) => resolve5 = res);
+          this.#asyncReaddirInFlight = new Promise((res) => resolve6 = res);
           try {
             for (const e of await this.#fs.promises.readdir(fullpath, {
               withFileTypes: true
@@ -14496,7 +15143,7 @@ var init_esm4 = __esm({
             children.provisional = 0;
           }
           this.#asyncReaddirInFlight = void 0;
-          resolve5();
+          resolve6();
         }
         return children.slice(0, children.provisional);
       }
@@ -14726,8 +15373,8 @@ var init_esm4 = __esm({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs6);
+      constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs7);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = fileURLToPath4(cwd);
         }
@@ -14737,7 +15384,7 @@ var init_esm4 = __esm({
         this.#resolveCache = new ResolveCache();
         this.#resolvePosixCache = new ResolveCache();
         this.#children = new ChildrenCache(childrenCacheSize);
-        const split = cwdPath.substring(this.rootPath.length).split(sep2);
+        const split = cwdPath.substring(this.rootPath.length).split(sep3);
         if (split.length === 1 && !split[0]) {
           split.pop();
         }
@@ -15285,8 +15932,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs6) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+      newRoot(fs7) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -15314,8 +15961,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs6) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+      newRoot(fs7) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -16455,7 +17102,7 @@ import { exec as exec5 } from "child_process";
 import { promisify as promisify7 } from "util";
 import { randomUUID as randomUUID2 } from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
-import fs5 from "fs";
+import fs6 from "fs";
 import { promises as fsPromises } from "fs";
 import path6 from "path";
 function isSessionCancelled(sessionId) {
@@ -16515,6 +17162,20 @@ function createWrappedTools(baseTools) {
       baseTools.bashTool.execute
     );
   }
+  if (baseTools.editTool) {
+    wrappedTools.editToolInstance = wrapToolWithEmitter(
+      baseTools.editTool,
+      "edit",
+      baseTools.editTool.execute
+    );
+  }
+  if (baseTools.createTool) {
+    wrappedTools.createToolInstance = wrapToolWithEmitter(
+      baseTools.createTool,
+      "create",
+      baseTools.createTool.execute
+    );
+  }
   return wrappedTools;
 }
 var toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
@@ -16525,9 +17186,9 @@ var init_probeTool = __esm({
     init_esm5();
     toolCallEmitter = new EventEmitter2();
     activeToolExecutions = /* @__PURE__ */ new Map();
-    wrapToolWithEmitter = (tool3, toolName, baseExecute) => {
+    wrapToolWithEmitter = (tool4, toolName, baseExecute) => {
       return {
-        ...tool3,
+        ...tool4,
         // Spread schema, description etc.
         execute: async (params) => {
           const debug = process.env.DEBUG === "1";
@@ -16762,8 +17423,10 @@ var init_index = __esm({
     init_file_lister();
     init_system_message();
     init_common();
+    init_edit();
     init_vercel();
     init_bash();
+    init_edit();
     init_ProbeAgent();
     init_simpleTelemetry();
     init_probeTool();
@@ -16796,10 +17459,22 @@ function extractThinkingContent(xmlString) {
   return thinkingMatch ? thinkingMatch[1].trim() : null;
 }
 function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
-  const attemptCompletionMatch = cleanedXmlString.match(/<attempt_completion>([\s\S]*?)(?:<\/attempt_completion>|$)/);
-  if (attemptCompletionMatch) {
-    const content = attemptCompletionMatch[1].trim();
-    const hasClosingTag = cleanedXmlString.includes("</attempt_completion>");
+  const openTagIndex = cleanedXmlString.indexOf("<attempt_completion>");
+  if (openTagIndex !== -1) {
+    const afterOpenTag = cleanedXmlString.substring(openTagIndex + "<attempt_completion>".length);
+    const closeTagIndex = cleanedXmlString.lastIndexOf("</attempt_completion>");
+    let content;
+    let hasClosingTag = false;
+    if (closeTagIndex !== -1 && closeTagIndex >= openTagIndex + "<attempt_completion>".length) {
+      content = cleanedXmlString.substring(
+        openTagIndex + "<attempt_completion>".length,
+        closeTagIndex
+      ).trim();
+      hasClosingTag = true;
+    } else {
+      content = afterOpenTag.trim();
+      hasClosingTag = false;
+    }
     if (content) {
       return {
         toolName: "attempt_completion",
@@ -16845,8 +17520,8 @@ function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
 function hasOtherToolTags(xmlString, validTools = []) {
   const defaultTools = ["search", "query", "extract", "listFiles", "searchFiles", "implement", "attempt_completion"];
   const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
-  for (const tool3 of toolsToCheck) {
-    if (tool3 !== "attempt_completion" && xmlString.includes(`<${tool3}`)) {
+  for (const tool4 of toolsToCheck) {
+    if (tool4 !== "attempt_completion" && xmlString.includes(`<${tool4}`)) {
       return true;
     }
   }
@@ -16884,6 +17559,10 @@ function createTools(configOptions) {
   if (configOptions.enableBash) {
     tools2.bashTool = bashTool(configOptions);
   }
+  if (configOptions.allowEdit) {
+    tools2.editTool = editTool(configOptions);
+    tools2.createTool = createTool(configOptions);
+  }
   return tools2;
 }
 function parseXmlToolCallWithThinking(xmlString, validTools) {
@@ -16984,7 +17663,7 @@ function createMockProvider() {
       provider: "mock",
       // Mock the doGenerate method used by Vercel AI SDK
       doGenerate: async ({ messages, tools: tools2 }) => {
-        await new Promise((resolve5) => setTimeout(resolve5, 10));
+        await new Promise((resolve6) => setTimeout(resolve6, 10));
         return {
           text: "This is a mock response for testing",
           toolCalls: [],
@@ -28971,16 +29650,6 @@ var init_parser2 = __esm({
         this.subgraph = this.RULE("subgraph", () => {
           this.CONSUME(SubgraphKeyword);
           this.OR([
-            {
-              ALT: () => {
-                this.CONSUME(Identifier, { LABEL: "subgraphId" });
-                this.OPTION(() => {
-                  this.CONSUME1(SquareOpen);
-                  this.SUBRULE(this.nodeContent);
-                  this.CONSUME1(SquareClose);
-                });
-              }
-            },
             {
               ALT: () => {
                 this.CONSUME(QuotedString, { LABEL: "subgraphTitleQ" });
@@ -28992,6 +29661,33 @@ var init_parser2 = __esm({
                 this.SUBRULE2(this.nodeContent);
                 this.CONSUME2(SquareClose);
               }
+            },
+            {
+              ALT: () => {
+                this.CONSUME1(Identifier, { LABEL: "subgraphIdOrFirstWord" });
+                this.OPTION(() => {
+                  this.OR1([
+                    {
+                      ALT: () => {
+                        this.CONSUME1(SquareOpen);
+                        this.SUBRULE(this.nodeContent);
+                        this.CONSUME1(SquareClose);
+                      }
+                    },
+                    {
+                      ALT: () => {
+                        this.AT_LEAST_ONE(() => {
+                          this.OR2([
+                            { ALT: () => this.CONSUME2(Identifier) },
+                            { ALT: () => this.CONSUME(Text) },
+                            { ALT: () => this.CONSUME(NumberLiteral) }
+                          ]);
+                        });
+                      }
+                    }
+                  ]);
+                });
+              }
             }
           ]);
           this.CONSUME(Newline);
@@ -29595,7 +30291,6 @@ var init_semantics = __esm({
             const last2 = allChildren[allChildren.length - 1];
             const isSlash = (t) => t.image === "/" || t.image === "\\";
             if (isSlash(first2) && isSlash(last2)) {
-              continue;
             }
           }
           const opens = ch.RoundOpen || [];
@@ -30389,16 +31084,19 @@ function mapFlowchartParserError(err, text) {
     const subgraphIdx = lineStr.indexOf("subgraph");
     if (subgraphIdx !== -1) {
       const afterSubgraph = lineStr.slice(subgraphIdx + 8).trim();
-      if (afterSubgraph && !afterSubgraph.startsWith('"') && !afterSubgraph.startsWith("'") && afterSubgraph.includes(" ")) {
-        return {
-          line,
-          column,
-          severity: "error",
-          code: "FL-SUBGRAPH-UNQUOTED-TITLE",
-          message: "Subgraph titles with spaces must be quoted.",
-          hint: 'Example: subgraph "Existing Logic Path" or use underscores: subgraph Existing_Logic_Path',
-          length: afterSubgraph.length
-        };
+      if (afterSubgraph && !afterSubgraph.startsWith('"') && !afterSubgraph.startsWith("'")) {
+        const hasHazard = /[\[\](){}/:|"'\\]/.test(afterSubgraph);
+        if (hasHazard) {
+          return {
+            line,
+            column,
+            severity: "error",
+            code: "FL-SUBGRAPH-UNQUOTED-TITLE",
+            message: "Subgraph title contains special characters; wrap it in quotes.",
+            hint: 'Example: subgraph "Streams (inside Gateway)"',
+            length: afterSubgraph.length
+          };
+        }
       }
     }
   }
@@ -31096,11 +31794,11 @@ function validateFlowchart(text, options = {}) {
         const byLine = /* @__PURE__ */ new Map();
         const collect = (arr) => {
           for (const e of arr || []) {
-            if (e && e.code === "FL-LABEL-PARENS-UNQUOTED") {
+            if (e && (e.code === "FL-LABEL-PARENS-UNQUOTED" || e.code === "FL-LABEL-AT-IN-UNQUOTED")) {
               const ln = e.line ?? 0;
               const col = e.column ?? 1;
               const list = byLine.get(ln) || [];
-              list.push(col);
+              list.push({ start: col, end: col });
               byLine.set(ln, list);
             }
           }
@@ -31109,33 +31807,91 @@ function validateFlowchart(text, options = {}) {
         collect(errs);
         const lines2 = text2.split(/\r?\n/);
         for (let ii = 0; ii < lines2.length; ii++) {
-          const raw2 = lines2[ii] || "";
-          if (!raw2.includes("[") || !raw2.includes("]"))
+          const raw = lines2[ii] || "";
+          if (!raw.includes("[") || !raw.includes("]"))
             continue;
-          let search2 = 0;
-          while (true) {
-            const open2 = raw2.indexOf("[", search2);
-            if (open2 === -1)
-              break;
-            const close2 = raw2.indexOf("]", open2 + 1);
-            if (close2 === -1)
-              break;
-            const seg2 = raw2.slice(open2 + 1, close2);
-            const trimmed2 = seg2.trim();
-            const ln2 = ii + 1;
-            const lsp = trimmed2.slice(0, 1);
-            const rsp = trimmed2.slice(-1);
-            const isSlashPair = (lsp === "/" || lsp === "\\") && (rsp === "/" || rsp === "\\");
-            const isParenWrapped = lsp === "(" && rsp === ")";
-            const segStartCol = open2 + 2;
-            const segEndCol = close2 + 1;
-            const existing = byLine.get(ln2) || [];
-            const covered = existing.some((c) => c >= segStartCol && c <= segEndCol);
-            if (!covered && !/^".*"$/.test(trimmed2) && (seg2.includes("(") || seg2.includes(")")) && !isSlashPair && !isParenWrapped) {
-              errs.push({ line: ln2, column: segStartCol, severity: "error", code: "FL-LABEL-PARENS-UNQUOTED", message: "Parentheses inside an unquoted label are not supported by Mermaid.", hint: 'Wrap the label in quotes, e.g., A["Mark (X)"] \u2014 or replace ( and ) with HTML entities: &#40; and &#41;.' });
-              byLine.set(ln2, existing.concat([segStartCol]));
+          let i = 0;
+          const n = raw.length;
+          let inQuote = false;
+          let esc = false;
+          while (i < n) {
+            const ch = raw[i];
+            if (inQuote) {
+              if (esc) {
+                esc = false;
+              } else if (ch === "\\") {
+                esc = true;
+              } else if (ch === '"') {
+                inQuote = false;
+              }
+              i++;
+              continue;
+            }
+            if (ch === '"') {
+              inQuote = true;
+              i++;
+              continue;
+            }
+            if (ch === "[") {
+              let j = i + 1;
+              let inQ = false;
+              let esc2 = false;
+              let depth = 1;
+              while (j < n && depth > 0) {
+                const cj = raw[j];
+                if (inQ) {
+                  if (esc2) {
+                    esc2 = false;
+                  } else if (cj === "\\") {
+                    esc2 = true;
+                  } else if (cj === '"') {
+                    inQ = false;
+                  }
+                  j++;
+                  continue;
+                }
+                if (cj === '"') {
+                  inQ = true;
+                  j++;
+                  continue;
+                }
+                if (cj === "[")
+                  depth++;
+                else if (cj === "]")
+                  depth--;
+                j++;
+              }
+              if (depth === 0) {
+                const startCol = i + 2;
+                const endCol = j;
+                const seg = raw.slice(i + 1, j - 1);
+                const trimmed = seg.trim();
+                const ln = ii + 1;
+                const lsp = trimmed.slice(0, 1), rsp = trimmed.slice(-1);
+                const isSlashPair = (lsp === "/" || lsp === "\\") && (rsp === "/" || rsp === "\\");
+                const isParenWrapped = lsp === "(" && rsp === ")";
+                const isQuoted = /^"[\s\S]*"$/.test(trimmed);
+                const existing = byLine.get(ln) || [];
+                const covered = existing.some((r) => !(endCol < r.start || startCol > r.end));
+                const hasParens = seg.includes("(") || seg.includes(")");
+                const hasAt = seg.includes("@");
+                if (!covered && !isQuoted && !isParenWrapped && hasParens) {
+                  errs.push({ line: ln, column: startCol, severity: "error", code: "FL-LABEL-PARENS-UNQUOTED", message: "Parentheses inside an unquoted label are not supported by Mermaid.", hint: 'Wrap the label in quotes, e.g., A["Mark (X)"] \u2014 or replace ( and ) with HTML entities: &#40; and &#41;.' });
+                  existing.push({ start: startCol, end: endCol });
+                  byLine.set(ln, existing);
+                }
+                if (!covered && !isQuoted && !isSlashPair && hasAt) {
+                  errs.push({ line: ln, column: startCol, severity: "error", code: "FL-LABEL-AT-IN-UNQUOTED", message: "'@' inside an unquoted label can be misparsed by Mermaid.", hint: 'Wrap the label in quotes, e.g., B["@probelabs/probe v0.6.0-rc149"]' });
+                  existing.push({ start: startCol, end: endCol });
+                  byLine.set(ln, existing);
+                }
+                i = j;
+                continue;
+              } else {
+                break;
+              }
             }
-            search2 = close2 + 1;
+            i++;
           }
         }
       }
@@ -42621,7 +43377,7 @@ var require_bk = __commonJS({
       return xs;
     }
     function buildBlockGraph(g, layering, root2, reverseSep) {
-      var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep2(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
+      var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep3(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
       _.forEach(layering, function(layer) {
         var u;
         _.forEach(layer, function(v) {
@@ -42711,7 +43467,7 @@ var require_bk = __commonJS({
       alignCoordinates(xss, smallestWidth);
       return balance(xss, g.graph().align);
     }
-    function sep2(nodeSep, edgeSep, reverseSep) {
+    function sep3(nodeSep, edgeSep, reverseSep) {
       return function(g, v, w) {
         var vLabel = g.node(v);
         var wLabel = g.node(w);
@@ -50005,7 +50761,7 @@ var require_compile = __commonJS({
       const schOrFunc = root2.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve5.call(this, root2, ref);
+      let _sch = resolve6.call(this, root2, ref);
       if (_sch === void 0) {
         const schema = (_a = root2.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -50032,7 +50788,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve5(root2, ref) {
+    function resolve6(root2, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -50607,7 +51363,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve5(baseURI, relativeURI, options) {
+    function resolve6(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -50834,7 +51590,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize2,
-      resolve: resolve5,
+      resolve: resolve6,
       resolveComponent,
       equal,
       serialize,
@@ -54852,15 +55608,15 @@ Provide only the corrected Mermaid diagram within a mermaid code block. Do not a
 });
 
 // src/agent/mcp/config.js
-import { readFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
+import { readFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join2, dirname as dirname3 } from "path";
 import { homedir } from "os";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!existsSync3(configPath)) {
+  if (!existsSync4(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
@@ -54889,7 +55645,7 @@ function loadMCPConfiguration() {
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
-    if (existsSync3(configPath)) {
+    if (existsSync4(configPath)) {
       try {
         const content = readFileSync(configPath, "utf8");
         config = JSON.parse(content);
@@ -54992,7 +55748,7 @@ var init_config = __esm({
   "src/agent/mcp/config.js"() {
     "use strict";
     __filename4 = fileURLToPath6(import.meta.url);
-    __dirname4 = dirname2(__filename4);
+    __dirname4 = dirname3(__filename4);
     DEFAULT_CONFIG = {
       mcpServers: {
         // Example probe server configuration
@@ -55181,12 +55937,12 @@ var init_client = __esm({
           const toolsResponse = await client.listTools();
           const toolCount = toolsResponse?.tools?.length || 0;
           if (toolsResponse && toolsResponse.tools) {
-            for (const tool3 of toolsResponse.tools) {
-              const qualifiedName = `${name}_${tool3.name}`;
+            for (const tool4 of toolsResponse.tools) {
+              const qualifiedName = `${name}_${tool4.name}`;
               this.tools.set(qualifiedName, {
-                ...tool3,
+                ...tool4,
                 serverName: name,
-                originalName: tool3.name
+                originalName: tool4.name
               });
               if (this.debug) {
                 console.error(`[MCP DEBUG]     Registered tool: ${qualifiedName}`);
@@ -55209,13 +55965,13 @@ var init_client = __esm({
        * @param {Object} args - Tool arguments
        */
       async callTool(toolName, args) {
-        const tool3 = this.tools.get(toolName);
-        if (!tool3) {
+        const tool4 = this.tools.get(toolName);
+        if (!tool4) {
           throw new Error(`Unknown tool: ${toolName}`);
         }
-        const clientInfo = this.clients.get(tool3.serverName);
+        const clientInfo = this.clients.get(tool4.serverName);
         if (!clientInfo) {
-          throw new Error(`Server ${tool3.serverName} not connected`);
+          throw new Error(`Server ${tool4.serverName} not connected`);
         }
         try {
           if (this.debug) {
@@ -55229,7 +55985,7 @@ var init_client = __esm({
           });
           const result = await Promise.race([
             clientInfo.client.callTool({
-              name: tool3.originalName,
+              name: tool4.originalName,
               arguments: args
             }),
             timeoutPromise
@@ -55252,11 +56008,11 @@ var init_client = __esm({
        */
       getTools() {
         const tools2 = {};
-        for (const [name, tool3] of this.tools.entries()) {
+        for (const [name, tool4] of this.tools.entries()) {
           tools2[name] = {
-            description: tool3.description,
-            inputSchema: tool3.inputSchema,
-            serverName: tool3.serverName
+            description: tool4.description,
+            inputSchema: tool4.inputSchema,
+            serverName: tool4.serverName
           };
         }
         return tools2;
@@ -55267,10 +56023,10 @@ var init_client = __esm({
        */
       getVercelTools() {
         const tools2 = {};
-        for (const [name, tool3] of this.tools.entries()) {
+        for (const [name, tool4] of this.tools.entries()) {
           tools2[name] = {
-            description: tool3.description,
-            inputSchema: tool3.inputSchema,
+            description: tool4.description,
+            inputSchema: tool4.inputSchema,
             execute: async (args) => {
               const result = await this.callTool(name, args);
               if (result.content && result.content[0]) {
@@ -55319,9 +56075,9 @@ var init_client = __esm({
 });
 
 // src/agent/mcp/xmlBridge.js
-function mcpToolToXmlDefinition(name, tool3) {
-  const description = tool3.description || "MCP tool";
-  const inputSchema = tool3.inputSchema || tool3.parameters || {};
+function mcpToolToXmlDefinition(name, tool4) {
+  const description = tool4.description || "MCP tool";
+  const inputSchema = tool4.inputSchema || tool4.parameters || {};
   let paramDocs = "";
   if (inputSchema.properties) {
     paramDocs = "\n\nParameters (provide as JSON object):";
@@ -55500,8 +56256,8 @@ var init_xmlBridge = __esm({
           const vercelTools = this.mcpManager.getVercelTools();
           this.mcpTools = vercelTools;
           const toolCount = Object.keys(vercelTools).length;
-          for (const [name, tool3] of Object.entries(vercelTools)) {
-            this.xmlDefinitions[name] = mcpToolToXmlDefinition(name, tool3);
+          for (const [name, tool4] of Object.entries(vercelTools)) {
+            this.xmlDefinitions[name] = mcpToolToXmlDefinition(name, tool4);
           }
           if (toolCount === 0) {
             console.error("[MCP INFO] MCP initialization complete: 0 tools loaded");
@@ -55548,14 +56304,14 @@ var init_xmlBridge = __esm({
           console.error(`[MCP DEBUG] Executing MCP tool: ${toolName}`);
           console.error(`[MCP DEBUG] Parameters:`, JSON.stringify(params, null, 2));
         }
-        const tool3 = this.mcpTools[toolName];
-        if (!tool3) {
+        const tool4 = this.mcpTools[toolName];
+        if (!tool4) {
           console.error(`[MCP ERROR] Unknown MCP tool: ${toolName}`);
           console.error(`[MCP ERROR] Available tools: ${this.getToolNames().join(", ")}`);
           throw new Error(`Unknown MCP tool: ${toolName}`);
         }
         try {
-          const result = await tool3.execute(params);
+          const result = await tool4.execute(params);
           if (this.debug) {
             console.error(`[MCP DEBUG] Tool ${toolName} executed successfully`);
           }
@@ -55609,22 +56365,800 @@ var init_mcp = __esm({
   }
 });
 
+// src/agent/RetryManager.js
+function isRetryableError(error, retryableErrors = DEFAULT_RETRYABLE_ERRORS) {
+  if (!error) return false;
+  const errorString = error.toString().toLowerCase();
+  const errorMessage = (error.message || "").toLowerCase();
+  const errorCode = (error.code || "").toLowerCase();
+  const errorType = (error.type || "").toLowerCase();
+  const statusCode = error.statusCode || error.status;
+  for (const pattern of retryableErrors) {
+    const lowerPattern = pattern.toLowerCase();
+    if (errorString.includes(lowerPattern) || errorMessage.includes(lowerPattern) || errorCode.includes(lowerPattern) || errorType.includes(lowerPattern) || statusCode?.toString() === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractErrorInfo(error) {
+  return {
+    message: error.message || error.toString(),
+    type: error.type || error.constructor.name,
+    code: error.code,
+    statusCode: error.statusCode || error.status,
+    provider: error.provider,
+    isRetryable: isRetryableError(error)
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+var DEFAULT_RETRYABLE_ERRORS, RetryManager;
+var init_RetryManager = __esm({
+  "src/agent/RetryManager.js"() {
+    "use strict";
+    DEFAULT_RETRYABLE_ERRORS = [
+      "Overloaded",
+      "overloaded",
+      "rate_limit",
+      "rate limit",
+      "429",
+      "500",
+      "502",
+      "503",
+      "504",
+      "timeout",
+      "ECONNRESET",
+      "ETIMEDOUT",
+      "ENOTFOUND",
+      "api_error"
+    ];
+    RetryManager = class {
+      /**
+       * Create a new RetryManager
+       * @param {Object} options - Configuration options
+       * @param {number} [options.maxRetries=3] - Maximum retry attempts
+       * @param {number} [options.initialDelay=1000] - Initial delay in ms (1 second)
+       * @param {number} [options.maxDelay=30000] - Maximum delay in ms (30 seconds)
+       * @param {number} [options.backoffFactor=2] - Exponential backoff multiplier
+       * @param {Array<string>} [options.retryableErrors] - List of retryable error patterns
+       * @param {boolean} [options.debug=false] - Enable debug logging
+       */
+      constructor(options = {}) {
+        this.maxRetries = this._validateNumber(options.maxRetries, 3, "maxRetries", 0, 100);
+        this.initialDelay = this._validateNumber(options.initialDelay, 1e3, "initialDelay", 0, 6e4);
+        this.maxDelay = this._validateNumber(options.maxDelay, 3e4, "maxDelay", 0, 3e5);
+        this.backoffFactor = this._validateNumber(options.backoffFactor, 2, "backoffFactor", 1, 10);
+        this.retryableErrors = options.retryableErrors || DEFAULT_RETRYABLE_ERRORS;
+        this.debug = options.debug ?? false;
+        this.jitter = options.jitter ?? true;
+        if (this.maxDelay < this.initialDelay) {
+          throw new Error("maxDelay must be greater than or equal to initialDelay");
+        }
+        this.stats = {
+          totalAttempts: 0,
+          totalRetries: 0,
+          successfulRetries: 0,
+          failedRetries: 0
+        };
+      }
+      /**
+       * Validate a numeric parameter
+       * @param {*} value - Value to validate
+       * @param {number} defaultValue - Default if undefined
+       * @param {string} name - Parameter name for error messages
+       * @param {number} min - Minimum allowed value
+       * @param {number} max - Maximum allowed value
+       * @returns {number} - Validated number
+       * @private
+       */
+      _validateNumber(value, defaultValue, name, min, max) {
+        if (value === void 0 || value === null) {
+          return defaultValue;
+        }
+        const num = Number(value);
+        if (isNaN(num)) {
+          throw new Error(`${name} must be a number, got: ${value}`);
+        }
+        if (num < min || num > max) {
+          throw new Error(`${name} must be between ${min} and ${max}, got: ${num}`);
+        }
+        return num;
+      }
+      /**
+       * Execute a function with retry logic
+       * @param {Function} fn - Async function to execute
+       * @param {Object} [context={}] - Context information for logging
+       * @param {AbortSignal} [context.signal] - Optional abort signal for cancellation
+       * @returns {Promise<*>} - Result from the function
+       * @throws {Error} - If all retries are exhausted or operation is aborted
+       */
+      async executeWithRetry(fn, context = {}) {
+        let lastError = null;
+        let currentDelay = this.initialDelay;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+          if (context.signal?.aborted) {
+            const abortError = new Error("Operation aborted");
+            abortError.name = "AbortError";
+            throw abortError;
+          }
+          this.stats.totalAttempts++;
+          try {
+            if (this.debug && attempt > 0) {
+              console.log(`[RetryManager] Retry attempt ${attempt}/${this.maxRetries}`, context);
+            }
+            const result = await fn();
+            if (attempt > 0) {
+              this.stats.successfulRetries++;
+              if (this.debug) {
+                console.log(`[RetryManager] \u2705 Retry successful on attempt ${attempt + 1}`, context);
+              }
+            }
+            return result;
+          } catch (error) {
+            lastError = error;
+            const errorInfo = extractErrorInfo(error);
+            const shouldRetry = isRetryableError(error, this.retryableErrors);
+            const hasRetriesLeft = attempt < this.maxRetries;
+            if (this.debug) {
+              console.log(`[RetryManager] \u274C Attempt ${attempt + 1}/${this.maxRetries + 1} failed:`, {
+                ...context,
+                error: errorInfo,
+                shouldRetry,
+                hasRetriesLeft
+              });
+            }
+            if (!shouldRetry) {
+              if (this.debug) {
+                console.log(`[RetryManager] Error is not retryable, failing immediately`, errorInfo);
+              }
+              throw error;
+            }
+            if (!hasRetriesLeft) {
+              this.stats.failedRetries++;
+              if (this.debug) {
+                console.log(`[RetryManager] Max retries (${this.maxRetries}) exhausted`, context);
+              }
+              throw error;
+            }
+            this.stats.totalRetries++;
+            let delayWithJitter = currentDelay;
+            if (this.jitter) {
+              const jitterAmount = currentDelay * 0.25;
+              delayWithJitter = currentDelay + (Math.random() * jitterAmount * 2 - jitterAmount);
+            }
+            if (this.debug) {
+              console.log(`[RetryManager] Waiting ${Math.round(delayWithJitter)}ms before retry...`);
+            }
+            await sleep(delayWithJitter);
+            currentDelay = Math.min(currentDelay * this.backoffFactor, this.maxDelay);
+          }
+        }
+        throw lastError;
+      }
+      /**
+       * Check if an error is retryable
+       * @param {Error} error - The error to check
+       * @returns {boolean} - True if error should be retried
+       */
+      isRetryable(error) {
+        return isRetryableError(error, this.retryableErrors);
+      }
+      /**
+       * Get retry statistics
+       * @returns {Object} - Statistics object
+       */
+      getStats() {
+        return { ...this.stats };
+      }
+      /**
+       * Reset statistics
+       */
+      resetStats() {
+        this.stats = {
+          totalAttempts: 0,
+          totalRetries: 0,
+          successfulRetries: 0,
+          failedRetries: 0
+        };
+      }
+    };
+  }
+});
+
+// src/agent/FallbackManager.js
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+function createFallbackManagerFromEnv(debug = false) {
+  const fallbackProvidersEnv = process.env.FALLBACK_PROVIDERS;
+  const fallbackModelsEnv = process.env.FALLBACK_MODELS;
+  if (!fallbackProvidersEnv && !fallbackModelsEnv) {
+    return null;
+  }
+  let providers = [];
+  let models = [];
+  let strategy = FALLBACK_STRATEGIES.ANY;
+  if (fallbackProvidersEnv) {
+    try {
+      if (typeof fallbackProvidersEnv !== "string" || fallbackProvidersEnv.length > 1e4) {
+        console.error("[FallbackManager] FALLBACK_PROVIDERS must be a valid JSON string under 10KB");
+        return null;
+      }
+      const parsed = JSON.parse(fallbackProvidersEnv);
+      if (!Array.isArray(parsed)) {
+        console.error("[FallbackManager] FALLBACK_PROVIDERS must be a JSON array");
+        return null;
+      }
+      providers = parsed;
+      strategy = FALLBACK_STRATEGIES.CUSTOM;
+    } catch (error) {
+      console.error("[FallbackManager] Failed to parse FALLBACK_PROVIDERS:", error.message);
+      return null;
+    }
+  }
+  if (fallbackModelsEnv) {
+    try {
+      if (typeof fallbackModelsEnv !== "string" || fallbackModelsEnv.length > 1e4) {
+        console.error("[FallbackManager] FALLBACK_MODELS must be a valid JSON string under 10KB");
+        return null;
+      }
+      const parsed = JSON.parse(fallbackModelsEnv);
+      if (!Array.isArray(parsed)) {
+        console.error("[FallbackManager] FALLBACK_MODELS must be a JSON array");
+        return null;
+      }
+      models = parsed;
+      strategy = FALLBACK_STRATEGIES.SAME_PROVIDER;
+    } catch (error) {
+      console.error("[FallbackManager] Failed to parse FALLBACK_MODELS:", error.message);
+      return null;
+    }
+  }
+  const maxTotalAttempts = process.env.FALLBACK_MAX_TOTAL_ATTEMPTS ? (() => {
+    const val = parseInt(process.env.FALLBACK_MAX_TOTAL_ATTEMPTS, 10);
+    if (isNaN(val) || val < 1 || val > 100) {
+      console.warn("[FallbackManager] FALLBACK_MAX_TOTAL_ATTEMPTS must be between 1 and 100, using default: 10");
+      return 10;
+    }
+    return val;
+  })() : 10;
+  return new FallbackManager({
+    strategy,
+    providers,
+    models,
+    maxTotalAttempts,
+    debug
+  });
+}
+function buildFallbackProvidersFromEnv(options = {}) {
+  const providers = [];
+  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;
+  const awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID;
+  const awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+  const awsRegion = process.env.AWS_REGION;
+  const awsApiKey = process.env.AWS_BEDROCK_API_KEY;
+  const llmBaseUrl = process.env.LLM_BASE_URL;
+  const anthropicApiUrl = process.env.ANTHROPIC_API_URL || process.env.ANTHROPIC_BASE_URL || llmBaseUrl;
+  const openaiApiUrl = process.env.OPENAI_API_URL || llmBaseUrl;
+  const googleApiUrl = process.env.GOOGLE_API_URL || llmBaseUrl;
+  const awsBedrockBaseUrl = process.env.AWS_BEDROCK_BASE_URL || llmBaseUrl;
+  const primaryProvider = options.primaryProvider?.toLowerCase();
+  const primaryModel = options.primaryModel;
+  if (primaryProvider === "anthropic" && anthropicApiKey) {
+    providers.push({
+      provider: "anthropic",
+      apiKey: anthropicApiKey,
+      ...anthropicApiUrl && { baseURL: anthropicApiUrl },
+      ...primaryModel && { model: primaryModel }
+    });
+  } else if (primaryProvider === "openai" && openaiApiKey) {
+    providers.push({
+      provider: "openai",
+      apiKey: openaiApiKey,
+      ...openaiApiUrl && { baseURL: openaiApiUrl },
+      ...primaryModel && { model: primaryModel }
+    });
+  } else if (primaryProvider === "google" && googleApiKey) {
+    providers.push({
+      provider: "google",
+      apiKey: googleApiKey,
+      ...googleApiUrl && { baseURL: googleApiUrl },
+      ...primaryModel && { model: primaryModel }
+    });
+  } else if (primaryProvider === "bedrock" && (awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey)) {
+    const config = { provider: "bedrock" };
+    if (awsApiKey) {
+      config.apiKey = awsApiKey;
+    } else {
+      config.accessKeyId = awsAccessKeyId;
+      config.secretAccessKey = awsSecretAccessKey;
+      config.region = awsRegion;
+      if (process.env.AWS_SESSION_TOKEN) {
+        config.sessionToken = process.env.AWS_SESSION_TOKEN;
+      }
+    }
+    if (awsBedrockBaseUrl) config.baseURL = awsBedrockBaseUrl;
+    if (primaryModel) config.model = primaryModel;
+    providers.push(config);
+  }
+  if (anthropicApiKey && primaryProvider !== "anthropic") {
+    providers.push({
+      provider: "anthropic",
+      apiKey: anthropicApiKey,
+      ...anthropicApiUrl && { baseURL: anthropicApiUrl }
+    });
+  }
+  if (openaiApiKey && primaryProvider !== "openai") {
+    providers.push({
+      provider: "openai",
+      apiKey: openaiApiKey,
+      ...openaiApiUrl && { baseURL: openaiApiUrl }
+    });
+  }
+  if (googleApiKey && primaryProvider !== "google") {
+    providers.push({
+      provider: "google",
+      apiKey: googleApiKey,
+      ...googleApiUrl && { baseURL: googleApiUrl }
+    });
+  }
+  if ((awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey) && primaryProvider !== "bedrock") {
+    const config = { provider: "bedrock" };
+    if (awsApiKey) {
+      config.apiKey = awsApiKey;
+    } else {
+      config.accessKeyId = awsAccessKeyId;
+      config.secretAccessKey = awsSecretAccessKey;
+      config.region = awsRegion;
+      if (process.env.AWS_SESSION_TOKEN) {
+        config.sessionToken = process.env.AWS_SESSION_TOKEN;
+      }
+    }
+    if (awsBedrockBaseUrl) config.baseURL = awsBedrockBaseUrl;
+    providers.push(config);
+  }
+  return providers;
+}
+var FALLBACK_STRATEGIES, DEFAULT_MODELS, FallbackManager;
+var init_FallbackManager = __esm({
+  "src/agent/FallbackManager.js"() {
+    "use strict";
+    FALLBACK_STRATEGIES = {
+      SAME_MODEL: "same-model",
+      // Try same model on different providers
+      SAME_PROVIDER: "same-provider",
+      // Try different models on same provider
+      ANY: "any",
+      // Try any available provider/model
+      CUSTOM: "custom"
+      // Use custom provider list
+    };
+    DEFAULT_MODELS = {
+      anthropic: "claude-sonnet-4-5-20250929",
+      openai: "gpt-4o",
+      google: "gemini-2.0-flash-exp",
+      bedrock: "anthropic.claude-sonnet-4-20250514-v1:0"
+    };
+    FallbackManager = class {
+      /**
+       * Create a new FallbackManager
+       * @param {Object} options - Configuration options
+       * @param {string} [options.strategy='any'] - Fallback strategy
+       * @param {Array<string>} [options.models] - List of models for same-provider fallback
+       * @param {Array<ProviderConfig>} [options.providers] - List of provider configurations
+       * @param {boolean} [options.stopOnSuccess=true] - Stop on first success
+       * @param {boolean} [options.continueOnNonRetryableError=false] - Continue to fallback on non-retryable errors
+       * @param {number} [options.maxTotalAttempts=10] - Maximum total attempts across all providers
+       * @param {boolean} [options.debug=false] - Enable debug logging
+       */
+      constructor(options = {}) {
+        this.strategy = options.strategy || FALLBACK_STRATEGIES.ANY;
+        this.models = Array.isArray(options.models) ? options.models : [];
+        this.providers = Array.isArray(options.providers) ? options.providers : [];
+        this.stopOnSuccess = options.stopOnSuccess ?? true;
+        this.continueOnNonRetryableError = options.continueOnNonRetryableError ?? false;
+        this.debug = options.debug ?? false;
+        const maxAttempts = options.maxTotalAttempts ?? 10;
+        if (typeof maxAttempts !== "number" || isNaN(maxAttempts) || maxAttempts < 1 || maxAttempts > 100) {
+          throw new Error(`FallbackManager: maxTotalAttempts must be a number between 1 and 100, got: ${maxAttempts}`);
+        }
+        this.maxTotalAttempts = maxAttempts;
+        this.stats = {
+          totalAttempts: 0,
+          providerAttempts: {},
+          successfulProvider: null,
+          failedProviders: []
+        };
+        this._validateConfiguration();
+      }
+      /**
+       * Validate the fallback configuration
+       * @private
+       */
+      _validateConfiguration() {
+        if (this.strategy === FALLBACK_STRATEGIES.SAME_PROVIDER && this.models.length === 0) {
+          throw new Error('FallbackManager: strategy "same-provider" requires models list');
+        }
+        if (this.strategy === FALLBACK_STRATEGIES.CUSTOM && this.providers.length === 0) {
+          throw new Error('FallbackManager: strategy "custom" requires providers list');
+        }
+        for (const config of this.providers) {
+          if (!config.provider) {
+            throw new Error('FallbackManager: Each provider config must have a "provider" field');
+          }
+          if (!["anthropic", "openai", "google", "bedrock"].includes(config.provider)) {
+            throw new Error(`FallbackManager: Invalid provider "${config.provider}". Must be: anthropic, openai, google, or bedrock`);
+          }
+          if (config.provider === "bedrock") {
+            const hasCredentials = config.accessKeyId && config.secretAccessKey && config.region;
+            const hasApiKey = config.apiKey;
+            if (!hasCredentials && !hasApiKey) {
+              throw new Error("FallbackManager: Bedrock provider requires either (accessKeyId, secretAccessKey, region) or apiKey");
+            }
+          } else {
+            if (!config.apiKey) {
+              throw new Error(`FallbackManager: Provider "${config.provider}" requires apiKey`);
+            }
+          }
+        }
+      }
+      /**
+       * Create a provider instance from configuration
+       * @param {ProviderConfig} config - Provider configuration
+       * @returns {Object} - Provider instance
+       * @throws {Error} - If provider creation fails
+       * @private
+       */
+      _createProviderInstance(config) {
+        try {
+          switch (config.provider) {
+            case "anthropic":
+              return createAnthropic({
+                apiKey: config.apiKey,
+                ...config.baseURL && { baseURL: config.baseURL }
+              });
+            case "openai":
+              return createOpenAI({
+                compatibility: "strict",
+                apiKey: config.apiKey,
+                ...config.baseURL && { baseURL: config.baseURL }
+              });
+            case "google":
+              return createGoogleGenerativeAI({
+                apiKey: config.apiKey,
+                ...config.baseURL && { baseURL: config.baseURL }
+              });
+            case "bedrock": {
+              const bedrockConfig = {};
+              if (config.apiKey) {
+                bedrockConfig.apiKey = config.apiKey;
+              } else if (config.accessKeyId && config.secretAccessKey) {
+                bedrockConfig.accessKeyId = config.accessKeyId;
+                bedrockConfig.secretAccessKey = config.secretAccessKey;
+                if (config.sessionToken) {
+                  bedrockConfig.sessionToken = config.sessionToken;
+                }
+              }
+              if (config.region) {
+                bedrockConfig.region = config.region;
+              }
+              if (config.baseURL) {
+                bedrockConfig.baseURL = config.baseURL;
+              }
+              return createAmazonBedrock(bedrockConfig);
+            }
+            default:
+              throw new Error(`FallbackManager: Unknown provider "${config.provider}"`);
+          }
+        } catch (error) {
+          const providerName = this._getProviderDisplayName(config);
+          throw new Error(`Failed to create provider instance for ${providerName}: ${error.message}`);
+        }
+      }
+      /**
+       * Get the model name for a provider configuration
+       * @param {ProviderConfig} config - Provider configuration
+       * @returns {string} - Model name
+       * @private
+       */
+      _getModelName(config) {
+        return config.model || DEFAULT_MODELS[config.provider];
+      }
+      /**
+       * Get provider display name for logging
+       * @param {ProviderConfig} config - Provider configuration
+       * @returns {string} - Display name
+       * @private
+       */
+      _getProviderDisplayName(config) {
+        const model = this._getModelName(config);
+        const provider = config.provider;
+        const url = config.baseURL ? ` (${config.baseURL})` : "";
+        return `${provider}/${model}${url}`;
+      }
+      /**
+       * Execute a function with fallback support
+       * @param {Function} fn - Function that takes (provider, model, config) and returns a Promise
+       * @returns {Promise<*>} - Result from the function
+       * @throws {Error} - If all fallbacks are exhausted
+       */
+      async executeWithFallback(fn) {
+        if (this.providers.length === 0) {
+          throw new Error("FallbackManager: No providers configured for fallback");
+        }
+        let lastError = null;
+        let totalAttempts = 0;
+        for (const config of this.providers) {
+          if (totalAttempts >= this.maxTotalAttempts) {
+            if (this.debug) {
+              console.log(`[FallbackManager] \u26A0\uFE0F  Max total attempts (${this.maxTotalAttempts}) reached`);
+            }
+            break;
+          }
+          totalAttempts++;
+          this.stats.totalAttempts++;
+          const providerName = this._getProviderDisplayName(config);
+          this.stats.providerAttempts[providerName] = (this.stats.providerAttempts[providerName] || 0) + 1;
+          try {
+            if (this.debug) {
+              console.log(`[FallbackManager] Attempting provider: ${providerName} (attempt ${totalAttempts}/${this.maxTotalAttempts})`);
+            }
+            const provider = this._createProviderInstance(config);
+            const model = this._getModelName(config);
+            const result = await fn(provider, model, config);
+            this.stats.successfulProvider = providerName;
+            if (this.debug) {
+              console.log(`[FallbackManager] \u2705 Success with provider: ${providerName}`);
+            }
+            return result;
+          } catch (error) {
+            lastError = error;
+            const errorInfo = {
+              message: error.message || error.toString(),
+              type: error.type || error.constructor.name,
+              statusCode: error.statusCode || error.status
+            };
+            this.stats.failedProviders.push({
+              provider: providerName,
+              error: errorInfo
+            });
+            if (this.debug) {
+              console.log(`[FallbackManager] \u274C Failed with provider: ${providerName}`, errorInfo);
+            }
+            if (!this.continueOnNonRetryableError && error.nonRetryable) {
+              if (this.debug) {
+                console.log(`[FallbackManager] Non-retryable error, stopping fallback chain`);
+              }
+              throw error;
+            }
+            if (this.debug) {
+              const remaining = this.providers.length - (this.providers.indexOf(config) + 1);
+              console.log(`[FallbackManager] Trying next provider (${remaining} remaining)...`);
+            }
+          }
+        }
+        if (this.debug) {
+          console.log(`[FallbackManager] \u274C All providers exhausted. Total attempts: ${totalAttempts}`);
+        }
+        const fallbackError = new Error(
+          `All provider fallbacks exhausted after ${totalAttempts} attempts. Last error: ${lastError?.message || "Unknown error"}`
+        );
+        fallbackError.cause = lastError;
+        fallbackError.stats = this.getStats();
+        fallbackError.allProvidersFailed = true;
+        throw fallbackError;
+      }
+      /**
+       * Get fallback statistics
+       * @returns {Object} - Statistics object
+       */
+      getStats() {
+        return {
+          ...this.stats,
+          providerAttempts: { ...this.stats.providerAttempts },
+          failedProviders: [...this.stats.failedProviders]
+        };
+      }
+      /**
+       * Reset statistics
+       */
+      resetStats() {
+        this.stats = {
+          totalAttempts: 0,
+          providerAttempts: {},
+          successfulProvider: null,
+          failedProviders: []
+        };
+      }
+    };
+  }
+});
+
+// src/agent/contextCompactor.js
+var contextCompactor_exports = {};
+__export(contextCompactor_exports, {
+  calculateCompactionStats: () => calculateCompactionStats,
+  compactMessages: () => compactMessages,
+  handleContextLimitError: () => handleContextLimitError,
+  identifyMessageSegments: () => identifyMessageSegments,
+  isContextLimitError: () => isContextLimitError
+});
+function isContextLimitError(error) {
+  if (!error) return false;
+  const errorMessage = (typeof error === "string" ? error : error?.message || "").toLowerCase();
+  const errorString = error.toString().toLowerCase();
+  for (const pattern of CONTEXT_LIMIT_ERROR_PATTERNS) {
+    const lowerPattern = pattern.toLowerCase();
+    if (errorMessage.includes(lowerPattern) || errorString.includes(lowerPattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function identifyMessageSegments(messages) {
+  const segments = [];
+  let currentSegment = null;
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === "system") {
+      continue;
+    }
+    if (msg.role === "user") {
+      const content = typeof msg.content === "string" ? msg.content : "";
+      const isToolResult = content.includes("<tool_result>");
+      if (isToolResult && currentSegment) {
+        currentSegment.finalIndex = i;
+        segments.push(currentSegment);
+        currentSegment = null;
+      } else {
+        if (currentSegment) {
+          segments.push(currentSegment);
+        }
+        currentSegment = {
+          userIndex: i,
+          monologueIndices: [],
+          finalIndex: null
+        };
+      }
+    }
+    if (msg.role === "assistant" && currentSegment) {
+      const content = typeof msg.content === "string" ? msg.content : "";
+      if (content.includes("<attempt_completion>") || content.includes("attempt_completion")) {
+        currentSegment.monologueIndices.push(i);
+        currentSegment.finalIndex = i;
+        segments.push(currentSegment);
+        currentSegment = null;
+      } else {
+        currentSegment.monologueIndices.push(i);
+      }
+    }
+  }
+  if (currentSegment) {
+    segments.push(currentSegment);
+  }
+  return segments;
+}
+function compactMessages(messages, options = {}) {
+  const {
+    keepLastSegment = true,
+    minSegmentsToKeep = 1
+  } = options;
+  if (!messages || messages.length === 0) {
+    return messages;
+  }
+  const segments = identifyMessageSegments(messages);
+  if (segments.length === 0) {
+    return messages;
+  }
+  const segmentsToPreserve = keepLastSegment ? Math.max(minSegmentsToKeep, 1) : minSegmentsToKeep;
+  const compactableSegments = segments.slice(0, -segmentsToPreserve);
+  const preservedSegments = segments.slice(-segmentsToPreserve);
+  const indicesToKeep = /* @__PURE__ */ new Set();
+  messages.forEach((msg, idx) => {
+    if (msg.role === "system") {
+      indicesToKeep.add(idx);
+    }
+  });
+  compactableSegments.forEach((segment) => {
+    indicesToKeep.add(segment.userIndex);
+    if (segment.finalIndex !== null) {
+      indicesToKeep.add(segment.finalIndex);
+    }
+  });
+  preservedSegments.forEach((segment) => {
+    indicesToKeep.add(segment.userIndex);
+    segment.monologueIndices.forEach((idx) => indicesToKeep.add(idx));
+    if (segment.finalIndex !== null) {
+      indicesToKeep.add(segment.finalIndex);
+    }
+  });
+  const compactedMessages = messages.filter((_, idx) => indicesToKeep.has(idx));
+  return compactedMessages;
+}
+function calculateCompactionStats(originalMessages, compactedMessages) {
+  const originalCount = originalMessages.length;
+  const compactedCount = compactedMessages.length;
+  const removed = originalCount - compactedCount;
+  const reductionPercent = originalCount > 0 ? (removed / originalCount * 100).toFixed(1) : 0;
+  const estimateTokens = (msgs) => {
+    return msgs.reduce((sum, msg) => {
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      return sum + Math.ceil(content.length / 4);
+    }, 0);
+  };
+  const originalTokens = estimateTokens(originalMessages);
+  const compactedTokens = estimateTokens(compactedMessages);
+  const tokensSaved = originalTokens - compactedTokens;
+  return {
+    originalCount,
+    compactedCount,
+    removed,
+    reductionPercent: parseFloat(reductionPercent),
+    originalTokens,
+    compactedTokens,
+    tokensSaved
+  };
+}
+function handleContextLimitError(error, messages, options = {}) {
+  if (!isContextLimitError(error)) {
+    return null;
+  }
+  const compactedMessages = compactMessages(messages, options);
+  const stats = calculateCompactionStats(messages, compactedMessages);
+  return {
+    compacted: true,
+    messages: compactedMessages,
+    stats
+  };
+}
+var CONTEXT_LIMIT_ERROR_PATTERNS;
+var init_contextCompactor = __esm({
+  "src/agent/contextCompactor.js"() {
+    "use strict";
+    CONTEXT_LIMIT_ERROR_PATTERNS = [
+      // Anthropic
+      "context_length_exceeded",
+      "prompt is too long",
+      // OpenAI
+      "maximum context length",
+      "context length is",
+      // Google/Gemini
+      "input token count exceeds",
+      "token limit exceeded",
+      // Generic patterns
+      "context window",
+      "too many tokens",
+      "token limit",
+      "context limit",
+      "exceed",
+      // Catches "exceeds", "exceed maximum", etc.
+      "over the limit",
+      "maximum tokens"
+    ];
+  }
+});
+
 // src/agent/ProbeAgent.js
 var ProbeAgent_exports = {};
 __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
 import dotenv2 from "dotenv";
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
+import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI as createGoogleGenerativeAI2 } from "@ai-sdk/google";
+import { createAmazonBedrock as createAmazonBedrock2 } from "@ai-sdk/amazon-bedrock";
 import { streamText } from "ai";
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter as EventEmitter3 } from "events";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { readFile, stat } from "fs/promises";
-import { resolve as resolve3, isAbsolute, dirname as dirname3 } from "path";
+import { resolve as resolve4, isAbsolute as isAbsolute2, dirname as dirname4 } from "path";
 var MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
@@ -55641,8 +57175,18 @@ var init_ProbeAgent = __esm({
     init_schemaUtils();
     init_xmlParsingUtils();
     init_mcp();
+    init_RetryManager();
+    init_FallbackManager();
+    init_contextCompactor();
     dotenv2.config();
-    MAX_TOOL_ITERATIONS = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
+    MAX_TOOL_ITERATIONS = (() => {
+      const val = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
+      if (isNaN(val) || val < 1 || val > 200) {
+        console.warn("[ProbeAgent] MAX_TOOL_ITERATIONS must be between 1 and 200, using default: 30");
+        return 30;
+      }
+      return val;
+    })();
     MAX_HISTORY_MESSAGES = 100;
     MAX_IMAGE_FILE_SIZE = 20 * 1024 * 1024;
     ProbeAgent = class _ProbeAgent {
@@ -55669,6 +57213,20 @@ var init_ProbeAgent = __esm({
        * @param {Array} [options.mcpServers] - Deprecated, use mcpConfig instead
        * @param {Object} [options.storageAdapter] - Custom storage adapter for history management
        * @param {Object} [options.hooks] - Hook callbacks for events (e.g., {'tool:start': callback})
+       * @param {Array<string>|null} [options.allowedTools] - List of allowed tool names. Use ['*'] for all tools (default), [] or null for no tools (raw AI mode), or specific tool names like ['search', 'query', 'extract']. Supports exclusion with '!' prefix (e.g., ['*', '!bash'])
+       * @param {boolean} [options.disableTools=false] - Convenience flag to disable all tools (equivalent to allowedTools: []). Takes precedence over allowedTools if set.
+       * @param {Object} [options.retry] - Retry configuration
+       * @param {number} [options.retry.maxRetries=3] - Maximum retry attempts per provider
+       * @param {number} [options.retry.initialDelay=1000] - Initial delay in ms
+       * @param {number} [options.retry.maxDelay=30000] - Maximum delay in ms
+       * @param {number} [options.retry.backoffFactor=2] - Exponential backoff multiplier
+       * @param {Array<string>} [options.retry.retryableErrors] - List of retryable error patterns
+       * @param {Object} [options.fallback] - Fallback configuration
+       * @param {string} [options.fallback.strategy] - Fallback strategy: 'same-model', 'same-provider', 'any', 'custom'
+       * @param {Array<string>} [options.fallback.models] - List of models for same-provider fallback
+       * @param {Array<Object>} [options.fallback.providers] - List of provider configurations for custom fallback
+       * @param {boolean} [options.fallback.stopOnSuccess=true] - Stop on first success
+       * @param {number} [options.fallback.maxTotalAttempts=10] - Maximum total attempts across all providers
        */
       constructor(options = {}) {
         this.sessionId = options.sessionId || randomUUID4();
@@ -55680,10 +57238,18 @@ var init_ProbeAgent = __esm({
         this.cancelled = false;
         this.tracer = options.tracer || null;
         this.outline = !!options.outline;
-        this.maxResponseTokens = options.maxResponseTokens || parseInt(process.env.MAX_RESPONSE_TOKENS || "0", 10) || null;
+        this.maxResponseTokens = options.maxResponseTokens || (() => {
+          const val = parseInt(process.env.MAX_RESPONSE_TOKENS || "0", 10);
+          if (isNaN(val) || val < 0 || val > 2e5) {
+            return null;
+          }
+          return val || null;
+        })();
         this.maxIterations = options.maxIterations || null;
         this.disableMermaidValidation = !!options.disableMermaidValidation;
         this.disableJsonValidation = !!options.disableJsonValidation;
+        const effectiveAllowedTools = options.disableTools ? [] : options.allowedTools;
+        this.allowedTools = this._parseAllowedTools(effectiveAllowedTools);
         this.storageAdapter = options.storageAdapter || new InMemoryStorageAdapter();
         this.hooks = new HookManager();
         if (options.hooks) {
@@ -55721,8 +57287,67 @@ var init_ProbeAgent = __esm({
         this.mcpServers = options.mcpServers || null;
         this.mcpBridge = null;
         this._mcpInitialized = false;
+        this.retryConfig = options.retry || {};
+        this.retryManager = null;
+        this.fallbackConfig = options.fallback || null;
+        this.fallbackManager = null;
         this.initializeModel();
       }
+      /**
+       * Parse allowedTools configuration
+       * @param {Array<string>|null|undefined} allowedTools - Tool filtering configuration
+       * @returns {Object} Parsed configuration with isEnabled method
+       * @private
+       */
+      _parseAllowedTools(allowedTools) {
+        const matchesPattern2 = (toolName, pattern) => {
+          if (!pattern.includes("*")) {
+            return toolName === pattern;
+          }
+          const regexPattern = pattern.replace(/\*/g, ".*");
+          return new RegExp(`^${regexPattern}$`).test(toolName);
+        };
+        if (!allowedTools || Array.isArray(allowedTools) && allowedTools.includes("*")) {
+          const exclusions = Array.isArray(allowedTools) ? allowedTools.filter((t) => t.startsWith("!")).map((t) => t.slice(1)) : [];
+          return {
+            mode: "all",
+            exclusions,
+            isEnabled: (toolName) => !exclusions.some((pattern) => matchesPattern2(toolName, pattern))
+          };
+        }
+        if (Array.isArray(allowedTools) && allowedTools.length === 0) {
+          return {
+            mode: "none",
+            isEnabled: () => false
+          };
+        }
+        const allowedPatterns = allowedTools.filter((t) => !t.startsWith("!"));
+        return {
+          mode: "whitelist",
+          allowed: allowedPatterns,
+          isEnabled: (toolName) => allowedPatterns.some((pattern) => matchesPattern2(toolName, pattern))
+        };
+      }
+      /**
+       * Check if an MCP tool is allowed based on allowedTools configuration
+       * Uses mcp__ prefix convention (like Claude Code)
+       * @param {string} toolName - The MCP tool name (without mcp__ prefix)
+       * @returns {boolean} - Whether the tool is allowed
+       * @private
+       */
+      _isMcpToolAllowed(toolName) {
+        const mcpToolName = `mcp__${toolName}`;
+        return this.allowedTools.isEnabled(mcpToolName) || this.allowedTools.isEnabled(toolName);
+      }
+      /**
+       * Filter MCP tools based on allowedTools configuration
+       * @param {string[]} mcpToolNames - Array of MCP tool names
+       * @returns {string[]} - Filtered array of allowed MCP tool names
+       * @private
+       */
+      _filterMcpTools(mcpToolNames) {
+        return mcpToolNames.filter((toolName) => this._isMcpToolAllowed(toolName));
+      }
       /**
        * Initialize the agent asynchronously (must be called after constructor)
        * This method initializes MCP and merges MCP tools into the tool list, and loads history from storage
@@ -55749,7 +57374,11 @@ var init_ProbeAgent = __esm({
             if (this.mcpBridge) {
               const mcpTools = this.mcpBridge.mcpTools || {};
               for (const [toolName, toolImpl] of Object.entries(mcpTools)) {
-                this.toolImplementations[toolName] = toolImpl;
+                if (this._isMcpToolAllowed(toolName)) {
+                  this.toolImplementations[toolName] = toolImpl;
+                } else if (this.debug) {
+                  console.error(`[DEBUG] MCP tool '${toolName}' filtered out by allowedTools`);
+                }
               }
             }
             if (this.debug) {
@@ -55805,6 +57434,14 @@ var init_ProbeAgent = __esm({
         if (this.enableBash && wrappedTools.bashToolInstance) {
           this.toolImplementations.bash = wrappedTools.bashToolInstance;
         }
+        if (this.allowEdit) {
+          if (wrappedTools.editToolInstance) {
+            this.toolImplementations.edit = wrappedTools.editToolInstance;
+          }
+          if (wrappedTools.createToolInstance) {
+            this.toolImplementations.create = wrappedTools.createToolInstance;
+          }
+        }
         this.wrappedTools = wrappedTools;
         if (this.debug) {
           console.error("\n[DEBUG] ========================================");
@@ -55855,36 +57492,147 @@ var init_ProbeAgent = __esm({
         if (forceProvider) {
           if (forceProvider === "anthropic" && anthropicApiKey) {
             this.initializeAnthropicModel(anthropicApiKey, anthropicApiUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           } else if (forceProvider === "openai" && openaiApiKey) {
             this.initializeOpenAIModel(openaiApiKey, openaiApiUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           } else if (forceProvider === "google" && googleApiKey) {
             this.initializeGoogleModel(googleApiKey, googleApiUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           } else if (forceProvider === "bedrock" && (awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey)) {
             this.initializeBedrockModel(awsAccessKeyId, awsSecretAccessKey, awsRegion, awsSessionToken, awsApiKey, awsBedrockBaseUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           }
           console.warn(`WARNING: Forced provider "${forceProvider}" selected but required API key is missing or invalid! Falling back to auto-detection.`);
         }
         if (anthropicApiKey) {
           this.initializeAnthropicModel(anthropicApiKey, anthropicApiUrl, modelName);
+          this.initializeFallbackManager("anthropic", modelName);
         } else if (openaiApiKey) {
           this.initializeOpenAIModel(openaiApiKey, openaiApiUrl, modelName);
+          this.initializeFallbackManager("openai", modelName);
         } else if (googleApiKey) {
           this.initializeGoogleModel(googleApiKey, googleApiUrl, modelName);
+          this.initializeFallbackManager("google", modelName);
         } else if (awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey) {
           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.");
         }
       }
+      /**
+       * Initialize fallback manager based on configuration
+       * @param {string} primaryProvider - The primary provider being used
+       * @param {string} primaryModel - The primary model being used
+       * @private
+       */
+      initializeFallbackManager(primaryProvider, primaryModel) {
+        if (this.fallbackConfig === false || process.env.DISABLE_FALLBACK === "1") {
+          return;
+        }
+        if (this.fallbackConfig && this.fallbackConfig.providers) {
+          try {
+            this.fallbackManager = new FallbackManager({
+              ...this.fallbackConfig,
+              debug: this.debug
+            });
+            if (this.debug) {
+              console.log(`[DEBUG] Fallback manager initialized with ${this.fallbackManager.providers.length} providers`);
+            }
+          } catch (error) {
+            console.error("[WARNING] Failed to initialize fallback manager:", error.message);
+          }
+          return;
+        }
+        const envFallbackManager = createFallbackManagerFromEnv(this.debug);
+        if (envFallbackManager) {
+          this.fallbackManager = envFallbackManager;
+          if (this.debug) {
+            console.log(`[DEBUG] Fallback manager initialized from environment variables`);
+          }
+          return;
+        }
+        if (process.env.AUTO_FALLBACK === "1" || this.fallbackConfig?.auto) {
+          const providers = buildFallbackProvidersFromEnv({
+            primaryProvider,
+            primaryModel
+          });
+          if (providers.length > 1) {
+            try {
+              this.fallbackManager = new FallbackManager({
+                strategy: "custom",
+                providers,
+                debug: this.debug
+              });
+              if (this.debug) {
+                console.log(`[DEBUG] Auto-fallback enabled with ${providers.length} providers`);
+              }
+            } catch (error) {
+              console.error("[WARNING] Failed to initialize auto-fallback:", error.message);
+            }
+          }
+        }
+      }
+      /**
+       * Execute streamText with retry and fallback support
+       * @param {Object} options - streamText options
+       * @returns {Promise<Object>} - streamText result
+       * @private
+       */
+      async streamTextWithRetryAndFallback(options) {
+        if (!this.retryManager) {
+          this.retryManager = new RetryManager({
+            maxRetries: this.retryConfig.maxRetries ?? 3,
+            initialDelay: this.retryConfig.initialDelay ?? 1e3,
+            maxDelay: this.retryConfig.maxDelay ?? 3e4,
+            backoffFactor: this.retryConfig.backoffFactor ?? 2,
+            retryableErrors: this.retryConfig.retryableErrors,
+            debug: this.debug
+          });
+        }
+        if (!this.fallbackManager) {
+          return await this.retryManager.executeWithRetry(
+            () => streamText(options),
+            {
+              provider: this.apiType,
+              model: this.model
+            }
+          );
+        }
+        return await this.fallbackManager.executeWithFallback(
+          async (provider, model, config) => {
+            const fallbackOptions = {
+              ...options,
+              model: provider(model)
+            };
+            const providerRetryManager = new RetryManager({
+              maxRetries: config.maxRetries ?? this.retryConfig.maxRetries ?? 3,
+              initialDelay: this.retryConfig.initialDelay ?? 1e3,
+              maxDelay: this.retryConfig.maxDelay ?? 3e4,
+              backoffFactor: this.retryConfig.backoffFactor ?? 2,
+              retryableErrors: this.retryConfig.retryableErrors,
+              debug: this.debug
+            });
+            return await providerRetryManager.executeWithRetry(
+              () => streamText(fallbackOptions),
+              {
+                provider: config.provider,
+                model
+              }
+            );
+          }
+        );
+      }
       /**
        * Initialize Anthropic model
        */
       initializeAnthropicModel(apiKey, apiUrl, modelName) {
-        this.provider = createAnthropic({
+        this.provider = createAnthropic2({
           apiKey,
           ...apiUrl && { baseURL: apiUrl }
         });
@@ -55898,7 +57646,7 @@ var init_ProbeAgent = __esm({
        * Initialize OpenAI model
        */
       initializeOpenAIModel(apiKey, apiUrl, modelName) {
-        this.provider = createOpenAI({
+        this.provider = createOpenAI2({
           compatibility: "strict",
           apiKey,
           ...apiUrl && { baseURL: apiUrl }
@@ -55913,7 +57661,7 @@ var init_ProbeAgent = __esm({
        * Initialize Google model
        */
       initializeGoogleModel(apiKey, apiUrl, modelName) {
-        this.provider = createGoogleGenerativeAI({
+        this.provider = createGoogleGenerativeAI2({
           apiKey,
           ...apiUrl && { baseURL: apiUrl }
         });
@@ -55943,7 +57691,7 @@ var init_ProbeAgent = __esm({
         if (baseURL) {
           config.baseURL = baseURL;
         }
-        this.provider = createAmazonBedrock(config);
+        this.provider = createAmazonBedrock2(config);
         this.model = modelName || "anthropic.claude-sonnet-4-20250514-v1:0";
         this.apiType = "bedrock";
         if (this.debug) {
@@ -55988,7 +57736,7 @@ var init_ProbeAgent = __esm({
           let resolvedPath = imagePath;
           if (!imagePath.includes("/") && !imagePath.includes("\\")) {
             for (const dir of listFilesDirectories) {
-              const potentialPath = resolve3(dir, imagePath);
+              const potentialPath = resolve4(dir, imagePath);
               const loaded = await this.loadImageIfValid(potentialPath);
               if (loaded) {
                 if (this.debug) {
@@ -56013,7 +57761,7 @@ var init_ProbeAgent = __esm({
         let match2;
         while ((match2 = fileHeaderPattern.exec(content)) !== null) {
           const filePath = match2[1].trim();
-          const dir = dirname3(filePath);
+          const dir = dirname4(filePath);
           if (dir && dir !== ".") {
             directories.push(dir);
             if (this.debug) {
@@ -56057,21 +57805,21 @@ var init_ProbeAgent = __esm({
           }
           const allowedDirs = this.allowedFolders && this.allowedFolders.length > 0 ? this.allowedFolders : [process.cwd()];
           let absolutePath;
-          let isPathAllowed = false;
-          if (isAbsolute(imagePath)) {
+          let isPathAllowed2 = false;
+          if (isAbsolute2(imagePath)) {
             absolutePath = imagePath;
-            isPathAllowed = allowedDirs.some((dir) => absolutePath.startsWith(resolve3(dir)));
+            isPathAllowed2 = allowedDirs.some((dir) => absolutePath.startsWith(resolve4(dir)));
           } else {
             for (const dir of allowedDirs) {
-              const resolvedPath = resolve3(dir, imagePath);
-              if (resolvedPath.startsWith(resolve3(dir))) {
+              const resolvedPath = resolve4(dir, imagePath);
+              if (resolvedPath.startsWith(resolve4(dir))) {
                 absolutePath = resolvedPath;
-                isPathAllowed = true;
+                isPathAllowed2 = true;
                 break;
               }
             }
           }
-          if (!isPathAllowed) {
+          if (!isPathAllowed2) {
             if (this.debug) {
               console.log(`[DEBUG] Image path outside allowed directories: ${imagePath}`);
             }
@@ -56250,7 +57998,11 @@ var init_ProbeAgent = __esm({
             if (this.mcpBridge) {
               const mcpTools = this.mcpBridge.mcpTools || {};
               for (const [toolName, toolImpl] of Object.entries(mcpTools)) {
-                this.toolImplementations[toolName] = toolImpl;
+                if (this._isMcpToolAllowed(toolName)) {
+                  this.toolImplementations[toolName] = toolImpl;
+                } else if (this.debug) {
+                  console.error(`[DEBUG] MCP tool '${toolName}' filtered out by allowedTools`);
+                }
               }
             }
           } catch (error) {
@@ -56260,19 +58012,49 @@ var init_ProbeAgent = __esm({
             }
           }
         }
-        let toolDefinitions = `
-${searchToolDefinition}
-${queryToolDefinition}
-${extractToolDefinition}
-${listFilesToolDefinition}
-${searchFilesToolDefinition}
-${attemptCompletionToolDefinition}
+        let toolDefinitions = "";
+        const isToolAllowed = (toolName) => this.allowedTools.isEnabled(toolName);
+        if (isToolAllowed("search")) {
+          toolDefinitions += `${searchToolDefinition}
 `;
-        if (this.allowEdit) {
+        }
+        if (isToolAllowed("query")) {
+          toolDefinitions += `${queryToolDefinition}
+`;
+        }
+        if (isToolAllowed("extract")) {
+          toolDefinitions += `${extractToolDefinition}
+`;
+        }
+        if (isToolAllowed("listFiles")) {
+          toolDefinitions += `${listFilesToolDefinition}
+`;
+        }
+        if (isToolAllowed("searchFiles")) {
+          toolDefinitions += `${searchFilesToolDefinition}
+`;
+        }
+        if (this.allowEdit && isToolAllowed("implement")) {
           toolDefinitions += `${implementToolDefinition}
 `;
         }
-        if (this.enableDelegate) {
+        if (this.allowEdit && isToolAllowed("edit")) {
+          toolDefinitions += `${editToolDefinition}
+`;
+        }
+        if (this.allowEdit && isToolAllowed("create")) {
+          toolDefinitions += `${createToolDefinition}
+`;
+        }
+        if (this.enableBash && isToolAllowed("bash")) {
+          toolDefinitions += `${bashToolDefinition}
+`;
+        }
+        if (isToolAllowed("attempt_completion")) {
+          toolDefinitions += `${attemptCompletionToolDefinition}
+`;
+        }
+        if (this.enableDelegate && isToolAllowed("delegate")) {
           toolDefinitions += `${delegateToolDefinition}
 `;
         }
@@ -56337,7 +58119,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.
-${this.allowEdit ? "- implement: Implement a feature or fix a bug using aider.\n" : ""}${this.enableDelegate ? "- delegate: Delegate big distinct tasks to specialized probe subagents.\n" : ""}
+${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).
 `;
@@ -56351,7 +58133,10 @@ Follow these instructions carefully:
 6. You MUST respond with exactly ONE tool call per message, using the specified XML format, until the task is complete.
 7. Wait for the tool execution result (provided in the next user message in a <tool_result> block) before proceeding to the next step.
 8. Once the task is fully completed, use the '<attempt_completion>' tool to provide the final result. This is the ONLY way to signal completion.
-9. Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.
+9. Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.${this.allowEdit ? `
+10. When modifying files, choose the appropriate tool:
+    - Use 'edit' for precise changes to existing files (requires exact string match)
+    - Use 'create' for new files or complete file rewrites` : ""}
 </instructions>
 `;
         const predefinedPrompts = {
@@ -56431,11 +58216,14 @@ ${xmlToolGuidelines}
 ${toolDefinitions}
 `;
         if (this.mcpBridge && this.mcpBridge.getToolNames().length > 0) {
-          systemMessage += `
+          const allMcpTools = this.mcpBridge.getToolNames();
+          const allowedMcpTools = this._filterMcpTools(allMcpTools);
+          if (allowedMcpTools.length > 0) {
+            systemMessage += `
 ## MCP Tools (JSON parameters in <params> tag)
 `;
-          systemMessage += this.mcpBridge.getXmlToolDefinitions();
-          systemMessage += `
+            systemMessage += this.mcpBridge.getXmlToolDefinitions(allowedMcpTools);
+            systemMessage += `
 
 For MCP tools, use JSON format within the params tag, e.g.:
 <mcp_tool>
@@ -56444,6 +58232,7 @@ For MCP tools, use JSON format within the params tag, e.g.:
 </params>
 </mcp_tool>
 `;
+          }
         }
         const searchDirectory = this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd();
         if (this.debug) {
@@ -56600,44 +58389,83 @@ You are working with a repository located at: ${searchDirectory}
               }
             }
             let assistantResponseContent = "";
-            try {
-              const executeAIRequest = async () => {
-                const messagesForAI = this.prepareMessagesWithImages(currentMessages);
-                const result = await streamText({
-                  model: this.provider(this.model),
-                  messages: messagesForAI,
-                  maxTokens: maxResponseTokens,
-                  temperature: 0.3
-                });
-                const usagePromise = result.usage;
-                for await (const delta of result.textStream) {
-                  assistantResponseContent += delta;
-                  if (options.onStream) {
-                    options.onStream(delta);
+            let compactionAttempted = false;
+            while (true) {
+              try {
+                const executeAIRequest = async () => {
+                  const messagesForAI = this.prepareMessagesWithImages(currentMessages);
+                  const result = await this.streamTextWithRetryAndFallback({
+                    model: this.provider(this.model),
+                    messages: messagesForAI,
+                    maxTokens: maxResponseTokens,
+                    temperature: 0.3
+                  });
+                  const usagePromise = result.usage;
+                  for await (const delta of result.textStream) {
+                    assistantResponseContent += delta;
+                    if (options.onStream) {
+                      options.onStream(delta);
+                    }
+                  }
+                  const usage = await usagePromise;
+                  if (usage) {
+                    this.tokenCounter.recordUsage(usage, result.experimental_providerMetadata);
                   }
+                  return result;
+                };
+                if (this.tracer) {
+                  await this.tracer.withSpan("ai.request", executeAIRequest, {
+                    "ai.model": this.model,
+                    "ai.provider": this.clientApiProvider || "auto",
+                    "iteration": currentIteration,
+                    "max_tokens": maxResponseTokens,
+                    "temperature": 0.3,
+                    "message_count": currentMessages.length
+                  });
+                } else {
+                  await executeAIRequest();
                 }
-                const usage = await usagePromise;
-                if (usage) {
-                  this.tokenCounter.recordUsage(usage, result.experimental_providerMetadata);
+                break;
+              } catch (error) {
+                if (!compactionAttempted && handleContextLimitError) {
+                  const compactionResult = handleContextLimitError(error, currentMessages, {
+                    keepLastSegment: true,
+                    minSegmentsToKeep: 1
+                  });
+                  if (compactionResult) {
+                    const { messages: compactedMessages, stats } = compactionResult;
+                    if (stats.removed === 0) {
+                      console.error(`[ERROR] Context window exceeded but no messages can be compacted.`);
+                      console.error(`[ERROR] The conversation history is already minimal (${stats.originalCount} messages).`);
+                      finalResult = `Error: Context window limit exceeded and conversation cannot be compacted further. Consider starting a new session or reducing system message size.`;
+                      throw new Error(finalResult);
+                    }
+                    compactionAttempted = true;
+                    console.log(`[INFO] Context window limit exceeded. Compacting conversation...`);
+                    console.log(`[INFO] Removed ${stats.removed} messages (${stats.reductionPercent}% reduction)`);
+                    console.log(`[INFO] Estimated token savings: ${stats.tokensSaved} tokens`);
+                    if (this.debug) {
+                      console.log(`[DEBUG] Compaction stats:`, stats);
+                      console.log(`[DEBUG] Original message count: ${stats.originalCount}`);
+                      console.log(`[DEBUG] Compacted message count: ${stats.compactedCount}`);
+                    }
+                    currentMessages = [...compactedMessages];
+                    if (this.tracer) {
+                      this.tracer.addEvent("context.compacted", {
+                        "iteration": currentIteration,
+                        "original_count": stats.originalCount,
+                        "compacted_count": stats.compactedCount,
+                        "reduction_percent": stats.reductionPercent,
+                        "tokens_saved": stats.tokensSaved
+                      });
+                    }
+                    continue;
+                  }
                 }
-                return result;
-              };
-              if (this.tracer) {
-                await this.tracer.withSpan("ai.request", executeAIRequest, {
-                  "ai.model": this.model,
-                  "ai.provider": this.clientApiProvider || "auto",
-                  "iteration": currentIteration,
-                  "max_tokens": maxResponseTokens,
-                  "temperature": 0.3,
-                  "message_count": currentMessages.length
-                });
-              } else {
-                await executeAIRequest();
+                console.error(`Error during streamText (Iter ${currentIteration}):`, error);
+                finalResult = `Error: Failed to get response from AI model during iteration ${currentIteration}. ${error.message}`;
+                throw new Error(finalResult);
               }
-            } catch (error) {
-              console.error(`Error during streamText (Iter ${currentIteration}):`, error);
-              finalResult = `Error: Failed to get response from AI model during iteration ${currentIteration}. ${error.message}`;
-              throw new Error(finalResult);
             }
             if (this.debug && assistantResponseContent) {
               const assistantPreview = createMessagePreview(assistantResponseContent);
@@ -56655,7 +58483,10 @@ You are working with a repository located at: ${searchDirectory}
               "attempt_completion"
             ];
             if (this.allowEdit) {
-              validTools.push("implement");
+              validTools.push("implement", "edit", "create");
+            }
+            if (this.enableBash) {
+              validTools.push("bash");
             }
             if (this.enableDelegate) {
               validTools.push("delegate");
@@ -56999,7 +58830,6 @@ Convert your previous response content into actual JSON data that follows this s
                 ...options,
                 _schemaFormatted: true
               });
-              finalResult = cleanSchemaResponse(finalResult);
               if (!this.disableMermaidValidation) {
                 try {
                   if (this.debug) {
@@ -57055,14 +58885,11 @@ Convert your previous response content into actual JSON data that follows this s
               } else if (this.debug) {
                 console.log(`[DEBUG] Mermaid validation: Skipped due to disableMermaidValidation option`);
               }
+              finalResult = cleanSchemaResponse(finalResult);
               if (isJsonSchema(options.schema)) {
                 if (this.debug) {
                   console.log(`[DEBUG] JSON validation: Starting validation process for schema response`);
-                  console.log(`[DEBUG] JSON validation: Response length: ${finalResult.length} chars`);
-                }
-                finalResult = cleanSchemaResponse(finalResult);
-                if (this.debug) {
-                  console.log(`[DEBUG] JSON validation: After cleaning, length: ${finalResult.length} chars`);
+                  console.log(`[DEBUG] JSON validation: Cleaned response length: ${finalResult.length} chars`);
                 }
                 if (this.tracer) {
                   this.tracer.recordJsonValidationEvent("started", {
@@ -57152,10 +58979,9 @@ Convert your previous response content into actual JSON data that follows this s
             console.log("[DEBUG] Skipping schema formatting due to max iterations reached without completion");
           } else if (completionAttempted && options.schema && !options._schemaFormatted && !options._skipValidation) {
             try {
-              finalResult = cleanSchemaResponse(finalResult);
               if (!this.disableMermaidValidation) {
                 if (this.debug) {
-                  console.log(`[DEBUG] Mermaid validation: Validating attempt_completion result...`);
+                  console.log(`[DEBUG] Mermaid validation: Validating attempt_completion result BEFORE schema cleaning...`);
                 }
                 const mermaidValidation = await validateAndFixMermaidResponse(finalResult, {
                   debug: this.debug,
@@ -57178,6 +59004,7 @@ Convert your previous response content into actual JSON data that follows this s
               } else if (this.debug) {
                 console.log(`[DEBUG] Mermaid validation: Skipped for attempt_completion result due to disableMermaidValidation option`);
               }
+              finalResult = cleanSchemaResponse(finalResult);
               if (isJsonSchema(options.schema)) {
                 if (this.debug) {
                   console.log(`[DEBUG] JSON validation: Starting validation process for attempt_completion result`);
@@ -57351,6 +59178,56 @@ Convert your previous response content into actual JSON data that follows this s
           console.log(`[DEBUG] Cleared conversation history and reset counters for session ${this.sessionId}`);
         }
       }
+      /**
+       * Manually compact conversation history
+       * Removes intermediate monologues from older segments while preserving
+       * user messages, final answers, and the most recent segment
+       *
+       * @param {Object} options - Compaction options
+       * @param {boolean} [options.keepLastSegment=true] - Keep the most recent segment intact
+       * @param {number} [options.minSegmentsToKeep=1] - Number of recent segments to preserve fully
+       * @returns {Object} Compaction statistics
+       */
+      async compactHistory(options = {}) {
+        const { compactMessages: compactMessages2, calculateCompactionStats: calculateCompactionStats2 } = await Promise.resolve().then(() => (init_contextCompactor(), contextCompactor_exports));
+        if (this.history.length === 0) {
+          if (this.debug) {
+            console.log(`[DEBUG] No history to compact for session ${this.sessionId}`);
+          }
+          return {
+            originalCount: 0,
+            compactedCount: 0,
+            removed: 0,
+            reductionPercent: 0,
+            originalTokens: 0,
+            compactedTokens: 0,
+            tokensSaved: 0
+          };
+        }
+        const compactedMessages = compactMessages2(this.history, options);
+        const stats = calculateCompactionStats2(this.history, compactedMessages);
+        this.history = compactedMessages;
+        try {
+          await this.storageAdapter.clearHistory(this.sessionId);
+          for (const message of compactedMessages) {
+            await this.storageAdapter.saveMessage(this.sessionId, message);
+          }
+        } catch (error) {
+          console.error(`[ERROR] Failed to save compacted messages to storage:`, error);
+        }
+        console.log(`[INFO] Manually compacted conversation history`);
+        console.log(`[INFO] Removed ${stats.removed} messages (${stats.reductionPercent}% reduction)`);
+        console.log(`[INFO] Estimated token savings: ${stats.tokensSaved} tokens`);
+        if (this.debug) {
+          console.log(`[DEBUG] Compaction stats:`, stats);
+        }
+        await this.hooks.emit(HOOK_TYPES.STORAGE_SAVE, {
+          sessionId: this.sessionId,
+          compacted: true,
+          stats
+        });
+        return stats;
+      }
       /**
        * Clone this agent's session to create a new agent with shared conversation history
        * @param {Object} options - Clone options
@@ -57373,6 +59250,14 @@ Convert your previous response content into actual JSON data that follows this s
         if (stripInternalMessages) {
           clonedHistory = this._stripInternalMessages(clonedHistory, keepSystemMessage);
         }
+        let allowedToolsArray = null;
+        if (this.allowedTools.mode === "whitelist") {
+          allowedToolsArray = [...this.allowedTools.allowed];
+        } else if (this.allowedTools.mode === "none") {
+          allowedToolsArray = [];
+        } else if (this.allowedTools.mode === "all" && this.allowedTools.exclusions.length > 0) {
+          allowedToolsArray = ["*", ...this.allowedTools.exclusions.map((t) => "!" + t)];
+        }
         const clonedAgent = new _ProbeAgent({
           // Copy current agent's config
           customPrompt: this.customPrompt,
@@ -57390,6 +59275,7 @@ Convert your previous response content into actual JSON data that follows this s
           maxIterations: this.maxIterations,
           disableMermaidValidation: this.disableMermaidValidation,
           disableJsonValidation: this.disableJsonValidation,
+          allowedTools: allowedToolsArray,
           enableMcp: !!this.mcpBridge,
           mcpConfig: this.mcpConfig,
           enableBash: this.enableBash,
@@ -57569,8 +59455,8 @@ import {
   ListToolsRequestSchema,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
-import { readFileSync as readFileSync2, existsSync as existsSync5 } from "fs";
-import { resolve as resolve4 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync6 } from "fs";
+import { resolve as resolve5 } from "path";
 
 // src/agent/acp/server.js
 import { randomUUID as randomUUID5 } from "crypto";
@@ -57829,8 +59715,8 @@ var ACPConnection = class extends EventEmitter4 {
     if (params !== null) {
       message.params = params;
     }
-    return new Promise((resolve5, reject2) => {
-      this.pendingRequests.set(id, { resolve: resolve5, reject: reject2 });
+    return new Promise((resolve6, reject2) => {
+      this.pendingRequests.set(id, { resolve: resolve6, reject: reject2 });
       this.sendMessage(message);
       setTimeout(() => {
         if (this.pendingRequests.has(id)) {
@@ -58244,8 +60130,8 @@ dotenv3.config();
 function readInputContent(input) {
   if (!input) return null;
   try {
-    const resolvedPath = resolve4(input);
-    if (existsSync5(resolvedPath)) {
+    const resolvedPath = resolve5(input);
+    if (existsSync6(resolvedPath)) {
       return readFileSync2(resolvedPath, "utf-8").trim();
     }
   } catch (error) {
@@ -58253,7 +60139,7 @@ function readInputContent(input) {
   return input;
 }
 function readFromStdin() {
-  return new Promise((resolve5, reject2) => {
+  return new Promise((resolve6, reject2) => {
     let data = "";
     let hasReceivedData = false;
     let dataChunks = [];
@@ -58278,7 +60164,7 @@ function readFromStdin() {
       if (!trimmed && dataChunks.length === 0) {
         reject2(new Error("No input received from stdin"));
       } else {
-        resolve5(trimmed);
+        resolve6(trimmed);
       }
     });
     process.stdin.on("error", (error) => {
@@ -58324,6 +60210,10 @@ function parseArgs() {
     // New flag to enable outline format
     noMermaidValidation: false,
     // New flag to disable mermaid validation
+    allowedTools: null,
+    // Tool filtering: ['*'] = all, [] = none, ['tool1', 'tool2'] = specific
+    disableTools: false,
+    // Convenience flag to disable all tools
     // Bash tool configuration
     enableBash: false,
     bashAllow: null,
@@ -58377,6 +60267,17 @@ function parseArgs() {
       config.outline = true;
     } else if (arg === "--no-mermaid-validation") {
       config.noMermaidValidation = true;
+    } else if (arg === "--allowed-tools" && i + 1 < args.length) {
+      const toolsArg = args[++i];
+      if (toolsArg === "*" || toolsArg === "all") {
+        config.allowedTools = ["*"];
+      } else if (toolsArg === "none" || toolsArg === "") {
+        config.allowedTools = [];
+      } else {
+        config.allowedTools = toolsArg.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+      }
+    } else if (arg === "--disable-tools") {
+      config.disableTools = true;
     } else if (arg === "--enable-bash") {
       config.enableBash = true;
     } else if (arg === "--bash-allow" && i + 1 < args.length) {
@@ -58421,6 +60322,13 @@ Options:
   --model <name>                   Override model name
   --allow-edit                     Enable code modification capabilities
   --enable-delegate                Enable delegate tool for task distribution to subagents
+  --allowed-tools <tools>          Filter available tools (comma-separated list)
+                                   Use '*' or 'all' for all tools (default)
+                                   Use 'none' or '' for no tools (raw AI mode)
+                                   Specific tools: search,query,extract,listFiles,searchFiles
+                                   Supports exclusion: '*,!bash' (all except bash)
+  --disable-tools                  Disable all tools (raw AI mode, no code analysis)
+                                   Convenience flag equivalent to --allowed-tools none
   --verbose                        Enable verbose output
   --outline                        Use outline-xml format for code search results
   --mcp                           Run as MCP server
@@ -58462,6 +60370,9 @@ Examples:
   probe agent "Analyze codebase" --schema schema.json  # Schema from file
   probe agent "Debug issue" --trace-file ./debug.jsonl --verbose
   probe agent "Analyze code" --trace-remote http://localhost:4318/v1/traces
+  probe agent "Explain this code" --allowed-tools search,extract  # Only search and extract
+  probe agent "What is this project about?" --allowed-tools none  # Raw AI mode (no tools)
+  probe agent "Tell me about this project" --disable-tools        # Raw AI mode (convenience flag)
   probe agent --mcp               # Start MCP server mode
   probe agent --acp               # Start ACP server mode
 
@@ -58588,7 +60499,9 @@ var ProbeAgentMcpServer = class {
             allowEdit: !!args.allow_edit,
             debug: process.env.DEBUG === "1",
             maxResponseTokens: args.max_response_tokens,
-            disableMermaidValidation: !!args.no_mermaid_validation
+            disableMermaidValidation: !!args.no_mermaid_validation,
+            allowedTools: args.allowed_tools,
+            disableTools: args.disable_tools
           };
           this.agent = new ProbeAgent(agentConfig2);
           await this.agent.initialize();
@@ -58804,7 +60717,7 @@ async function main() {
         bashConfig.timeout = timeout;
       }
       if (config.bashWorkingDir) {
-        if (!existsSync5(config.bashWorkingDir)) {
+        if (!existsSync6(config.bashWorkingDir)) {
           console.error(`Error: Bash working directory does not exist: ${config.bashWorkingDir}`);
           process.exit(1);
         }
@@ -58826,6 +60739,8 @@ async function main() {
       outline: config.outline,
       maxResponseTokens: config.maxResponseTokens,
       disableMermaidValidation: config.noMermaidValidation,
+      allowedTools: config.allowedTools,
+      disableTools: config.disableTools,
       enableBash: config.enableBash,
       bashConfig
     };