@tanstack/ai-compaction 0.0.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,9 +1,155 @@
-# @tanstack/ai-compaction
+<div align="center">
+  <picture>
+    <source
+      media="(prefers-color-scheme: dark)"
+      srcset="https://tanstack.com/api/readme/ai.png?theme=dark"
+    />
+    <source
+      media="(prefers-color-scheme: light)"
+      srcset="https://tanstack.com/api/readme/ai.png"
+    />
+    <img
+      src="https://tanstack.com/api/readme/ai.png"
+      alt="TanStack AI"
+      width="900"
+    />
+  </picture>
+</div>
 
-## IMPORTANT NOTICE
+<br />
 
-This package is created solely for the purpose of setting up OIDC trusted publishing with npm.
+# @tanstack/ai-compaction
 
-This is NOT a functional package and contains NO code or functionality beyond the OIDC setup configuration.
+Context-window compaction as a `chat()` middleware. When the working message set
+grows past `maxTokens`, `withCompaction` runs a pluggable **strategy** that
+rewrites provider context. It runs before every model call, so compaction is
+incremental and rolling. The canonical transcript and system prompt stay
+unchanged.
 
-DO NOT USE THIS PACKAGE as a dependency.
+```bash
+npm install @tanstack/ai-compaction
+```
+
+## Quick start
+
+The default strategy (`evictOldest`) drops the oldest messages and keeps the
+recent ones.
+
+```ts
+import { chat } from '@tanstack/ai'
+import { withCompaction } from '@tanstack/ai-compaction'
+
+chat({
+  adapter,
+  messages,
+  middleware: [withCompaction({ maxTokens: 100_000 })],
+})
+```
+
+## Strategies
+
+Pass `strategy` to change how the history shrinks. Three are built in.
+
+| Strategy                | What it does                                            | Cost                |
+| ----------------------- | ------------------------------------------------------- | ------------------- |
+| `evictOldest` (default) | Drop the oldest messages, leave a marker                | No extra model call |
+| `summarizeOldest`       | Replace the oldest messages with an LLM summary         | One summarize call  |
+| `clearToolResults`      | Stub the content of old tool results, keep the messages | No extra model call |
+
+```ts
+import {
+  withCompaction,
+  evictOldest,
+  summarizeOldest,
+  clearToolResults,
+} from '@tanstack/ai-compaction'
+
+// Tune how much recent history to keep.
+withCompaction({
+  maxTokens: 100_000,
+  strategy: evictOldest({ keepRecentTokens: 40_000 }),
+})
+
+// Summarize instead of dropping. `summarize` gets the messages being removed.
+withCompaction({
+  maxTokens: 100_000,
+  strategy: summarizeOldest({ summarize: (msgs) => summarizeToText(msgs) }),
+})
+
+// Best for agent loops: stub old tool output, keep the messages in place.
+withCompaction({
+  maxTokens: 100_000,
+  strategy: clearToolResults({ keepRecentToolResults: 5 }),
+})
+```
+
+### Combine them
+
+`composeStrategies` runs strategies in order and escalates: it stops once the
+result is back under `maxTokens`. Put the cheap one first.
+
+```ts
+import {
+  withCompaction,
+  composeStrategies,
+  clearToolResults,
+  evictOldest,
+} from '@tanstack/ai-compaction'
+
+// Clear old tool output first; only drop old messages if that isn't enough.
+withCompaction({
+  maxTokens: 100_000,
+  strategy: composeStrategies(clearToolResults(), evictOldest()),
+})
+```
+
+### Write your own
+
+A strategy gets the messages and the budget, and returns the rewritten messages
+(or `null` to change nothing). It runs only when the estimate is over
+`maxTokens`.
+
+```ts
+import type { CompactionStrategy } from '@tanstack/ai-compaction'
+
+const keepLastOnly: CompactionStrategy = (messages) =>
+  messages.length <= 1 ? null : messages.slice(-1)
+
+withCompaction({
+  maxTokens: 100_000,
+  strategy: keepLastOnly,
+  strategyKey: 'keep-last-v1',
+})
+```
+
+## Options
+
+### `withCompaction`
+
+| Option           | Default         | What it does                                                                 |
+| ---------------- | --------------- | ---------------------------------------------------------------------------- |
+| `maxTokens`      | (required)      | Compact when estimated tokens exceed this.                                   |
+| `strategy`       | `evictOldest()` | How to shrink the messages.                                                  |
+| `estimateTokens` | chars / 4       | Per-message token estimate. Swap in a real tokenizer for accuracy.           |
+| `strategyKey`    | built-in key    | Stable checkpoint identity. Set it for custom strategies or estimators.      |
+| `onCompact`      | —               | Observe each compaction (`before`/`after`/`messagesBefore`/`messagesAfter`). |
+
+### Strategy options
+
+| Strategy           | Options                                                                         |
+| ------------------ | ------------------------------------------------------------------------------- |
+| `evictOldest`      | `keepRecentTokens` (default `maxTokens / 2`), `marker`                          |
+| `summarizeOldest`  | `summarize` (required), `keepRecentTokens`, `summaryRole` (default `assistant`) |
+| `clearToolResults` | `keepRecentToolResults` (default `3`), `stub`                                   |
+
+The token estimate is a rough `chars / 4` heuristic, good enough to trigger on,
+not exact. Pass `estimateTokens` if you need provider-accurate counts.
+
+When `withPersistence` provides a metadata store, compaction saves a validated
+checkpoint automatically. The next request reuses the compacted prefix and adds
+new canonical messages. Without metadata, compaction remains stateless.
+
+TanStack AI DevTools has a Compaction tab with started, state, and ended
+events, before/after counts, and dropped vs sent message previews. Those
+stats ride the chat stream as `compaction:started`, `compaction:state`, and
+`compaction:ended` CUSTOM events.

