@deepstrike/wasm 0.2.77 → 0.2.78

package/dist/memory/lifecycle.js

@@ -0,0 +1,46 @@
+export function memoryRecordExpired(record, nowMs) {
+    return record.ttl_days !== undefined && nowMs > record.updated_at + record.ttl_days * 86_400_000;
+}
+export function verifyMemoryLease(lease, agentId, scope, nowMs, budget) {
+    if (!lease)
+        return { valid: false, reason_code: "lease_missing" };
+    if (lease.agent_id !== agentId || lease.scope.tenant_id !== scope.tenant_id || lease.scope.namespace !== scope.namespace)
+        return { valid: false, reason_code: "lease_scope_mismatch" };
+    if (lease.revoked_at !== undefined && nowMs >= lease.revoked_at)
+        return { valid: false, reason_code: "lease_revoked" };
+    if (nowMs >= lease.expires_at)
+        return { valid: false, reason_code: "lease_expired" };
+    if ((budget?.writes_used ?? lease.writes_used) >= (budget?.max_writes ?? lease.max_writes))
+        return { valid: false, reason_code: "memory_write_budget_exhausted" };
+    return { valid: true };
+}
+export function consumeMemoryLeaseWrite(lease) { return { ...lease, writes_used: lease.writes_used + 1 }; }
+export function revokeMemoryLease(lease, revokedAt) { return { ...lease, revoked_at: revokedAt }; }
+export function scopeMatchesMemoryDeletion(record, scope) {
+    return (scope.tenant_id === undefined || record.scope.tenant_id === scope.tenant_id) && (scope.namespace === undefined || record.scope.namespace === scope.namespace);
+}
+export class InMemoryMemoryLifecycleController {
+    leases = new Map();
+    consumed = new Map();
+    deletedRecords = new Map();
+    journal = [];
+    issueLease(lease) { const old = this.leases.get(lease.lease_id); if (old && JSON.stringify(old) !== JSON.stringify(lease))
+        throw new Error("memory lease conflict"); if (old)
+        return structuredClone(old); this.leases.set(lease.lease_id, structuredClone(lease)); this.append("lease_issued", lease, undefined, lease.issued_at, { max_writes: lease.max_writes, expires_at: lease.expires_at }); return structuredClone(lease); }
+    getLease(agentId, scope) { const lease = [...this.leases.values()].find(item => item.agent_id === agentId && item.scope.tenant_id === scope.tenant_id && item.scope.namespace === scope.namespace); return lease ? structuredClone(lease) : undefined; }
+    renewLease(agentId, leaseId, expiresAt, renewedAt) { const lease = this.require(agentId, leaseId); if (expiresAt <= renewedAt || expiresAt < lease.expires_at)
+        throw new Error("invalid memory lease renewal"); const updated = { ...lease, expires_at: expiresAt }; this.leases.set(leaseId, updated); this.append("lease_renewed", updated, undefined, renewedAt, { expires_at: expiresAt }); return structuredClone(updated); }
+    consumeWrite(agentId, scope, operationId, nowMs) { const key = `${agentId}:${operationId}`; const prior = this.consumed.get(key); if (prior)
+        return structuredClone(prior); const lease = this.getLease(agentId, scope); const verdict = verifyMemoryLease(lease, agentId, scope, nowMs); if (!verdict.valid) {
+        this.consumed.set(key, verdict);
+        return structuredClone(verdict);
+    } const updated = consumeMemoryLeaseWrite(lease); this.leases.set(updated.lease_id, updated); const event = this.append("lease_write_consumed", updated, operationId, nowMs, { writes_used: updated.writes_used }); const result = { valid: true, lease: updated, event_id: event.event_id }; this.consumed.set(key, result); return structuredClone(result); }
+    revokeLease(agentId, leaseId, revokedAt) { const lease = this.require(agentId, leaseId); if (lease.revoked_at !== undefined)
+        return structuredClone(lease); const updated = revokeMemoryLease(lease, revokedAt); this.leases.set(leaseId, updated); this.append("lease_revoked", updated, undefined, revokedAt, { revoked_at: revokedAt }); return structuredClone(updated); }
+    deleteRecord(agentId, scope, recordId, deletionId, priorDigest) { const key = `${agentId}:${deletionId}`; const old = this.deletedRecords.get(key); if (old)
+        return structuredClone(old); const payload = { deletion_id: deletionId, record_id: recordId, ...(priorDigest ? { prior_digest: priorDigest } : {}) }; const lease = { lease_id: `deletion:${deletionId}`, agent_id: agentId, scope: structuredClone(scope), issued_at: 0, expires_at: 0, max_writes: 0, writes_used: 0 }; this.append("deletion_requested", lease, deletionId, Date.now(), payload); const event = this.append("deletion_applied", lease, deletionId, Date.now(), payload); const receipt = { deletion_id: deletionId, agent_id: agentId, scope: structuredClone(scope), record_id: recordId, ...(priorDigest ? { prior_digest: priorDigest } : {}), status: "applied", event_sequence: event.sequence }; this.deletedRecords.set(key, receipt); return structuredClone(receipt); }
+    events() { return structuredClone(this.journal); }
+    require(agentId, leaseId) { const lease = this.leases.get(leaseId); if (!lease || lease.agent_id !== agentId)
+        throw new Error("memory lease not found"); return lease; }
+    append(type, lease, operationId, occurredAt, payload) { const event = { event_id: `${type}:${lease.lease_id}:${operationId ?? this.journal.length}`, sequence: this.journal.length, type, agent_id: lease.agent_id, lease_id: lease.lease_id, scope: structuredClone(lease.scope), ...(operationId ? { operation_id: operationId } : {}), occurred_at: occurredAt, payload }; this.journal.push(event); return event; }
+}

