@cuylabs/agent-core 4.9.0 → 5.0.0

package/dist/chunk-DYZGHHDB.js

@@ -0,0 +1,1458 @@
+import {
+  estimateConversationTokens,
+  estimateMessageTokens,
+  estimateTokens,
+  isAgentContextFragmentMessage,
+  truncateTextMiddle,
+  truncateTextPrefix
+} 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) {
+  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 tokens > getAutoCompactTokenLimit(limits);
+}
+function finiteNonNegativeInteger(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.floor(value));
+}
+function createCompactionEffectiveness(tokensBefore, tokensAfter, minSavingsRatio = DEFAULT_COMPACTION_EFFECTIVE_MIN_SAVINGS_RATIO) {
+  const before = finiteNonNegativeInteger(tokensBefore);
+  const after = finiteNonNegativeInteger(tokensAfter);
+  const removed = Math.max(0, before - after);
+  const savingsRatio = before > 0 ? removed / before : 0;
+  const effective = removed > 0 && savingsRatio >= Math.max(0, Number.isFinite(minSavingsRatio) ? minSavingsRatio : 0);
+  return {
+    tokensBefore: before,
+    tokensAfter: after,
+    tokensRemoved: removed,
+    savingsRatio,
+    effective
+  };
+}
+function clampRatio(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  if (value <= 0) return void 0;
+  return Math.min(1, value);
+}
+function resolveSummaryOutputTokens(options) {
+  const limits = options.limits ?? DEFAULT_CONTEXT_LIMITS;
+  const configuredCap = finitePositiveInteger(options.summaryMaxOutputTokens) ?? DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS;
+  const reserveCap = Math.max(1, Math.floor(limits.reserveTokens * 0.8));
+  const cap = Math.max(1, Math.min(configuredCap, reserveCap));
+  const ratio = clampRatio(options.summaryTargetRatio);
+  if (ratio === void 0) {
+    return cap;
+  }
+  const inputTokens = finitePositiveInteger(options.inputTokens) ?? 0;
+  const target = Math.max(1, Math.ceil(inputTokens * ratio));
+  return Math.min(cap, target);
+}
+
+// src/context/window/cut-planner.ts
+function hasToolCalls(message) {
+  return message.role === "assistant" && Array.isArray(message.toolCalls) && message.toolCalls.length > 0;
+}
+function getToolCallIds(message) {
+  if (!hasToolCalls(message)) return [];
+  return message.toolCalls.map((toolCall) => toolCall.toolCallId).filter((id) => id.length > 0);
+}
+function hasValidToolResultShape(messages) {
+  const pendingToolCallIds = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.role === "tool") {
+      if (!pendingToolCallIds.has(message.toolCallId)) {
+        return false;
+      }
+      pendingToolCallIds.delete(message.toolCallId);
+      continue;
+    }
+    if (pendingToolCallIds.size > 0) {
+      return false;
+    }
+    for (const toolCallId of getToolCallIds(message)) {
+      pendingToolCallIds.add(toolCallId);
+    }
+  }
+  return pendingToolCallIds.size === 0;
+}
+function isLocallySafeCutBoundary(messages, index) {
+  if (index <= 0 || index >= messages.length) return false;
+  const firstKept = messages[index];
+  if (!firstKept || firstKept.role === "tool") return false;
+  if (hasToolCalls(firstKept)) {
+    const next = messages[index + 1];
+    return next?.role === "tool";
+  }
+  return true;
+}
+function isSafeCutBoundary(messages, index) {
+  return isLocallySafeCutBoundary(messages, index) && hasValidToolResultShape(messages.slice(index));
+}
+function isPreferredCutBoundary(messages, index) {
+  const firstKept = messages[index];
+  if (!firstKept) return false;
+  if (firstKept.role === "system") return true;
+  return firstKept.role === "user" && !isAgentContextFragmentMessage(firstKept);
+}
+function findLatestUserMessageIndex(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "user" && !isAgentContextFragmentMessage(message)) {
+      return i;
+    }
+  }
+  return void 0;
+}
+function getAdjustedCutReason(options) {
+  if (options.cutIndex === options.targetCutIndex) {
+    return "protected-window";
+  }
+  if (options.latestUserIndex !== void 0 && options.targetCutIndex > options.latestUserIndex && options.cutIndex <= options.latestUserIndex) {
+    return "latest-user";
+  }
+  return options.targetBoundaryWasSafe ? "turn-boundary" : "tool-boundary";
+}
+function buildCutPlan(messages, cutIndex, protectedTokens, reason, tokenEstimator) {
+  if (cutIndex === 0) {
+    return {
+      kind: "conversation",
+      cutIndex: 0,
+      removedMessages: [],
+      keptMessages: [...messages],
+      tokensRemoved: 0,
+      tokensKept: estimateConversationTokens(messages, tokenEstimator),
+      protectedTokens,
+      reason,
+      historyMessages: [],
+      currentTurnPrefixMessages: []
+    };
+  }
+  const removedMessages = messages.slice(0, cutIndex);
+  const keptMessages = messages.slice(cutIndex);
+  return {
+    kind: "conversation",
+    cutIndex,
+    removedMessages,
+    keptMessages,
+    tokensRemoved: estimateConversationTokens(removedMessages, tokenEstimator),
+    tokensKept: estimateConversationTokens(keptMessages, tokenEstimator),
+    protectedTokens,
+    reason,
+    historyMessages: removedMessages,
+    currentTurnPrefixMessages: []
+  };
+}
+function buildSplitTurnPrefixPlan(messages, cutIndex, protectedTokens, currentTurnStartIndex, tokenEstimator) {
+  const removedMessages = messages.slice(0, cutIndex);
+  const keptMessages = messages.slice(cutIndex);
+  const historyMessages = messages.slice(0, currentTurnStartIndex);
+  const currentTurnPrefixMessages = messages.slice(
+    currentTurnStartIndex,
+    cutIndex
+  );
+  return {
+    kind: "split-turn-prefix",
+    cutIndex,
+    removedMessages,
+    keptMessages,
+    tokensRemoved: estimateConversationTokens(removedMessages, tokenEstimator),
+    tokensKept: estimateConversationTokens(keptMessages, tokenEstimator),
+    protectedTokens,
+    reason: "split-turn-prefix",
+    historyMessages,
+    currentTurnPrefixMessages,
+    currentTurnStartIndex
+  };
+}
+function getProtectedWindowStart(messages, protectedTokens, tokenEstimator) {
+  let tokensFromEnd = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    tokensFromEnd += estimateMessageTokens(messages[i], tokenEstimator);
+    if (tokensFromEnd >= protectedTokens) {
+      return i;
+    }
+  }
+  return messages.length;
+}
+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, tokenEstimator),
+    currentTurnStartIndex + 1
+  );
+  let bestPlan;
+  const consider = (index) => {
+    if (!isSafeCutBoundary(messages, index)) return false;
+    const plan = buildSplitTurnPrefixPlan(
+      messages,
+      index,
+      protectedTokens,
+      currentTurnStartIndex,
+      tokenEstimator
+    );
+    if (plan.tokensKept >= normalPlan.tokensKept) return false;
+    if (maxKeptTokens === void 0 || plan.tokensKept <= maxKeptTokens) {
+      bestPlan = plan;
+      return true;
+    }
+    if (!bestPlan || plan.tokensKept < bestPlan.tokensKept) {
+      bestPlan = plan;
+    }
+    return false;
+  };
+  for (let i = targetStart; i >= currentTurnStartIndex + 1; i--) {
+    if (consider(i)) return bestPlan;
+  }
+  for (let i = targetStart + 1; i < messages.length; i++) {
+    if (consider(i)) return bestPlan;
+  }
+  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",
+      tokenEstimator
+    );
+  }
+  const targetCutIndex = getProtectedWindowStart(
+    messages,
+    protectedTokens,
+    tokenEstimator
+  );
+  if (targetCutIndex <= 1) {
+    const noSafePlan2 = buildCutPlan(
+      messages,
+      0,
+      protectedTokens,
+      "no-safe-cut",
+      tokenEstimator
+    );
+    if (options.allowSplitTurn) {
+      return findSplitTurnPrefixPlan(
+        messages,
+        protectedTokens,
+        options.maxKeptTokens,
+        noSafePlan2,
+        tokenEstimator
+      ) ?? noSafePlan2;
+    }
+    return noSafePlan2;
+  }
+  const latestUserIndex = findLatestUserMessageIndex(messages);
+  const rawStartIndex = targetCutIndex >= messages.length ? messages.length - 1 : targetCutIndex;
+  const startIndex = latestUserIndex === void 0 ? rawStartIndex : Math.min(rawStartIndex, latestUserIndex);
+  const targetBoundaryWasSafe = targetCutIndex <= startIndex && isSafeCutBoundary(messages, targetCutIndex);
+  if (startIndex <= 0) {
+    const noSafePlan2 = buildCutPlan(
+      messages,
+      0,
+      protectedTokens,
+      "no-safe-cut",
+      tokenEstimator
+    );
+    if (options.allowSplitTurn) {
+      return findSplitTurnPrefixPlan(
+        messages,
+        protectedTokens,
+        options.maxKeptTokens,
+        noSafePlan2,
+        tokenEstimator
+      ) ?? noSafePlan2;
+    }
+    return noSafePlan2;
+  }
+  for (let i = startIndex; i >= 1; i--) {
+    if (isPreferredCutBoundary(messages, i) && isSafeCutBoundary(messages, i)) {
+      const plan = buildCutPlan(
+        messages,
+        i,
+        protectedTokens,
+        getAdjustedCutReason({
+          cutIndex: i,
+          targetCutIndex,
+          latestUserIndex,
+          targetBoundaryWasSafe
+        }),
+        tokenEstimator
+      );
+      if (options.allowSplitTurn && options.maxKeptTokens !== void 0 && plan.tokensKept > options.maxKeptTokens) {
+        return findSplitTurnPrefixPlan(
+          messages,
+          protectedTokens,
+          options.maxKeptTokens,
+          plan,
+          tokenEstimator
+        ) ?? plan;
+      }
+      return plan;
+    }
+  }
+  for (let i = startIndex; i >= 1; i--) {
+    if (isSafeCutBoundary(messages, i)) {
+      const plan = buildCutPlan(
+        messages,
+        i,
+        protectedTokens,
+        getAdjustedCutReason({
+          cutIndex: i,
+          targetCutIndex,
+          latestUserIndex,
+          targetBoundaryWasSafe
+        }),
+        tokenEstimator
+      );
+      if (options.allowSplitTurn && options.maxKeptTokens !== void 0 && plan.tokensKept > options.maxKeptTokens) {
+        return findSplitTurnPrefixPlan(
+          messages,
+          protectedTokens,
+          options.maxKeptTokens,
+          plan,
+          tokenEstimator
+        ) ?? plan;
+      }
+      return plan;
+    }
+  }
+  const noSafePlan = buildCutPlan(
+    messages,
+    0,
+    protectedTokens,
+    "no-safe-cut",
+    tokenEstimator
+  );
+  if (options.allowSplitTurn) {
+    return findSplitTurnPrefixPlan(
+      messages,
+      protectedTokens,
+      options.maxKeptTokens,
+      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, 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 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 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 createDecision({
+      needed: false,
+      reason: "under-limit",
+      strategy: "none",
+      forced,
+      trigger,
+      compactionReason,
+      canSummarize,
+      inputTokens,
+      limit,
+      overflowTokens,
+      protectedTokens: limits.protectedTokens,
+      pruneMinimum: limits.pruneMinimum
+    });
+  }
+  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
+var PRUNE_PROTECTED_TOOLS = ["skill"];
+
+// src/context/window/summary.ts
+import { generateText } from "ai";
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_MESSAGE_INPUT_TOKENS = 1500;
+var SUMMARY_HEADING = "## Previous Conversation Summary";
+var SUMMARY_PREFIX = `${SUMMARY_HEADING}
+
+`;
+var DEFAULT_SUMMARY_PROMPT = `You are summarizing a conversation to continue it with context.
+
+Create a structured summary that captures:
+1. **Goal**: What the user is trying to accomplish
+2. **Progress**: What has been done so far
+3. **Decisions**: Key decisions made during the conversation
+4. **Current State**: Where we left off
+5. **Next Steps**: What should happen next
+
+Be concise but comprehensive. Include specific file paths, function names, and technical details that would be lost otherwise.
+
+Format as a clear summary that could be given to another assistant to continue the work.`;
+var UPDATE_SUMMARY_PROMPT = `You are updating an existing conversation handoff summary.
+
+Preserve durable facts from the existing summary, incorporate the new conversation material, and remove only details that are clearly obsolete. Keep the result concise but specific enough for another assistant to continue the work without the removed messages.`;
+var SPLIT_TURN_SUMMARY_PROMPT = `You are creating a context checkpoint for a conversation where the active turn became too large to keep as one contiguous block.
+
+The later suffix of the active turn remains verbatim after this summary. Summarize only the removed material. The summary is reference context, not a new user instruction.
+
+Preserve:
+1. The user's original active-turn request, if it appears in the removed prefix
+2. Early progress, decisions, file paths, commands, and tool results needed to understand the kept suffix
+3. Relevant older conversation state that still matters
+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()}`;
+}
+function extractCompactionSummaryText(message) {
+  if (message.role !== "system") return void 0;
+  if (!message.content.startsWith(SUMMARY_PREFIX)) return void 0;
+  return message.content.slice(SUMMARY_PREFIX.length).trim();
+}
+function estimateCharsFromTokens(tokens, fallback) {
+  if (tokens === void 0 || !Number.isFinite(tokens) || tokens <= 0) {
+    return fallback * CHARS_PER_TOKEN;
+  }
+  return Math.max(1, Math.floor(tokens) * CHARS_PER_TOKEN);
+}
+function stringifyForSummary(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function redactSummaryText(text) {
+  return text.replace(/\bsk-[A-Za-z0-9_-]{12,}\b/g, "[REDACTED]").replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, "Bearer [REDACTED]").replace(
+    /((?:api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret|password|secret|token)\s*[:=]\s*["']?)[^"',\s}]{8,}/gi,
+    "$1[REDACTED]"
+  );
+}
+function compactText(text, maxChars) {
+  if (maxChars <= 0) return "";
+  const redacted = redactSummaryText(text);
+  return truncateTextMiddle(redacted, maxChars, {
+    headRatio: 0.7,
+    marker: (omitted) => `
+
+[...${omitted} characters omitted for compaction...]
+
+`
+  });
+}
+function renderToolCalls(message, maxChars) {
+  if (message.role !== "assistant" || !message.toolCalls?.length) return "";
+  const lines = message.toolCalls.map((toolCall) => {
+    const args = compactText(stringifyForSummary(toolCall.args), maxChars);
+    return `- ${toolCall.toolName} (${toolCall.toolCallId}): ${args}`;
+  });
+  return `[TOOL CALLS]
+${lines.join("\n")}`;
+}
+function serializeMessageForSummary(message, maxChars) {
+  const role = message.role.toUpperCase();
+  if (message.role === "tool") {
+    const content2 = compactText(message.content, maxChars);
+    return `[TOOL RESULT: ${message.toolName} ${message.toolCallId}]
+${content2}`;
+  }
+  const content = compactText(message.content, maxChars);
+  const toolCalls = renderToolCalls(
+    message,
+    Math.max(512, Math.floor(maxChars / 2))
+  );
+  const parts = [`[${role}]
+${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,
+    DEFAULT_SUMMARY_MAX_INPUT_TOKENS
+  );
+  const maxMessageChars = estimateCharsFromTokens(
+    options.maxMessageTokens,
+    DEFAULT_MESSAGE_INPUT_TOKENS
+  );
+  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.]`;
+  }
+  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, {
+    maxInputTokens: options.maxInputTokens
+  });
+  const previousSummary = options.previousSummary ? redactSummaryText(options.previousSummary) : void 0;
+  const systemPrompt = options.customPrompt ?? (previousSummary ? UPDATE_SUMMARY_PROMPT : DEFAULT_SUMMARY_PROMPT);
+  const prompt = previousSummary ? `Existing handoff summary:
+
+${previousSummary}
+
+New conversation material to incorporate:
+
+${conversationText}
+
+Return the updated handoff summary only.` : `Conversation material to summarize:
+
+${conversationText}
+
+Return the handoff summary only.`;
+  const { text } = await generateText({
+    model: options.model,
+    maxOutputTokens: options.maxTokens ?? 2e3,
+    system: systemPrompt,
+    prompt
+  });
+  return redactSummaryText(text);
+}
+async function generateSplitTurnSummary(options) {
+  const historyText = serializeMessagesForSummary(options.historyMessages, {
+    maxInputTokens: options.maxInputTokens
+  });
+  const currentTurnPrefixText = serializeMessagesForSummary(
+    options.currentTurnPrefixMessages,
+    {
+      maxInputTokens: options.maxInputTokens
+    }
+  );
+  const previousSummary = options.previousSummary ? redactSummaryText(options.previousSummary) : void 0;
+  const systemPrompt = options.customPrompt ?? SPLIT_TURN_SUMMARY_PROMPT;
+  const promptParts = [
+    previousSummary ? `Existing handoff summary:
+
+${previousSummary}` : void 0,
+    options.historyMessages.length > 0 ? `Removed earlier conversation material:
+
+${historyText}` : void 0,
+    `Removed early active-turn material:
+
+${currentTurnPrefixText}`,
+    `Return a compact handoff summary with sections for prior conversation context and "Earlier In This Turn".`
+  ].filter((part) => part !== void 0);
+  const { text } = await generateText({
+    model: options.model,
+    maxOutputTokens: options.maxTokens ?? 2e3,
+    system: systemPrompt,
+    prompt: promptParts.join("\n\n---\n\n")
+  });
+  return redactSummaryText(text);
+}
+
+// src/context/window/tool-pruning.ts
+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 "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function compactPreview(value, maxChars) {
+  const text = redactSummaryText(
+    stringifyToolValue(value).replace(/\s+/g, " ").trim()
+  );
+  return truncateTextPrefix(text, maxChars, {
+    boundary: "word",
+    marker: "...",
+    separator: ""
+  });
+}
+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, policy) {
+  if (typeof value === "string")
+    return compactLongArgumentString(value, policy);
+  if (value === null || typeof value !== "object") return value;
+  if (depth >= policy.argumentMaxDepth) {
+    return {
+      __contextWindowCompaction: {
+        reason: "max-depth",
+        preview: compactPreview(value, policy.argumentPreviewChars)
+      }
+    };
+  }
+  if (seen.has(value)) {
+    return {
+      __contextWindowCompaction: {
+        reason: "circular-reference"
+      }
+    };
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    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, policy)
+    );
+    if (shouldSlice) {
+      compacted2.push({
+        __contextWindowCompaction: {
+          reason: "array-length",
+          omittedItems: value.length - policy.argumentArrayHeadItems - policy.argumentArrayTailItems
+        }
+      });
+      compacted2.push(
+        ...tail.map(
+          (item) => compactToolArgumentValue(item, depth + 1, seen, policy)
+        )
+      );
+    }
+    seen.delete(value);
+    return compacted2;
+  }
+  const entries = Object.entries(value);
+  const compacted = {};
+  const keptEntries = entries.slice(0, policy.argumentObjectMaxKeys);
+  for (const [key, entryValue] of keptEntries) {
+    compacted[key] = compactToolArgumentValue(
+      entryValue,
+      depth + 1,
+      seen,
+      policy
+    );
+  }
+  if (entries.length > keptEntries.length) {
+    compacted.__contextWindowCompaction = {
+      reason: "object-size",
+      omittedKeys: entries.length - keptEntries.length
+    };
+  }
+  seen.delete(value);
+  return compacted;
+}
+function compactToolCallArgs(args, policy, tokenEstimator) {
+  const beforeText = stringifyToolValue(args);
+  if (estimateTokens(beforeText, tokenEstimator) < policy.argumentThresholdTokens) {
+    return { args, compacted: false };
+  }
+  const compactedArgs = compactToolArgumentValue(
+    args,
+    0,
+    /* @__PURE__ */ new WeakSet(),
+    policy
+  );
+  const afterText = stringifyToolValue(compactedArgs);
+  if (afterText.length < beforeText.length) {
+    return { args: compactedArgs, compacted: true };
+  }
+  return {
+    args: {
+      __contextWindowCompaction: {
+        reason: "argument-size",
+        originalEstimatedTokens: estimateTokens(beforeText, tokenEstimator),
+        preview: compactPreview(args, policy.argumentMaxStringChars)
+      }
+    },
+    compacted: true
+  };
+}
+function collectToolCallArgs(messages) {
+  const argsByCallId = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role !== "assistant" || !message.toolCalls) continue;
+    for (const toolCall of message.toolCalls) {
+      argsByCallId.set(toolCall.toolCallId, toolCall.args);
+    }
+  }
+  return argsByCallId;
+}
+function summarizeToolOutput(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, policy.argumentPreviewChars);
+  const rawFirstLine = lines[0] ?? "";
+  const firstLine = rawFirstLine.length > 0 && rawFirstLine.length <= 160 ? compactPreview(rawFirstLine, 160) : "";
+  const details = [
+    `tool=${tool.toolName}`,
+    `call=${tool.toolCallId}`,
+    `estimatedTokens=${currentTokens}`,
+    `lines=${lineCount}`
+  ];
+  if (argsPreview) {
+    details.push(`args=${argsPreview}`);
+  }
+  if (firstLine) {
+    details.push(`preview=${firstLine}`);
+  }
+  return `[Tool output compacted] ${details.join("; ")}`;
+}
+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, policy, tokenEstimator);
+    if (!result.compacted) return toolCall;
+    compactedCount++;
+    return {
+      ...toolCall,
+      args: result.args
+    };
+  });
+  if (compactedCount === 0) return { message, compactedCount };
+  return {
+    message: {
+      ...message,
+      toolCalls
+    },
+    compactedCount
+  };
+}
+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 ?? []
+  ]);
+  const argsByCallId = collectToolCallArgs(messages);
+  const newestFullOutputByContent = /* @__PURE__ */ new Map();
+  const tokensBefore = messages.reduce(
+    (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], tokenEstimator);
+    tokenPositions[i] = tokensFromEnd;
+  }
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role !== "tool") continue;
+    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, tokenEstimator) < policy.outputThresholdTokens;
+    if (!isRetained) continue;
+    if (!newestFullOutputByContent.has(message.content)) {
+      newestFullOutputByContent.set(message.content, message.toolCallId);
+    }
+  }
+  let outputCompactedCount = 0;
+  let argumentCompactedCount = 0;
+  const nextMessages = messages.map((msg, i) => {
+    if (tokenPositions[i] < protectedTokens) return msg;
+    if (!("role" in msg)) return msg;
+    if (msg.role === "assistant") {
+      const result = maybeCompactAssistantToolCalls(
+        msg,
+        protectedToolSet,
+        policy,
+        tokenEstimator
+      );
+      argumentCompactedCount += result.compactedCount;
+      return result.message;
+    }
+    if (msg.role !== "tool") return msg;
+    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, 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++;
+    return {
+      ...toolMsg,
+      content: compactedContent,
+      result: compactedContent,
+      compactedAt: Date.now()
+    };
+  });
+  const tokensAfter = nextMessages.reduce(
+    (total, message) => total + estimateMessageTokens(message, tokenEstimator),
+    0
+  );
+  return {
+    messages: nextMessages,
+    report: {
+      outputCompactedCount,
+      argumentCompactedCount,
+      tokensBefore,
+      tokensAfter,
+      tokensRemoved: Math.max(0, tokensBefore - tokensAfter)
+    }
+  };
+}
+function pruneToolContext(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.protectedTokens, options) {
+  return pruneToolContextWithReport(messages, protectedTokens, options).messages;
+}
+
+// src/context/window/summary-policy.ts
+var ContextSummaryModelRequiredError = class extends Error {
+  constructor() {
+    super(
+      "Context compaction removed conversation history, but no summary model is configured."
+    );
+    this.name = "ContextSummaryModelRequiredError";
+  }
+};
+function resolveContextSummaryPolicy(policy, activeModel) {
+  const mode = policy?.mode ?? "required";
+  const model = mode === "disabled" ? void 0 : policy?.model ?? activeModel;
+  return {
+    mode,
+    model,
+    prompt: policy?.prompt,
+    maxInputTokens: policy?.maxInputTokens,
+    maxOutputTokens: policy?.maxOutputTokens,
+    targetRatio: policy?.targetRatio
+  };
+}
+function canGenerateCompactionSummary(policy) {
+  return policy.mode !== "disabled" && policy.model !== void 0;
+}
+function shouldFallbackOnSummaryFailure(options) {
+  return options.force === true || options.policy.mode === "best-effort";
+}
+
+// src/context/window/compactor.ts
+function prepareSummarySource(messages) {
+  let previousSummary;
+  const messagesToSummarize = [];
+  for (const message of messages) {
+    const summary = extractCompactionSummaryText(message);
+    if (summary !== void 0) {
+      previousSummary = summary;
+      continue;
+    }
+    messagesToSummarize.push(message);
+  }
+  return { previousSummary, messagesToSummarize };
+}
+async function pruneContext(messages, options = {}) {
+  const limits = options.limits ?? DEFAULT_CONTEXT_LIMITS;
+  let currentMessages = [...messages];
+  let tokensRemoved = 0;
+  let removedCount = 0;
+  let summarized = false;
+  let summary;
+  let summaryOutputTokens;
+  const summaryPolicy = resolveContextSummaryPolicy(options.summary);
+  const tokenEstimator = options.tokenEstimator;
+  const initialTokens = estimateConversationTokens(
+    currentMessages,
+    tokenEstimator
+  );
+  const decision = decideContextCompaction(currentMessages, {
+    limits,
+    force: options.force,
+    canSummarize: canGenerateCompactionSummary(summaryPolicy),
+    inputTokens: initialTokens,
+    trigger: options.trigger,
+    reason: options.reason,
+    tokenEstimator
+  });
+  if (!decision.needed) {
+    return {
+      messages: currentMessages,
+      decision,
+      effectiveness: createCompactionEffectiveness(
+        initialTokens,
+        initialTokens
+      ),
+      removedCount: 0,
+      tokensRemoved: 0,
+      summarized: false,
+      summaryPolicy,
+      cutIndex: 0,
+      cutReason: "no-safe-cut"
+    };
+  }
+  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,
+      decision,
+      effectiveness: createCompactionEffectiveness(
+        initialTokens,
+        afterPruneTokens
+      ),
+      removedCount: 0,
+      tokensRemoved,
+      summarized: false,
+      summaryPolicy,
+      cutIndex: 0,
+      cutReason: "no-safe-cut",
+      toolContext
+    };
+  }
+  const cutPlan = planCompactionCut(currentMessages, limits.protectedTokens, {
+    allowSplitTurn: summaryPolicy.mode !== "disabled",
+    maxKeptTokens: getUsableTokenLimit(limits),
+    tokenEstimator
+  });
+  if (cutPlan.cutIndex === 0) {
+    return {
+      messages: currentMessages,
+      decision,
+      effectiveness: createCompactionEffectiveness(
+        initialTokens,
+        afterPruneTokens
+      ),
+      removedCount: 0,
+      tokensRemoved,
+      summarized: false,
+      summaryPolicy,
+      cutIndex: 0,
+      cutReason: cutPlan.reason,
+      toolContext
+    };
+  }
+  const removedMessages = cutPlan.removedMessages;
+  const toKeep = cutPlan.keptMessages;
+  const { previousSummary, messagesToSummarize } = prepareSummarySource(
+    cutPlan.historyMessages
+  );
+  const currentTurnPrefixMessages = cutPlan.currentTurnPrefixMessages;
+  removedCount = removedMessages.length;
+  tokensRemoved += cutPlan.tokensRemoved;
+  if (summaryPolicy.mode === "disabled") {
+    currentMessages = toKeep;
+  } else {
+    if (!summaryPolicy.model) {
+      throw new ContextSummaryModelRequiredError();
+    }
+    const summaryInputMessages = [
+      ...messagesToSummarize,
+      ...currentTurnPrefixMessages
+    ];
+    const summaryInputTokens = summaryInputMessages.length > 0 ? estimateConversationTokens(summaryInputMessages, tokenEstimator) : cutPlan.tokensRemoved;
+    summaryOutputTokens = resolveSummaryOutputTokens({
+      inputTokens: summaryInputTokens,
+      limits,
+      summaryMaxOutputTokens: summaryPolicy.maxOutputTokens,
+      summaryTargetRatio: summaryPolicy.targetRatio
+    });
+    if (cutPlan.kind === "split-turn-prefix") {
+      summary = await generateSplitTurnSummary({
+        model: summaryPolicy.model,
+        historyMessages: messagesToSummarize,
+        currentTurnPrefixMessages,
+        maxInputTokens: summaryPolicy.maxInputTokens,
+        maxTokens: summaryOutputTokens,
+        customPrompt: summaryPolicy.prompt,
+        previousSummary
+      });
+      summarized = true;
+    } else if (messagesToSummarize.length > 0 || previousSummary !== void 0) {
+      summary = await generateSummary(messagesToSummarize, {
+        model: summaryPolicy.model,
+        maxInputTokens: summaryPolicy.maxInputTokens,
+        maxTokens: summaryOutputTokens,
+        customPrompt: summaryPolicy.prompt,
+        previousSummary
+      });
+      summarized = true;
+    }
+    const summaryMessage = {
+      id: crypto.randomUUID(),
+      role: "system",
+      content: createCompactionSummaryContent(
+        summary ?? previousSummary ?? "Earlier conversation context was compacted."
+      ),
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    currentMessages = [summaryMessage, ...toKeep];
+  }
+  return {
+    messages: currentMessages,
+    decision,
+    effectiveness: createCompactionEffectiveness(
+      initialTokens,
+      estimateConversationTokens(currentMessages, tokenEstimator)
+    ),
+    removedCount,
+    tokensRemoved,
+    summarized,
+    summary,
+    summaryPolicy,
+    removedMessages,
+    keptMessages: toKeep,
+    summaryOutputTokens,
+    ...previousSummary !== void 0 ? { previousSummary } : {},
+    cutIndex: cutPlan.cutIndex,
+    cutReason: cutPlan.reason,
+    toolContext
+  };
+}
+
+// src/context/window/manager.ts
+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() {
+    return { ...this.limits };
+  }
+  /** Update context limits (e.g. when switching models). */
+  setLimits(limits) {
+    this.limits = { ...this.limits, ...limits };
+  }
+  /** Set the active agent model used for summaries unless overridden. */
+  setModel(model) {
+    this.activeModel = model;
+  }
+  /** Set the summary policy used when conversation history must be cut. */
+  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, this.tokenEstimator);
+  }
+  /** Check whether the context is overflowing. */
+  isOverflowing(messages) {
+    const tokens = this.estimateTokens(messages);
+    return isContextOverflowing(tokens, this.limits);
+  }
+  /** Check whether pruning should be triggered. */
+  shouldPrune(messages) {
+    const tokens = this.estimateTokens(messages);
+    return shouldPruneContext(tokens, this.limits);
+  }
+  /** Explain whether context compaction should run. */
+  decide(messages, options) {
+    const summaryPolicy = this.getSummaryPolicy();
+    return decideContextCompaction(messages, {
+      limits: this.limits,
+      force: options?.force,
+      inputTokens: options?.inputTokens,
+      trigger: options?.trigger,
+      reason: options?.reason,
+      canSummarize: canGenerateCompactionSummary(summaryPolicy),
+      tokenEstimator: this.tokenEstimator
+    });
+  }
+  /** Prune context to fit within limits. */
+  async prune(messages, options) {
+    return pruneContext(messages, {
+      limits: this.limits,
+      summary: this.getSummaryPolicy(),
+      force: options?.force,
+      trigger: options?.trigger,
+      reason: options?.reason,
+      toolPruning: options?.toolPruning ?? this.toolPruning,
+      tokenEstimator: this.tokenEstimator
+    });
+  }
+  /**
+   * Get a snapshot of token statistics.
+   *
+   * Useful for dashboards, logging, or deciding whether to prune.
+   */
+  getStats(messages) {
+    const tokens = this.estimateTokens(messages);
+    const effectiveContextWindow = getEffectiveContextWindow(this.limits);
+    const usableLimit = getUsableTokenLimit(this.limits);
+    const autoCompactLimit = getAutoCompactTokenLimit(this.limits);
+    const limit = autoCompactLimit;
+    return {
+      tokens,
+      limit,
+      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)
+    };
+  }
+};
+
+export {
+  DEFAULT_CONTEXT_LIMITS,
+  DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS,
+  DEFAULT_SUMMARY_MAX_INPUT_TOKENS,
+  DEFAULT_COMPACTION_EFFECTIVE_MIN_SAVINGS_RATIO,
+  getUsableTokenLimit,
+  getEffectiveContextWindow,
+  getAutoCompactTokenLimit,
+  isContextOverflowing,
+  shouldPruneContext,
+  createCompactionEffectiveness,
+  resolveSummaryOutputTokens,
+  planCompactionCut,
+  decideContextCompaction,
+  PRUNE_PROTECTED_TOOLS,
+  createCompactionSummaryContent,
+  extractCompactionSummaryText,
+  redactSummaryText,
+  serializeMessagesForSummary,
+  generateSummary,
+  generateSplitTurnSummary,
+  DEFAULT_TOOL_CONTEXT_PRUNE_POLICY,
+  pruneToolContextWithReport,
+  pruneToolContext,
+  ContextSummaryModelRequiredError,
+  resolveContextSummaryPolicy,
+  canGenerateCompactionSummary,
+  shouldFallbackOnSummaryFailure,
+  pruneContext,
+  ContextWindowManager
+};