package/dist/esm/index.d.ts

@@ -0,0 +1,148 @@
+import { ChatMiddleware, ModelMessage } from '@tanstack/ai';
+/** CUSTOM stream event: compaction is about to run. */
+export declare const COMPACTION_STARTED_EVENT = "compaction:started";
+/** CUSTOM stream event: compaction result (counts and previews). */
+export declare const COMPACTION_STATE_EVENT = "compaction:state";
+/** CUSTOM stream event: compaction finished. */
+export declare const COMPACTION_ENDED_EVENT = "compaction:ended";
+export type CompactionStreamEventName = typeof COMPACTION_STARTED_EVENT | typeof COMPACTION_STATE_EVENT | typeof COMPACTION_ENDED_EVENT;
+/** One message in a `compaction:state` preview list. */
+export interface CompactionMessagePreview {
+    role: string;
+    tokens: number;
+    text: string;
+}
+/** Payload of {@link COMPACTION_STARTED_EVENT}. */
+export interface CompactionStartedEventValue {
+    before: number;
+    messagesBefore: number;
+    reusedCheckpoint: boolean;
+    maxTokens: number;
+    strategyKey?: string;
+}
+/** Payload of {@link COMPACTION_STATE_EVENT}. */
+export interface CompactionStateEventValue {
+    before: number;
+    after: number;
+    messagesBefore: number;
+    messagesAfter: number;
+    reusedCheckpoint: boolean;
+    maxTokens: number;
+    strategyKey?: string;
+    /** Messages removed or rewritten. */
+    dropped?: Array<CompactionMessagePreview>;
+    /** Messages the model will see after compaction. */
+    result?: Array<CompactionMessagePreview>;
+}
+/** Payload of {@link COMPACTION_ENDED_EVENT}. */
+export interface CompactionEndedEventValue {
+    after: number;
+    messagesAfter: number;
+    reusedCheckpoint: boolean;
+    maxTokens: number;
+    durationMs: number;
+    strategyKey?: string;
+}
+/** Rough token estimate for one message. Default: characters / 4. */
+export declare function estimateMessageTokens(message: ModelMessage): number;
+/** What a {@link CompactionStrategy} receives alongside the messages. */
+export interface CompactionContext {
+    /** The `maxTokens` budget from `withCompaction`. */
+    maxTokens: number;
+    /** The shared token estimator (default {@link estimateMessageTokens}). */
+    estimate: (message: ModelMessage) => number;
+}
+/**
+ * Shrinks a message list. Called only when the estimate is over budget.
+ * Return the rewritten messages, or `null` to leave them unchanged.
+ */
+export type CompactionStrategy = (messages: ReadonlyArray<ModelMessage>, ctx: CompactionContext) => Array<ModelMessage> | null | Promise<Array<ModelMessage> | null>;
+/** Reported to `onCompact` after each compaction event. */
+export interface CompactionInfo {
+    /** Estimated tokens before compaction. */
+    before: number;
+    /** Estimated tokens after compaction. */
+    after: number;
+    /** Message count before compaction. */
+    messagesBefore: number;
+    /** Message count after compaction (unchanged for {@link clearToolResults}). */
+    messagesAfter: number;
+}
+export interface CompactionOptions {
+    /** Compact when estimated tokens across `messages` exceed this. */
+    maxTokens: number;
+    /** How to shrink the messages. Default: {@link evictOldest}. */
+    strategy?: CompactionStrategy;
+    /** Per-message token estimator. Default: {@link estimateMessageTokens}. */
+    estimateTokens?: (message: ModelMessage) => number;
+    /**
+     * Stable identity for persisted checkpoints. Set this for custom strategies
+     * or estimators, and change it when their output can change.
+     */
+    strategyKey?: string;
+    /** Observe each compaction (logging, metrics). */
+    onCompact?: (info: CompactionInfo) => void;
+}
+/**
+ * Drop the oldest messages and replace them with a short marker. Cheapest
+ * strategy — no extra model call. This is the default.
+ */
+export declare function evictOldest(options?: {
+    /** Tokens of recent messages to keep verbatim. Default `floor(maxTokens/2)`. */
+    keepRecentTokens?: number;
+    /** Build the marker that replaces the dropped head. */
+    marker?: (droppedCount: number) => string;
+}): CompactionStrategy;
+/**
+ * Drop the oldest messages and replace them with an LLM summary. Keeps the gist
+ * of old turns at the cost of one summarization call. Wire `summarize` to
+ * `summarize()` or any model call.
+ */
+export declare function summarizeOldest(options: {
+    summarize: (messages: Array<ModelMessage>) => Promise<string>;
+    /** Tokens of recent messages to keep verbatim. Default `floor(maxTokens/2)`. */
+    keepRecentTokens?: number;
+    /** Role of the injected summary message. Default `'assistant'`. */
+    summaryRole?: 'user' | 'assistant';
+}): CompactionStrategy;
+/**
+ * Replace the content of old tool-result messages with a stub, keeping every
+ * message and its tool-call pairing in place. Best for agent loops where tool
+ * output (file reads, command output) dominates the token count — it clears the
+ * bulk without disturbing the conversation shape. No extra model call.
+ */
+export declare function clearToolResults(options?: {
+    /** Number of most-recent tool results to keep verbatim. Default `3`. */
+    keepRecentToolResults?: number;
+    /** Text that replaces a cleared tool result. */
+    stub?: string;
+}): CompactionStrategy;
+/**
+ * Run several strategies in order, escalating: stop as soon as the running
+ * estimate is back under `maxTokens`. Put the cheap, targeted strategy first
+ * (for example {@link clearToolResults}) and a broad fallback last (for example
+ * {@link evictOldest}) — the fallback only runs when clearing was not enough.
+ * A strategy that returns `null` (no change) is skipped and the next one runs.
+ *
+ * @example
+ * ```ts
+ * withCompaction({
+ *   maxTokens: 100_000,
+ *   strategy: composeStrategies(clearToolResults(), evictOldest()),
+ * })
+ * ```
+ */
+export declare function composeStrategies(...strategies: Array<CompactionStrategy>): CompactionStrategy;
+/**
+ * Context-compaction middleware. Add to `chat({ middleware: [...] })`.
+ *
+ * @example
+ * ```ts
+ * chat({
+ *   adapter,
+ *   messages,
+ *   middleware: [withCompaction({ maxTokens: 100_000 })], // evictOldest by default
+ * })
+ * ```
+ */
+export declare function withCompaction(options: CompactionOptions): ChatMiddleware;

