agentfootprint 7.15.0 → 7.17.0

package/dist/core/agent/window/removal.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * window/removal — "these messages left" → the facts the ledger needs.
+ *
+ * Pattern: Pure function over the meter's provenance.
+ * Role:    core/ layer. The stage binds this into every
+ *          `WindowStrategyInput.removalFacts`, so a strategy can name what it
+ *          removed without ever touching the meter — and cannot file a
+ *          removal it is unable to name.
+ * Emits:   N/A.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexRange = exports.removalFacts = void 0;
+/**
+ * Resolve which stages wrote the removed messages, and how long each lived.
+ *
+ * `survivalMs` is measured (`atMs - bornAtMs`), and is 0 — not a guess — when
+ * a message's birth is unknown, which happens only for a window seeded from
+ * outside this run.
+ */
+function removalFacts(origins, indices, atMs) {
+    const removedStageIds = [];
+    const evictions = [];
+    for (const index of indices) {
+        const origin = origins[index];
+        if (origin !== undefined && !removedStageIds.includes(origin.stageId)) {
+            removedStageIds.push(origin.stageId);
+        }
+        evictions.push({
+            index,
+            survivalMs: origin === undefined ? 0 : Math.max(0, atMs - origin.bornAtMs),
+        });
+    }
+    return { removedStageIds, evictions };
+}
+exports.removalFacts = removalFacts;
+/** `[from, toExclusive)` as a list of indices. */
+function indexRange(from, toExclusive) {
+    const out = [];
+    for (let i = from; i < toExclusive; i++)
+        out.push(i);
+    return out;
+}
+exports.indexRange = indexRange;
+//# sourceMappingURL=removal.js.map

package/dist/core/agent/window/removal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"removal.js","sourceRoot":"","sources":["../../../../src/core/agent/window/removal.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAKH;;;;;;GAMG;AACH,SAAgB,YAAY,CAC1B,OAAiC,EACjC,OAA0B,EAC1B,IAAY;IAEZ,MAAM,eAAe,GAAa,EAAE,CAAC;IACrC,MAAM,SAAS,GAAqB,EAAE,CAAC;IACvC,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;YACtE,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACvC,CAAC;QACD,SAAS,CAAC,IAAI,CAAC;YACb,KAAK;YACL,UAAU,EAAE,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC;SAC3E,CAAC,CAAC;IACL,CAAC;IACD,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC;AACxC,CAAC;AAlBD,oCAkBC;AAED,kDAAkD;AAClD,SAAgB,UAAU,CAAC,IAAY,EAAE,WAAmB;IAC1D,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE;QAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACrD,OAAO,GAAG,CAAC;AACb,CAAC;AAJD,gCAIC"}

