agentfootprint 7.16.0 → 7.17.0

package/dist/esm/core/agent/window/turns.d.ts

@@ -0,0 +1,108 @@
+/**
+ * window/turns — where a turn boundary is, and which turns may leave.
+ *
+ * Pattern: Pure functions over the window (no scope, no I/O, no clock).
+ * Role:    core/ layer. THE refusal engine. Every window strategy — the three
+ *          that ship, and any a consumer writes — decides what leaves the
+ *          window by calling these functions and nothing else, because the
+ *          whole safety argument of the family lives here:
+ *
+ *            a removal that splits an assistant's `tool_use` from its
+ *            `tool_result` produces a request the vendor rejects, and a
+ *            removal that swallows an unanswered question destroys the
+ *            referent of the answer that has not arrived yet.
+ *
+ *          Strategies never import this module. `WindowStrategyInput` hands
+ *          them `planRemoval` already bound to this iteration's turns and
+ *          guards, so a strategy CANNOT skip the refusal rules — that is a
+ *          property of the seam, not of the documentation.
+ * Emits:   N/A.
+ *
+ * Testable on its own — see `test/core/window-turns.test.ts`.
+ */
+import type { LLMMessage } from '../../../adapters/types.js';
+import type { WindowRefusal, WindowRefusalReason } from './types.js';
+/**
+ * One turn: a `user` / `assistant` / `system` message plus every `tool`
+ * message that answers it. Tool results belong to the assistant turn that
+ * requested them — that pairing is the thing a removal must never break.
+ */
+export interface Turn {
+    /** Index of this turn in the segmentation. */
+    readonly index: number;
+    /** Index of the turn's FIRST message in the window. */
+    readonly start: number;
+    /** Number of messages in the turn. */
+    readonly length: number;
+    readonly messages: readonly LLMMessage[];
+}
+/**
+ * Segment a window into turns.
+ *
+ * A new turn starts at any non-`tool` message; `tool` messages join the turn
+ * in progress. A leading `tool` message (only reachable from a hand-built
+ * history) starts its own turn rather than being silently dropped.
+ */
+export declare function segmentTurns(history: readonly LLMMessage[]): readonly Turn[];
+/**
+ * Context a removal decision needs beyond the turn itself.
+ *
+ * Internal: the stage builds it from scope and binds it into the
+ * `planRemoval` a strategy is handed, so no strategy has to know it exists.
+ */
+export interface RemovalGuards {
+    /** Every `toolCallId` answered anywhere in the window. */
+    readonly answeredCallIds: ReadonlySet<string>;
+    /** The tool call this run is paused on, when it is paused. */
+    readonly pausedToolCallId?: string;
+    /** True when the pause is a check-in (human consent) rather than askHuman. */
+    readonly pausedCheckIn?: boolean;
+}
+/** Every tool_call id that has a matching `role: 'tool'` message. */
+export declare function answeredCallIds(history: readonly LLMMessage[]): ReadonlySet<string>;
+/**
+ * Why this turn may NOT leave the window, or `undefined` when it may.
+ *
+ * Order matters only for which reason gets reported first; every check is
+ * independent. `paused-tool` / `pending-check-in` are separated from
+ * `unresolved-tool-call` on purpose: they are the same shape but a different
+ * fact about the world, and "we are waiting on a human" is what the person
+ * reading the trace needs to see.
+ */
+export declare function refusalFor(turn: Turn, guards: RemovalGuards): WindowRefusalReason | undefined;
+/** The span a removal will take, plus every refusal it had to name to get there. */
+export interface RemovalPlan {
+    /** First turn index in the span; -1 when nothing may be removed. */
+    readonly from: number;
+    /** Last turn index in the span (inclusive); -1 when nothing may be removed. */
+    readonly to: number;
+    readonly refusals: readonly WindowRefusal[];
+}
+/**
+ * Choose the removal span: the LONGEST CONTIGUOUS run of removable candidate
+ * turns, starting at the oldest removable one.
+ *
+ * Contiguity is not fussiness — it is what keeps the conversation in order.
+ * A fold replaces its span with ONE summary message; if the span skipped over
+ * an unremovable turn, that turn would end up after a summary of things that
+ * happened before it. So an unremovable turn at the front is stepped over (the
+ * span "takes the next oldest instead") and an unremovable turn in the middle
+ * ends the span. Everything not removed keeps its position.
+ *
+ * The drop strategies take the same span for a second reason: it is what makes
+ * a refusal reason mean the same thing under every strategy. A turn that ends
+ * the span this iteration is retried the next one — by which time the tool
+ * result it was waiting on has usually arrived.
+ *
+ * @param turns             the window's turn segmentation
+ * @param keepRecent        how many trailing turns are off-limits
+ * @param guards            what must not leave (unanswered calls, the pause)
+ * @param isExistingSummary optional: true for a turn that is a summary a prior
+ *   fold wrote. When the whole span is one such turn, the plan refuses with
+ *   `only-existing-summary` — re-summarizing a summary spends an LLM call to
+ *   lose detail. The drop strategies omit it: a drop spends nothing, so there
+ *   is nothing to protect against.
+ */
+export declare function planRemoval(turns: readonly Turn[], keepRecent: number, guards: RemovalGuards, isExistingSummary?: (turn: Turn) => boolean): RemovalPlan;
+/** Total characters of message content in a window. Exact; not tokens. */
+export declare function windowChars(history: readonly LLMMessage[]): number;