package/dist/esm/index.js

@@ -0,0 +1,343 @@
+import { MetadataCapability, getMetadata } from "@tanstack/ai";
+//#region src/index.ts
+/**
+* `@tanstack/ai-compaction` — context-window compaction as a `chat()`
+* middleware. `withCompaction({ maxTokens, strategy })` runs before each model
+* call: when the working message set grows past `maxTokens`, the chosen
+* `CompactionStrategy` rewrites the messages. Because it runs every call,
+* compaction is incremental and rolling.
+*
+* Strategies are pluggable, mirroring `AgentLoopStrategy`. Three are built in:
+* {@link evictOldest}, {@link summarizeOldest}, and {@link clearToolResults}.
+* Write your own by passing any {@link CompactionStrategy}.
+*
+* The system prompt is never touched — `chat()` keeps it separate from
+* `messages`.
+*/
+/** CUSTOM stream event: compaction is about to run. */
+var COMPACTION_STARTED_EVENT = "compaction:started";
+/** CUSTOM stream event: compaction result (counts and previews). */
+var COMPACTION_STATE_EVENT = "compaction:state";
+/** CUSTOM stream event: compaction finished. */
+var COMPACTION_ENDED_EVENT = "compaction:ended";
+var PREVIEW_CHARS = 4e3;
+var MAX_PREVIEWS = 24;
+function emitCompactionStarted(ctx, value) {
+	ctx.emitCustomEvent(COMPACTION_STARTED_EVENT, value);
+}
+function emitCompactionState(ctx, value) {
+	ctx.emitCustomEvent(COMPACTION_STATE_EVENT, value);
+}
+function emitCompactionEnded(ctx, value) {
+	ctx.emitCustomEvent(COMPACTION_ENDED_EVENT, value);
+}
+var strategyKeys = /* @__PURE__ */ new WeakMap();
+var CHECKPOINT_NAMESPACE = "@tanstack/ai-compaction";
+function identifyStrategy(strategy, key) {
+	if (key) strategyKeys.set(strategy, key);
+	return strategy;
+}
+async function hashMessages(messages) {
+	const bytes = new TextEncoder().encode(JSON.stringify(messages));
+	const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function isModelMessage(value) {
+	return typeof value === "object" && value !== null && "role" in value && (value.role === "user" || value.role === "assistant" || value.role === "tool") && "content" in value;
+}
+function isCompactionCheckpoint(value) {
+	return typeof value === "object" && value !== null && "schemaVersion" in value && value.schemaVersion === 1 && "sourceMessageCount" in value && typeof value.sourceMessageCount === "number" && Number.isInteger(value.sourceMessageCount) && value.sourceMessageCount >= 0 && "sourceHash" in value && typeof value.sourceHash === "string" && "strategyKey" in value && typeof value.strategyKey === "string" && "compactedMessages" in value && Array.isArray(value.compactedMessages) && value.compactedMessages.every(isModelMessage);
+}
+function messagePreviewText(message) {
+	if (typeof message.content === "string") return message.content;
+	return JSON.stringify(message.content ?? "");
+}
+function toMessagePreview(message, estimate) {
+	const text = messagePreviewText(message);
+	return {
+		role: message.role,
+		tokens: estimate(message),
+		text: text.length > PREVIEW_CHARS ? `${text.slice(0, PREVIEW_CHARS)}…` : text
+	};
+}
+function previewList(messages, estimate) {
+	const mapped = messages.map((message) => toMessagePreview(message, estimate));
+	if (mapped.length <= MAX_PREVIEWS) return mapped;
+	return mapped.slice(0, MAX_PREVIEWS);
+}
+function droppedMessages(before, after) {
+	const afterKeys = new Set(after.map((message) => JSON.stringify(message)));
+	return before.filter((message) => !afterKeys.has(JSON.stringify(message)));
+}
+function compactionStateValue(args) {
+	const value = {
+		before: args.before,
+		after: args.after,
+		messagesBefore: args.messagesBefore,
+		messagesAfter: args.messagesAfter,
+		reusedCheckpoint: args.reusedCheckpoint,
+		maxTokens: args.maxTokens,
+		...args.strategyKey ? { strategyKey: args.strategyKey } : {}
+	};
+	if (args.afterMessages) value.result = previewList(args.afterMessages, args.estimate);
+	if (args.beforeMessages && args.afterMessages) value.dropped = previewList(droppedMessages(args.beforeMessages, args.afterMessages), args.estimate);
+	return value;
+}
+/** Rough token estimate for one message. Default: characters / 4. */
+function estimateMessageTokens(message) {
+	let text = messagePreviewText(message);
+	if (message.toolCalls?.length) text += JSON.stringify(message.toolCalls);
+	return Math.ceil(text.length / 4);
+}
+var sum = (messages, estimate) => messages.reduce((total, m) => total + estimate(m), 0);
+/**
+* Find the split point that keeps the most recent messages up to
+* `keepRecentTokens`, then moves the cut forward past any leading tool result
+* so the kept tail never starts with an orphan (its tool call would be dropped).
+* Returns the index where the tail begins (head is `messages[0..cut)`).
+*/
+function splitAtRecent(messages, estimate, keepRecentTokens) {
+	let kept = 0;
+	let cut = messages.length;
+	while (cut > 0) {
+		const prev = messages[cut - 1];
+		if (!prev) break;
+		const size = estimate(prev);
+		if (kept + size > keepRecentTokens) break;
+		kept += size;
+		cut--;
+	}
+	if (cut >= messages.length) cut = messages.length - 1;
+	while (cut < messages.length && messages[cut]?.role === "tool") cut++;
+	if (cut >= messages.length) {
+		cut = messages.length;
+		while (cut > 0 && messages[cut - 1]?.role === "tool") cut--;
+		if (cut > 0) cut--;
+	}
+	return cut;
+}
+/**
+* Drop the oldest messages and replace them with a short marker. Cheapest
+* strategy — no extra model call. This is the default.
+*/
+function evictOldest(options = {}) {
+	const strategy = (messages, ctx) => {
+		const keep = options.keepRecentTokens ?? Math.floor(ctx.maxTokens / 2);
+		const cut = splitAtRecent(messages, ctx.estimate, keep);
+		if (cut <= 0) return null;
+		return [{
+			role: "user",
+			content: options.marker?.(cut) ?? `[${cut} earlier message(s) omitted to save context.]`
+		}, ...messages.slice(cut)];
+	};
+	return identifyStrategy(strategy, options.marker ? void 0 : `evict-oldest:${options.keepRecentTokens ?? "half"}`);
+}
+/**
+* Drop the oldest messages and replace them with an LLM summary. Keeps the gist
+* of old turns at the cost of one summarization call. Wire `summarize` to
+* `summarize()` or any model call.
+*/
+function summarizeOldest(options) {
+	const strategy = async (messages, ctx) => {
+		const keep = options.keepRecentTokens ?? Math.floor(ctx.maxTokens / 2);
+		const cut = splitAtRecent(messages, ctx.estimate, keep);
+		if (cut <= 0) return null;
+		const summary = await options.summarize(messages.slice(0, cut));
+		return [{
+			role: options.summaryRole ?? "assistant",
+			content: `<untrusted-conversation-summary>\n${summary}\n</untrusted-conversation-summary>`
+		}, ...messages.slice(cut)];
+	};
+	return identifyStrategy(strategy, `summarize-oldest:${options.keepRecentTokens ?? "half"}:${options.summaryRole ?? "assistant"}`);
+}
+/**
+* Replace the content of old tool-result messages with a stub, keeping every
+* message and its tool-call pairing in place. Best for agent loops where tool
+* output (file reads, command output) dominates the token count — it clears the
+* bulk without disturbing the conversation shape. No extra model call.
+*/
+function clearToolResults(options = {}) {
+	const keepN = options.keepRecentToolResults ?? 3;
+	const stub = options.stub ?? "[tool output cleared to save context]";
+	const strategy = (messages) => {
+		const toolIndexes = [];
+		messages.forEach((m, i) => {
+			if (m.role === "tool") toolIndexes.push(i);
+		});
+		if (toolIndexes.length <= keepN) return null;
+		const clearBefore = toolIndexes[toolIndexes.length - keepN] ?? 0;
+		let changed = false;
+		const next = messages.map((m, i) => {
+			if (m.role === "tool" && i < clearBefore && m.content !== stub) {
+				changed = true;
+				return {
+					...m,
+					content: stub
+				};
+			}
+			return m;
+		});
+		return changed ? next : null;
+	};
+	return identifyStrategy(strategy, `clear-tool-results:${keepN}:${stub}`);
+}
+/**
+* Run several strategies in order, escalating: stop as soon as the running
+* estimate is back under `maxTokens`. Put the cheap, targeted strategy first
+* (for example {@link clearToolResults}) and a broad fallback last (for example
+* {@link evictOldest}) — the fallback only runs when clearing was not enough.
+* A strategy that returns `null` (no change) is skipped and the next one runs.
+*
+* @example
+* ```ts
+* withCompaction({
+*   maxTokens: 100_000,
+*   strategy: composeStrategies(clearToolResults(), evictOldest()),
+* })
+* ```
+*/
+function composeStrategies(...strategies) {
+	const strategy = async (messages, ctx) => {
+		let current = messages;
+		let result = null;
+		for (const itemStrategy of strategies) {
+			if (sum(current, ctx.estimate) <= ctx.maxTokens) break;
+			const out = await itemStrategy(current, ctx);
+			if (out) {
+				current = out;
+				result = out;
+			}
+		}
+		return result;
+	};
+	const keys = strategies.map((item) => strategyKeys.get(item));
+	return identifyStrategy(strategy, keys.every((key) => key !== void 0) ? keys.join("|") : void 0);
+}
+/**
+* Context-compaction middleware. Add to `chat({ middleware: [...] })`.
+*
+* @example
+* ```ts
+* chat({
+*   adapter,
+*   messages,
+*   middleware: [withCompaction({ maxTokens: 100_000 })], // evictOldest by default
+* })
+* ```
+*/
+function withCompaction(options) {
+	const estimate = options.estimateTokens ?? estimateMessageTokens;
+	const strategy = options.strategy ?? evictOldest();
+	const strategyKey = options.strategyKey ?? (options.estimateTokens ? void 0 : strategyKeys.get(strategy));
+	const checkpointStrategyKey = strategyKey ? `${strategyKey}:maxTokens=${options.maxTokens}` : void 0;
+	return {
+		name: "compaction",
+		optionalRequires: [MetadataCapability],
+		async onConfig(ctx, config) {
+			if (ctx.phase === "init") return;
+			const startedAt = Date.now();
+			const { messages } = config;
+			const inputMessages = config.providerMessages ?? messages;
+			const metadata = getMetadata(ctx, { optional: true });
+			let workingMessages = inputMessages;
+			let reusedCheckpoint = false;
+			if (metadata && checkpointStrategyKey && inputMessages === messages) {
+				const stored = await metadata.get(CHECKPOINT_NAMESPACE, ctx.threadId);
+				if (isCompactionCheckpoint(stored) && stored.strategyKey === checkpointStrategyKey && stored.sourceMessageCount <= messages.length && stored.sourceHash === await hashMessages(messages.slice(0, stored.sourceMessageCount))) {
+					workingMessages = [...stored.compactedMessages, ...messages.slice(stored.sourceMessageCount)];
+					reusedCheckpoint = true;
+				}
+			}
+			const before = sum(workingMessages, estimate);
+			const startedValue = {
+				before,
+				messagesBefore: workingMessages.length,
+				reusedCheckpoint,
+				maxTokens: options.maxTokens,
+				...checkpointStrategyKey ? { strategyKey: checkpointStrategyKey } : {}
+			};
+			if (before <= options.maxTokens) {
+				if (reusedCheckpoint) {
+					emitCompactionStarted(ctx, startedValue);
+					emitCompactionState(ctx, compactionStateValue({
+						before,
+						after: before,
+						messagesBefore: workingMessages.length,
+						messagesAfter: workingMessages.length,
+						reusedCheckpoint: true,
+						maxTokens: options.maxTokens,
+						strategyKey: checkpointStrategyKey,
+						afterMessages: workingMessages,
+						estimate
+					}));
+					emitCompactionEnded(ctx, {
+						after: before,
+						messagesAfter: workingMessages.length,
+						reusedCheckpoint: true,
+						maxTokens: options.maxTokens,
+						durationMs: Date.now() - startedAt,
+						...checkpointStrategyKey ? { strategyKey: checkpointStrategyKey } : {}
+					});
+					return { providerMessages: workingMessages };
+				}
+				return;
+			}
+			emitCompactionStarted(ctx, startedValue);
+			const next = await strategy(workingMessages, {
+				maxTokens: options.maxTokens,
+				estimate
+			});
+			if (!next || next === workingMessages) {
+				emitCompactionEnded(ctx, {
+					after: before,
+					messagesAfter: workingMessages.length,
+					reusedCheckpoint,
+					maxTokens: options.maxTokens,
+					durationMs: Date.now() - startedAt,
+					...checkpointStrategyKey ? { strategyKey: checkpointStrategyKey } : {}
+				});
+				if (reusedCheckpoint) return { providerMessages: workingMessages };
+				return;
+			}
+			const info = {
+				before,
+				after: sum(next, estimate),
+				messagesBefore: workingMessages.length,
+				messagesAfter: next.length
+			};
+			options.onCompact?.(info);
+			emitCompactionState(ctx, compactionStateValue({
+				...info,
+				reusedCheckpoint,
+				maxTokens: options.maxTokens,
+				strategyKey: checkpointStrategyKey,
+				beforeMessages: workingMessages,
+				afterMessages: next,
+				estimate
+			}));
+			emitCompactionEnded(ctx, {
+				after: info.after,
+				messagesAfter: info.messagesAfter,
+				reusedCheckpoint,
+				maxTokens: options.maxTokens,
+				durationMs: Date.now() - startedAt,
+				...checkpointStrategyKey ? { strategyKey: checkpointStrategyKey } : {}
+			});
+			if (metadata && checkpointStrategyKey && inputMessages === messages) {
+				const checkpoint = {
+					schemaVersion: 1,
+					sourceMessageCount: messages.length,
+					sourceHash: await hashMessages(messages),
+					strategyKey: checkpointStrategyKey,
+					compactedMessages: next
+				};
+				if (!ctx.signal?.aborted) await metadata.set(CHECKPOINT_NAMESPACE, ctx.threadId, checkpoint);
+			}
+			return { providerMessages: next };
+		}
+	};
+}
+//#endregion
+export { COMPACTION_ENDED_EVENT, COMPACTION_STARTED_EVENT, COMPACTION_STATE_EVENT, clearToolResults, composeStrategies, estimateMessageTokens, evictOldest, summarizeOldest, withCompaction };
+
+//# sourceMappingURL=index.js.map