@cuylabs/agent-core 4.10.0 → 5.0.0

package/dist/{chunk-NMJNN6LS.js → chunk-DYZGHHDB.js}

@@ -5,27 +5,56 @@ import {
   isAgentContextFragmentMessage,
   truncateTextMiddle,
   truncateTextPrefix
-} from "./chunk-AAGKWUXR.js";
+} from "./chunk-CGP6UNCQ.js";
 
 // src/context/window/budget.ts
 var DEFAULT_CONTEXT_LIMITS = {
   contextWindow: 128e3,
+  effectiveContextWindowPercent: 95,
   reserveTokens: 16e3,
   protectedTokens: 4e4,
   pruneMinimum: 2e4
 };
+var MIN_EFFECTIVE_CONTEXT_WINDOW_PERCENT = 1;
+var MAX_EFFECTIVE_CONTEXT_WINDOW_PERCENT = 100;
+function finitePositiveInteger(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  const normalized = Math.floor(value);
+  return normalized > 0 ? normalized : void 0;
+}
+function normalizePercent(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(
+    MAX_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+    Math.max(MIN_EFFECTIVE_CONTEXT_WINDOW_PERCENT, Math.floor(value))
+  );
+}
 var DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS = 2e3;
 var DEFAULT_SUMMARY_MAX_INPUT_TOKENS = 24e3;
 var DEFAULT_COMPACTION_EFFECTIVE_MIN_SAVINGS_RATIO = 0.02;
 function getUsableTokenLimit(limits) {
-  return limits.contextWindow - limits.reserveTokens;
+  const effectiveWindow = getEffectiveContextWindow(limits);
+  const reserveLimitedWindow = limits.contextWindow - limits.reserveTokens;
+  return Math.max(1, Math.min(effectiveWindow, reserveLimitedWindow));
+}
+function getEffectiveContextWindow(limits) {
+  const percent = normalizePercent(
+    limits.effectiveContextWindowPercent,
+    DEFAULT_CONTEXT_LIMITS.effectiveContextWindowPercent ?? 95
+  );
+  return Math.max(1, Math.floor(limits.contextWindow * percent / 100));
+}
+function getAutoCompactTokenLimit(limits) {
+  const usableLimit = getUsableTokenLimit(limits);
+  const configured = finitePositiveInteger(limits.autoCompactTokenLimit);
+  return Math.min(configured ?? usableLimit, usableLimit);
 }
 function isContextOverflowing(tokens, limits = DEFAULT_CONTEXT_LIMITS) {
   return tokens > getUsableTokenLimit(limits);
 }
 function shouldPruneContext(tokens, limits = DEFAULT_CONTEXT_LIMITS) {
   if (tokens < limits.pruneMinimum) return false;
-  return isContextOverflowing(tokens, limits);
+  return tokens > getAutoCompactTokenLimit(limits);
 }
 function finiteNonNegativeInteger(value) {
   if (!Number.isFinite(value)) return 0;
@@ -45,11 +74,6 @@ function createCompactionEffectiveness(tokensBefore, tokensAfter, minSavingsRati
     effective
   };
 }
-function finitePositiveInteger(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
-  const normalized = Math.floor(value);
-  return normalized > 0 ? normalized : void 0;
-}
 function clampRatio(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
   if (value <= 0) return void 0;
@@ -133,7 +157,7 @@ function getAdjustedCutReason(options) {
   }
   return options.targetBoundaryWasSafe ? "turn-boundary" : "tool-boundary";
 }