package/dist/memory/recall-projection.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryQuery, MemoryRecall, MemoryRecord } from "./index.js";
+/** The answer to `memory(record_id)`: the record itself, or nothing when it is gone, expired,
+ *  outside the query's scope or not one of the kinds asked for. A fetch is a point read, so a
+ *  found record carries no ranking — the kernel refuses any record but the one it named. */
+export declare function memoryFetchRecall(record: MemoryRecord | null, query: Pick<MemoryQuery, "scope" | "kinds">, nowMs: number): MemoryRecall[];

package/dist/memory/recall-projection.js

@@ -0,0 +1,18 @@
+// M5 · the host half of reading one record in full. Recall itself is the kernel's: it queries for
+// the goal at run start and after each renewal and lands an index line per hit as keyed knowledge
+// `memory:<record_id>`. The model reads a record with `memory(record_id)`, answered here.
+import { memoryRecordExpired } from "./lifecycle.js";
+/** The answer to `memory(record_id)`: the record itself, or nothing when it is gone, expired,
+ *  outside the query's scope or not one of the kinds asked for. A fetch is a point read, so a
+ *  found record carries no ranking — the kernel refuses any record but the one it named. */
+export function memoryFetchRecall(record, query, nowMs) {
+    if (!record)
+        return [];
+    if (record.scope.tenant_id !== query.scope.tenant_id || record.scope.namespace !== query.scope.namespace)
+        return [];
+    if (query.kinds.length > 0 && !query.kinds.includes(record.kind))
+        return [];
+    if (memoryRecordExpired(record, nowMs))
+        return [];
+    return [{ record, score: 1, why: "record_id" }];
+}

package/dist/memory/runtime-policy.d.ts

