@oh-my-pi/pi-agent-core 18.1.17 → 18.1.18

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [18.1.18] - 2026-09-11
+
+### Added
+
+- Anthropic server-side compaction as a `remote` compaction backend: model lines the beta supports (`compat.supportsServerCompaction`, rule-owned in the catalog: Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5) on the official endpoint, resolved the way the provider routes requests, plus Anthropic-compatible routes with `remoteCompaction.enabled`, compact by re-issuing the live turn's own request — same system prompt, tools, and history, so it reads the prompt cache the last turn wrote — with the `compact_20260112` edit paused after the summary and the harness summary prompt as `instructions`. The instructions name where the retained tail begins so the summary covers only the history the rebuilt context drops. The API's summary is stored as the entry text and as `preserveData.anthropicCompaction`, replayed natively on later Anthropic requests and read as plain text by every other provider; the retained tail comes from session entries as with a local summary. Contexts below 55k tokens (the API trigger floor plus margin) keep summarizing locally, and a response without a summary is a native failure, like the OpenAI lanes. An aborted compaction response is the abort (a cancellation, never a native failure) and an error response keeps its HTTP status, so auth and timeout classification match the OpenAI lanes; the block's opaque `encrypted_content` is persisted as `preserveData.anthropicCompaction.encryptedContent` and replayed verbatim.
+
+### Fixed
+
+- `compact()` now forwards the caller's `oneshotRetry` opt-out to every summarization oneshot; auto-compaction's outer retry loop no longer multiplies with the inner transient-failure retries.
+
 ## [18.1.17] - 2026-09-10
 
 ### Changed