package/dist/esm/core/agent/{compaction → window}/turns.js

@@ -1,15 +1,24 @@
 /**
- * compaction/turns — where a turn boundary is, and which turns may fold.
+ * window/turns — where a turn boundary is, and which turns may leave.
  *
  * Pattern: Pure functions over the window (no scope, no I/O, no clock).
- * Role:    core/ layer. The whole safety argument of compaction lives here:
- *          a fold that splits an assistant's `tool_use` from its
- *          `tool_result` produces a request the vendor rejects, and a fold
- *          that swallows an unanswered question destroys the referent of the
- *          answer that has not arrived yet.
+ * Role:    core/ layer. THE refusal engine. Every window strategy — the three
+ *          that ship, and any a consumer writes — decides what leaves the
+ *          window by calling these functions and nothing else, because the
+ *          whole safety argument of the family lives here:
+ *
+ *            a removal that splits an assistant's `tool_use` from its
+ *            `tool_result` produces a request the vendor rejects, and a
+ *            removal that swallows an unanswered question destroys the
+ *            referent of the answer that has not arrived yet.
+ *
+ *          Strategies never import this module. `WindowStrategyInput` hands
+ *          them `planRemoval` already bound to this iteration's turns and
+ *          guards, so a strategy CANNOT skip the refusal rules — that is a
+ *          property of the seam, not of the documentation.
  * Emits:   N/A.
  *
- * Testable on its own — see `test/core/agent/compaction-turns.test.ts`.
+ * Testable on its own — see `test/core/window-turns.test.ts`.
  */
 /**
  * Segment a window into turns.
@@ -49,7 +58,7 @@ export function answeredCallIds(history) {
     return answered;
 }
 /**
- * Why this turn may NOT fold, or `undefined` when it may.
+ * Why this turn may NOT leave the window, or `undefined` when it may.
  *
  * Order matters only for which reason gets reported first; every check is
  * independent. `paused-tool` / `pending-check-in` are separated from
@@ -57,44 +66,53 @@ export function answeredCallIds(history) {
  * fact about the world, and "we are waiting on a human" is what the person
  * reading the trace needs to see.
  */