@@ -0,0 +1,15 @@
+export type MemoryRetrievalPolicy = "disabled" | "host";
+export type MemoryWritePolicy = "disabled" | "candidate_sink";
+export interface MemoryRuntimePolicy {
+    retrieval: MemoryRetrievalPolicy;
+    modelWrites: MemoryWritePolicy;
+}
+export interface ResolvedMemoryRuntimePolicy {
+    retrievalEnabled: boolean;
+    modelWritesEnabled: boolean;
+    /** The path is on and its writes go to the candidate sink, not the memory store. */
+    modelWritesToCandidateSink: boolean;
+}
+/** Validate a host-supplied policy and project it onto runner gates. `undefined` keeps the
+ *  existing behavior: every memory path stays enabled. */
+export declare function resolveMemoryRuntimePolicy(policy: MemoryRuntimePolicy | undefined): ResolvedMemoryRuntimePolicy | undefined;

package/dist/memory/runtime-policy.js

@@ -0,0 +1,26 @@
+// Host-facing memory runtime policy (contract M1). Each capability is an independent switch: a
+// host can keep retrieval while turning off model-authored writes. `"disabled"` turns a path off;
+// `"candidate_sink"` keeps writes on but hands them to the host's `MemoryCandidateSink` (M2).
+const POLICY_FIELDS = ["retrieval", "modelWrites"];
+/** Validate a host-supplied policy and project it onto runner gates. `undefined` keeps the
+ *  existing behavior: every memory path stays enabled. */
+export function resolveMemoryRuntimePolicy(policy) {
+    if (policy === undefined)
+        return undefined;
+    const unknown = Object.keys(policy).filter(key => !POLICY_FIELDS.includes(key));
+    if (unknown.length > 0) {
+        throw new TypeError(`unknown memory runtime policy field(s): ${unknown.join(", ")}`);
+    }
+    for (const field of POLICY_FIELDS) {
+        const value = policy[field];
+        const allowed = field === "retrieval" ? ["disabled", "host"] : ["disabled", "candidate_sink"];
+        if (value === undefined || !allowed.includes(value)) {
+            throw new TypeError(`memory runtime policy ${field} must be one of ${allowed.join(" | ")}, got ${String(value)}`);
+        }
+    }
+    return {
+        retrievalEnabled: policy.retrieval !== "disabled",
+        modelWritesEnabled: policy.modelWrites !== "disabled",
+        modelWritesToCandidateSink: policy.modelWrites === "candidate_sink",
+    };
+}

package/dist/memory/writer.d.ts

@@ -0,0 +1,22 @@
+import type { MemoryCandidate, MemoryCandidateReceipt, MemoryCandidateSink } from "./candidate-sink.js";
+import type { MemoryRecord, MemoryStore } from "./index.js";
+export interface MemoryWriterOptions {
+    store?: MemoryStore;
+    sink?: MemoryCandidateSink;
+}
+/** What a direct write settles with: the record the store now holds and its content digest. */
+export interface MemoryPersistReceipt {
+    record_ref: string;
+    digest: string;
+}
+export declare class MemoryWriter {
+    private readonly opts;
+    constructor(opts: MemoryWriterOptions);
+    /** Write `record` to the store. Throws when there is no store. */
+    persist(agentId: string, record: MemoryRecord): Promise<MemoryPersistReceipt>;
+    /**
+     * Hand `candidate` to the sink and check its answer names this candidate (spec §2.3). A sink that
+     * throws has given no answer, and the same candidate may be redelivered.
+     */
+    propose(agentId: string, candidate: MemoryCandidate): Promise<MemoryCandidateReceipt>;
+}

package/dist/memory/writer.js