package/dist/core/agent/window/strategies/drop.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * window/strategies/drop — the mechanic both drop strategies share.
+ *
+ * Pattern: One pure function over a `WindowStrategyInput`.
+ * Role:    core/ layer. `slidingWindow` and `tokenBudget` differ ONLY in when
+ *          they engage and what they file; what actually leaves the window is
+ *          decided here, once, so a refusal reason means the same thing under
+ *          both — and under compaction, which asks the same `planRemoval`.
+ * Emits:   N/A.
+ *
+ * A drop makes no LLM call and writes no summary. What it must still do is
+ * keep the request valid and keep the record honest:
+ *
+ *   • the span comes from the shared refusal engine, so an unanswered tool
+ *     call, the paused tool, a pending check-in and the recent turns never
+ *     leave, and each refusal is named;
+ *   • when the span reaches the window's HEAD, an authored notice takes that
+ *     position — the window must open on a user turn (see notice.ts), and a
+ *     message we are forced to author should tell the truth;
+ *   • when it does not, nothing is inserted: the original opening turn is
+ *     still there, so there is no wire problem to solve.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dropOldestSpan = void 0;
+const notice_js_1 = require("../notice.js");
+const removal_js_1 = require("../removal.js");
+const turns_js_1 = require("../turns.js");
+/**
+ * Drop the oldest contiguous removable span, if there is one.
+ *
+ * @param input            the strategy's input, with the bound refusal engine
+ * @param keepRecentTurns  how many trailing turns are off-limits
+ * @param strategyName     named in the authored notice, so a reader of the
+ *                         window itself can tell which policy removed things
+ */
+function dropOldestSpan(input, keepRecentTurns, strategyName) {
+    const { history, turns, iteration } = input;
+    const charsBefore = (0, turns_js_1.windowChars)(history);
+    const nothing = (refusals) => ({
+        refusals,
+        removedStageIds: [],
+        removedMessageCount: 0,
+        evictions: [],
+        windowCharsBefore: charsBefore,
+        windowCharsAfter: charsBefore,
+        turnsBefore: turns.length,
+        turnsAfter: turns.length,
+    });
+    // No `isExistingSummary` predicate: that refusal exists to stop a strategy
+    // spending an LLM call to re-summarize a summary. A drop spends nothing, so
+    // there is nothing to protect against — a stale summary is as droppable as
+    // any other old turn.
+    const plan = input.planRemoval(keepRecentTurns);
+    if (plan.from === -1)
+        return nothing(plan.refusals);
+    const spanStart = turns[plan.from].start;
+    const spanEnd = turns[plan.to].start + turns[plan.to].length;
+    const head = history.slice(0, spanStart);
+    const span = history.slice(spanStart, spanEnd);
+    const tail = history.slice(spanEnd);
+    let window;
+    let insertedAtMs;
+    const droppedAtMs = input.now();
+    if (spanStart === 0) {
+        // The head is leaving: something must open the window, and it must be a
+        // user turn. Author the notice — and refuse the whole drop if that notice
+        // would not be smaller than what it replaces, because dropping two tiny
+        // turns to insert a longer notice is pure loss.
+        const notice = (0, notice_js_1.buildDropNotice)({
+            droppedMessageCount: span.length,
+            iteration,
+            strategy: strategyName,
+        });
+        if (notice.content.length >= (0, turns_js_1.windowChars)(span)) {
+            return nothing([
+                { reason: 'summary-not-smaller', turnIndex: plan.from, messageIndex: spanStart },
+                ...plan.refusals,
+            ]);
+        }
+        window = [notice, ...tail];
+        insertedAtMs = droppedAtMs;
+    }
+    else {
+        window = [...head, ...tail];
+    }
+    const facts = input.removalFacts((0, removal_js_1.indexRange)(spanStart, spanEnd), droppedAtMs);
+    return {
+        refusals: plan.refusals,
+        window,
+        rebase: {
+            headCount: head.length,
+            keptTailCount: tail.length,
+            ...(insertedAtMs !== undefined && { insertedAtMs }),
+        },
+        removedStageIds: facts.removedStageIds,
+        removedMessageCount: span.length,
+        evictions: facts.evictions,
+        windowCharsBefore: charsBefore,
+        windowCharsAfter: (0, turns_js_1.windowChars)(window),
+        turnsBefore: turns.length,
+        turnsAfter: (0, turns_js_1.segmentTurns)(window).length,
+    };
+}
+exports.dropOldestSpan = dropOldestSpan;
+//# sourceMappingURL=drop.js.map

package/dist/core/agent/window/strategies/drop.js.map

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