-export function refusalFor(turn, ctx) {
+export function refusalFor(turn, guards) {
     for (const msg of turn.messages) {
         if (msg.role === 'system')
             return 'system-envelope';
     }
-    const paused = ctx.pausedToolCallId;
+    const paused = guards.pausedToolCallId;
     if (paused !== undefined && paused.length > 0) {
         for (const msg of turn.messages) {
             const holdsPaused = msg.toolCallId === paused || (msg.toolCalls ?? []).some((tc) => tc.id === paused);
             if (holdsPaused)
-                return ctx.pausedCheckIn === true ? 'pending-check-in' : 'paused-tool';
+                return guards.pausedCheckIn === true ? 'pending-check-in' : 'paused-tool';
         }
     }
     for (const msg of turn.messages) {
         for (const call of msg.toolCalls ?? []) {
-            if (!ctx.answeredCallIds.has(call.id))
+            if (!guards.answeredCallIds.has(call.id))
                 return 'unresolved-tool-call';
         }
     }
     return undefined;
 }
 /**
- * Choose the fold span: the LONGEST CONTIGUOUS run of foldable candidate
- * turns, starting at the oldest foldable one.
+ * Choose the removal span: the LONGEST CONTIGUOUS run of removable candidate
+ * turns, starting at the oldest removable one.
  *
  * Contiguity is not fussiness — it is what keeps the conversation in order.
  * A fold replaces its span with ONE summary message; if the span skipped over
- * an unfoldable turn, that turn would end up after a summary of things that
- * happened before it. So an unfoldable turn at the front is stepped over (the
- * fold "takes the next oldest instead") and an unfoldable turn in the middle
- * ends the span. Everything not folded keeps its position.
+ * an unremovable turn, that turn would end up after a summary of things that
+ * happened before it. So an unremovable turn at the front is stepped over (the
+ * span "takes the next oldest instead") and an unremovable turn in the middle
+ * ends the span. Everything not removed keeps its position.
+ *
+ * The drop strategies take the same span for a second reason: it is what makes
+ * a refusal reason mean the same thing under every strategy. A turn that ends
+ * the span this iteration is retried the next one — by which time the tool
+ * result it was waiting on has usually arrived.
  *
- * @param turns         the window's turn segmentation
- * @param keepRecent    how many trailing turns are off-limits
- * @param ctx           foldability inputs
- * @param isSummaryTurn true for a turn that is a summary a prior fold wrote
+ * @param turns             the window's turn segmentation
+ * @param keepRecent        how many trailing turns are off-limits
+ * @param guards            what must not leave (unanswered calls, the pause)
+ * @param isExistingSummary optional: true for a turn that is a summary a prior
+ *   fold wrote. When the whole span is one such turn, the plan refuses with
+ *   `only-existing-summary` — re-summarizing a summary spends an LLM call to
+ *   lose detail. The drop strategies omit it: a drop spends nothing, so there
+ *   is nothing to protect against.
  */
-export function planFold(turns, keepRecent, ctx, isSummaryTurn) {
+export function planRemoval(turns, keepRecent, guards, isExistingSummary) {
     const refusals = [];
     const candidateCount = Math.max(0, turns.length - keepRecent);
     for (let i = candidateCount; i < turns.length; i++) {
@@ -108,7 +126,7 @@ export function planFold(turns, keepRecent, ctx, isSummaryTurn) {
     let to = -1;
     for (let i = 0; i < candidateCount; i++) {
         const turn = turns[i];
-        const reason = refusalFor(turn, ctx);
+        const reason = refusalFor(turn, guards);
         if (reason === undefined) {
             if (from === -1)
                 from = i;
@@ -117,12 +135,16 @@ export function planFold(turns, keepRecent, ctx, isSummaryTurn) {
         }
         before.push({ reason, turnIndex: i, messageIndex: turn.start });
         if (from !== -1)
-            break; // an unfoldable turn ENDS the span
+            break; // an unremovable turn ENDS the span
     }
     // A span that is nothing but one existing summary is not worth a call:
     // re-summarizing a summary spends tokens to lose detail and names nothing
     // new. It becomes foldable again as soon as a real turn joins it.
-    if (from !== -1 && from === to && isSummaryTurn(turns[from])) {
+    const summaryOnly = isExistingSummary !== undefined &&
+        from !== -1 &&
+        from === to &&
+        isExistingSummary(turns[from]);
+    if (summaryOnly) {
         return {
             from: -1,
             to: -1,

package/dist/esm/core/agent/window/turns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turns.js","sourceRoot":"","sources":["../../../../../src/core/agent/window/turns.ts"],"names":[],"mappings":"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"}

package/dist/esm/core/agent/window/types.d.ts

@@ -0,0 +1,263 @@
+/**
+ * window/types — what each window strategy accepts, and what it writes into
+ * the ledger.
+ *
+ * Pattern: Value objects (no behavior) + resolved-config types.
+ * Role:    core/ layer. The law this whole folder exists to keep is stated
+ *          once, here, because every other file implements a piece of it:
+ *          **a window strategy edits the WINDOW, never the LEDGER.**
+ * Emits:   N/A (types only).
+ *
+ * The window is `scope.history` — the array `call-llm` hands the provider.
+ * The ledger is footprintjs's commit log, which is append-only: the turns a
+ * strategy removes from the window were committed by `seed#0` /
+ * `tool-calls#N` BEFORE the removal and stay in those bundles byte-identical
+ * forever. A strategy therefore cannot destroy history even in principle; it
+ * can only stop re-sending it. A summary is a CLAIM about the past, so it is
+ * filed as a claim — its own recorded step, naming every `runtimeStageId` it
+ * folded. A drop is an ABSENCE, and it is filed the same way: the record and
+ * the eviction events name what left, by id.
+ */
+import type { LLMProvider } from '../../../adapters/types.js';
+/**
+ * Why a turn refused to leave the window. Every one of these is NAMED in the
+ * commit — a removal that took less than it could have has to say why, or the
+ * next person debugging an oversized window has to guess.
+ *
+ * The set is closed and shared: the same reason means the same thing under
+ * every strategy, because every strategy resolves it through the same
+ * function (`refusalFor`, bound into `WindowStrategyInput.planRemoval`).
+ */
+export type WindowRefusalReason = 
+/** The turn holds a `role: 'system'` message. The envelope never leaves. */
+'system-envelope'
+/**
+ * An assistant `tool_use` in this turn has no matching `tool_result` in the
+ * window. Removing an unanswered question destroys the answer's referent —
+ * and the referent may still arrive (a paused run resumes).
+ */
+ | 'unresolved-tool-call'
+/** The turn holds the tool call this run is currently paused on. */
+ | 'paused-tool'
+/** The turn holds a tool call waiting on a human check-in decision. */
+ | 'pending-check-in'
+/** Inside `keepRecentTurns` — the recent window is never a candidate. */
+ | 'inside-keep-window'
+/**
+ * The only removable candidate is a summary a previous fold wrote. Folding
+ * a summary of a summary with nothing new to add spends a call to lose
+ * detail. Only `summarizeOldest` can report this: a drop spends nothing.
+ */
+ | 'only-existing-summary'
+/** The summarizer threw. No fold this iteration; the window stays big. */
+ | 'summarizer-failed'
+/**
+ * The REPLACEMENT came back no smaller than the span it would replace, so
+ * the removal was abandoned. Both sides are measured in chars — the same
+ * unit, an exact comparison, not a token guess.
+ *
+ * For `summarizeOldest` the replacement is the summary message: folding
+ * here would spend a call to make the window BIGGER and lose the detail as
+ * well. For the drop strategies it is the authored drop notice that has to
+ * take the window's head position (see `DROP_NOTICE_PREFIX`): dropping two
+ * tiny turns to insert a longer notice is pure loss, so it does not happen.
+ */
+ | 'summary-not-smaller';
+/** One named refusal, positioned so a reader can find the turn. */
+export interface WindowRefusal {
+    readonly reason: WindowRefusalReason;
+    /** Index of the turn in this iteration's turn segmentation. */
+    readonly turnIndex: number;
+    /** Index of the turn's first message in the pre-removal window. */
+    readonly messageIndex: number;
+}
+/**
+ * @deprecated Renamed to {@link WindowRefusal} in 7.17 — refusals are shared
+ * by every window strategy, and only one of them folds. This alias is the
+ * same type and is not going away in 7.x.
+ */
+export type FoldRefusal = WindowRefusal;
+/**
+ * @deprecated Renamed to {@link WindowRefusalReason} in 7.17. Same values,
+ * same meanings; kept as an alias for code written against 7.16.
+ */
+export type FoldRefusalReason = WindowRefusalReason;
+/**
+ * What one visit to the window stage put in the ledger.
+ *
+ * Every strategy files one of these — including the visits that removed
+ * NOTHING, which are the interesting ones. They are appended to
+ * `scope.compactions`, so the run's whole window story is one array in the
+ * commit log.
+ *
+ * (`compactions` is the key `.compaction()` shipped with in 7.16 and the key
+ * every strategy still writes: it is committed state, which is public surface
+ * for anyone reading a run, and renaming it for a better word would break
+ * those readers for nothing. It is named for the family's first member.)
+ *
+ * On `windowChars*` vs tokens: the char counts are EXACT and measured here.
+ * There is deliberately no `tokensAfter` — nothing can count the tokens of a
+ * window that has not been sent yet, and inventing one would be exactly the
+ * guess this family exists to refuse. The honest "after" is the NEXT call's
+ * `stream.llm_end` usage.
+ */
+export interface WindowRecord {
+    /**
+     * `WindowStrategy.name` of the strategy that decided — `'summarize-oldest'`,
+     * `'sliding-window'`, `'token-budget'`, or your own. Narrow on it.
+     */
+    readonly strategy: string;
+    /** ReAct iteration this visit belongs to. */
+    readonly iteration: number;
+    /** `runtimeStageId`s of the stages that appended the messages that left. */
+    readonly removedStageIds: readonly string[];
+    /** How many messages left the window. */
+    readonly removedMessageCount: number;
+    /** Window size in chars before / after this visit. Exact, and not tokens. */
+    readonly windowCharsBefore: number;
+    readonly windowCharsAfter: number;
+    /** Every turn that refused to leave, named. */
+    readonly refusals: readonly WindowRefusal[];
+}
+/**
+ * What one OVER-BUDGET visit to `summarizeOldest` (what `.compaction()`
+ * configures) put in the ledger.
+ */
+export interface CompactionRecord extends WindowRecord {
+    /** Adapter-reported input tokens of the last call — what tripped the check. */
+    readonly measuredTokens: number;
+    /** The budget it was compared against. */
+    readonly thresholdTokens: number;
+    /** True when the measurement was over budget (a fold was attempted). */
+    readonly overBudget: boolean;
+    /**
+     * @deprecated Use {@link WindowRecord.removedStageIds} — the family name for
+     * the same value, published alongside it since 7.17. Both are written.
+     */
+    readonly foldedStageIds: readonly string[];
+    /**
+     * @deprecated Use {@link WindowRecord.removedMessageCount} — the family name
+     * for the same value, published alongside it since 7.17. Both are written.
+     */
+    readonly foldedMessageCount: number;
+    /** Length of the summary text the summarizer produced (0 when none). */
+    readonly summaryChars: number;
+    /** What the summarizer call itself cost, when it reported usage. */
+    readonly summarizerTokens?: {
+        readonly input: number;
+        readonly output: number;
+    };
+}
+/** What one visit to `slidingWindow` put in the ledger. */
+export interface SlidingWindowRecord extends WindowRecord {
+    readonly strategy: 'sliding-window';
+    /** The configured keep depth this visit measured against. */
+    readonly keepRecentTurns: number;
+    /** Turns in the window before / after this visit. Counted, not estimated. */
+    readonly turnsBefore: number;
+    readonly turnsAfter: number;
+}
+/** What one OVER-BUDGET visit to `tokenBudget` put in the ledger. */
+export interface TokenBudgetRecord extends WindowRecord {
+    readonly strategy: 'token-budget';
+    /** Adapter-reported input tokens of the last call — what tripped the check. */
+    readonly measuredTokens: number;
+    /** The budget it was compared against. */
+    readonly thresholdTokens: number;
+    /** True when the measurement was over budget (a drop was attempted). */
+    readonly overBudget: boolean;
+    /** How many recent turns were off-limits to this visit. */
+    readonly keepRecentTurns: number;
+}
+/**
+ * What `.compaction({...})` — and `summarizeOldest({...})` — accepts.
+ *
+ * @example
+ * ```ts
+ * const agent = Agent.create({ provider: anthropic(), model: 'claude-sonnet-4-5' })
+ *   .compaction({
+ *     thresholdTokens: 120_000,
+ *     summarizer: anthropic(),          // usually the cheap one
+ *     model: 'claude-haiku-4-5',
+ *     keepRecentTurns: 6,
+ *   })
+ *   .build();
+ * ```
+ */
+export interface CompactionOptions {
+    /**
+     * Fold when the LAST call's adapter-reported input tokens exceed this.
+     *
+     * REQUIRED, with no default. A default budget here would be a number the
+     * library invented for a window whose size only the consumer's model and
+     * wallet know — and every run would silently inherit it.
+     */
+    readonly thresholdTokens: number;
+    /**
+     * How many of the most recent turns are never folded. Default 6.
+     *
+     * The recent turns are what the model is actually reasoning over; folding
+     * them is how a compacting agent loses the thread.
+     */
+    readonly keepRecentTurns?: number;
+    /**
+     * The provider that writes the summary. Explicitly chosen — the library
+     * never quietly bills your main model for compaction.
+     */
+    readonly summarizer: LLMProvider;
+    /**
+     * Model id for the summarizer call. Defaults to the agent's own model, so
+     * `summarizer: anthropic()` alone works; name a cheap model to spend less.
+     */
+    readonly model?: string;
+}
+/** Resolved form — defaults applied at build time, validated once. */
+export interface ResolvedCompaction {
+    readonly thresholdTokens: number;
+    readonly keepRecentTurns: number;
+    readonly summarizer: LLMProvider;
+    readonly model: string | undefined;
+}
+/**
+ * What `slidingWindow({...})` accepts.
+ *
+ * @example
+ * ```ts
+ * const agent = Agent.create({ provider: anthropic(), model: 'claude-sonnet-4-5' })
+ *   .window(slidingWindow({ keepRecentTurns: 12 }))
+ *   .build();
+ * ```
+ */
+export interface SlidingWindowOptions {
+    /**
+     * How many of the most recent turns stay in the window. Everything older is
+     * dropped — unless it refuses by name.
+     *
+     * REQUIRED, with no default. It *is* the policy: how much past this agent
+     * needs is a fact about your agent, not about this library.
+     */
+    readonly keepRecentTurns: number;
+}
+/**
+ * What `tokenBudget({...})` accepts.
+ *
+ * @example
+ * ```ts
+ * const agent = Agent.create({ provider: anthropic(), model: 'claude-sonnet-4-5' })
+ *   .window(tokenBudget({ thresholdTokens: 120_000 }))
+ *   .build();
+ * ```
+ */
+export interface TokenBudgetOptions {
+    /**
+     * Drop when the LAST call's adapter-reported input tokens exceed this.
+     *
+     * REQUIRED, with no default — the same reason as `.compaction()`: only your
+     * model and your bill know the right number.
+     */
+    readonly thresholdTokens: number;
+    /**
+     * How many of the most recent turns are never dropped. Default 6.
+     */
+    readonly keepRecentTurns?: number;
+}

package/dist/esm/core/agent/window/types.js

@@ -0,0 +1,22 @@
+/**
+ * window/types — what each window strategy accepts, and what it writes into
+ * the ledger.
+ *
+ * Pattern: Value objects (no behavior) + resolved-config types.
+ * Role:    core/ layer. The law this whole folder exists to keep is stated
+ *          once, here, because every other file implements a piece of it:
+ *          **a window strategy edits the WINDOW, never the LEDGER.**
+ * Emits:   N/A (types only).
+ *
+ * The window is `scope.history` — the array `call-llm` hands the provider.
+ * The ledger is footprintjs's commit log, which is append-only: the turns a
+ * strategy removes from the window were committed by `seed#0` /
+ * `tool-calls#N` BEFORE the removal and stay in those bundles byte-identical
+ * forever. A strategy therefore cannot destroy history even in principle; it
+ * can only stop re-sending it. A summary is a CLAIM about the past, so it is
+ * filed as a claim — its own recorded step, naming every `runtimeStageId` it
+ * folded. A drop is an ABSENCE, and it is filed the same way: the record and
+ * the eviction events name what left, by id.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/core/agent/window/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/core/agent/window/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG"}

package/dist/esm/index.d.ts

@@ -27,7 +27,7 @@ export { LLMCall, LLMCallBuilder, type LLMCallInput, type LLMCallOptions, type L
 export { type MessageApiChartDeps } from './core/agent/buildMessageApiChart.js';
 export { buildAgentMessageApiChart, type AgentMessageApiChartDeps, } from './core/agent/buildAgentMessageApiChart.js';
 export { Agent, AgentBuilder, type AgentInput, type AgentOptions, type AgentOutput, type ObserverDeliveryOptions, } from './core/Agent.js';
-export { CompactionUnmeasurableError, COMPACTED_FRAME_PREFIX, isCompactedSummary, type CompactionOptions, type CompactionRecord, type FoldRefusal, type FoldRefusalReason, } from './core/agent/compaction/index.js';
+export { CompactionUnmeasurableError, COMPACTED_FRAME_PREFIX, DROP_NOTICE_PREFIX, isCompactedSummary, isDropNotice, slidingWindow, summarizeOldest, tokenBudget, type CompactionOptions, type CompactionRecord, type FoldRefusal, type FoldRefusalReason, type RemovalFacts, type RemovalPlan, type SlidingWindowOptions, type SlidingWindowRecord, type TokenBudgetOptions, type TokenBudgetRecord, type Turn, type WindowEviction, type WindowRecord, type WindowRefusal, type WindowRefusalReason, type WindowStrategy, type WindowStrategyInput, type WindowStrategyResult, } from './core/agent/window/index.js';
 export type { SelfExplainOptions } from './lib/trace-toolpack/selfExplain.js';
 export type { ObserverDrainResult, ObserverStats } from 'footprintjs';
 export type { ToolArgValidationMode } from './core/agent/toolArgsValidation.js';

package/dist/esm/index.js

@@ -84,11 +84,16 @@ export { LLMCall, LLMCallBuilder, } from './core/LLMCall.js';
 // only additions over buildMessageApiChart. See buildAgentMessageApiChart.
 export { buildAgentMessageApiChart, } from './core/agent/buildAgentMessageApiChart.js';
 export { Agent, AgentBuilder, } from './core/Agent.js';
-// `.compaction()` — keep the live window inside a token budget without ever
-// losing the record. The fold edits the WINDOW; the LEDGER keeps every folded
-// turn byte-identical, and the summary enters as its own recorded step naming
-// every runtimeStageId it folded.
-export { CompactionUnmeasurableError, COMPACTED_FRAME_PREFIX, isCompactedSummary, } from './core/agent/compaction/index.js';
+// `.window(strategy)` / `.compaction()` — keep the live context window inside
+// its budget without ever losing the record. A strategy edits the WINDOW; the
+// LEDGER keeps every removed turn byte-identical, and every strategy files its
+// own recorded step naming the runtimeStageIds whose messages left.
+//
+// Three ship, over one turn segmentation and one refusal engine:
+//   summarizeOldest  fold the oldest span into a summary  (what `.compaction()` is)
+//   slidingWindow    keep the last N turns, drop older ones
+//   tokenBudget      counted-token trigger, drop instead of summarize
+export { CompactionUnmeasurableError, COMPACTED_FRAME_PREFIX, DROP_NOTICE_PREFIX, isCompactedSummary, isDropNotice, slidingWindow, summarizeOldest, tokenBudget, } from './core/agent/window/index.js';
 export { OutputSchemaError, applyOutputSchema, } from './core/outputSchema.js';
 export { RunCheckpointError } from './core/runCheckpoint.js';
 export { flowchartAsTool, } from './core/flowchartAsTool.js';

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}