@@ -0,0 +1,41 @@
+// The host's side of a memory write, in one place. The runner decides which path a write takes
+// (the store, or the candidate sink for review); the writer decides what the write's answer
+// names: the stored record and its digest, or the sink's receipt under its contract.
+import { sha256Hex } from "../runtime/sha256.js";
+export class MemoryWriter {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Write `record` to the store. Throws when there is no store. */
+    async persist(agentId, record) {
+        if (!this.opts.store)
+            throw new Error("memory persistence requires RuntimeOptions.memoryStore");
+        await this.opts.store.put(agentId, record);
+        return { record_ref: record.record_id, digest: sha256Hex(record.content) };
+    }
+    /**
+     * Hand `candidate` to the sink and check its answer names this candidate (spec §2.3). A sink that
+     * throws has given no answer, and the same candidate may be redelivered.
+     */
+    async propose(agentId, candidate) {
+        const sink = this.opts.sink;
+        if (!sink)
+            throw new Error("memory candidate writes require RuntimeOptions.memoryCandidateSink");
+        const receipt = await sink.submit(agentId, candidate);
+        const candidateId = candidate.candidate_id;
+        if (receipt.candidate_id !== candidateId || typeof receipt.receipt_id !== "string" || !receipt.receipt_id) {
+            throw new Error(`memory candidate sink answered for ${String(receipt.candidate_id)} without a receipt for ${candidateId}`);
+        }
+        if (receipt.status === "accepted" && (typeof receipt.record_ref !== "string" || !receipt.record_ref || typeof receipt.digest !== "string" || !receipt.digest)) {
+            throw new Error("memory candidate sink accepted a write without record_ref/digest");
+        }
+        if (!["pending", "accepted", "rejected"].includes(receipt.status)) {
+            throw new Error(`memory candidate sink answered with unknown status ${String(receipt.status)}`);
+        }
+        if (receipt.status === "rejected" && (typeof receipt.reason_code !== "string" || !receipt.reason_code)) {
+            throw new Error("memory candidate sink rejected a write without reason_code");
+        }
+        return receipt;
+    }
+}

package/dist/providers/anthropic-compaction.d.ts

@@ -0,0 +1,84 @@
+export declare const THRESHOLD_COMPACTION_BETA = "compact-2026-01-12";
+export declare const ON_DEMAND_COMPACTION_BETA = "compact-2026-09-04";
+/** `compact_20260112` settings. Unset fields take the API defaults. */
+export interface AnthropicThresholdCompaction {
+    mode?: "threshold";
+    /** Input tokens at which the API summarizes earlier history (at least 50,000; API default 150,000). */
+    triggerInputTokens?: number;
+    /** A summarization prompt that replaces the API's default one. */
+    instructions?: string;
+    /** Stop after the summary is written, then continue with the newest history messages kept
+     *  verbatim behind it. Their thinking blocks are dropped: they were produced with the full
+     *  history in view and would fail the API's prefix check. */
+    pauseAfterCompaction?: {
+        keepRecentMessages: number;
+    };
+}
+/** On-demand compaction settings (`compact-2026-09-04`). */
+export interface AnthropicOnDemandCompaction {
+    mode: "on_demand";
+    /** Once a turn's input plus output reaches this many tokens, the provider asks for a summary of
+     *  that turn's history in the background and adopts it on the first request after it arrives. */
+    compactAtInputTokens: number;
+    /** A summarization prompt that replaces the API's default one (at most 16,384 characters). */
+    instructions?: string;
+    /** `max_tokens` for the summarization call; defaults to the turn's own. */
+    maxTokens?: number;
+}
+export type AnthropicCompaction = AnthropicThresholdCompaction | AnthropicOnDemandCompaction;
+export type ResolvedCompaction = {
+    mode: "threshold";
+    edit: Record<string, unknown>;
+    keepRecentMessages?: number;
+} | {
+    mode: "on_demand";
+    config: AnthropicOnDemandCompaction;
+};
+type WireMessage = Record<string, unknown>;
+type WireBlock = Record<string, unknown>;
+export declare function resolveCompaction(config: true | AnthropicCompaction): ResolvedCompaction;
+/** The request that continues a paused threshold compaction: the same edits without the pause. */
+export declare function withoutCompactionPause(params: Record<string, unknown>): Record<string, unknown>;
+export declare function compactionBlock(content: unknown): WireBlock | undefined;
+export interface CompactionResume {
+    /** The messages of the continuation request. */
+    messages: WireMessage[];
+    /** When recent turns were kept: the wire index of the assistant message the block now heads,
+     *  and that message's new content (the block, then its own blocks without thinking). */
+    anchor?: {
+        wireIndex: number;
+        content: WireBlock[];
+    };
+}
+/** How a paused threshold compaction continues. With `keepRecentMessages` the block heads the
+ *  nearest assistant message at or before the first kept history message, so the kept turns follow
+ *  the summary verbatim; without it (or when no assistant message qualifies) the block is
+ *  appended as an assistant turn of its own, as the API's pause flow does. `historyCount` is the
+ *  number of leading wire messages that are history (the volatile state turn follows them). */
+export declare function resumeAfterCompactionPause(messages: WireMessage[], historyCount: number, block: WireBlock, keepRecentMessages: number | undefined): CompactionResume;
+/** The compaction request a turn's request becomes: the same model, system, tools and thinking,
+ *  its history messages only, and none of the fields the API rejects on a summarization call. */
+export declare function onDemandCompactionBody(sent: Record<string, unknown>, historyCount: number, config: AnthropicOnDemandCompaction): Record<string, unknown>;
+/** Owns on-demand compaction for one provider: decides when to ask for a summary, runs the
+ *  request in the background, and swaps the block in for the messages it summarized. Adoptions
+ *  chain — a later summary covers the earlier block — and every request re-derives the swap from
+ *  the full history the kernel rendered, so a history the summary no longer matches (a renewal, a
+ *  changed system prompt or toolset) is sent whole and the stale adoptions are dropped. State is
+ *  in memory: after a restart the first turn past the limit compacts again. */
+export declare class OnDemandCompactor {
+    private readonly config;
+    private readonly send;
+    private adoptions;
+    private pending?;
+    constructor(config: AnthropicOnDemandCompaction, send: (body: Record<string, unknown>) => Promise<Record<string, unknown>>);
+    /** Swap the adopted summaries into a request's messages. Mutates `params`; returns whether a
+     *  block was swapped in (the request then needs the on-demand beta). */
+    apply(params: Record<string, unknown>): boolean;
+    /** After a turn completes: once its input plus output reaches the limit, summarize the history
+     *  that turn sent, unless a summary is already being written. Never throws; a summary that does
+     *  not come back leaves the history as it is, and the next turn past the limit asks again. */
+    observe(sent: Record<string, unknown>, historyCount: number, totalTokens: number): void;
+    /** Resolves once any summary in flight has settled. For tests and orderly shutdown. */
+    idle(): Promise<void>;
+}
+export {};