package/dist/types/compaction/anthropic.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Anthropic server-side compaction (`compact-2026-01-12` beta).
+ *
+ * The compaction request is the live turn's own request shape — same system
+ * prompt, tools, and message history — plus the `compact_20260112` edit with
+ * `pause_after_compaction`. The API summarizes the prompt from the already
+ * cached prefix and stops; the summary arrives as a `compaction` block that
+ * the provider surfaces as an `anthropicCompaction` payload. The summary is
+ * plain text, so it doubles as the compaction entry's readable summary for
+ * every other provider, while the Anthropic provider replays it as a native
+ * block (the API drops everything that precedes it). The retained tail after
+ * the cut point is replayed from session entries exactly like a local summary.
+ */
+import type { AnthropicCompactionPayload, ApiKey, Effort, Message, Model, SimpleStreamOptions, Tool, Usage } from "@oh-my-pi/pi-ai";
+import { type InstrumentedChatSpanOptions } from "../telemetry.js";
+export declare const ANTHROPIC_COMPACTION_PRESERVE_KEY = "anthropicCompaction";
+/** The API rejects a `compact_20260112` trigger below this many input tokens. */
+export declare const ANTHROPIC_COMPACTION_MIN_TRIGGER_TOKENS = 50000;
+/**
+ * Smallest context the native lane accepts. The trigger sits at the API
+ * floor, so a prompt that lands below it is answered instead of compacted;
+ * the margin over the floor absorbs the difference between the last reported
+ * context size and the compaction request's own input.
+ */
+export declare const ANTHROPIC_COMPACTION_MIN_CONTEXT_TOKENS = 55000;
+/** Summary persisted under {@link ANTHROPIC_COMPACTION_PRESERVE_KEY}. */
+export interface AnthropicCompactionPreserveData {
+    provider: string;
+    content: string;
+    /** Opaque provider state the API attached to the block; replayed verbatim. */
+    encryptedContent?: string;
+    /** Harness file metadata (`<files>` section) replayed after the native block. */
+    filesText?: string;
+    /** Model that wrote the summary. */
+    model?: string;
+    /** Prompt tokens the compaction request processed, for display. */
+    usedTokens?: number;
+}
+/**
+ * Whether a model compacts through the Anthropic compaction beta. Model
+ * eligibility is catalog policy (`compat.supportsServerCompaction`, the
+ * lineage the beta documents); endpoint eligibility is resolved the way the
+ * provider routes requests, so a Foundry or `ANTHROPIC_BASE_URL` reroute of a
+ * first-party model is excluded unless the route opted in with
+ * `remoteCompaction.enabled`.
+ */
+export declare function shouldUseAnthropicNativeCompaction(model: Model): model is Model<"anthropic-messages">;
+export declare function getPreservedAnthropicCompactionData(preserveData: Record<string, unknown> | undefined): AnthropicCompactionPreserveData | undefined;
+/** Set or strip the Anthropic compaction slot; a new compaction never inherits a stale summary. */
+export declare function withAnthropicCompactionPreserveData(preserveData: Record<string, unknown> | undefined, compaction: AnthropicCompactionPreserveData | undefined): Record<string, unknown> | undefined;
+/** Replay payload for a compaction summary the active model produced natively. */
+export declare function getAnthropicCompactionPayload(preserveData: Record<string, unknown> | undefined): AnthropicCompactionPayload | undefined;
+/**
+ * The retained tail as the model will see it, for the summarization
+ * instructions: how many of the conversation's final wire messages stay in
+ * context verbatim, and the role of the first. The compaction request carries
+ * the whole conversation so the prompt cache the live turn wrote is read, but
+ * the summary must cover only the history before that tail — the local
+ * summarizer never sees the tail, and the rebuilt context replays it after the
+ * summary. Counting mirrors the provider's message conversion (consecutive
+ * tool results collapse into one user message; developer messages are user
+ * messages). Structured for the prompt template, which renders the
+ * singular/plural wording; the description quotes no content: quoting the
+ * tail would hand the summarizer the very facts it must leave to the tail.
+ */
+export interface RetainedTailScope {
+    count: number;
+    role: "assistant" | "user";
+}
+export declare function describeRetainedTail(messages: readonly Message[]): RetainedTailScope | undefined;
+/**
+ * Summarization prompt sent as the edit's `instructions`, which replace the
+ * API default entirely. The template lays out the retained-tail boundary
+ * first, so the summary covers only the history the rebuilt context drops,
+ * then the caller's extra context, the same structure prompt as the local
+ * summarizer, the caller's focus, and the tool-abstention clause the API
+ * recommends when tools are defined (a summarization pass that calls a tool
+ * yields no summary).
+ */
+export declare function buildAnthropicCompactionInstructions(basePrompt: string, customInstructions: string | undefined, extraContext: string | undefined, retainedTail: RetainedTailScope | undefined): string;
+export interface AnthropicNativeCompactionRequest {
+    systemPrompt: string[];
+    messages: Message[];
+    tools?: Tool[];
+    instructions: string;
+    maxTokens: number;
+    reasoning?: Effort;
+}
+export interface AnthropicNativeCompactionResponse {
+    content: string;
+    encryptedContent?: string;
+    usage: Usage;
+    model: string;
+}
+export interface AnthropicNativeCompactionOptions extends Pick<SimpleStreamOptions, "initiatorOverride" | "metadata" | "fetch" | "sessionId" | "promptCacheKey" | "providerSessionState" | "maxInFlightRequests">, Pick<InstrumentedChatSpanOptions, "completeImpl" | "telemetry" | "retry"> {
+}
+/**
+ * Run one compaction request and return the summary the API wrote, with the
+ * opaque `encrypted_content` the API attached for the replay. `completeSimple`
+ * resolves terminal failures as messages, so their classification is restored
+ * here: an aborted response is an `AbortError` (a cancellation, never a native
+ * failure) and an error response keeps its HTTP status, so auth and timeout
+ * handling downstream classify it the same way as the OpenAI lanes. A response
+ * without a summary is a native failure — the API answers the prompt instead
+ * when its input never reached the trigger, and returns an empty block when
+ * the model called a tool during summarization.
+ */
+export declare function requestAnthropicNativeCompaction(model: Model<"anthropic-messages">, apiKey: ApiKey, request: AnthropicNativeCompactionRequest, signal: AbortSignal | undefined, options: AnthropicNativeCompactionOptions): Promise<AnthropicNativeCompactionResponse>;

package/dist/types/compaction/compaction.d.ts

@@ -65,7 +65,11 @@ export declare const DEFAULT_RESERVE_TOKENS = 16384;
  */
 export declare const MAX_SUMMARY_TOKENS = 16384;
 export declare const DEFAULT_COMPACTION_SETTINGS: CompactionSettings;
-/** Whether a compaction candidate preserves provider-native transport under the effective settings. */
+/**
+ * Whether a compaction candidate preserves provider-native transport under the
+ * effective settings: an OpenAI Responses compact route (V1 or streamed V2) or
+ * the Anthropic compaction beta.
+ */
 export declare function shouldUseProviderNativeCompaction(model: Model, settings: Pick<CompactionSettings, "remoteEnabled" | "remoteStreamingV2Enabled">): boolean;
 /**
  * Calculate total context tokens from usage.
@@ -290,6 +294,8 @@ export interface CompactionPreparation {
     tokensBefore: number;
     /** Summary from previous compaction, for iterative update */
     previousSummary?: string;