-function buildCutPlan(messages, cutIndex, protectedTokens, reason) {
+function buildCutPlan(messages, cutIndex, protectedTokens, reason, tokenEstimator) {
   if (cutIndex === 0) {
     return {
       kind: "conversation",
@@ -141,7 +165,7 @@ function buildCutPlan(messages, cutIndex, protectedTokens, reason) {
       removedMessages: [],
       keptMessages: [...messages],
       tokensRemoved: 0,
-      tokensKept: estimateConversationTokens(messages),
+      tokensKept: estimateConversationTokens(messages, tokenEstimator),
       protectedTokens,
       reason,
       historyMessages: [],
@@ -155,15 +179,15 @@ function buildCutPlan(messages, cutIndex, protectedTokens, reason) {
     cutIndex,
     removedMessages,
     keptMessages,
-    tokensRemoved: estimateConversationTokens(removedMessages),
-    tokensKept: estimateConversationTokens(keptMessages),
+    tokensRemoved: estimateConversationTokens(removedMessages, tokenEstimator),
+    tokensKept: estimateConversationTokens(keptMessages, tokenEstimator),
     protectedTokens,
     reason,
     historyMessages: removedMessages,
     currentTurnPrefixMessages: []
   };
 }
-function buildSplitTurnPrefixPlan(messages, cutIndex, protectedTokens, currentTurnStartIndex) {
+function buildSplitTurnPrefixPlan(messages, cutIndex, protectedTokens, currentTurnStartIndex, tokenEstimator) {
   const removedMessages = messages.slice(0, cutIndex);
   const keptMessages = messages.slice(cutIndex);
   const historyMessages = messages.slice(0, currentTurnStartIndex);
@@ -176,8 +200,8 @@ function buildSplitTurnPrefixPlan(messages, cutIndex, protectedTokens, currentTu
     cutIndex,
     removedMessages,
     keptMessages,
-    tokensRemoved: estimateConversationTokens(removedMessages),
-    tokensKept: estimateConversationTokens(keptMessages),
+    tokensRemoved: estimateConversationTokens(removedMessages, tokenEstimator),
+    tokensKept: estimateConversationTokens(keptMessages, tokenEstimator),
     protectedTokens,
     reason: "split-turn-prefix",
     historyMessages,
@@ -185,23 +209,23 @@ function buildSplitTurnPrefixPlan(messages, cutIndex, protectedTokens, currentTu
     currentTurnStartIndex
   };
 }
-function getProtectedWindowStart(messages, protectedTokens) {
+function getProtectedWindowStart(messages, protectedTokens, tokenEstimator) {
   let tokensFromEnd = 0;
   for (let i = messages.length - 1; i >= 0; i--) {
-    tokensFromEnd += estimateMessageTokens(messages[i]);
+    tokensFromEnd += estimateMessageTokens(messages[i], tokenEstimator);
     if (tokensFromEnd >= protectedTokens) {
       return i;
     }
   }
   return messages.length;
 }
-function findSplitTurnPrefixPlan(messages, protectedTokens, maxKeptTokens, normalPlan) {
+function findSplitTurnPrefixPlan(messages, protectedTokens, maxKeptTokens, normalPlan, tokenEstimator) {
   const currentTurnStartIndex = findLatestUserMessageIndex(messages);
   if (currentTurnStartIndex === void 0 || currentTurnStartIndex >= messages.length - 1) {
     return void 0;
   }
   const targetStart = Math.max(
-    getProtectedWindowStart(messages, protectedTokens),
+    getProtectedWindowStart(messages, protectedTokens, tokenEstimator),
     currentTurnStartIndex + 1
   );
   let bestPlan;
@@ -211,7 +235,8 @@ function findSplitTurnPrefixPlan(messages, protectedTokens, maxKeptTokens, norma
       messages,
       index,
       protectedTokens,
-      currentTurnStartIndex
+      currentTurnStartIndex,
+      tokenEstimator
     );
     if (plan.tokensKept >= normalPlan.tokensKept) return false;
     if (maxKeptTokens === void 0 || plan.tokensKept <= maxKeptTokens) {
@@ -232,23 +257,36 @@ function findSplitTurnPrefixPlan(messages, protectedTokens, maxKeptTokens, norma
   return bestPlan;
 }
 function planCompactionCut(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.protectedTokens, options = {}) {
+  const tokenEstimator = options.tokenEstimator;
   if (messages.length === 0) {
-    return buildCutPlan(messages, 0, protectedTokens, "no-safe-cut");
+    return buildCutPlan(
+      messages,
+      0,
+      protectedTokens,
+      "no-safe-cut",
+      tokenEstimator
+    );
   }
-  const targetCutIndex = getProtectedWindowStart(messages, protectedTokens);
+  const targetCutIndex = getProtectedWindowStart(
+    messages,
+    protectedTokens,
+    tokenEstimator
+  );
   if (targetCutIndex <= 1) {
     const noSafePlan2 = buildCutPlan(
       messages,
       0,
       protectedTokens,
-      "no-safe-cut"
+      "no-safe-cut",
+      tokenEstimator
     );
     if (options.allowSplitTurn) {
       return findSplitTurnPrefixPlan(
         messages,
         protectedTokens,
         options.maxKeptTokens,
-        noSafePlan2
+        noSafePlan2,
+        tokenEstimator
       ) ?? noSafePlan2;
     }
     return noSafePlan2;
@@ -262,14 +300,16 @@ function planCompactionCut(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.pr
       messages,
       0,
       protectedTokens,
-      "no-safe-cut"
+      "no-safe-cut",
+      tokenEstimator
     );
     if (options.allowSplitTurn) {
       return findSplitTurnPrefixPlan(
         messages,
         protectedTokens,
         options.maxKeptTokens,
-        noSafePlan2
+        noSafePlan2,
+        tokenEstimator
       ) ?? noSafePlan2;
     }
     return noSafePlan2;
@@ -285,14 +325,16 @@ function planCompactionCut(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.pr
           targetCutIndex,
           latestUserIndex,
           targetBoundaryWasSafe
-        })
+        }),
+        tokenEstimator
       );
       if (options.allowSplitTurn && options.maxKeptTokens !== void 0 && plan.tokensKept > options.maxKeptTokens) {
         return findSplitTurnPrefixPlan(
           messages,
           protectedTokens,
           options.maxKeptTokens,
-          plan
+          plan,
+          tokenEstimator
         ) ?? plan;
       }
       return plan;
@@ -309,93 +351,138 @@ function planCompactionCut(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.pr
           targetCutIndex,
           latestUserIndex,
           targetBoundaryWasSafe
-        })
+        }),
+        tokenEstimator
       );
       if (options.allowSplitTurn && options.maxKeptTokens !== void 0 && plan.tokensKept > options.maxKeptTokens) {
         return findSplitTurnPrefixPlan(
           messages,
           protectedTokens,
           options.maxKeptTokens,
-          plan
+          plan,
+          tokenEstimator
         ) ?? plan;
       }
       return plan;
     }
   }
-  const noSafePlan = buildCutPlan(messages, 0, protectedTokens, "no-safe-cut");
+  const noSafePlan = buildCutPlan(
+    messages,
+    0,
+    protectedTokens,
+    "no-safe-cut",
+    tokenEstimator
+  );
   if (options.allowSplitTurn) {
     return findSplitTurnPrefixPlan(
       messages,
       protectedTokens,
       options.maxKeptTokens,
-      noSafePlan
+      noSafePlan,
+      tokenEstimator
     ) ?? noSafePlan;
   }
   return noSafePlan;
 }
 
 // src/context/window/decision.ts
+function defaultCompactionReason(options) {
+  if (options.reason) return options.reason;
+  if (options.trigger === "manual") return "manual-request";
+  if (options.forced) return "provider-overflow";
+  return "context-limit";
+}
+function createDecision(params) {
+  return {
+    needed: params.needed,
+    reason: params.reason,
+    strategy: params.strategy,
+    forced: params.forced,
+    trigger: params.trigger,
+    compactionReason: params.compactionReason,
+    canSummarize: params.canSummarize,
+    inputTokens: params.inputTokens,
+    limit: params.limit,
+    overflowTokens: params.overflowTokens,
+    protectedTokens: params.protectedTokens,
+    pruneMinimum: params.pruneMinimum
+  };
+}
 function decideContextCompaction(messages, options = {}) {
   const limits = options.limits ?? DEFAULT_CONTEXT_LIMITS;
-  const inputTokens = options.inputTokens ?? estimateConversationTokens(messages);
-  const limit = getUsableTokenLimit(limits);
+  const inputTokens = options.inputTokens ?? estimateConversationTokens(messages, options.tokenEstimator);
+  const limit = getAutoCompactTokenLimit(limits);
   const overflowTokens = Math.max(0, inputTokens - limit);
   const forced = options.force === true;
+  const trigger = options.trigger ?? (forced ? "recovery" : "auto");
+  const compactionReason = defaultCompactionReason({
+    forced,
+    trigger,
+    reason: options.reason
+  });
   const canSummarize = options.canSummarize === true;
   if (forced) {
-    return {
+    return createDecision({
       needed: true,
       reason: "forced-recovery",
       strategy: "tool-context-first",
       forced,
+      trigger,
+      compactionReason,
       canSummarize,
       inputTokens,
       limit,
       overflowTokens,
       protectedTokens: limits.protectedTokens,
       pruneMinimum: limits.pruneMinimum
-    };
+    });
   }
   if (inputTokens < limits.pruneMinimum) {
-    return {
+    return createDecision({
       needed: false,
       reason: "below-prune-minimum",
       strategy: "none",
       forced,
+      trigger,
+      compactionReason,
       canSummarize,
       inputTokens,
       limit,
       overflowTokens,
       protectedTokens: limits.protectedTokens,
       pruneMinimum: limits.pruneMinimum
-    };
+    });
   }
   if (!shouldPruneContext(inputTokens, limits)) {
-    return {
+    return createDecision({
       needed: false,
       reason: "under-limit",
       strategy: "none",
       forced,
+      trigger,
+      compactionReason,
       canSummarize,
       inputTokens,
       limit,
       overflowTokens,
       protectedTokens: limits.protectedTokens,
       pruneMinimum: limits.pruneMinimum
-    };
+    });
   }
-  return {
+  return createDecision({
     needed: true,
     reason: "overflow",
     strategy: "tool-context-first",
     forced,
+    trigger,
+    compactionReason,
     canSummarize,
     inputTokens,
     limit,
     overflowTokens,
     protectedTokens: limits.protectedTokens,
     pruneMinimum: limits.pruneMinimum
-  };
+  });
 }
 
 // src/types/compaction.ts
@@ -435,6 +522,7 @@ Preserve:
 4. Open issues or blockers that the kept suffix depends on
 
 Do not invent next steps. Do not ask or answer questions from the removed material. Return only the handoff summary body.`;
+var DEFAULT_RECENT_MESSAGE_RATIO = 0.65;
 function createCompactionSummaryContent(summary) {
   return `${SUMMARY_PREFIX}${summary.trim()}`;
 }
@@ -465,6 +553,7 @@ function redactSummaryText(text) {
   );
 }
 function compactText(text, maxChars) {
+  if (maxChars <= 0) return "";
   const redacted = redactSummaryText(text);
   return truncateTextMiddle(redacted, maxChars, {
     headRatio: 0.7,
@@ -501,6 +590,95 @@ ${content}`];
   if (toolCalls) parts.push(toolCalls);
   return parts.join("\n\n");
 }