package/dist/providers/anthropic-compaction.js

@@ -0,0 +1,222 @@
+// Server-side compaction for the Anthropic provider, in its two forms. Threshold compaction
+// (`compact_20260112`) rides on every request and the API summarizes once input reaches the
+// trigger; with `pauseAfterCompaction` the API stops after writing the summary so the provider can
+// keep the newest turns verbatim behind it. On-demand compaction (`compact-2026-09-04`) is a
+// separate request the provider sends in the background once a turn's input passes a limit; the
+// signed block it returns replaces the messages it summarized on every later request. Either way
+// the kernel sees an ordinary turn: the provider owns the block, and the kernel's renewal still
+// decides on the full local history. Mirrors node/src/providers/anthropic-compaction.ts.
+export const THRESHOLD_COMPACTION_BETA = "compact-2026-01-12";
+export const ON_DEMAND_COMPACTION_BETA = "compact-2026-09-04";
+function positiveInteger(value, field) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError(`AnthropicProvider compaction.${field} must be a positive integer`);
+    }
+    return value;
+}
+export function resolveCompaction(config) {
+    const c = config === true ? {} : config;
+    if (c.mode === "on_demand") {
+        positiveInteger(c.compactAtInputTokens, "compactAtInputTokens");
+        if (c.maxTokens !== undefined)
+            positiveInteger(c.maxTokens, "maxTokens");
+        for (const field of ["triggerInputTokens", "pauseAfterCompaction"]) {
+            if (c[field] !== undefined) {
+                throw new TypeError(`AnthropicProvider compaction.${field} applies to threshold compaction, not on_demand`);
+            }
+        }
+        return { mode: "on_demand", config: c };
+    }
+    if (c.mode !== undefined && c.mode !== "threshold") {
+        throw new TypeError(`AnthropicProvider compaction.mode must be "threshold" or "on_demand", got ${String(c.mode)}`);
+    }
+    const keep = c.pauseAfterCompaction?.keepRecentMessages;
+    if (c.pauseAfterCompaction !== undefined && (typeof keep !== "number" || !Number.isSafeInteger(keep) || keep < 0)) {
+        throw new TypeError("AnthropicProvider compaction.pauseAfterCompaction.keepRecentMessages must be a non-negative integer");
+    }
+    return {
+        mode: "threshold",
+        edit: {
+            type: "compact_20260112",
+            ...(c.triggerInputTokens !== undefined ? { trigger: { type: "input_tokens", value: c.triggerInputTokens } } : {}),
+            ...(c.pauseAfterCompaction !== undefined ? { pause_after_compaction: true } : {}),
+            ...(c.instructions !== undefined ? { instructions: c.instructions } : {}),
+        },
+        ...(keep !== undefined ? { keepRecentMessages: keep } : {}),
+    };
+}
+/** The request that continues a paused threshold compaction: the same edits without the pause. */
+export function withoutCompactionPause(params) {
+    const management = params.context_management;
+    if (!Array.isArray(management?.edits))
+        return params;
+    return {
+        ...params,
+        context_management: {
+            ...management,
+            edits: management.edits.map(edit => {
+                if (edit?.type !== "compact_20260112")
+                    return edit;
+                const { pause_after_compaction: _pause, ...rest } = edit;
+                return rest;
+            }),
+        },
+    };
+}
+export function compactionBlock(content) {
+    return Array.isArray(content)
+        ? content.find(block => block?.type === "compaction")
+        : undefined;
+}
+function contentBlocks(message) {
+    const content = message.content;
+    if (typeof content === "string")
+        return content ? [{ type: "text", text: content }] : [];
+    return Array.isArray(content) ? content : [];
+}
+function withoutCacheControl(block) {
+    const { cache_control: _cache, ...rest } = block;
+    return rest;
+}
+/** How a paused threshold compaction continues. With `keepRecentMessages` the block heads the
+ *  nearest assistant message at or before the first kept history message, so the kept turns follow
+ *  the summary verbatim; without it (or when no assistant message qualifies) the block is
+ *  appended as an assistant turn of its own, as the API's pause flow does. `historyCount` is the
+ *  number of leading wire messages that are history (the volatile state turn follows them). */
+export function resumeAfterCompactionPause(messages, historyCount, block, keepRecentMessages) {
+    const keep = keepRecentMessages ?? 0;
+    if (keep > 0) {
+        const firstKept = historyCount - keep;
+        for (let index = Math.min(firstKept, historyCount - 1); index > 0; index--) {
+            if (messages[index]?.role !== "assistant")
+                continue;
+            const own = contentBlocks(messages[index])
+                .filter(item => item.type !== "thinking" && item.type !== "redacted_thinking")
+                .map(withoutCacheControl);
+            const content = [block, ...own];
+            return {
+                messages: [{ role: "assistant", content }, ...messages.slice(index + 1)],
+                anchor: { wireIndex: index, content },
+            };
+        }
+    }
+    return { messages: [...messages, { role: "assistant", content: [block] }] };
+}
+/** Wire values as the API compares them: `cache_control` is a request annotation, not content,
+ *  and a string message body is the same content as one text block (a cache marker turns the one
+ *  into the other). */
+function stableJson(value) {
+    return JSON.stringify(value, (key, item) => {
+        if (key === "cache_control")
+            return undefined;
+        if (item && typeof item === "object" && !Array.isArray(item)
+            && typeof item.role === "string" && typeof item.content === "string") {
+            return { ...item, content: contentBlocks(item) };
+        }
+        return item;
+    });
+}
+/** The compaction request a turn's request becomes: the same model, system, tools and thinking,
+ *  its history messages only, and none of the fields the API rejects on a summarization call. */
+export function onDemandCompactionBody(sent, historyCount, config) {
+    const { stream: _stream, context_management: _management, stop_sequences: _stop, ...body } = sent;
+    const choice = body.tool_choice;
+    if (choice?.type === "any" || choice?.type === "tool")
+        delete body.tool_choice;
+    const output = body.output_config;
+    if (output) {
+        const { format: _format, task_budget: budget, ...rest } = output;
+        const taskBudget = budget && typeof budget === "object"
+            ? (({ remaining: _remaining, ...kept }) => kept)(budget)
+            : undefined;
+        const next = { ...rest, ...(taskBudget ? { task_budget: taskBudget } : {}) };
+        if (Object.keys(next).length)
+            body.output_config = next;
+        else
+            delete body.output_config;
+    }
+    const betas = (Array.isArray(sent.betas) ? sent.betas : [])
+        .filter(beta => beta !== THRESHOLD_COMPACTION_BETA);
+    if (!betas.includes(ON_DEMAND_COMPACTION_BETA))
+        betas.push(ON_DEMAND_COMPACTION_BETA);
+    return {
+        ...body,
+        messages: sent.messages.slice(0, historyCount),
+        ...(config.maxTokens !== undefined ? { max_tokens: config.maxTokens } : {}),
+        compaction: {
+            type: "summarize",
+            ...(config.instructions?.trim() ? { instructions: config.instructions } : {}),
+        },
+        betas,
+    };
+}
+/** Owns on-demand compaction for one provider: decides when to ask for a summary, runs the
+ *  request in the background, and swaps the block in for the messages it summarized. Adoptions
+ *  chain — a later summary covers the earlier block — and every request re-derives the swap from
+ *  the full history the kernel rendered, so a history the summary no longer matches (a renewal, a
+ *  changed system prompt or toolset) is sent whole and the stale adoptions are dropped. State is
+ *  in memory: after a restart the first turn past the limit compacts again. */
+export class OnDemandCompactor {
+    config;
+    send;
+    adoptions = [];
+    pending;
+    constructor(config, send) {
+        this.config = config;
+        this.send = send;
+    }
+    /** Swap the adopted summaries into a request's messages. Mutates `params`; returns whether a
+     *  block was swapped in (the request then needs the on-demand beta). */
+    apply(params) {
+        if (this.pending?.settled !== undefined) {
+            if (this.pending.settled)
+                this.adoptions.push(this.pending.settled);
+            this.pending = undefined;
+        }
+        if (!this.adoptions.length)
+            return false;
+        const frame = stableJson([params.system ?? null, params.tools ?? null]);
+        let messages = params.messages;
+        let applied = 0;
+        for (const adoption of this.adoptions) {
+            if (adoption.frame !== frame || adoption.summarized.length > messages.length)
+                break;
+            const matches = adoption.summarized.every((digest, index) => stableJson(messages[index]) === digest);
+            if (!matches)
+                break;
+            messages = [adoption.message, ...messages.slice(adoption.summarized.length)];
+            applied++;
+        }
+        this.adoptions.length = applied;
+        if (!applied)
+            return false;
+        params.messages = messages;
+        const betas = Array.isArray(params.betas) ? [...params.betas] : [];
+        if (!betas.includes(ON_DEMAND_COMPACTION_BETA))
+            betas.push(ON_DEMAND_COMPACTION_BETA);
+        params.betas = betas;
+        return true;
+    }
+    /** After a turn completes: once its input plus output reaches the limit, summarize the history
+     *  that turn sent, unless a summary is already being written. Never throws; a summary that does
+     *  not come back leaves the history as it is, and the next turn past the limit asks again. */
+    observe(sent, historyCount, totalTokens) {
+        if (this.pending || totalTokens < this.config.compactAtInputTokens || historyCount <= 0)
+            return;
+        const body = onDemandCompactionBody(sent, historyCount, this.config);
+        const summarized = body.messages.map(stableJson);
+        const frame = stableJson([body.system ?? null, body.tools ?? null]);
+        const pending = { done: Promise.resolve() };
+        pending.done = this.send(body).then(raw => {
+            const block = raw.stop_reason === "compaction" ? compactionBlock(raw.content) : undefined;
+            pending.settled = block ? { summarized, frame, message: { role: "assistant", content: [block] } } : null;
+        }, () => {
+            pending.settled = null;
+        });
+        this.pending = pending;
+    }
+    /** Resolves once any summary in flight has settled. For tests and orderly shutdown. */
+    async idle() {
+        await this.pending?.done;
+    }
+}

