@cuylabs/agent-core 4.8.1 → 4.10.0

package/dist/chunk-NMJNN6LS.js

@@ -0,0 +1,1155 @@
+import {
+  estimateConversationTokens,
+  estimateMessageTokens,
+  estimateTokens,
+  isAgentContextFragmentMessage,
+  truncateTextMiddle,
+  truncateTextPrefix
+} from "./chunk-AAGKWUXR.js";
+
+// src/context/window/budget.ts
+var DEFAULT_CONTEXT_LIMITS = {
+  contextWindow: 128e3,
+  reserveTokens: 16e3,
+  protectedTokens: 4e4,
+  pruneMinimum: 2e4
+};
+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;
+}
+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);
+}
+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 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;
+  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) {
+  if (cutIndex === 0) {
+    return {
+      kind: "conversation",
+      cutIndex: 0,
+      removedMessages: [],
+      keptMessages: [...messages],
+      tokensRemoved: 0,
+      tokensKept: estimateConversationTokens(messages),
+      protectedTokens,
+      reason,
+      historyMessages: [],
+      currentTurnPrefixMessages: []
+    };
+  }
+  const removedMessages = messages.slice(0, cutIndex);
+  const keptMessages = messages.slice(cutIndex);
+  return {
+    kind: "conversation",
+    cutIndex,
+    removedMessages,
+    keptMessages,
+    tokensRemoved: estimateConversationTokens(removedMessages),
+    tokensKept: estimateConversationTokens(keptMessages),
+    protectedTokens,
+    reason,
+    historyMessages: removedMessages,
+    currentTurnPrefixMessages: []
+  };
+}
+function buildSplitTurnPrefixPlan(messages, cutIndex, protectedTokens, currentTurnStartIndex) {
+  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),
+    tokensKept: estimateConversationTokens(keptMessages),
+    protectedTokens,
+    reason: "split-turn-prefix",
+    historyMessages,
+    currentTurnPrefixMessages,
+    currentTurnStartIndex
+  };
+}
+function getProtectedWindowStart(messages, protectedTokens) {
+  let tokensFromEnd = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    tokensFromEnd += estimateMessageTokens(messages[i]);
+    if (tokensFromEnd >= protectedTokens) {
+      return i;
+    }
+  }
+  return messages.length;
+}
+function findSplitTurnPrefixPlan(messages, protectedTokens, maxKeptTokens, normalPlan) {
+  const currentTurnStartIndex = findLatestUserMessageIndex(messages);
+  if (currentTurnStartIndex === void 0 || currentTurnStartIndex >= messages.length - 1) {
+    return void 0;
+  }
+  const targetStart = Math.max(
+    getProtectedWindowStart(messages, protectedTokens),
+    currentTurnStartIndex + 1
+  );
+  let bestPlan;
+  const consider = (index) => {
+    if (!isSafeCutBoundary(messages, index)) return false;
+    const plan = buildSplitTurnPrefixPlan(
+      messages,
+      index,
+      protectedTokens,
+      currentTurnStartIndex
+    );
+    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 = {}) {
+  if (messages.length === 0) {
+    return buildCutPlan(messages, 0, protectedTokens, "no-safe-cut");
+  }
+  const targetCutIndex = getProtectedWindowStart(messages, protectedTokens);
+  if (targetCutIndex <= 1) {
+    const noSafePlan2 = buildCutPlan(
+      messages,
+      0,
+      protectedTokens,
+      "no-safe-cut"
+    );
+    if (options.allowSplitTurn) {
+      return findSplitTurnPrefixPlan(
+        messages,
+        protectedTokens,
+        options.maxKeptTokens,
+        noSafePlan2
+      ) ?? 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"
+    );
+    if (options.allowSplitTurn) {
+      return findSplitTurnPrefixPlan(
+        messages,
+        protectedTokens,
+        options.maxKeptTokens,
+        noSafePlan2
+      ) ?? 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
+        })
+      );
+      if (options.allowSplitTurn && options.maxKeptTokens !== void 0 && plan.tokensKept > options.maxKeptTokens) {
+        return findSplitTurnPrefixPlan(
+          messages,
+          protectedTokens,
+          options.maxKeptTokens,
+          plan
+        ) ?? 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
+        })
+      );
+      if (options.allowSplitTurn && options.maxKeptTokens !== void 0 && plan.tokensKept > options.maxKeptTokens) {
+        return findSplitTurnPrefixPlan(
+          messages,
+          protectedTokens,
+          options.maxKeptTokens,
+          plan
+        ) ?? plan;
+      }
+      return plan;
+    }
+  }
+  const noSafePlan = buildCutPlan(messages, 0, protectedTokens, "no-safe-cut");
+  if (options.allowSplitTurn) {
+    return findSplitTurnPrefixPlan(
+      messages,
+      protectedTokens,
+      options.maxKeptTokens,
+      noSafePlan
+    ) ?? noSafePlan;
+  }
+  return noSafePlan;
+}
+
+// src/context/window/decision.ts
+function decideContextCompaction(messages, options = {}) {
+  const limits = options.limits ?? DEFAULT_CONTEXT_LIMITS;
+  const inputTokens = options.inputTokens ?? estimateConversationTokens(messages);
+  const limit = getUsableTokenLimit(limits);
+  const overflowTokens = Math.max(0, inputTokens - limit);
+  const forced = options.force === true;
+  const canSummarize = options.canSummarize === true;
+  if (forced) {
+    return {
+      needed: true,
+      reason: "forced-recovery",
+      strategy: "tool-context-first",
+      forced,
+      canSummarize,
+      inputTokens,
+      limit,
+      overflowTokens,
+      protectedTokens: limits.protectedTokens,
+      pruneMinimum: limits.pruneMinimum
+    };
+  }
+  if (inputTokens < limits.pruneMinimum) {
+    return {
+      needed: false,
+      reason: "below-prune-minimum",
+      strategy: "none",
+      forced,
+      canSummarize,
+      inputTokens,
+      limit,
+      overflowTokens,
+      protectedTokens: limits.protectedTokens,
+      pruneMinimum: limits.pruneMinimum
+    };
+  }
+  if (!shouldPruneContext(inputTokens, limits)) {
+    return {
+      needed: false,
+      reason: "under-limit",
+      strategy: "none",
+      forced,
+      canSummarize,
+      inputTokens,
+      limit,
+      overflowTokens,
+      protectedTokens: limits.protectedTokens,
+      pruneMinimum: limits.pruneMinimum
+    };
+  }
+  return {
+    needed: true,
+    reason: "overflow",
+    strategy: "tool-context-first",
+    forced,
+    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.`;
+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) {
+  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 serializeMessagesForSummary(messages, options = {}) {
+  const maxChars = estimateCharsFromTokens(
+    options.maxInputTokens,
+    DEFAULT_SUMMARY_MAX_INPUT_TOKENS
+  );
+  const maxMessageChars = estimateCharsFromTokens(
+    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("");
+  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.]";
+}
+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 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;
+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) {
+  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,
+    marker: (omitted) => `
+[${omitted} characters omitted by context compaction]
+`
+  });
+}
+function compactToolArgumentValue(value, depth, seen) {
+  if (typeof value === "string") return compactLongArgumentString(value);
+  if (value === null || typeof value !== "object") return value;
+  if (depth >= TOOL_ARGUMENT_MAX_DEPTH) {
+    return {
+      __contextWindowCompaction: {
+        reason: "max-depth",
+        preview: compactPreview(value, TOOL_ARGUMENT_PREVIEW_CHARS)
+      }
+    };
+  }
+  if (seen.has(value)) {
+    return {
+      __contextWindowCompaction: {
+        reason: "circular-reference"
+      }
+    };
+  }
+  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 compacted2 = head.map(
+      (item) => compactToolArgumentValue(item, depth + 1, seen)
+    );
+    if (shouldSlice) {
+      compacted2.push({
+        __contextWindowCompaction: {
+          reason: "array-length",
+          omittedItems: value.length - TOOL_ARGUMENT_ARRAY_HEAD_ITEMS - TOOL_ARGUMENT_ARRAY_TAIL_ITEMS
+        }
+      });
+      compacted2.push(
+        ...tail.map((item) => compactToolArgumentValue(item, depth + 1, seen))
+      );
+    }
+    seen.delete(value);
+    return compacted2;
+  }
+  const entries = Object.entries(value);
+  const compacted = {};
+  const keptEntries = entries.slice(0, TOOL_ARGUMENT_OBJECT_MAX_KEYS);
+  for (const [key, entryValue] of keptEntries) {
+    compacted[key] = compactToolArgumentValue(entryValue, depth + 1, seen);
+  }
+  if (entries.length > keptEntries.length) {
+    compacted.__contextWindowCompaction = {
+      reason: "object-size",
+      omittedKeys: entries.length - keptEntries.length
+    };
+  }
+  seen.delete(value);
+  return compacted;
+}
+function compactToolCallArgs(args) {
+  const beforeText = stringifyToolValue(args);
+  if (estimateTokens(beforeText) < TOOL_ARGUMENT_PRUNE_THRESHOLD) {
+    return { args, compacted: false };
+  }
+  const compactedArgs = compactToolArgumentValue(args, 0, /* @__PURE__ */ new WeakSet());
+  const afterText = stringifyToolValue(compactedArgs);
+  if (afterText.length < beforeText.length) {
+    return { args: compactedArgs, compacted: true };
+  }
+  return {
+    args: {
+      __contextWindowCompaction: {
+        reason: "argument-size",
+        originalEstimatedTokens: estimateTokens(beforeText),
+        preview: compactPreview(args, TOOL_ARGUMENT_MAX_STRING_CHARS)
+      }
+    },
+    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, 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 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) {
+  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);
+    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 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),
+    0
+  );
+  let tokensFromEnd = 0;
+  const tokenPositions = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    tokensFromEnd += estimateMessageTokens(messages[i]);
+    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) < TOOL_OUTPUT_PRUNE_THRESHOLD;
+    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);
+      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);
+    if (currentTokens < TOOL_OUTPUT_PRUNE_THRESHOLD) return msg;
+    const duplicateOf = newestFullOutputByContent.get(toolMsg.content);
+    const compactedContent = summarizeToolOutput({
+      tool: toolMsg,
+      args: argsByCallId.get(toolMsg.toolCallId),
+      currentTokens,
+      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),
+    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 initialTokens = estimateConversationTokens(currentMessages);
+  const decision = decideContextCompaction(currentMessages, {
+    limits,
+    force: options.force,
+    canSummarize: canGenerateCompactionSummary(summaryPolicy),
+    inputTokens: initialTokens
+  });
+  if (!decision.needed) {
+    return {
+      messages: currentMessages,
+      decision,
+      effectiveness: createCompactionEffectiveness(
+        initialTokens,
+        initialTokens
+      ),
+      removedCount: 0,
+      tokensRemoved: 0,
+      summarized: false,
+      summaryPolicy,
+      cutIndex: 0,
+      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;
+  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)
+  });
+  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) : 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)
+    ),
+    removedCount,
+    tokensRemoved,
+    summarized,
+    summary,
+    summaryPolicy,
+    removedMessages,
+    keptMessages: toKeep,
+    summaryOutputTokens,
+    cutIndex: cutPlan.cutIndex,
+    cutReason: cutPlan.reason,
+    toolContext
+  };
+}
+
+// src/context/window/manager.ts
+var ContextWindowManager = class {
+  limits;
+  activeModel;
+  summaryPolicy;
+  constructor(options) {
+    this.limits = { ...DEFAULT_CONTEXT_LIMITS, ...options?.limits };
+    this.activeModel = options?.model;
+    this.summaryPolicy = options?.summary;
+  }
+  /** 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;
+  }
+  /** 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);
+  }
+  /** 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,
+      canSummarize: canGenerateCompactionSummary(summaryPolicy)
+    });
+  }
+  /** Prune context to fit within limits. */
+  async prune(messages, options) {
+    return pruneContext(messages, {
+      limits: this.limits,
+      summary: this.getSummaryPolicy(),
+      force: options?.force
+    });
+  }
+  /**
+   * Get a snapshot of token statistics.
+   *
+   * Useful for dashboards, logging, or deciding whether to prune.
+   */
+  getStats(messages) {
+    const tokens = this.estimateTokens(messages);
+    const limit = getUsableTokenLimit(this.limits);
+    return {
+      tokens,
+      limit,
+      available: Math.max(0, limit - 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,
+  isContextOverflowing,
+  shouldPruneContext,
+  createCompactionEffectiveness,
+  resolveSummaryOutputTokens,
+  planCompactionCut,
+  decideContextCompaction,
+  PRUNE_PROTECTED_TOOLS,
+  createCompactionSummaryContent,
+  extractCompactionSummaryText,
+  redactSummaryText,
+  serializeMessagesForSummary,
+  generateSummary,
+  generateSplitTurnSummary,
+  pruneToolContextWithReport,
+  pruneToolContext,
+  ContextSummaryModelRequiredError,
+  resolveContextSummaryPolicy,
+  canGenerateCompactionSummary,
+  shouldFallbackOnSummaryFailure,
+  pruneContext,
+  ContextWindowManager
+};