@probelabs/probe 0.6.0-rc161 → 0.6.0-rc163

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);
       }
@@ -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;
@@ -17148,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",
@@ -53941,6 +54264,8 @@ __export(schemaUtils_exports, {
   createSchemaDefinitionCorrectionPrompt: () => createSchemaDefinitionCorrectionPrompt,
   decodeHtmlEntities: () => decodeHtmlEntities,
   extractMermaidFromMarkdown: () => extractMermaidFromMarkdown,
+  generateExampleFromSchema: () => generateExampleFromSchema,
+  generateSchemaInstructions: () => generateSchemaInstructions,
   isJsonSchema: () => isJsonSchema,
   isJsonSchemaDefinition: () => isJsonSchemaDefinition,
   isMermaidSchema: () => isMermaidSchema,
@@ -53953,6 +54278,63 @@ __export(schemaUtils_exports, {
   validateMermaidResponse: () => validateMermaidResponse,
   validateXmlResponse: () => validateXmlResponse
 });
+function generateExampleFromSchema(schema, options = {}) {
+  const { debug = false } = options;
+  try {
+    const parsedSchema = typeof schema === "string" ? JSON.parse(schema) : schema;
+    if (parsedSchema.type !== "object" || !parsedSchema.properties) {
+      return null;
+    }
+    const exampleObj = {};
+    for (const [key, value] of Object.entries(parsedSchema.properties)) {
+      if (value.type === "boolean") {
+        exampleObj[key] = false;
+      } else if (value.type === "number") {
+        exampleObj[key] = 0;
+      } else if (value.type === "string") {
+        exampleObj[key] = value.description || "your answer here";
+      } else if (value.type === "array") {
+        exampleObj[key] = [];
+      } else {
+        exampleObj[key] = {};
+      }
+    }
+    return exampleObj;
+  } catch (e) {
+    if (debug) {
+      console.error("[DEBUG] generateExampleFromSchema: Failed to parse schema:", e.message);
+    }
+    return null;
+  }
+}
+function generateSchemaInstructions(schema, options = {}) {
+  const { debug = false } = options;
+  let instructions = "\n\nIMPORTANT: When you provide your final answer using attempt_completion, you MUST format it as valid JSON matching this schema:\n\n";
+  try {
+    const parsedSchema = typeof schema === "string" ? JSON.parse(schema) : schema;
+    instructions += `${JSON.stringify(parsedSchema, null, 2)}
+
+`;
+    const exampleObj = generateExampleFromSchema(parsedSchema, { debug });
+    if (exampleObj) {
+      instructions += `Example:
+<attempt_completion>
+${JSON.stringify(exampleObj, null, 2)}
+</attempt_completion>
+
+`;
+    }
+  } catch (e) {
+    if (debug) {
+      console.error("[DEBUG] generateSchemaInstructions: Failed to parse schema:", e.message);
+    }
+    instructions += `${schema}
+
+`;
+  }
+  instructions += "Your response inside attempt_completion must be ONLY valid JSON - no plain text, no explanations, no markdown.";
+  return instructions;
+}
 function enforceNoAdditionalProperties(schema) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -56656,6 +57038,170 @@ var init_FallbackManager = __esm({
   }
 });
 
+// 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, {
@@ -56690,6 +57236,7 @@ var init_ProbeAgent = __esm({
     init_mcp();
     init_RetryManager();
     init_FallbackManager();
+    init_contextCompactor();
     dotenv2.config();
     MAX_TOOL_ITERATIONS = (() => {
       const val = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
@@ -56725,6 +57272,8 @@ 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
@@ -56758,6 +57307,8 @@ var init_ProbeAgent = __esm({
         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) {
@@ -56801,6 +57352,61 @@ var init_ProbeAgent = __esm({
         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
@@ -56827,7 +57433,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) {
@@ -57447,7 +58057,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) {
@@ -57457,27 +58071,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.allowEdit && isToolAllowed("edit")) {
           toolDefinitions += `${editToolDefinition}
 `;
+        }
+        if (this.allowEdit && isToolAllowed("create")) {
           toolDefinitions += `${createToolDefinition}
 `;
         }
-        if (this.enableBash) {
+        if (this.enableBash && isToolAllowed("bash")) {
           toolDefinitions += `${bashToolDefinition}
 `;
         }
-        if (this.enableDelegate) {
+        if (isToolAllowed("attempt_completion")) {
+          toolDefinitions += `${attemptCompletionToolDefinition}
+`;
+        }
+        if (this.enableDelegate && isToolAllowed("delegate")) {
           toolDefinitions += `${delegateToolDefinition}
 `;
         }
@@ -57639,11 +58275,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>
@@ -57652,6 +58291,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) {
@@ -57724,9 +58364,14 @@ You are working with a repository located at: ${searchDirectory}
           });
           const systemMessage = await this.getSystemMessage();
           let userMessage = { role: "user", content: message.trim() };
+          if (options.schema && !options._schemaFormatted) {
+            const schemaInstructions = generateSchemaInstructions(options.schema, { debug: this.debug });
+            userMessage.content = message.trim() + schemaInstructions;
+          }
           if (images && images.length > 0) {
+            const textContent = userMessage.content;
             userMessage.content = [
-              { type: "text", text: message.trim() },
+              { type: "text", text: textContent },
               ...images.map((image) => ({
                 type: "image",
                 image
@@ -57808,44 +58453,83 @@ You are working with a repository located at: ${searchDirectory}
               }
             }
             let assistantResponseContent = "";
-            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);
+            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);
@@ -58116,15 +58800,7 @@ Remember: Use proper XML format with BOTH opening and closing tags:
 <tool_name>
 <parameter>value</parameter>
 </tool_name>
-
-IMPORTANT: A schema was provided for the final output format.
-
-You MUST use attempt_completion to provide your answer:
-<attempt_completion>
-[Your complete answer here - provide in natural language, it will be automatically formatted to match the schema]
-</attempt_completion>
-
-Your response will be automatically formatted to JSON. You can provide your answer in natural language or as JSON - either will work.`;
+` + generateSchemaInstructions(options.schema, { debug: this.debug }).trim();
               } else {
                 reminderContent = `Please use one of the available tools to help answer the question, or use attempt_completion if you have enough information to provide a final answer.
 
@@ -58210,7 +58886,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) {
@@ -58266,14 +58941,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", {
@@ -58363,10 +59035,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,
@@ -58389,6 +59060,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`);
@@ -58562,6 +59234,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
@@ -58584,6 +59306,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,
@@ -58601,6 +59331,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,
@@ -59535,6 +60266,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,
@@ -59588,6 +60323,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) {
@@ -59632,6 +60378,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
@@ -59673,6 +60426,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
 
@@ -59799,7 +60555,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();
@@ -60037,6 +60795,8 @@ async function main() {
       outline: config.outline,
       maxResponseTokens: config.maxResponseTokens,
       disableMermaidValidation: config.noMermaidValidation,
+      allowedTools: config.allowedTools,
+      disableTools: config.disableTools,
       enableBash: config.enableBash,
       bashConfig
     };