package/dist/providers/anthropic.d.ts

@@ -1,11 +1,44 @@
 import type { PreparedProviderRequest, ProviderRunState } from "../types.js";
 import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, ModelMessage, ProviderDescriptor, ProviderReplay } from "../types.js";
+import { type AnthropicCompaction } from "./anthropic-compaction.js";
+export type { AnthropicCompaction, AnthropicOnDemandCompaction, AnthropicThresholdCompaction, } from "./anthropic-compaction.js";
+/** `clear_tool_uses_20250919` settings. Unset fields take the API defaults. */
+export interface AnthropicContextEditing {
+    /** Input tokens above which clearing starts. */
+    triggerInputTokens?: number;
+    /** Most recent tool uses kept intact. */
+    keepToolUses?: number;
+    /** Skip a clearing that would remove fewer tokens than this — each clearing rewrites the cached prefix. */
+    clearAtLeastInputTokens?: number;
+    /** Tools whose uses and results are never cleared. */
+    excludeTools?: string[];
+    /** Also clear the tool-call inputs, not only the results. */
+    clearToolInputs?: boolean;
+}
+export interface AnthropicProviderOptions {
+    /** Clear old tool results server-side (context editing). The provider then declares the tier
+     *  native and the kernel stops clearing tool results itself; `true` takes the API defaults. */
+    contextEditing?: true | AnthropicContextEditing;
+    /** Summarize earlier history server-side: at a threshold on every request (`compact_20260112`,
+     *  the default mode), or on demand once a turn passes a limit (`compact-2026-09-04`, `mode:
+     *  "on_demand"`). The provider then declares compaction native and the kernel stops compacting
+     *  itself; its renewal stays the safety net, so set the trigger below the kernel's renewal
+     *  threshold. */
+    compaction?: true | AnthropicCompaction;
+}
 export declare class AnthropicProvider implements LLMProvider {
     private readonly apiKey;
     private readonly model;
     private readonly maxTokens;
     private nativeAssistantBlocks;
-    constructor(apiKey: string, model?: string, maxTokens?: number);
+    /** Server-side context edits and the beta each needs. */
+    private readonly nativeContextEdits;
+    /** Threshold compaction with a pause: how many history messages stay verbatim behind the block. */
+    private readonly compactionPauseKeep?;
+    private readonly onDemandCompactor?;
+    constructor(apiKey: string, model?: string, maxTokens?: number, options?: AnthropicProviderOptions);
+    /** On-demand compaction in flight settles; for tests and orderly shutdown. */
+    compactionIdle(): Promise<void>;
     descriptor(): ProviderDescriptor;
     requestPlanIdentity(): {
         providerId: string;
@@ -20,6 +53,13 @@ export declare class AnthropicProvider implements LLMProvider {
     seedProviderReplay(message: Pick<ModelMessage, "content" | "toolCalls">, replay: ProviderReplay): void;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ModelMessage>;
     prepareRequest(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): PreparedProviderRequest;
+    /** One turn: the response's events, or — when a compaction pause stops the response at the
+     *  summary — the continuation's. With a pause configured, events are held until the response
+     *  shows it is not a pause (any non-usage event) or ends. */
+    private streamTurn;
+    private headers;
+    /** A non-streaming request; the on-demand compaction request goes this way. */
+    private createMessage;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
     private streamBody;
     private rememberNativeBlocks;