+    /** ISO timestamp of the previous compaction entry, for iterative update */
+    previousSummaryTimestamp?: string;
     /** Preserved opaque compaction payload from the previous compaction, if any. */
     previousPreserveData?: Record<string, unknown>;
     /** File operations extracted from messagesToSummarize */

package/dist/types/compaction/index.d.ts

@@ -1,6 +1,7 @@
 /**
  * Compaction and summarization utilities.
  */
+export * from "./anthropic.js";
 export * from "./branch-summarization.js";
 export * from "./compaction.js";
 export * from "./entries.js";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "18.1.17",
+	"version": "18.1.18",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -35,16 +35,16 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.1.17",
-		"@oh-my-pi/pi-catalog": "18.1.17",
-		"@oh-my-pi/pi-natives": "18.1.17",
-		"@oh-my-pi/pi-utils": "18.1.17",
-		"@oh-my-pi/pi-wire": "18.1.17",
-		"@oh-my-pi/snapcompact": "18.1.17",
+		"@oh-my-pi/pi-ai": "18.1.18",
+		"@oh-my-pi/pi-catalog": "18.1.18",
+		"@oh-my-pi/pi-natives": "18.1.18",
+		"@oh-my-pi/pi-utils": "18.1.18",
+		"@oh-my-pi/pi-wire": "18.1.18",
+		"@oh-my-pi/snapcompact": "18.1.18",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {
-		"@oh-my-pi/omptype": "18.1.17",
+		"@oh-my-pi/omptype": "18.1.18",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.9.0",
 		"@types/bun": "^1.3.14"

package/src/compaction/anthropic.ts

@@ -0,0 +1,310 @@
+/**
+ * Anthropic server-side compaction (`compact-2026-01-12` beta).
+ *
+ * The compaction request is the live turn's own request shape — same system
+ * prompt, tools, and message history — plus the `compact_20260112` edit with
+ * `pause_after_compaction`. The API summarizes the prompt from the already
+ * cached prefix and stops; the summary arrives as a `compaction` block that
+ * the provider surfaces as an `anthropicCompaction` payload. The summary is
+ * plain text, so it doubles as the compaction entry's readable summary for
+ * every other provider, while the Anthropic provider replays it as a native
+ * block (the API drops everything that precedes it). The retained tail after
+ * the cut point is replayed from session entries exactly like a local summary.
+ */
+
+import type {
+	AnthropicCompactionPayload,
+	ApiKey,
+	AssistantMessage,
+	Effort,
+	Message,
+	Model,
+	SimpleStreamOptions,
+	Tool,
+	Usage,
+} from "@oh-my-pi/pi-ai";
+import * as AIError from "@oh-my-pi/pi-ai/error";
+import { supportsAnthropicCompaction } from "@oh-my-pi/pi-ai/providers/anthropic";
+import { isRecord, prompt } from "@oh-my-pi/pi-utils";
+import { type InstrumentedChatSpanOptions, instrumentedCompleteSimple } from "../telemetry";
+import anthropicCompactionInstructionsPrompt from "./prompts/anthropic-compaction-instructions.md" with { type: "text" };
+
+export const ANTHROPIC_COMPACTION_PRESERVE_KEY = "anthropicCompaction";
+
+/** The API rejects a `compact_20260112` trigger below this many input tokens. */
+export const ANTHROPIC_COMPACTION_MIN_TRIGGER_TOKENS = 50_000;
+
+/**
+ * Smallest context the native lane accepts. The trigger sits at the API
+ * floor, so a prompt that lands below it is answered instead of compacted;
+ * the margin over the floor absorbs the difference between the last reported
+ * context size and the compaction request's own input.
+ */
+export const ANTHROPIC_COMPACTION_MIN_CONTEXT_TOKENS = 55_000;
+
+/** Summary persisted under {@link ANTHROPIC_COMPACTION_PRESERVE_KEY}. */
+export interface AnthropicCompactionPreserveData {
+	provider: string;
+	content: string;
+	/** Opaque provider state the API attached to the block; replayed verbatim. */
+	encryptedContent?: string;
+	/** Harness file metadata (`<files>` section) replayed after the native block. */
+	filesText?: string;
+	/** Model that wrote the summary. */
+	model?: string;
+	/** Prompt tokens the compaction request processed, for display. */
+	usedTokens?: number;
+}
+
+function isAnthropicMessagesModel(model: Model): model is Model<"anthropic-messages"> {
+	return model.api === "anthropic-messages";
+}
+
+/**
+ * Whether a model compacts through the Anthropic compaction beta. Model
+ * eligibility is catalog policy (`compat.supportsServerCompaction`, the
+ * lineage the beta documents); endpoint eligibility is resolved the way the
+ * provider routes requests, so a Foundry or `ANTHROPIC_BASE_URL` reroute of a
+ * first-party model is excluded unless the route opted in with
+ * `remoteCompaction.enabled`.
+ */
+export function shouldUseAnthropicNativeCompaction(model: Model): model is Model<"anthropic-messages"> {
+	return isAnthropicMessagesModel(model) && supportsAnthropicCompaction(model);
+}
+
+export function getPreservedAnthropicCompactionData(
+	preserveData: Record<string, unknown> | undefined,
+): AnthropicCompactionPreserveData | undefined {
+	const candidate = preserveData?.[ANTHROPIC_COMPACTION_PRESERVE_KEY];
+	if (!isRecord(candidate)) return undefined;
+	if (typeof candidate.provider !== "string" || candidate.provider.length === 0) return undefined;
+	if (typeof candidate.content !== "string" || candidate.content.length === 0) return undefined;
+	return {
+		provider: candidate.provider,
+		content: candidate.content,
+		...(typeof candidate.encryptedContent === "string" && candidate.encryptedContent.length > 0
+			? { encryptedContent: candidate.encryptedContent }
+			: {}),
+		...(typeof candidate.filesText === "string" && candidate.filesText.length > 0
+			? { filesText: candidate.filesText }
+			: {}),
+		...(typeof candidate.model === "string" ? { model: candidate.model } : {}),
+		...(typeof candidate.usedTokens === "number" ? { usedTokens: candidate.usedTokens } : {}),
+	};
+}
+
+/** Set or strip the Anthropic compaction slot; a new compaction never inherits a stale summary. */
+export function withAnthropicCompactionPreserveData(
+	preserveData: Record<string, unknown> | undefined,
+	compaction: AnthropicCompactionPreserveData | undefined,
+): Record<string, unknown> | undefined {
+	if (compaction) {
+		return { ...preserveData, [ANTHROPIC_COMPACTION_PRESERVE_KEY]: compaction };
+	}
+	if (!preserveData || !(ANTHROPIC_COMPACTION_PRESERVE_KEY in preserveData)) {
+		return preserveData;
+	}
+	const { [ANTHROPIC_COMPACTION_PRESERVE_KEY]: _removed, ...rest } = preserveData;
+	return Object.keys(rest).length > 0 ? rest : undefined;
+}
+
+/** Replay payload for a compaction summary the active model produced natively. */
+export function getAnthropicCompactionPayload(
+	preserveData: Record<string, unknown> | undefined,
+): AnthropicCompactionPayload | undefined {
+	const preserved = getPreservedAnthropicCompactionData(preserveData);
+	if (!preserved) return undefined;
+	return {
+		type: "anthropicCompaction",
+		provider: preserved.provider,
+		content: preserved.content,
+		...(preserved.encryptedContent ? { encryptedContent: preserved.encryptedContent } : {}),
+		...(preserved.filesText ? { filesText: preserved.filesText } : {}),
+	};
+}
+
+/**
+ * The retained tail as the model will see it, for the summarization
+ * instructions: how many of the conversation's final wire messages stay in
+ * context verbatim, and the role of the first. The compaction request carries
+ * the whole conversation so the prompt cache the live turn wrote is read, but
+ * the summary must cover only the history before that tail — the local
+ * summarizer never sees the tail, and the rebuilt context replays it after the
+ * summary. Counting mirrors the provider's message conversion (consecutive
+ * tool results collapse into one user message; developer messages are user
+ * messages). Structured for the prompt template, which renders the
+ * singular/plural wording; the description quotes no content: quoting the
+ * tail would hand the summarizer the very facts it must leave to the tail.
+ */
+export interface RetainedTailScope {
+	count: number;
+	role: "assistant" | "user";
+}
+
+export function describeRetainedTail(messages: readonly Message[]): RetainedTailScope | undefined {
+	const first = messages[0];
+	if (!first) return undefined;
+	let count = 0;
+	let previousWasToolResult = false;
+	for (const message of messages) {
+		const isToolResult = message.role === "toolResult";
+		if (!(isToolResult && previousWasToolResult)) count += 1;
+		previousWasToolResult = isToolResult;
+	}
+	// Mirror the provider's trailing-assistant prefill: a tail ending in a
+	// live assistant turn gains a synthetic trailing user message on the
+	// wire, which stays verbatim too. Only blocks the converter emits count —
+	// blank text never serializes, and images, redacted thinking, and fallback
+	// markers need target context this scope lacks, so a turn of only those
+	// emits nothing and draws no pad. Without the pad in
+	// the scope, the summary could duplicate the tail head.
+	const last = messages[messages.length - 1];
+	if (last?.role === "assistant" && last.content.some(emitsWireBlock)) {
+		count += 1;
+	}
+	return { count, role: first.role === "assistant" ? "assistant" : "user" };
+}
+
+/**
+ * Whether an assistant content block reaches the wire. Server-tool blocks
+ * serialize unconditionally; blank text never does. Redacted thinking and
+ * fallback markers replay only for specific deployments, which the scope
+ * cannot see, so a turn of only those conservatively draws no pad.
+ */
+function emitsWireBlock(block: AssistantMessage["content"][number]): boolean {
+	switch (block.type) {
+		case "text":
+			return block.text.trim().length > 0;
+		case "toolCall":
+		case "anthropicServerTool":
+			return true;
+		case "thinking":
+			return block.thinking.trim().length > 0 || (block.thinkingSignature ?? "").trim().length > 0;
+		default:
+			return false;
+	}
+}
+
+/**
+ * Summarization prompt sent as the edit's `instructions`, which replace the
+ * API default entirely. The template lays out the retained-tail boundary
+ * first, so the summary covers only the history the rebuilt context drops,
+ * then the caller's extra context, the same structure prompt as the local
+ * summarizer, the caller's focus, and the tool-abstention clause the API
+ * recommends when tools are defined (a summarization pass that calls a tool
+ * yields no summary).
+ */
+export function buildAnthropicCompactionInstructions(
+	basePrompt: string,
+	customInstructions: string | undefined,
+	extraContext: string | undefined,
+	retainedTail: RetainedTailScope | undefined,
+): string {
+	return prompt.render(anthropicCompactionInstructionsPrompt, {
+		basePrompt,
+		customInstructions,
+		extraContext,
+		retainedTail,
+	});
+}
+
+export interface AnthropicNativeCompactionRequest {
+	systemPrompt: string[];
+	messages: Message[];
+	tools?: Tool[];
+	instructions: string;
+	maxTokens: number;
+	reasoning?: Effort;
+}
+
+export interface AnthropicNativeCompactionResponse {
+	content: string;
+	encryptedContent?: string;
+	usage: Usage;
+	model: string;
+}
+
+export interface AnthropicNativeCompactionOptions
+	extends
+		Pick<
+			SimpleStreamOptions,
+			| "initiatorOverride"
+			| "metadata"
+			| "fetch"
+			| "sessionId"
+			| "promptCacheKey"
+			| "providerSessionState"
+			| "maxInFlightRequests"
+		>,
+		Pick<InstrumentedChatSpanOptions, "completeImpl" | "telemetry" | "retry"> {}
+
+/**
+ * Run one compaction request and return the summary the API wrote, with the
+ * opaque `encrypted_content` the API attached for the replay. `completeSimple`
+ * resolves terminal failures as messages, so their classification is restored
+ * here: an aborted response is an `AbortError` (a cancellation, never a native
+ * failure) and an error response keeps its HTTP status, so auth and timeout
+ * handling downstream classify it the same way as the OpenAI lanes. A response
+ * without a summary is a native failure — the API answers the prompt instead
+ * when its input never reached the trigger, and returns an empty block when
+ * the model called a tool during summarization.
+ */
+export async function requestAnthropicNativeCompaction(
+	model: Model<"anthropic-messages">,
+	apiKey: ApiKey,
+	request: AnthropicNativeCompactionRequest,
+	signal: AbortSignal | undefined,
+	options: AnthropicNativeCompactionOptions,
+): Promise<AnthropicNativeCompactionResponse> {
+	const response = await instrumentedCompleteSimple(
+		model,
+		{ systemPrompt: request.systemPrompt, messages: request.messages, tools: request.tools },
+		{
+			apiKey,
+			signal,
+			maxTokens: request.maxTokens,
+			reasoning: request.reasoning,
+			initiatorOverride: options.initiatorOverride,
+			metadata: options.metadata,
+			fetch: options.fetch,
+			sessionId: options.sessionId,
+			promptCacheKey: options.promptCacheKey,
+			providerSessionState: options.providerSessionState,
+			maxInFlightRequests: options.maxInFlightRequests,
+			anthropicCompaction: {
+				triggerInputTokens: ANTHROPIC_COMPACTION_MIN_TRIGGER_TOKENS,
+				pauseAfterCompaction: true,
+				instructions: request.instructions,
+			},
+		},
+		{
+			telemetry: options.telemetry,
+			oneshotKind: "compaction_native",
+			completeImpl: options.completeImpl,
+			retry: options.retry,
+		},
+	);
+	if (response.stopReason === "aborted") {
+		throw new AIError.AbortError("Anthropic compaction aborted", { cause: signal?.reason });
+	}
+	if (response.stopReason === "error") {
+		const message = `Anthropic compaction failed: ${response.errorMessage ?? "unknown error"}`;
+		throw response.errorStatus === undefined
+			? new Error(message)
+			: new AIError.ProviderHttpError(message, response.errorStatus);
+	}
+	const payload = response.providerPayload;
+	if (payload?.type !== "anthropicCompaction" || payload.content.length === 0) {
+		throw new Error(
+			response.stopDetails?.type === "compaction"
+				? "Anthropic compaction returned no summary"
+				: "Anthropic compaction response carried no compaction block",
+		);
+	}
+	return {
+		content: payload.content,
+		encryptedContent: payload.encryptedContent,
+		usage: response.usage,
+		model: response.model,
+	};
+}

package/src/compaction/compaction.ts

@@ -42,6 +42,15 @@ import { type AgentTelemetry, instrumentedCompleteSimple } from "../telemetry";
 import { ThinkingLevel } from "../thinking";
 import { Tokenizer } from "../tokenizer";
 import type { AgentMessage } from "../types";
+import {
+	ANTHROPIC_COMPACTION_MIN_CONTEXT_TOKENS,
+	buildAnthropicCompactionInstructions,
+	describeRetainedTail,
+	getPreservedAnthropicCompactionData,
+	requestAnthropicNativeCompaction,
+	shouldUseAnthropicNativeCompaction,
+	withAnthropicCompactionPreserveData,
+} from "./anthropic";
 import {
 	buildCompactionV2Request,
 	buildCompactionV2RequestFromBody,
@@ -53,7 +62,13 @@ import {
 } from "./compaction-v2-streaming";
 import type { CompactionEntry, SessionEntry } from "./entries";
 import { NativeCompactionError } from "./errors";
-import { type ConvertToLlm, createBranchSummaryMessage, createCustomMessage, defaultConvertToLlm } from "./messages";
+import {
+	type ConvertToLlm,
+	createBranchSummaryMessage,
+	createCompactionSummaryMessage,
+	createCustomMessage,
+	defaultConvertToLlm,
+} from "./messages";
 import {
 	buildOpenAiNativeHistory,
 	getPreservedOpenAiRemoteCompactionData,
@@ -224,7 +239,11 @@ export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
 	v2RetainedMessageBudget: V2_RETAINED_MESSAGE_TOKEN_BUDGET,
 };
 
-/** Whether a compaction candidate preserves provider-native transport under the effective settings. */
+/**
+ * Whether a compaction candidate preserves provider-native transport under the
+ * effective settings: an OpenAI Responses compact route (V1 or streamed V2) or
+ * the Anthropic compaction beta.
+ */
 export function shouldUseProviderNativeCompaction(
 	model: Model,
 	settings: Pick<CompactionSettings, "remoteEnabled" | "remoteStreamingV2Enabled">,
@@ -232,7 +251,8 @@ export function shouldUseProviderNativeCompaction(
 	if (settings.remoteEnabled === false) return false;
 	return (
 		shouldUseOpenAiRemoteCompaction(model) ||
-		(settings.remoteStreamingV2Enabled !== false && shouldUseCompactionV2Streaming(model))
+		(settings.remoteStreamingV2Enabled !== false && shouldUseCompactionV2Streaming(model)) ||
+		shouldUseAnthropicNativeCompaction(model)
 	);
 }
 
@@ -1236,6 +1256,8 @@ export interface CompactionPreparation {
 	tokensBefore: number;
 	/** Summary from previous compaction, for iterative update */
 	previousSummary?: string;
+	/** ISO timestamp of the previous compaction entry, for iterative update */
+	previousSummaryTimestamp?: string;
 	/** Preserved opaque compaction payload from the previous compaction, if any. */
 	previousPreserveData?: Record<string, unknown>;
 	/** File operations extracted from messagesToSummarize */
@@ -1410,6 +1432,7 @@ export function prepareCompaction(
 		isSplitTurn: cutPoint.isSplitTurn,
 		tokensBefore,
 		previousSummary: previousCompaction?.summary,
+		previousSummaryTimestamp: previousCompaction?.timestamp,
 		previousPreserveData: previousCompaction?.preserveData,
 		fileOps,
 		settings,
@@ -1566,6 +1589,9 @@ export async function compact(
 		tools: options?.tools,
 		fetch: options?.fetch,
 		completeImpl: options?.completeImpl,
+		// The caller's opt-out must reach every summarization oneshot, otherwise
+		// an outer retry loop multiplies with the inner one (see SummaryOptions).
+		oneshotRetry: options?.oneshotRetry,
 	};
 
 	const previousSnapcompactArchive = snapcompact.getPreservedArchive(previousPreserveData);
@@ -1580,7 +1606,10 @@ export async function compact(
 		? createSnapcompactArchiveMigrationMessage(previousSnapcompactArchiveText)
 		: undefined;
 
-	let preserveData = withOpenAiRemoteCompactionPreserveData(previousPreserveData, undefined);
+	let preserveData = withAnthropicCompactionPreserveData(
+		withOpenAiRemoteCompactionPreserveData(previousPreserveData, undefined),
+		undefined,
+	);
 	const remoteMessages: AgentMessage[] = [
 		...(snapcompactArchiveMigrationMessage ? [snapcompactArchiveMigrationMessage] : []),
 		...messagesToSummarize,
@@ -1765,6 +1794,112 @@ export async function compact(
 		}
 	}
 
+	// Anthropic server-side compaction: the live turn's request shape plus the
+	// compact edit, so the API summarizes from its cached prefix. The summary is
+	// real text, persisted both as the entry summary and as the native replay
+	// payload. A context below the API's trigger floor cannot compact remotely
+	// and takes the local summarizer instead — an eligibility boundary, not a
+	// failure.
+	let nativeSummary: string | undefined;
+	let nativeEncryptedContent: string | undefined;
+	let nativeUsedTokens: number | undefined;
+	if (
+		!usedRemoteCompaction &&
+		settings.remoteEnabled !== false &&
+		shouldUseAnthropicNativeCompaction(model) &&
+		tokensBefore >= ANTHROPIC_COMPACTION_MIN_CONTEXT_TOKENS
+	) {
+		const previousNative = getPreservedAnthropicCompactionData(previousPreserveData);
+		// Lead with the previous summary exactly as the live context renders it:
+		// natively when this provider wrote it, as text otherwise. The request
+		// then shares the live turn's prefix byte-for-byte. A prior snapcompact
+		// archive is already merged into that summary text, so the archive
+		// migration message the OpenAI lanes carry is omitted here.
+		// The rewrite marker must precede every message this request replays —
+		// summarized history and retained tail alike — exactly like the live
+		// context rebuild predates its tail. A previous compaction's commit
+		// timestamp is newer than re-retained or re-summarized turns, so
+		// reusing it would strip their bound thinking only in this request,
+		// diverging from the cached live prefix (and possibly dropping below
+		// the trigger). Manually built preparations with no input at all fall
+		// back to the current time.
+		const firstReplayed = messagesToSummarize[0] ?? turnPrefixMessages[0] ?? recentMessages[0];
+		const previousSummaryAt =
+			firstReplayed !== undefined ? new Date(firstReplayed.timestamp - 1).toISOString() : new Date().toISOString();
+		const previousSummaryMessage = previousSummaryForCompaction
+			? createCompactionSummaryMessage(previousSummaryForCompaction, tokensBefore, previousSummaryAt, {
+					providerPayload:
+						previousNative?.provider === model.provider
+							? {
+									type: "anthropicCompaction",
+									provider: previousNative.provider,
+									content: previousNative.content,
+									...(previousNative.encryptedContent
+										? { encryptedContent: previousNative.encryptedContent }
+										: {}),
+									...(previousNative.filesText ? { filesText: previousNative.filesText } : {}),
+								}
+							: undefined,
+				})
+			: undefined;
+		const convertToLlm = summaryOptions.convertToLlm ?? defaultConvertToLlm;
+		const retainedTail = convertToLlm(recentMessages);
+		const messages = [
+			...convertToLlm([
+				...(previousSummaryMessage ? [previousSummaryMessage] : []),
+				...messagesToSummarize,
+				...turnPrefixMessages,
+			]),
+			...retainedTail,
+		];
+		try {
+			const remote = await requestAnthropicNativeCompaction(
+				model,
+				apiKey,
+				{
+					systemPrompt: summaryOptions.remoteSystemPrompt ?? [SUMMARIZATION_SYSTEM_PROMPT],
+					messages,
+					tools: summaryOptions.tools,
+					instructions: buildAnthropicCompactionInstructions(
+						summaryOptions.promptOverride ?? SUMMARIZATION_PROMPT,
+						customInstructions,
+						formatAdditionalContext(summaryOptions.extraContext).trim() || undefined,
+						describeRetainedTail(retainedTail),
+					),
+					maxTokens: Math.min(Math.floor(0.8 * reserveTokens), MAX_SUMMARY_TOKENS),
+					reasoning: resolveCompactionEffort(model, summaryOptions.thinkingLevel),
+				},
+				signal,
+				{
+					initiatorOverride: summaryOptions.initiatorOverride,
+					metadata: summaryOptions.metadata,
+					fetch: summaryOptions.fetch,
+					sessionId: summaryOptions.sessionId,
+					promptCacheKey: summaryOptions.promptCacheKey,
+					providerSessionState: summaryOptions.providerSessionState,
+					completeImpl: summaryOptions.completeImpl,
+					telemetry: summaryOptions.telemetry,
+					retry: summaryOneshotRetry(summaryOptions),
+				},
+			);
+			nativeSummary = remote.content;
+			nativeEncryptedContent = remote.encryptedContent;
+			nativeUsedTokens = calculatePromptTokens(remote.usage);
+			usedRemoteCompaction = true;
+		} catch (err) {
+			// A user/session abort is a cancellation, not a remote failure —
+			// swallowing it here would downgrade Esc into "fall back to local
+			// summarization" and keep compaction running on an aborted signal.
+			if (signal?.aborted) throw err;
+			nativeCompactionError = selectNativeCompactionError(nativeCompactionError, err);
+			logger.warn("Anthropic server-side compaction failed", {
+				error: err instanceof Error ? err.message : String(err),
+				model: model.id,
+				provider: model.provider,
+			});
+		}
+	}
+
 	if (!usedRemoteCompaction && nativeCompactionError !== undefined && !summaryOptions.remoteEndpoint) {
 		throw new NativeCompactionError(nativeCompactionError);
 	}
@@ -1772,7 +1907,11 @@ export async function compact(
 	// Generate summaries (can be parallel if both needed) and merge into one
 	let summary: string;
 
-	if (usedRemoteCompaction) {
+	if (nativeSummary !== undefined) {
+		// The API wrote a real summary; it is the entry text. The replayed
+		// block below stays verbatim so it matches the opaque state.
+		summary = nativeSummary;
+	} else if (usedRemoteCompaction) {
 		// Remote compaction (V2 or V1) already compacted remotely; the durable
 		// history lives in the provider replay payload (preserveData). Skip local
 		// summarization so a successful remote compaction never pays for a second,
@@ -1831,6 +1970,22 @@ export async function compact(
 	// Compute file lists and append to summary
 	const { readFiles, modifiedFiles } = computeFileLists(fileOps);
 	summary = upsertFileOperations(summary, readFiles, modifiedFiles, fileOps.read);
+	if (nativeSummary !== undefined) {
+		// The replayed block stays byte-identical to the API's summary so it
+		// matches `encryptedContent`. The harness file lists above travel
+		// separately: the converter replaces the summary message with the
+		// block and skips its text, so they would otherwise be invisible to
+		// this provider. Every other provider keeps reading the entry text.
+		const filesText = upsertFileOperations("", readFiles, modifiedFiles, fileOps.read) || undefined;
+		preserveData = withAnthropicCompactionPreserveData(preserveData, {
+			provider: model.provider,
+			content: nativeSummary,
+			...(nativeEncryptedContent ? { encryptedContent: nativeEncryptedContent } : {}),
+			...(filesText ? { filesText } : {}),
+			model: model.id,
+			usedTokens: nativeUsedTokens,
+		});
+	}
 
 	if (!firstKeptEntryId) {
 		throw new Error("First kept entry has no ID - session may need migration");

package/src/compaction/index.ts

@@ -2,6 +2,7 @@
  * Compaction and summarization utilities.
  */
 
+export * from "./anthropic";
 export * from "./branch-summarization";
 export * from "./compaction";
 export * from "./entries";

package/src/compaction/prompts/anthropic-compaction-instructions.md

@@ -0,0 +1,17 @@
+{{#if retainedTail}}
+SCOPE: The conversation's final {{#when retainedTail.count "==" 1}}{{retainedTail.role}} message stays{{else}}{{retainedTail.count}} messages, starting with a {{retainedTail.role}} message, stay{{/when}} in context verbatim after your summary. Summarize ONLY the history before those messages. You MUST NOT restate anything from those final messages — the reader sees them right after the summary — and you MUST treat them as the most recent state when describing progress and next steps.
+{{else}}
+SCOPE: The conversation above is the transcript to summarize. The API replaces everything before your summary with it, so nothing you leave out survives into the next context window.
+{{/if}}
+
+{{#if extraContext}}
+{{extraContext}}
+
+{{/if}}
+{{basePrompt}}
+{{#if customInstructions}}
+
+Additional focus: {{customInstructions}}
+{{/if}}
+
+You MUST NOT call any tools while writing the summary; respond with the summary text only.