package/dist/core/agent/window/strategies/slidingWindow.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * slidingWindow — keep the last N turns, drop what is older.
+ *
+ * Pattern: WindowStrategy implementation. Its own module, registering
+ *          nothing at import.
+ * Role:    core/ layer.
+ * Emits:   N/A — the stage emits, records and costs; this file decides.
+ *
+ * The market's simplest window policy (LangChain's `trim_messages`, the
+ * "last N messages" every framework ships). Two things are different here:
+ *
+ *   1. **It refuses by name.** It goes through the SAME turn segmentation and
+ *      the SAME refusal engine as compaction, so it will not drop half of a
+ *      `tool_use` / `tool_result` pair, will not drop an unanswered tool call
+ *      whose answer may still arrive, will not drop the tool a paused run is
+ *      waiting on or a pending check-in, and cannot touch the system
+ *      envelope. Message-counting trimmers split those pairs and the vendor
+ *      rejects the request; this one steps over them and says so in the
+ *      record.
+ *   2. **It says what it dropped.** Every dropped message is an eviction
+ *      event with its measured lifetime, and the record names the stage ids
+ *      the messages came from. The turns themselves stay in the commit log,
+ *      byte for byte.
+ *
+ * It triggers on turn COUNT, not tokens — so it needs no summarizer, makes no
+ * LLM call, and runs on ANY provider, including the ones that report no usage
+ * at all. Nothing here is unmeasurable, so nothing here throws.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slidingWindow = exports.SLIDING_WINDOW = void 0;
+const drop_js_1 = require("./drop.js");
+const options_js_1 = require("../options.js");
+/** `WindowRecord.strategy` written by every record this strategy files. */
+exports.SLIDING_WINDOW = 'sliding-window';
+/**
+ * Keep the most recent `keepRecentTurns` turns in the live window and drop
+ * the older ones — except anything that refuses.
+ *
+ * @example
+ * ```ts
+ * import { Agent, slidingWindow } from 'agentfootprint';
+ * import { ollama } from 'agentfootprint/llm-providers';
+ *
+ * // Works on a provider that reports no usage at all: the trigger is turns.
+ * const agent = Agent.create({ provider: ollama(), model: 'llama3' })
+ *   .window(slidingWindow({ keepRecentTurns: 12 }))
+ *   .build();
+ * ```
+ */
+function slidingWindow(options) {
+    const config = (0, options_js_1.resolveSlidingWindowOptions)(options, 'slidingWindow');
+    return {
+        name: exports.SLIDING_WINDOW,
+        async plan(input) {
+            // Did not engage: the window is already within its target depth. No
+            // record — the ledger tracks what this strategy DID, not every time it
+            // looked and there was nothing to do.
+            if (input.turns.length <= config.keepRecentTurns)
+                return undefined;
+            const outcome = (0, drop_js_1.dropOldestSpan)(input, config.keepRecentTurns, exports.SLIDING_WINDOW);
+            const record = {
+                strategy: exports.SLIDING_WINDOW,
+                iteration: input.iteration,
+                keepRecentTurns: config.keepRecentTurns,
+                removedStageIds: outcome.removedStageIds,
+                removedMessageCount: outcome.removedMessageCount,
+                windowCharsBefore: outcome.windowCharsBefore,
+                windowCharsAfter: outcome.windowCharsAfter,
+                turnsBefore: outcome.turnsBefore,
+                turnsAfter: outcome.turnsAfter,
+                refusals: outcome.refusals,
+            };
+            // No `budgetPressure`: this strategy has no token budget. Reporting a
+            // cap nobody configured would be the invented number the family exists
+            // to refuse — so it reports evictions and stays quiet about budgets.
+            return {
+                ...(outcome.window !== undefined && { window: outcome.window }),
+                ...(outcome.rebase !== undefined && { rebase: outcome.rebase }),
+                record,
+                evictions: outcome.evictions,
+            };
+        },
+    };
+}
+exports.slidingWindow = slidingWindow;
+//# sourceMappingURL=slidingWindow.js.map

package/dist/core/agent/window/strategies/slidingWindow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slidingWindow.js","sourceRoot":"","sources":["../../../../../src/core/agent/window/strategies/slidingWindow.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;;;AAEH,uCAA2C;AAC3C,8CAA4D;AAI5D,2EAA2E;AAC9D,QAAA,cAAc,GAAG,gBAAgB,CAAC;AAE/C;;;;;;;;;;;;;;GAcG;AACH,SAAgB,aAAa,CAAC,OAA6B;IACzD,MAAM,MAAM,GAAG,IAAA,wCAA2B,EAAC,OAAO,EAAE,eAAe,CAAC,CAAC;IAErE,OAAO;QACL,IAAI,EAAE,sBAAc;QAEpB,KAAK,CAAC,IAAI,CAAC,KAA0B;YACnC,oEAAoE;YACpE,uEAAuE;YACvE,sCAAsC;YACtC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,IAAI,MAAM,CAAC,eAAe;gBAAE,OAAO,SAAS,CAAC;YAEnE,MAAM,OAAO,GAAG,IAAA,wBAAc,EAAC,KAAK,EAAE,MAAM,CAAC,eAAe,EAAE,sBAAc,CAAC,CAAC;YAC9E,MAAM,MAAM,GAAwB;gBAClC,QAAQ,EAAE,sBAAc;gBACxB,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,eAAe,EAAE,MAAM,CAAC,eAAe;gBACvC,eAAe,EAAE,OAAO,CAAC,eAAe;gBACxC,mBAAmB,EAAE,OAAO,CAAC,mBAAmB;gBAChD,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;gBAC5C,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;gBAC1C,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,QAAQ,EAAE,OAAO,CAAC,QAAQ;aAC3B,CAAC;YAEF,sEAAsE;YACtE,uEAAuE;YACvE,qEAAqE;YACrE,OAAO;gBACL,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;gBAC/D,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;gBAC/D,MAAM;gBACN,SAAS,EAAE,OAAO,CAAC,SAAS;aAC7B,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AArCD,sCAqCC"}

