@probelabs/probe 0.6.0-rc161 → 0.6.0-rc163

package/cjs/agent/ProbeAgent.cjs

@@ -9781,7 +9781,10 @@ var init_CborCodec = __esm({
             }
           } else if (ns.isStructSchema()) {
             for (const [key, memberSchema] of ns.structIterator()) {
-              newObject[key] = this.readValue(memberSchema, value[key]);
+              const v3 = this.readValue(memberSchema, value[key]);
+              if (v3 != null) {
+                newObject[key] = v3;
+              }
             }
           }
           return newObject;
@@ -11302,10 +11305,7 @@ var init_JsonShapeSerializer = __esm({
           if (ns === this.rootSchema) {
             return value;
           }
-          if (!this.serdeContext?.base64Encoder) {
-            return (0, import_util_base645.toBase64)(value);
-          }
-          return this.serdeContext?.base64Encoder(value);
+          return (this.serdeContext?.base64Encoder ?? import_util_base645.toBase64)(value);
         }
         if ((ns.isTimestampSchema() || ns.isDocumentSchema()) && value instanceof Date) {
           const format2 = determineTimestampFormat(ns, this.settings);
@@ -12940,7 +12940,13 @@ var init_AwsQueryProtocol = __esm({
           Code: errorData.Code,
           Message: message
         };
-        const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, errorData, metadata, (registry, errorName) => registry.find((schema) => NormalizedSchema.of(schema).getMergedTraits().awsQueryError?.[0] === errorName));
+        const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, errorData, metadata, (registry, errorName) => {
+          try {
+            return registry.getSchema(errorName);
+          } catch (e3) {
+            return registry.find((schema) => NormalizedSchema.of(schema).getMergedTraits().awsQueryError?.[0] === errorName);
+          }
+        });
         const ns = NormalizedSchema.of(errorSchema);
         const ErrorCtor = TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error;
         const exception = new ErrorCtor(message);
@@ -15306,7 +15312,11 @@ var require_dist_cjs39 = __commonJS({
     var validRegions = /* @__PURE__ */ new Set();
     var checkRegion = (region, check = utilEndpoints.isValidHostLabel) => {
       if (!validRegions.has(region) && !check(region)) {
-        throw new Error(`Region not accepted: region="${region}" is not a valid hostname component.`);
+        if (region === "*") {
+          console.warn(`@smithy/config-resolver WARN - Please use the caller region instead of "*". See "sigv4a" in https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md.`);
+        } else {
+          throw new Error(`Region not accepted: region="${region}" is not a valid hostname component.`);
+        }
       } else {
         validRegions.add(region);
       }
@@ -15504,42 +15514,40 @@ var require_getSSOTokenFromFile = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getSSOTokenFromFile = exports2.tokenIntercept = void 0;
-    var fs_1 = require("fs");
+    var promises_1 = require("fs/promises");
     var getSSOTokenFilepath_1 = require_getSSOTokenFilepath();
-    var { readFile: readFile2 } = fs_1.promises;
     exports2.tokenIntercept = {};
     var getSSOTokenFromFile = async (id) => {
       if (exports2.tokenIntercept[id]) {
         return exports2.tokenIntercept[id];
       }
       const ssoTokenFilepath = (0, getSSOTokenFilepath_1.getSSOTokenFilepath)(id);
-      const ssoTokenText = await readFile2(ssoTokenFilepath, "utf8");
+      const ssoTokenText = await (0, promises_1.readFile)(ssoTokenFilepath, "utf8");
       return JSON.parse(ssoTokenText);
     };
     exports2.getSSOTokenFromFile = getSSOTokenFromFile;
   }
 });
 
-// node_modules/@smithy/shared-ini-file-loader/dist-cjs/slurpFile.js
-var require_slurpFile = __commonJS({
-  "node_modules/@smithy/shared-ini-file-loader/dist-cjs/slurpFile.js"(exports2) {
+// node_modules/@smithy/shared-ini-file-loader/dist-cjs/readFile.js
+var require_readFile = __commonJS({
+  "node_modules/@smithy/shared-ini-file-loader/dist-cjs/readFile.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.slurpFile = exports2.fileIntercept = exports2.filePromisesHash = void 0;
-    var fs_1 = require("fs");
-    var { readFile: readFile2 } = fs_1.promises;
-    exports2.filePromisesHash = {};
+    exports2.readFile = exports2.fileIntercept = exports2.filePromises = void 0;
+    var promises_1 = require("node:fs/promises");
+    exports2.filePromises = {};
     exports2.fileIntercept = {};
-    var slurpFile = (path7, options) => {
+    var readFile2 = (path7, options) => {
       if (exports2.fileIntercept[path7] !== void 0) {
         return exports2.fileIntercept[path7];
       }
-      if (!exports2.filePromisesHash[path7] || options?.ignoreCache) {
-        exports2.filePromisesHash[path7] = readFile2(path7, "utf8");
+      if (!exports2.filePromises[path7] || options?.ignoreCache) {
+        exports2.filePromises[path7] = (0, promises_1.readFile)(path7, "utf8");
       }
-      return exports2.filePromisesHash[path7];
+      return exports2.filePromises[path7];
     };
-    exports2.slurpFile = slurpFile;
+    exports2.readFile = readFile2;
   }
 });
 
@@ -15552,7 +15560,7 @@ var require_dist_cjs42 = __commonJS({
     var getSSOTokenFromFile = require_getSSOTokenFromFile();
     var path7 = require("path");
     var types2 = require_dist_cjs();
-    var slurpFile = require_slurpFile();
+    var readFile2 = require_readFile();
     var ENV_PROFILE = "AWS_PROFILE";
     var DEFAULT_PROFILE = "default";
     var getProfileName = (init) => init.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE;
@@ -15636,10 +15644,10 @@ var require_dist_cjs42 = __commonJS({
         resolvedConfigFilepath = path7.join(homeDir, configFilepath.slice(2));
       }
       const parsedFiles = await Promise.all([
-        slurpFile.slurpFile(resolvedConfigFilepath, {
+        readFile2.readFile(resolvedConfigFilepath, {
           ignoreCache: init.ignoreCache
         }).then(parseIni).then(getConfigData).catch(swallowError$1),
-        slurpFile.slurpFile(resolvedFilepath, {
+        readFile2.readFile(resolvedFilepath, {
           ignoreCache: init.ignoreCache
         }).then(parseIni).catch(swallowError$1)
       ]);
@@ -15650,7 +15658,7 @@ var require_dist_cjs42 = __commonJS({
     };
     var getSsoSessionData = (data2) => Object.entries(data2).filter(([key]) => key.startsWith(types2.IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR)).reduce((acc, [key, value]) => ({ ...acc, [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value }), {});
     var swallowError = () => ({});
-    var loadSsoSessionData = async (init = {}) => slurpFile.slurpFile(init.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError);
+    var loadSsoSessionData = async (init = {}) => readFile2.readFile(init.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError);
     var mergeConfigFiles = (...files) => {
       const merged = {};
       for (const file of files) {
@@ -15670,10 +15678,10 @@ var require_dist_cjs42 = __commonJS({
     };
     var externalDataInterceptor = {
       getFileRecord() {
-        return slurpFile.fileIntercept;
+        return readFile2.fileIntercept;
       },
       interceptFile(path8, contents) {
-        slurpFile.fileIntercept[path8] = Promise.resolve(contents);
+        readFile2.fileIntercept[path8] = Promise.resolve(contents);
       },
       getTokenRecord() {
         return getSSOTokenFromFile.tokenIntercept;
@@ -15688,6 +15696,12 @@ var require_dist_cjs42 = __commonJS({
         return getSSOTokenFromFile.getSSOTokenFromFile;
       }
     });
+    Object.defineProperty(exports2, "readFile", {
+      enumerable: true,
+      get: function() {
+        return readFile2.readFile;
+      }
+    });
     exports2.CONFIG_PREFIX_SEPARATOR = CONFIG_PREFIX_SEPARATOR;
     exports2.DEFAULT_PROFILE = DEFAULT_PROFILE;
     exports2.ENV_PROFILE = ENV_PROFILE;
@@ -16827,7 +16841,7 @@ var require_package2 = __commonJS({
     module2.exports = {
       name: "@aws-sdk/client-bedrock-runtime",
       description: "AWS SDK for JavaScript Bedrock Runtime Client for Node.js, Browser and React Native",
-      version: "3.922.0",
+      version: "3.928.0",
       scripts: {
         build: "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
         "build:cjs": "node ../../scripts/compilation/inline client-bedrock-runtime",
@@ -16846,22 +16860,22 @@ var require_package2 = __commonJS({
       dependencies: {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
-        "@aws-sdk/core": "3.922.0",
-        "@aws-sdk/credential-provider-node": "3.922.0",
+        "@aws-sdk/core": "3.928.0",
+        "@aws-sdk/credential-provider-node": "3.928.0",
         "@aws-sdk/eventstream-handler-node": "3.922.0",
         "@aws-sdk/middleware-eventstream": "3.922.0",
         "@aws-sdk/middleware-host-header": "3.922.0",
         "@aws-sdk/middleware-logger": "3.922.0",
         "@aws-sdk/middleware-recursion-detection": "3.922.0",
-        "@aws-sdk/middleware-user-agent": "3.922.0",
+        "@aws-sdk/middleware-user-agent": "3.928.0",
         "@aws-sdk/middleware-websocket": "3.922.0",
-        "@aws-sdk/region-config-resolver": "3.922.0",
-        "@aws-sdk/token-providers": "3.922.0",
+        "@aws-sdk/region-config-resolver": "3.925.0",
+        "@aws-sdk/token-providers": "3.928.0",
         "@aws-sdk/types": "3.922.0",
         "@aws-sdk/util-endpoints": "3.922.0",
         "@aws-sdk/util-user-agent-browser": "3.922.0",
-        "@aws-sdk/util-user-agent-node": "3.922.0",
-        "@smithy/config-resolver": "^4.4.1",
+        "@aws-sdk/util-user-agent-node": "3.928.0",
+        "@smithy/config-resolver": "^4.4.2",
         "@smithy/core": "^3.17.2",
         "@smithy/eventstream-serde-browser": "^4.2.4",
         "@smithy/eventstream-serde-config-resolver": "^4.3.4",
@@ -16884,7 +16898,7 @@ var require_package2 = __commonJS({
         "@smithy/util-body-length-browser": "^4.2.0",
         "@smithy/util-body-length-node": "^4.2.1",
         "@smithy/util-defaults-mode-browser": "^4.3.5",
-        "@smithy/util-defaults-mode-node": "^4.2.7",
+        "@smithy/util-defaults-mode-node": "^4.2.8",
         "@smithy/util-endpoints": "^3.2.4",
         "@smithy/util-middleware": "^4.2.4",
         "@smithy/util-retry": "^4.2.4",
@@ -17608,7 +17622,7 @@ var init_package = __esm({
   "node_modules/@aws-sdk/nested-clients/package.json"() {
     package_default = {
       name: "@aws-sdk/nested-clients",
-      version: "3.922.0",
+      version: "3.928.0",
       description: "Nested clients for AWS SDK packages.",
       main: "./dist-cjs/index.js",
       module: "./dist-es/index.js",
@@ -17637,17 +17651,17 @@ var init_package = __esm({
       dependencies: {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
-        "@aws-sdk/core": "3.922.0",
+        "@aws-sdk/core": "3.928.0",
         "@aws-sdk/middleware-host-header": "3.922.0",
         "@aws-sdk/middleware-logger": "3.922.0",
         "@aws-sdk/middleware-recursion-detection": "3.922.0",
-        "@aws-sdk/middleware-user-agent": "3.922.0",
-        "@aws-sdk/region-config-resolver": "3.922.0",
+        "@aws-sdk/middleware-user-agent": "3.928.0",
+        "@aws-sdk/region-config-resolver": "3.925.0",
         "@aws-sdk/types": "3.922.0",
         "@aws-sdk/util-endpoints": "3.922.0",
         "@aws-sdk/util-user-agent-browser": "3.922.0",
-        "@aws-sdk/util-user-agent-node": "3.922.0",
-        "@smithy/config-resolver": "^4.4.1",
+        "@aws-sdk/util-user-agent-node": "3.928.0",
+        "@smithy/config-resolver": "^4.4.2",
         "@smithy/core": "^3.17.2",
         "@smithy/fetch-http-handler": "^5.3.5",
         "@smithy/hash-node": "^4.2.4",
@@ -17667,7 +17681,7 @@ var init_package = __esm({
         "@smithy/util-body-length-browser": "^4.2.0",
         "@smithy/util-body-length-node": "^4.2.1",
         "@smithy/util-defaults-mode-browser": "^4.3.5",
-        "@smithy/util-defaults-mode-node": "^4.2.7",
+        "@smithy/util-defaults-mode-node": "^4.2.8",
         "@smithy/util-endpoints": "^3.2.4",
         "@smithy/util-middleware": "^4.2.4",
         "@smithy/util-retry": "^4.2.4",
@@ -19088,7 +19102,7 @@ var require_package3 = __commonJS({
     module2.exports = {
       name: "@aws-sdk/client-sso",
       description: "AWS SDK for JavaScript Sso Client for Node.js, Browser and React Native",
-      version: "3.922.0",
+      version: "3.928.0",
       scripts: {
         build: "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
         "build:cjs": "node ../../scripts/compilation/inline client-sso",
@@ -19107,17 +19121,17 @@ var require_package3 = __commonJS({
       dependencies: {
         "@aws-crypto/sha256-browser": "5.2.0",
         "@aws-crypto/sha256-js": "5.2.0",
-        "@aws-sdk/core": "3.922.0",
+        "@aws-sdk/core": "3.928.0",
         "@aws-sdk/middleware-host-header": "3.922.0",
         "@aws-sdk/middleware-logger": "3.922.0",
         "@aws-sdk/middleware-recursion-detection": "3.922.0",
-        "@aws-sdk/middleware-user-agent": "3.922.0",
-        "@aws-sdk/region-config-resolver": "3.922.0",
+        "@aws-sdk/middleware-user-agent": "3.928.0",
+        "@aws-sdk/region-config-resolver": "3.925.0",
         "@aws-sdk/types": "3.922.0",
         "@aws-sdk/util-endpoints": "3.922.0",
         "@aws-sdk/util-user-agent-browser": "3.922.0",
-        "@aws-sdk/util-user-agent-node": "3.922.0",
-        "@smithy/config-resolver": "^4.4.1",
+        "@aws-sdk/util-user-agent-node": "3.928.0",
+        "@smithy/config-resolver": "^4.4.2",
         "@smithy/core": "^3.17.2",
         "@smithy/fetch-http-handler": "^5.3.5",
         "@smithy/hash-node": "^4.2.4",
@@ -19137,7 +19151,7 @@ var require_package3 = __commonJS({
         "@smithy/util-body-length-browser": "^4.2.0",
         "@smithy/util-body-length-node": "^4.2.1",
         "@smithy/util-defaults-mode-browser": "^4.3.5",
-        "@smithy/util-defaults-mode-node": "^4.2.7",
+        "@smithy/util-defaults-mode-node": "^4.2.8",
         "@smithy/util-endpoints": "^3.2.4",
         "@smithy/util-middleware": "^4.2.4",
         "@smithy/util-retry": "^4.2.4",
@@ -26431,6 +26445,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: name14, arguments: args } = message.function_call;
+    if (name14) {
+      tokens += countStringTokens(name14);
+    }
+    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 [name14, param] of Object.entries(obj.properties)) {
+    if (param.description && indent < 2) {
+      lines.push(`${indentString}// ${param.description}`);
+    }
+    const isRequired = requiredParams.has(name14);
+    const formattedType = formatType(param, indent);
+    lines.push(`${indentString}${name14}${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({
@@ -26444,11 +26614,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 = [
@@ -26523,11 +26694,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|>";
@@ -26538,6 +26713,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|>";
   }
 });
 
@@ -26564,11 +26747,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 = /'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 = /(?:'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");
   }
 });
 
@@ -26585,7 +26773,7 @@ function Cl100KBase(bytePairRankDecoder) {
     [EndOfPrompt, 100276]
   ]);
   return {
-    tokenSplitRegex: CL_AND_O_TOKEN_SPLIT_PATTERN,
+    tokenSplitRegex: CL100K_TOKEN_SPLIT_REGEX,
     bytePairRankDecoder,
     specialTokensEncoder: specialTokenMapping
   };
@@ -26599,26 +26787,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]
+    ];
   }
 });
 
@@ -26692,6 +26923,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}`);
   }
@@ -26700,6 +26933,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();
@@ -26712,6 +26946,7 @@ var init_GptEncoding = __esm({
   "node_modules/gpt-tokenizer/esm/GptEncoding.js"() {
     init_BytePairEncodingCore();
     init_constants();
+    init_functionCalling();
     init_mapping();
     init_modelParams();
     init_specialTokens();
@@ -26730,8 +26965,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);
@@ -26764,8 +27001,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);
@@ -26838,9 +27136,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]);
@@ -26863,8 +27168,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;
         }
@@ -26922,6 +27230,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);
       }
@@ -33362,7 +33679,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;
@@ -42814,10 +43139,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",
@@ -79607,6 +79944,8 @@ __export(schemaUtils_exports, {
   createSchemaDefinitionCorrectionPrompt: () => createSchemaDefinitionCorrectionPrompt,
   decodeHtmlEntities: () => decodeHtmlEntities,
   extractMermaidFromMarkdown: () => extractMermaidFromMarkdown,
+  generateExampleFromSchema: () => generateExampleFromSchema,
+  generateSchemaInstructions: () => generateSchemaInstructions,
   isJsonSchema: () => isJsonSchema,
   isJsonSchemaDefinition: () => isJsonSchemaDefinition,
   isMermaidSchema: () => isMermaidSchema,
@@ -79619,6 +79958,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 (e3) {
+    if (debug) {
+      console.error("[DEBUG] generateExampleFromSchema: Failed to parse schema:", e3.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 (e3) {
+    if (debug) {
+      console.error("[DEBUG] generateSchemaInstructions: Failed to parse schema:", e3.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;
@@ -82322,6 +82718,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(error2) {
+  if (!error2) return false;
+  const errorMessage = (typeof error2 === "string" ? error2 : error2?.message || "").toLowerCase();
+  const errorString = error2.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 i3 = 0; i3 < messages.length; i3++) {
+    const msg = messages[i3];
+    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 = i3;
+        segments.push(currentSegment);
+        currentSegment = null;
+      } else {
+        if (currentSegment) {
+          segments.push(currentSegment);
+        }
+        currentSegment = {
+          userIndex: i3,
+          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(i3);
+        currentSegment.finalIndex = i3;
+        segments.push(currentSegment);
+        currentSegment = null;
+      } else {
+        currentSegment.monologueIndices.push(i3);
+      }
+    }
+  }
+  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((_2, 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(error2, messages, options = {}) {
+  if (!isContextLimitError(error2)) {
+    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, {
@@ -82356,6 +82916,7 @@ var init_ProbeAgent = __esm({
     init_mcp();
     init_RetryManager();
     init_FallbackManager();
+    init_contextCompactor();
     import_dotenv2.default.config();
     MAX_TOOL_ITERATIONS = (() => {
       const val = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
@@ -82391,6 +82952,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
@@ -82424,6 +82987,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) {
@@ -82467,6 +83032,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((t3) => t3.startsWith("!")).map((t3) => t3.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((t3) => !t3.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
@@ -82493,7 +83113,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) {
@@ -83113,7 +83737,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 (error2) {
@@ -83123,27 +83751,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}
 `;
         }
@@ -83305,11 +83955,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>
@@ -83318,6 +83971,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) {
@@ -83390,9 +84044,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
@@ -83474,44 +84133,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 (error2) {
+                if (!compactionAttempted && handleContextLimitError) {
+                  const compactionResult = handleContextLimitError(error2, 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}):`, error2);
+                finalResult = `Error: Failed to get response from AI model during iteration ${currentIteration}. ${error2.message}`;
+                throw new Error(finalResult);
               }
-            } catch (error2) {
-              console.error(`Error during streamText (Iter ${currentIteration}):`, error2);
-              finalResult = `Error: Failed to get response from AI model during iteration ${currentIteration}. ${error2.message}`;
-              throw new Error(finalResult);
             }
             if (this.debug && assistantResponseContent) {
               const assistantPreview = createMessagePreview(assistantResponseContent);
@@ -83782,15 +84480,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.
 
@@ -83876,7 +84566,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) {
@@ -83932,14 +84621,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", {
@@ -84029,10 +84715,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,
@@ -84055,6 +84740,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`);
@@ -84228,6 +84914,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 (error2) {
+          console.error(`[ERROR] Failed to save compacted messages to storage:`, error2);
+        }
+        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
@@ -84250,6 +84986,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((t3) => "!" + t3)];
+        }
         const clonedAgent = new _ProbeAgent({
           // Copy current agent's config
           customPrompt: this.customPrompt,
@@ -84267,6 +85011,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,