+function separatorLength(parts) {
+  return parts.length > 0 ? 2 : 0;
+}
+function joinedLength(parts) {
+  if (parts.length === 0) return 0;
+  return parts.reduce((total, part) => total + part.length, 0) + (parts.length - 1) * 2;
+}
+function clampRecentMessageRatio(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return DEFAULT_RECENT_MESSAGE_RATIO;
+  }
+  return Math.min(0.9, Math.max(0.1, value));
+}
+function appendWithinBudget(params) {
+  const remaining = params.budget - joinedLength(params.parts) - separatorLength(params.parts);
+  if (remaining <= 0) return false;
+  if (params.text.length <= remaining) {
+    params.parts.push(params.text);
+    return true;
+  }
+  if (!params.allowPartial) return false;
+  const compacted = compactText(params.text, remaining);
+  if (!compacted) return false;
+  params.parts.push(compacted);
+  return true;
+}
+function prependWithinBudget(params) {
+  const remaining = params.budget - joinedLength(params.parts) - separatorLength(params.parts);
+  if (remaining <= 0) return false;
+  if (params.text.length <= remaining) {
+    params.parts.unshift(params.text);
+    return true;
+  }
+  if (!params.allowPartial) return false;
+  const compacted = compactText(params.text, remaining);
+  if (!compacted) return false;
+  params.parts.unshift(compacted);
+  return true;
+}
+function serializeBoundedMessages(serializedMessages, maxChars, recentMessageRatio) {
+  if (serializedMessages.length === 0) {
+    return "[No message content was available for summarization.]";
+  }
+  const fullTranscript = serializedMessages.join("\n\n");
+  if (fullTranscript.length <= maxChars) {
+    return fullTranscript;
+  }
+  if (serializedMessages.length === 1) {
+    return compactText(serializedMessages[0], maxChars);
+  }
+  const markerFor = (omittedCount2) => omittedCount2 > 0 ? `[...${omittedCount2} messages omitted for compaction; preserved beginning and most recent removed context...]` : "[...message content omitted for compaction; preserved beginning and most recent removed context...]";
+  const markerReserve = markerFor(serializedMessages.length).length + 4;
+  const contentBudget = Math.max(1, maxChars - markerReserve);
+  const tailBudget = Math.max(
+    1,
+    Math.floor(contentBudget * recentMessageRatio)
+  );
+  const headBudget = Math.max(1, contentBudget - tailBudget);
+  const headParts = [];
+  let headEnd = 0;
+  for (let i = 0; i < serializedMessages.length; i++) {
+    const added = appendWithinBudget({
+      parts: headParts,
+      text: serializedMessages[i],
+      budget: headBudget,
+      allowPartial: headParts.length === 0
+    });
+    if (!added) break;
+    headEnd = i + 1;
+    if (joinedLength(headParts) >= headBudget) break;
+  }
+  const tailParts = [];
+  let tailStart = serializedMessages.length;
+  for (let i = serializedMessages.length - 1; i >= headEnd; i--) {
+    const added = prependWithinBudget({
+      parts: tailParts,
+      text: serializedMessages[i],
+      budget: tailBudget,
+      allowPartial: tailParts.length === 0
+    });
+    if (!added) break;
+    tailStart = i;
+    if (joinedLength(tailParts) >= tailBudget) break;
+  }
+  const omittedCount = Math.max(0, tailStart - headEnd);
+  const marker = markerFor(omittedCount);
+  const transcript = [...headParts, marker, ...tailParts].filter((part) => part.length > 0).join("\n\n");
+  return transcript.length <= maxChars ? transcript : compactText(transcript, maxChars);
+}
 function serializeMessagesForSummary(messages, options = {}) {
   const maxChars = estimateCharsFromTokens(
     options.maxInputTokens,
@@ -510,28 +688,25 @@ function serializeMessagesForSummary(messages, options = {}) {
     options.maxMessageTokens,
     DEFAULT_MESSAGE_INPUT_TOKENS
   );
-  const parts = [];
-  let usedChars = 0;
-  for (const message of messages) {
-    const serialized = serializeMessageForSummary(message, maxMessageChars);
-    const separator = parts.length > 0 ? "\n\n" : "";
-    const remaining = maxChars - usedChars - separator.length;
-    if (remaining <= 0) break;
-    if (serialized.length > remaining) {
-      parts.push(`${separator}${compactText(serialized, remaining)}`);
-      usedChars = maxChars;
-      break;
-    }
-    parts.push(`${separator}${serialized}`);
-    usedChars += separator.length + serialized.length;
-  }
-  const transcript = parts.join("");
+  const serializedMessages = messages.map(
+    (message) => serializeMessageForSummary(message, maxMessageChars)
+  );
+  const transcript = serializeBoundedMessages(
+    serializedMessages,
+    maxChars,
+    clampRecentMessageRatio(options.recentMessageRatio)
+  );
   if (messages.length > 0 && transcript.length >= maxChars) {
     return `${transcript}
 
 [Summary input reached its configured compaction cap.]`;
   }
-  return transcript || "[No message content was available for summarization.]";
+  if (messages.length > 0 && serializedMessages.join("\n\n").length > transcript.length) {
+    return `${transcript}
+
+[Summary input reached its configured compaction cap.]`;
+  }
+  return transcript;
 }
 async function generateSummary(messages, options) {
   const conversationText = serializeMessagesForSummary(messages, {
@@ -594,16 +769,67 @@ ${currentTurnPrefixText}`,
 }
 
 // src/context/window/tool-pruning.ts
-var TOOL_OUTPUT_PRUNE_THRESHOLD = 500;
-var TOOL_ARGUMENT_PRUNE_THRESHOLD = 500;
-var TOOL_ARGUMENT_PREVIEW_CHARS = 240;
-var TOOL_ARGUMENT_MAX_STRING_CHARS = 1800;
-var TOOL_ARGUMENT_STRING_HEAD_CHARS = 1200;
-var TOOL_ARGUMENT_STRING_TAIL_CHARS = 400;
-var TOOL_ARGUMENT_ARRAY_HEAD_ITEMS = 24;
-var TOOL_ARGUMENT_ARRAY_TAIL_ITEMS = 8;
-var TOOL_ARGUMENT_OBJECT_MAX_KEYS = 80;
-var TOOL_ARGUMENT_MAX_DEPTH = 8;
+var DEFAULT_TOOL_CONTEXT_PRUNE_POLICY = {
+  outputThresholdTokens: 500,
+  argumentThresholdTokens: 500,
+  argumentPreviewChars: 240,
+  argumentMaxStringChars: 1800,
+  argumentStringHeadChars: 1200,
+  argumentStringTailChars: 400,
+  argumentArrayHeadItems: 24,
+  argumentArrayTailItems: 8,
+  argumentObjectMaxKeys: 80,
+  argumentMaxDepth: 8
+};
+function positiveIntegerOrDefault(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  const normalized = Math.floor(value);
+  return normalized > 0 ? normalized : fallback;
+}
+function resolveToolContextPrunePolicy(policy) {
+  return {
+    outputThresholdTokens: positiveIntegerOrDefault(
+      policy?.outputThresholdTokens,
+      DEFAULT_TOOL_CONTEXT_PRUNE_POLICY.outputThresholdTokens
+    ),
+    argumentThresholdTokens: positiveIntegerOrDefault(
+      policy?.argumentThresholdTokens,
+      DEFAULT_TOOL_CONTEXT_PRUNE_POLICY.argumentThresholdTokens
+    ),
+    argumentPreviewChars: positiveIntegerOrDefault(
+      policy?.argumentPreviewChars,
+      DEFAULT_TOOL_CONTEXT_PRUNE_POLICY.argumentPreviewChars
+    ),
+    argumentMaxStringChars: positiveIntegerOrDefault(
+      policy?.argumentMaxStringChars,
+      DEFAULT_TOOL_CONTEXT_PRUNE_POLICY.argumentMaxStringChars
+    ),
+    argumentStringHeadChars: positiveIntegerOrDefault(
+      policy?.argumentStringHeadChars,
+      DEFAULT_TOOL_CONTEXT_PRUNE_POLICY.argumentStringHeadChars
+    ),
+    argumentStringTailChars: positiveIntegerOrDefault(
+      policy?.argumentStringTailChars,
+      DEFAULT_TOOL_CONTEXT_PRUNE_POLICY.argumentStringTailChars
+    ),
+    argumentArrayHeadItems: positiveIntegerOrDefault(
+      policy?.argumentArrayHeadItems,
+      DEFAULT_TOOL_CONTEXT_PRUNE_POLICY.argumentArrayHeadItems
+    ),
+    argumentArrayTailItems: positiveIntegerOrDefault(
+      policy?.argumentArrayTailItems,
+      DEFAULT_TOOL_CONTEXT_PRUNE_POLICY.argumentArrayTailItems
+    ),
+    argumentObjectMaxKeys: positiveIntegerOrDefault(
+      policy?.argumentObjectMaxKeys,
+      DEFAULT_TOOL_CONTEXT_PRUNE_POLICY.argumentObjectMaxKeys
+    ),
+    argumentMaxDepth: positiveIntegerOrDefault(
+      policy?.argumentMaxDepth,
+      DEFAULT_TOOL_CONTEXT_PRUNE_POLICY.argumentMaxDepth
+    )
+  };
+}
 function stringifyToolValue(value) {
   if (typeof value === "string") return value;
   if (value === void 0) return "";
@@ -623,24 +849,25 @@ function compactPreview(value, maxChars) {
     separator: ""
   });
 }
-function compactLongArgumentString(value) {
-  if (value.length <= TOOL_ARGUMENT_MAX_STRING_CHARS) return value;
-  const totalKeptArgumentChars = TOOL_ARGUMENT_STRING_HEAD_CHARS + TOOL_ARGUMENT_STRING_TAIL_CHARS;
-  return truncateTextMiddle(value, TOOL_ARGUMENT_MAX_STRING_CHARS, {
-    headRatio: TOOL_ARGUMENT_STRING_HEAD_CHARS / totalKeptArgumentChars,
+function compactLongArgumentString(value, policy) {
+  if (value.length <= policy.argumentMaxStringChars) return value;
+  const totalKeptArgumentChars = policy.argumentStringHeadChars + policy.argumentStringTailChars;
+  return truncateTextMiddle(value, policy.argumentMaxStringChars, {
+    headRatio: policy.argumentStringHeadChars / totalKeptArgumentChars,
     marker: (omitted) => `
 [${omitted} characters omitted by context compaction]
 `
   });
 }
-function compactToolArgumentValue(value, depth, seen) {
-  if (typeof value === "string") return compactLongArgumentString(value);
+function compactToolArgumentValue(value, depth, seen, policy) {
+  if (typeof value === "string")
+    return compactLongArgumentString(value, policy);
   if (value === null || typeof value !== "object") return value;
-  if (depth >= TOOL_ARGUMENT_MAX_DEPTH) {
+  if (depth >= policy.argumentMaxDepth) {
     return {
       __contextWindowCompaction: {
         reason: "max-depth",
-        preview: compactPreview(value, TOOL_ARGUMENT_PREVIEW_CHARS)
+        preview: compactPreview(value, policy.argumentPreviewChars)
       }
     };
   }
@@ -653,21 +880,23 @@ function compactToolArgumentValue(value, depth, seen) {
   }
   seen.add(value);
   if (Array.isArray(value)) {
-    const shouldSlice = value.length > TOOL_ARGUMENT_ARRAY_HEAD_ITEMS + TOOL_ARGUMENT_ARRAY_TAIL_ITEMS;
-    const head = shouldSlice ? value.slice(0, TOOL_ARGUMENT_ARRAY_HEAD_ITEMS) : value;
-    const tail = shouldSlice ? value.slice(-TOOL_ARGUMENT_ARRAY_TAIL_ITEMS) : [];
+    const shouldSlice = value.length > policy.argumentArrayHeadItems + policy.argumentArrayTailItems;
+    const head = shouldSlice ? value.slice(0, policy.argumentArrayHeadItems) : value;
+    const tail = shouldSlice ? value.slice(-policy.argumentArrayTailItems) : [];
     const compacted2 = head.map(
-      (item) => compactToolArgumentValue(item, depth + 1, seen)
+      (item) => compactToolArgumentValue(item, depth + 1, seen, policy)
     );
     if (shouldSlice) {
       compacted2.push({
         __contextWindowCompaction: {
           reason: "array-length",
-          omittedItems: value.length - TOOL_ARGUMENT_ARRAY_HEAD_ITEMS - TOOL_ARGUMENT_ARRAY_TAIL_ITEMS
+          omittedItems: value.length - policy.argumentArrayHeadItems - policy.argumentArrayTailItems
         }
       });
       compacted2.push(
-        ...tail.map((item) => compactToolArgumentValue(item, depth + 1, seen))
+        ...tail.map(
+          (item) => compactToolArgumentValue(item, depth + 1, seen, policy)
+        )
       );
     }
     seen.delete(value);
@@ -675,9 +904,14 @@ function compactToolArgumentValue(value, depth, seen) {
   }
   const entries = Object.entries(value);
   const compacted = {};
-  const keptEntries = entries.slice(0, TOOL_ARGUMENT_OBJECT_MAX_KEYS);
+  const keptEntries = entries.slice(0, policy.argumentObjectMaxKeys);
   for (const [key, entryValue] of keptEntries) {
-    compacted[key] = compactToolArgumentValue(entryValue, depth + 1, seen);
+    compacted[key] = compactToolArgumentValue(
+      entryValue,
+      depth + 1,
+      seen,
+      policy
+    );
   }
   if (entries.length > keptEntries.length) {
     compacted.__contextWindowCompaction = {
@@ -688,12 +922,17 @@ function compactToolArgumentValue(value, depth, seen) {
   seen.delete(value);
   return compacted;
 }
-function compactToolCallArgs(args) {
+function compactToolCallArgs(args, policy, tokenEstimator) {
   const beforeText = stringifyToolValue(args);
-  if (estimateTokens(beforeText) < TOOL_ARGUMENT_PRUNE_THRESHOLD) {
+  if (estimateTokens(beforeText, tokenEstimator) < policy.argumentThresholdTokens) {
     return { args, compacted: false };
   }
-  const compactedArgs = compactToolArgumentValue(args, 0, /* @__PURE__ */ new WeakSet());
+  const compactedArgs = compactToolArgumentValue(
+    args,
+    0,
+    /* @__PURE__ */ new WeakSet(),
+    policy
+  );
   const afterText = stringifyToolValue(compactedArgs);
   if (afterText.length < beforeText.length) {
     return { args: compactedArgs, compacted: true };
@@ -702,8 +941,8 @@ function compactToolCallArgs(args) {
     args: {
       __contextWindowCompaction: {
         reason: "argument-size",
-        originalEstimatedTokens: estimateTokens(beforeText),
-        preview: compactPreview(args, TOOL_ARGUMENT_MAX_STRING_CHARS)
+        originalEstimatedTokens: estimateTokens(beforeText, tokenEstimator),
+        preview: compactPreview(args, policy.argumentMaxStringChars)
       }
     },
     compacted: true
@@ -720,13 +959,13 @@ function collectToolCallArgs(messages) {
   return argsByCallId;
 }
 function summarizeToolOutput(options) {
-  const { tool, args, currentTokens, duplicateOf } = options;
+  const { tool, args, currentTokens, policy, duplicateOf } = options;
   if (duplicateOf) {
     return `[Tool output compacted] ${tool.toolName} produced duplicate output already retained in call ${duplicateOf}. Original output was ${currentTokens} estimated tokens.`;
   }
   const lines = tool.content.split(/\r?\n/).filter((line) => line.trim());
   const lineCount = lines.length;
-  const argsPreview = compactPreview(args, TOOL_ARGUMENT_PREVIEW_CHARS);
+  const argsPreview = compactPreview(args, policy.argumentPreviewChars);
   const rawFirstLine = lines[0] ?? "";
   const firstLine = rawFirstLine.length > 0 && rawFirstLine.length <= 160 ? compactPreview(rawFirstLine, 160) : "";
   const details = [
@@ -743,14 +982,14 @@ function summarizeToolOutput(options) {
   }
   return `[Tool output compacted] ${details.join("; ")}`;
 }
-function maybeCompactAssistantToolCalls(message, protectedToolSet) {
+function maybeCompactAssistantToolCalls(message, protectedToolSet, policy, tokenEstimator) {
   if (!message.toolCalls || message.toolCalls.length === 0) {
     return { message, compactedCount: 0 };
   }
   let compactedCount = 0;
   const toolCalls = message.toolCalls.map((toolCall) => {
     if (protectedToolSet.has(toolCall.toolName)) return toolCall;
-    const result = compactToolCallArgs(toolCall.args);
+    const result = compactToolCallArgs(toolCall.args, policy, tokenEstimator);
     if (!result.compacted) return toolCall;
     compactedCount++;
     return {
@@ -768,6 +1007,8 @@ function maybeCompactAssistantToolCalls(message, protectedToolSet) {
   };
 }
 function pruneToolContextWithReport(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.protectedTokens, options) {
+  const policy = resolveToolContextPrunePolicy(options?.policy);
+  const tokenEstimator = options?.tokenEstimator;
   const protectedToolSet = /* @__PURE__ */ new Set([
     ...PRUNE_PROTECTED_TOOLS,
     ...options?.protectedTools ?? []
@@ -775,13 +1016,13 @@ function pruneToolContextWithReport(messages, protectedTokens = DEFAULT_CONTEXT_
   const argsByCallId = collectToolCallArgs(messages);
   const newestFullOutputByContent = /* @__PURE__ */ new Map();
   const tokensBefore = messages.reduce(
-    (total, message) => total + estimateMessageTokens(message),
+    (total, message) => total + estimateMessageTokens(message, tokenEstimator),
     0
   );
   let tokensFromEnd = 0;
   const tokenPositions = [];
   for (let i = messages.length - 1; i >= 0; i--) {
-    tokensFromEnd += estimateMessageTokens(messages[i]);
+    tokensFromEnd += estimateMessageTokens(messages[i], tokenEstimator);
     tokenPositions[i] = tokensFromEnd;
   }
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -790,7 +1031,7 @@ function pruneToolContextWithReport(messages, protectedTokens = DEFAULT_CONTEXT_
     if (typeof message.content !== "string" || message.content.length < 200) {
       continue;
     }
-    const isRetained = tokenPositions[i] < protectedTokens || Boolean(message.compactedAt) || message.toolName !== void 0 && protectedToolSet.has(message.toolName) || estimateTokens(message.content) < TOOL_OUTPUT_PRUNE_THRESHOLD;
+    const isRetained = tokenPositions[i] < protectedTokens || Boolean(message.compactedAt) || message.toolName !== void 0 && protectedToolSet.has(message.toolName) || estimateTokens(message.content, tokenEstimator) < policy.outputThresholdTokens;
     if (!isRetained) continue;
     if (!newestFullOutputByContent.has(message.content)) {
       newestFullOutputByContent.set(message.content, message.toolCallId);
@@ -802,7 +1043,12 @@ function pruneToolContextWithReport(messages, protectedTokens = DEFAULT_CONTEXT_
     if (tokenPositions[i] < protectedTokens) return msg;
     if (!("role" in msg)) return msg;
     if (msg.role === "assistant") {
-      const result = maybeCompactAssistantToolCalls(msg, protectedToolSet);
+      const result = maybeCompactAssistantToolCalls(
+        msg,
+        protectedToolSet,
+        policy,
+        tokenEstimator
+      );
       argumentCompactedCount += result.compactedCount;
       return result.message;
     }
@@ -810,13 +1056,14 @@ function pruneToolContextWithReport(messages, protectedTokens = DEFAULT_CONTEXT_
     const toolMsg = msg;
     if ("compactedAt" in toolMsg && toolMsg.compactedAt) return msg;
     if (toolMsg.toolName && protectedToolSet.has(toolMsg.toolName)) return msg;
-    const currentTokens = estimateTokens(toolMsg.content);
-    if (currentTokens < TOOL_OUTPUT_PRUNE_THRESHOLD) return msg;
+    const currentTokens = estimateTokens(toolMsg.content, tokenEstimator);
+    if (currentTokens < policy.outputThresholdTokens) return msg;
     const duplicateOf = newestFullOutputByContent.get(toolMsg.content);
     const compactedContent = summarizeToolOutput({
       tool: toolMsg,
       args: argsByCallId.get(toolMsg.toolCallId),
       currentTokens,
+      policy,
       duplicateOf: duplicateOf && duplicateOf !== toolMsg.toolCallId ? duplicateOf : void 0
     });
     outputCompactedCount++;
@@ -828,7 +1075,7 @@ function pruneToolContextWithReport(messages, protectedTokens = DEFAULT_CONTEXT_
     };
   });
   const tokensAfter = nextMessages.reduce(
-    (total, message) => total + estimateMessageTokens(message),
+    (total, message) => total + estimateMessageTokens(message, tokenEstimator),
     0
   );
   return {
@@ -897,12 +1144,19 @@ async function pruneContext(messages, options = {}) {
   let summary;
   let summaryOutputTokens;
   const summaryPolicy = resolveContextSummaryPolicy(options.summary);
-  const initialTokens = estimateConversationTokens(currentMessages);
+  const tokenEstimator = options.tokenEstimator;
+  const initialTokens = estimateConversationTokens(
+    currentMessages,
+    tokenEstimator
+  );
   const decision = decideContextCompaction(currentMessages, {
     limits,
     force: options.force,
     canSummarize: canGenerateCompactionSummary(summaryPolicy),
-    inputTokens: initialTokens
+    inputTokens: initialTokens,
+    trigger: options.trigger,
+    reason: options.reason,
+    tokenEstimator
   });
   if (!decision.needed) {
     return {
@@ -920,15 +1174,26 @@ async function pruneContext(messages, options = {}) {
       cutReason: "no-safe-cut"
     };
   }
-  const toolContextResult = pruneToolContextWithReport(
-    currentMessages,
-    limits.protectedTokens
-  );
-  const toolContext = toolContextResult.report;
-  const prunedMessages = toolContextResult.messages;
-  const afterPruneTokens = estimateConversationTokens(prunedMessages);
-  tokensRemoved = Math.max(0, initialTokens - afterPruneTokens);
-  currentMessages = prunedMessages;
+  let toolContext;
+  let afterPruneTokens = initialTokens;
+  if (options.toolPruning?.enabled !== false) {
+    const toolContextResult = pruneToolContextWithReport(
+      currentMessages,
+      limits.protectedTokens,
+      {
+        policy: options.toolPruning?.policy,
+        tokenEstimator
+      }
+    );
+    toolContext = toolContextResult.report;
+    const prunedMessages = toolContextResult.messages;
+    afterPruneTokens = estimateConversationTokens(
+      prunedMessages,
+      tokenEstimator
+    );
+    tokensRemoved = Math.max(0, initialTokens - afterPruneTokens);
+    currentMessages = prunedMessages;
+  }
   if (!isContextOverflowing(afterPruneTokens, limits)) {
     return {
       messages: currentMessages,
@@ -948,7 +1213,8 @@ async function pruneContext(messages, options = {}) {
   }
   const cutPlan = planCompactionCut(currentMessages, limits.protectedTokens, {
     allowSplitTurn: summaryPolicy.mode !== "disabled",
-    maxKeptTokens: getUsableTokenLimit(limits)
+    maxKeptTokens: getUsableTokenLimit(limits),
+    tokenEstimator
   });
   if (cutPlan.cutIndex === 0) {
     return {
@@ -985,7 +1251,7 @@ async function pruneContext(messages, options = {}) {
       ...messagesToSummarize,
       ...currentTurnPrefixMessages
     ];
-    const summaryInputTokens = summaryInputMessages.length > 0 ? estimateConversationTokens(summaryInputMessages) : cutPlan.tokensRemoved;
+    const summaryInputTokens = summaryInputMessages.length > 0 ? estimateConversationTokens(summaryInputMessages, tokenEstimator) : cutPlan.tokensRemoved;
     summaryOutputTokens = resolveSummaryOutputTokens({
       inputTokens: summaryInputTokens,
       limits,
@@ -1028,7 +1294,7 @@ async function pruneContext(messages, options = {}) {
     decision,
     effectiveness: createCompactionEffectiveness(
       initialTokens,
-      estimateConversationTokens(currentMessages)
+      estimateConversationTokens(currentMessages, tokenEstimator)
     ),
     removedCount,
     tokensRemoved,
@@ -1038,6 +1304,7 @@ async function pruneContext(messages, options = {}) {
     removedMessages,
     keptMessages: toKeep,
     summaryOutputTokens,
+    ...previousSummary !== void 0 ? { previousSummary } : {},
     cutIndex: cutPlan.cutIndex,
     cutReason: cutPlan.reason,
     toolContext
@@ -1049,10 +1316,14 @@ var ContextWindowManager = class {
   limits;
   activeModel;
   summaryPolicy;
+  toolPruning;
+  tokenEstimator;
   constructor(options) {
     this.limits = { ...DEFAULT_CONTEXT_LIMITS, ...options?.limits };
     this.activeModel = options?.model;
     this.summaryPolicy = options?.summary;
+    this.toolPruning = options?.toolPruning;
+    this.tokenEstimator = options?.tokenEstimator;
   }
   /** Get a copy of the current context limits. */
   getLimits() {
@@ -1070,13 +1341,29 @@ var ContextWindowManager = class {
   setSummaryPolicy(policy) {
     this.summaryPolicy = policy;
   }
+  /** Set deterministic tool-context pruning behavior. */
+  setToolPruning(options) {
+    this.toolPruning = options;
+  }
+  /** Get deterministic tool-context pruning behavior. */
+  getToolPruning() {
+    return this.toolPruning ? { ...this.toolPruning } : void 0;
+  }
+  /** Set the token estimator used for context-window planning. */
+  setTokenEstimator(estimator) {
+    this.tokenEstimator = estimator;
+  }
+  /** Get the token estimator used for context-window planning. */
+  getTokenEstimator() {
+    return this.tokenEstimator;
+  }
   /** Resolve summary policy against the active agent model. */
   getSummaryPolicy() {
     return resolveContextSummaryPolicy(this.summaryPolicy, this.activeModel);
   }
   /** Estimate total tokens for a message array. */
   estimateTokens(messages) {
-    return estimateConversationTokens(messages);
+    return estimateConversationTokens(messages, this.tokenEstimator);
   }
   /** Check whether the context is overflowing. */
   isOverflowing(messages) {
@@ -1095,7 +1382,10 @@ var ContextWindowManager = class {
       limits: this.limits,
       force: options?.force,
       inputTokens: options?.inputTokens,
-      canSummarize: canGenerateCompactionSummary(summaryPolicy)
+      trigger: options?.trigger,
+      reason: options?.reason,
+      canSummarize: canGenerateCompactionSummary(summaryPolicy),
+      tokenEstimator: this.tokenEstimator
     });
   }
   /** Prune context to fit within limits. */
@@ -1103,7 +1393,11 @@ var ContextWindowManager = class {
     return pruneContext(messages, {
       limits: this.limits,
       summary: this.getSummaryPolicy(),
-      force: options?.force
+      force: options?.force,
+      trigger: options?.trigger,
+      reason: options?.reason,
+      toolPruning: options?.toolPruning ?? this.toolPruning,
+      tokenEstimator: this.tokenEstimator
     });
   }
   /**
@@ -1113,11 +1407,17 @@ var ContextWindowManager = class {
    */
   getStats(messages) {
     const tokens = this.estimateTokens(messages);
-    const limit = getUsableTokenLimit(this.limits);
+    const effectiveContextWindow = getEffectiveContextWindow(this.limits);
+    const usableLimit = getUsableTokenLimit(this.limits);
+    const autoCompactLimit = getAutoCompactTokenLimit(this.limits);
+    const limit = autoCompactLimit;
     return {
       tokens,
       limit,
-      available: Math.max(0, limit - tokens),
+      effectiveContextWindow,
+      usableLimit,
+      autoCompactLimit,
+      available: Math.max(0, usableLimit - tokens),
       utilizationPercent: Math.round(tokens / limit * 100),
       isOverflowing: isContextOverflowing(tokens, this.limits),
       shouldPrune: shouldPruneContext(tokens, this.limits)
@@ -1131,6 +1431,8 @@ export {
   DEFAULT_SUMMARY_MAX_INPUT_TOKENS,
   DEFAULT_COMPACTION_EFFECTIVE_MIN_SAVINGS_RATIO,
   getUsableTokenLimit,
+  getEffectiveContextWindow,
+  getAutoCompactTokenLimit,
   isContextOverflowing,
   shouldPruneContext,
   createCompactionEffectiveness,
@@ -1144,6 +1446,7 @@ export {
   serializeMessagesForSummary,
   generateSummary,
   generateSplitTurnSummary,
+  DEFAULT_TOOL_CONTEXT_PRUNE_POLICY,
   pruneToolContextWithReport,
   pruneToolContext,
   ContextSummaryModelRequiredError,