package/dist/core/agent/window/strategies/summarizeOldest.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * summarizeOldest — fold the oldest foldable turns into one summary message.
+ *
+ * Pattern: WindowStrategy implementation. Its own module, importing nothing
+ *          that registers anything, so a bundle that never mentions it never
+ *          carries it (and never carries the summarizer machinery either).
+ * Role:    core/ layer.
+ * Emits:   N/A — the stage emits, records and costs; this file decides.
+ *
+ * This is what `.compaction({...})` configures, and the market's familiar
+ * move (Claude Code / the Claude Agent SDK call it compaction). What is
+ * different here is not the fold — it is that the fold is filed as a claim:
+ * a summary is a claim ABOUT the past, and the past itself stays in the
+ * commit log, byte for byte.
+ *
+ * Everything it decides, it explains. Every engaged path returns a record —
+ * including the paths that change nothing, which are the ones a person
+ * debugging an over-budget window actually needs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeOldest = exports.SUMMARIZE_OLDEST = void 0;
+const errors_js_1 = require("../errors.js");
+const options_js_1 = require("../options.js");
+const removal_js_1 = require("../removal.js");
+const summarize_js_1 = require("../summarize.js");
+const turns_js_1 = require("../turns.js");
+/** `WindowRecord.strategy` written by every record this strategy files. */
+exports.SUMMARIZE_OLDEST = 'summarize-oldest';
+/**
+ * Fold the oldest contiguous run of foldable turns into one summary message,
+ * keeping the recent turns and stepping over anything unresolved.
+ *
+ * Triggered by COUNTED tokens: the last call's adapter-reported input tokens
+ * against `thresholdTokens`. A provider that reports no usage gets
+ * `CompactionUnmeasurableError` rather than an invented number.
+ *
+ * @example
+ * ```ts
+ * import { Agent, summarizeOldest } from 'agentfootprint';
+ *
+ * const agent = Agent.create({ provider: anthropic(), model: 'claude-sonnet-4-5' })
+ *   .window(summarizeOldest({ thresholdTokens: 120_000, summarizer: anthropic() }))
+ *   .build();
+ * // `.compaction({ ... })` is this exact line, spelled shorter.
+ * ```
+ */
+function summarizeOldest(options) {
+    const config = (0, options_js_1.resolveCompactionOptions)(options, 'summarizeOldest');
+    return {
+        name: exports.SUMMARIZE_OLDEST,
+        async plan(input) {
+            const { history, turns, iteration, measured } = input;
+            // Iteration 1: nothing has been sent, so nothing has been counted. A
+            // compactor that acted here would be guessing.
+            if (measured === undefined)
+                return undefined;
+            if (measured.input === 0 && measured.output === 0) {
+                throw new errors_js_1.CompactionUnmeasurableError(input.providerName);
+            }
+            if (measured.input <= config.thresholdTokens)
+                return undefined;
+            const model = config.model ?? input.agentModel;
+            const charsBefore = (0, turns_js_1.windowChars)(history);
+            const base = {
+                strategy: exports.SUMMARIZE_OLDEST,
+                iteration,
+                measuredTokens: measured.input,
+                thresholdTokens: config.thresholdTokens,
+                overBudget: true,
+                windowCharsBefore: charsBefore,
+            };
+            const unchanged = (refusals, extra = {}) => ({
+                record: {
+                    ...base,
+                    removedStageIds: [],
+                    removedMessageCount: 0,
+                    foldedStageIds: [],
+                    foldedMessageCount: 0,
+                    windowCharsAfter: charsBefore,
+                    summaryChars: 0,
+                    refusals,
+                    ...extra,
+                },
+                evictions: [],
+                budgetPressure: {
+                    capTokens: config.thresholdTokens,
+                    projectedTokens: measured.input,
+                    planAction: 'none',
+                },
+            });
+            const plan = input.planRemoval(config.keepRecentTurns, (turn) => (0, summarize_js_1.isCompactedSummary)(turn.messages[0]));
+            if (plan.from === -1) {
+                // Nothing foldable. The window stays over budget and the run proceeds
+                // — reported, not silently truncated.
+                return unchanged(plan.refusals);
+            }
+            const spanStart = turns[plan.from].start;
+            const spanEnd = turns[plan.to].start + turns[plan.to].length;
+            const head = history.slice(0, spanStart);
+            const span = history.slice(spanStart, spanEnd);
+            const tail = history.slice(spanEnd);
+            // A broken summarizer must not take down the run.
+            let summary;
+            try {
+                const result = await (0, summarize_js_1.runSummarizer)(config.summarizer, model, span, input.signal);
+                summary = {
+                    text: result.text,
+                    usage: { input: result.usage.input, output: result.usage.output },
+                };
+            }
+            catch (err) {
+                return {
+                    ...unchanged([
+                        { reason: 'summarizer-failed', turnIndex: plan.from, messageIndex: spanStart },
+                        ...plan.refusals,
+                    ]),
+                    warning: `the summarizer threw, so nothing was folded this iteration and the window ` +
+                        `stays over budget (${measured.input} tokens vs a threshold of ` +
+                        `${config.thresholdTokens}). The run continues. Cause: ` +
+                        `${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+            const summaryMessage = (0, summarize_js_1.buildSummaryMessage)(summary.text, {
+                foldedMessageCount: span.length,
+                iteration,
+                model,
+            });
+            const spend = { model, usage: summary.usage };
+            // Would the fold actually help? A summary plus its authored frame can be
+            // LONGER than a handful of short turns; folding then spends a call to
+            // grow the window and lose detail at the same time. Both sides are
+            // measured in chars — one unit, an exact comparison, not a token guess.
+            if (summaryMessage.content.length >= (0, turns_js_1.windowChars)(span)) {
+                return {
+                    ...unchanged([
+                        { reason: 'summary-not-smaller', turnIndex: plan.from, messageIndex: spanStart },
+                        ...plan.refusals,
+                    ], { summaryChars: summaryMessage.content.length, summarizerTokens: summary.usage }),
+                    spend, // the call still happened, so it still counts
+                };
+            }
+            const foldedAtMs = input.now();
+            const facts = input.removalFacts((0, removal_js_1.indexRange)(spanStart, spanEnd), foldedAtMs);
+            const window = [...head, summaryMessage, ...tail];
+            const record = {
+                ...base,
+                removedStageIds: facts.removedStageIds,
+                removedMessageCount: span.length,
+                // The 7.16 names for the two values above, kept and deprecated.
+                foldedStageIds: facts.removedStageIds,
+                foldedMessageCount: span.length,
+                windowCharsAfter: (0, turns_js_1.windowChars)(window),
+                summaryChars: summaryMessage.content.length,
+                summarizerTokens: summary.usage,
+                refusals: plan.refusals,
+            };
+            return {
+                window,
+                rebase: {
+                    headCount: head.length,
+                    keptTailCount: tail.length,
+                    insertedAtMs: foldedAtMs,
+                },
+                record,
+                evictions: facts.evictions,
+                budgetPressure: {
+                    capTokens: config.thresholdTokens,
+                    projectedTokens: measured.input,
+                    planAction: 'summarize',
+                },
+                spend,
+            };
+        },
+    };
+}
+exports.summarizeOldest = summarizeOldest;
+//# sourceMappingURL=summarizeOldest.js.map

package/dist/core/agent/window/strategies/summarizeOldest.js.map

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

package/dist/core/agent/window/strategies/tokenBudget.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * tokenBudget — compaction's trigger discipline, without the summarizer.
+ *
+ * Pattern: WindowStrategy implementation. Its own module, registering
+ *          nothing at import.
+ * Role:    core/ layer.
+ * Emits:   N/A — the stage emits, records and costs; this file decides.
+ *
+ * The market's other familiar policy: cap the window at a token budget
+ * (Mastra's `TokenLimiter` is the closest sibling). What is different here is
+ * the same thing that is different about compaction — the number is COUNTED,
+ * never guessed:
+ *
+ *   • the trigger reads the input tokens the PROVIDER reported for the last
+ *     call, not a character estimate and not a divide-by-four heuristic;
+ *   • a provider that reports no usage gets `CompactionUnmeasurableError` by
+ *     name, the same refusal `.compaction()` makes, rather than an invented
+ *     window size or a configured budget that silently never applies.
+ *
+ * When over budget it drops the oldest contiguous removable span — the same
+ * span compaction would have folded, chosen by the same refusal engine — and
+ * writes no summary at all. Nothing is claimed about what left, because
+ * nothing was read: the record and the eviction events name it, and the
+ * commit log still has it verbatim.
+ *
+ * Use it over `summarizeOldest` when you would rather lose the old turns than
+ * pay a summarizer to paraphrase them, and over `slidingWindow` when the
+ * thing you are actually defending is a token bill rather than a turn depth.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenBudget = exports.TOKEN_BUDGET = void 0;
+const drop_js_1 = require("./drop.js");
+const errors_js_1 = require("../errors.js");
+const options_js_1 = require("../options.js");
+/** `WindowRecord.strategy` written by every record this strategy files. */
+exports.TOKEN_BUDGET = 'token-budget';
+/**
+ * Drop the oldest turns whenever the last call's adapter-reported input
+ * tokens exceed `thresholdTokens`.
+ *
+ * @example
+ * ```ts
+ * import { Agent, tokenBudget } from 'agentfootprint';
+ *
+ * const agent = Agent.create({ provider: anthropic(), model: 'claude-sonnet-4-5' })
+ *   .window(tokenBudget({ thresholdTokens: 120_000 }))
+ *   .build();
+ * ```
+ */
+function tokenBudget(options) {
+    const config = (0, options_js_1.resolveTokenBudgetOptions)(options, 'tokenBudget');
+    return {
+        name: exports.TOKEN_BUDGET,
+        async plan(input) {
+            const { measured } = input;
+            // Iteration 1: nothing has been sent, so nothing has been counted.
+            if (measured === undefined)
+                return undefined;
+            // Counted, not guessed — the same wall compaction hits, by the same name.
+            if (measured.input === 0 && measured.output === 0) {
+                throw new errors_js_1.CompactionUnmeasurableError(input.providerName);
+            }
+            if (measured.input <= config.thresholdTokens)
+                return undefined;
+            const outcome = (0, drop_js_1.dropOldestSpan)(input, config.keepRecentTurns, exports.TOKEN_BUDGET);
+            const record = {
+                strategy: exports.TOKEN_BUDGET,
+                iteration: input.iteration,
+                measuredTokens: measured.input,
+                thresholdTokens: config.thresholdTokens,
+                overBudget: true,
+                keepRecentTurns: config.keepRecentTurns,
+                removedStageIds: outcome.removedStageIds,
+                removedMessageCount: outcome.removedMessageCount,
+                windowCharsBefore: outcome.windowCharsBefore,
+                windowCharsAfter: outcome.windowCharsAfter,
+                refusals: outcome.refusals,
+            };
+            return {
+                ...(outcome.window !== undefined && { window: outcome.window }),
+                ...(outcome.rebase !== undefined && { rebase: outcome.rebase }),
+                record,
+                evictions: outcome.evictions,
+                budgetPressure: {
+                    capTokens: config.thresholdTokens,
+                    projectedTokens: measured.input,
+                    planAction: outcome.removedMessageCount > 0 ? 'evict' : 'none',
+                },
+            };
+        },
+    };
+}
+exports.tokenBudget = tokenBudget;
+//# sourceMappingURL=tokenBudget.js.map

package/dist/core/agent/window/strategies/tokenBudget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenBudget.js","sourceRoot":"","sources":["../../../../../src/core/agent/window/strategies/tokenBudget.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;;;AAEH,uCAA2C;AAC3C,4CAA2D;AAC3D,8CAA0D;AAI1D,2EAA2E;AAC9D,QAAA,YAAY,GAAG,cAAc,CAAC;AAE3C;;;;;;;;;;;;GAYG;AACH,SAAgB,WAAW,CAAC,OAA2B;IACrD,MAAM,MAAM,GAAG,IAAA,sCAAyB,EAAC,OAAO,EAAE,aAAa,CAAC,CAAC;IAEjE,OAAO;QACL,IAAI,EAAE,oBAAY;QAElB,KAAK,CAAC,IAAI,CAAC,KAA0B;YACnC,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;YAE3B,mEAAmE;YACnE,IAAI,QAAQ,KAAK,SAAS;gBAAE,OAAO,SAAS,CAAC;YAC7C,0EAA0E;YAC1E,IAAI,QAAQ,CAAC,KAAK,KAAK,CAAC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAClD,MAAM,IAAI,uCAA2B,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAC5D,CAAC;YACD,IAAI,QAAQ,CAAC,KAAK,IAAI,MAAM,CAAC,eAAe;gBAAE,OAAO,SAAS,CAAC;YAE/D,MAAM,OAAO,GAAG,IAAA,wBAAc,EAAC,KAAK,EAAE,MAAM,CAAC,eAAe,EAAE,oBAAY,CAAC,CAAC;YAC5E,MAAM,MAAM,GAAsB;gBAChC,QAAQ,EAAE,oBAAY;gBACtB,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,cAAc,EAAE,QAAQ,CAAC,KAAK;gBAC9B,eAAe,EAAE,MAAM,CAAC,eAAe;gBACvC,UAAU,EAAE,IAAI;gBAChB,eAAe,EAAE,MAAM,CAAC,eAAe;gBACvC,eAAe,EAAE,OAAO,CAAC,eAAe;gBACxC,mBAAmB,EAAE,OAAO,CAAC,mBAAmB;gBAChD,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;gBAC5C,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;gBAC1C,QAAQ,EAAE,OAAO,CAAC,QAAQ;aAC3B,CAAC;YAEF,OAAO;gBACL,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;gBAC/D,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;gBAC/D,MAAM;gBACN,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,cAAc,EAAE;oBACd,SAAS,EAAE,MAAM,CAAC,eAAe;oBACjC,eAAe,EAAE,QAAQ,CAAC,KAAK;oBAC/B,UAAU,EAAE,OAAO,CAAC,mBAAmB,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM;iBAC/D;aACF,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AA7CD,kCA6CC"}

package/dist/core/agent/window/strategy.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * window/strategy — PUBLIC. How a window strategy is shaped.
+ *
+ * Pattern: Strategy (GoF), with the dangerous half of the decision handed in
+ *          pre-bound rather than left to the implementer to re-derive.
+ * Role:    core/ layer. The window stage does the wiring — read the meter,
+ *          write the window, emit, record, cost — and delegates the one
+ *          interesting question to a strategy:
+ *
+ *              given the segmented turns and what the provider actually
+ *              counted → what should the window become, and what does the
+ *              ledger need to be told about it?
+ *
+ * Emits:   N/A. A strategy is pure decision + (optionally) its own LLM call;
+ *          it never touches scope, never emits, and never writes. That is
+ *          what makes it testable without a chart, and what keeps the
+ *          "record everything you did" duty in ONE place (the stage) rather
+ *          than duplicated per strategy.
+ *
+ * Three strategies ship — `summarizeOldest` (what `.compaction()`
+ * configures), `slidingWindow`, `tokenBudget` — and `.window(...)` takes any
+ * object that satisfies `WindowStrategy`.
+ *
+ * Two things are deliberately NOT left to the implementer:
+ *
+ *   1. **The refusal rules.** `planRemoval` arrives already bound to this
+ *      iteration's turns and guards. A strategy cannot forget that an
+ *      unanswered tool call must not leave the window, because it never gets
+ *      the chance to decide that for itself — it asks, and it is told, with
+ *      every refusal named. That is safety by construction, not by docs.
+ *   2. **Provenance.** `removalFacts` turns "these indices left" into the
+ *      stage ids that wrote them and how long each lived. A strategy cannot
+ *      file a removal it cannot name.
+ *
+ * The TRIGGER, by contrast, is entirely the strategy's own: `plan` is called
+ * at every ReAct iteration boundary and answers `undefined` when it did not
+ * engage. That is why `slidingWindow` can run on a provider that reports no
+ * usage at all while `summarizeOldest` and `tokenBudget` refuse by name.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=strategy.js.map

package/dist/core/agent/window/strategy.js.map

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