@linxiraos/pi-agent-core 1.1.20 → 1.1.23

package/src/agent.ts

@@ -34,11 +34,19 @@ import {
 	normalizeMessagesForProvider,
 	normalizeTools,
 	resolveOwnedDialectFromEnv,
+	steeringQueueState,
 	unpairedToolCallTail,
 } from "./agent-loop";
 import type { AppendOnlyContextManager } from "./append-only-context";
 import { isProviderRefusalMessage } from "./replay-policy";
+import { SentToolDefinitions } from "./sent-tool-definitions";
 import { Tokenizer, tokenizerEncodingForModel } from "./tokenizer";
+import {
+	createAdditionalContextMessage,
+	joinAdditionalContext,
+	TOOL_RESULT_ADDITIONAL_CONTEXT,
+	type ToolResultWithAdditionalContext,
+} from "./tool-context";
 import type {
 	AgentBeforeModelCall,
 	AgentContext,
@@ -65,7 +73,7 @@ import { EventLoopKeepalive } from "./utils/yield";
 function defaultConvertToLlm(messages: AgentMessage[]): Message[] {
 	return messages.filter((m): m is Message => {
 		if (m.role === "assistant") return !isProviderRefusalMessage(m);
-		return m.role === "user" || m.role === "toolResult";
+		return m.role === "user" || m.role === "developer" || m.role === "toolResult";
 	});
 }
 
@@ -271,6 +279,11 @@ export interface AgentOptions {
 	pruneToolDescriptions?: boolean;
 	/** Owned tool-calling dialect. Undefined keeps provider-native tool calling. */
 	dialect?: Dialect;
+	/**
+	 * Per-request owned-dialect resolver, consulted with the model being requested.
+	 * Authoritative when set (like {@link serviceTierResolver}): replaces {@link dialect}.
+	 */
+	dialectResolver?: (model: Model) => Dialect | undefined;
 	/**
 	 * When owned tool calling is active and the model fabricates a tool result
 	 * mid-turn: `true` (default) aborts the provider request immediately; `false`
@@ -333,6 +346,8 @@ export interface AgentOptions {
 	 * tool-call arguments). See {@link AgentLoopConfig.transformAssistantMessage}.
 	 */
 	transformAssistantMessage?: AgentLoopConfig["transformAssistantMessage"];
+	/** See {@link AgentLoopConfig.transformAssistantMessagePreservesToolCalls}. */
+	transformAssistantMessagePreservesToolCalls?: boolean;
 
 	/**
 	 * Opt-in OpenTelemetry instrumentation. Passing `{}` enables the loop's
@@ -361,6 +376,12 @@ interface CursorToolResultEntry {
 	 * `message_end` lands in the same chunk as the tool result.
 	 */
 	pending?: Promise<void>;
+	/**
+	 * Passive context the executor attached via
+	 * {@link TOOL_RESULT_ADDITIONAL_CONTEXT}, captured before any transformer
+	 * can replace the message. Injected after the buffered results.
+	 */
+	additionalContext?: string;
 }
 
 type QueuedMessageQueue = "steering" | "followUp";
@@ -389,9 +410,18 @@ export class Agent {
 	#convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
 	#transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
 	#transformProviderContext?: (context: Context, model: Model) => Context | Promise<Context>;
+	#sentToolDefinitions = new SentToolDefinitions();
 	#steeringQueue: AgentMessage[] = [];
 	#followUpQueue: AgentMessage[] = [];
 	#queuedMessageClaims: Partial<Record<QueuedMessageQueue, QueuedMessageClaim>> = {};
+	/**
+	 * Steering live steering took for the in-flight response (`onLiveSteeringTaken`) that the
+	 * transcript has not recorded yet, whether or not the provider accepted it. Kept apart from
+	 * {@link #queuedMessageDeliveries}: the loop drops it on abort instead of recording it, so queue
+	 * replacement must not drop it too; the run's end requeues whatever it did not record, and
+	 * {@link withdrawLiveSteering} takes it back ahead of an abort.
+	 */
+	#liveSteered: { message: AgentMessage; controller: AbortController | undefined }[] = [];
 	/** Dequeued originals remain recoverable until their transcript events arrive. */
 	#queuedMessageDeliveries = new Set<{
 		queue: QueuedMessageQueue;
@@ -439,6 +469,7 @@ export class Agent {
 	#intentTracing: boolean;
 	#pruneToolDescriptions: boolean;
 	#dialect?: Dialect;
+	#dialectResolver?: (model: Model) => Dialect | undefined;
 	#abortOnFabricatedToolResult?: boolean;
 	#getToolChoice?: () => ToolChoiceDirective | undefined;
 	#onToolChoiceUnavailable?: () => void;
@@ -482,10 +513,17 @@ export class Agent {
 	 * UI emission, and tool dispatch. Reassign at any time to swap the implementation.
 	 */
 	transformAssistantMessage?: AgentLoopConfig["transformAssistantMessage"];
+	/** Declares {@link transformAssistantMessage} never rewrites streamed tool calls; reassign alongside it. */
+	transformAssistantMessagePreservesToolCalls?: boolean;
 	/**
 	 * Hook that peeks whether interrupting IRC asides are queued for the next boundary.
 	 */
 	hasIrcInterrupts?: AgentLoopConfig["hasIrcInterrupts"];
+	/**
+	 * Hook that peeks whether background completions (jobs, supervised processes)
+	 * are queued for the next boundary.
+	 */
+	hasBackgroundCompletions?: AgentLoopConfig["hasBackgroundCompletions"];
 
 	constructor(opts: AgentOptions = {}) {
 		this.#state = { ...this.#state, ...opts.initialState };
@@ -533,6 +571,7 @@ export class Agent {
 		this.#intentTracing = opts.intentTracing === true;
 		this.#pruneToolDescriptions = opts.pruneToolDescriptions === true;
 		this.#dialect = opts.dialect;
+		this.#dialectResolver = opts.dialectResolver;
 		this.#abortOnFabricatedToolResult = opts.abortOnFabricatedToolResult;
 		this.#getToolChoice = opts.getToolChoice;
 		this.#onToolChoiceUnavailable = opts.onToolChoiceUnavailable;
@@ -541,6 +580,7 @@ export class Agent {
 		this.beforeToolCall = opts.beforeToolCall;
 		this.afterToolCall = opts.afterToolCall;
 		this.transformAssistantMessage = opts.transformAssistantMessage;
+		this.transformAssistantMessagePreservesToolCalls = opts.transformAssistantMessagePreservesToolCalls;
 		this.#telemetry = opts.telemetry;
 		this.#appendOnlyContext = opts.appendOnlyContext;
 		this.#transformProviderContext = opts.transformProviderContext;
@@ -742,6 +782,33 @@ export class Agent {
 		this.#hideThinkingSummary = value;
 	}
 
+	/** Strip tool descriptions from provider-bound specs; read per request. */
+	get pruneToolDescriptions(): boolean {
+		return this.#pruneToolDescriptions;
+	}
+
+	set pruneToolDescriptions(value: boolean) {
+		this.#pruneToolDescriptions = value;
+	}
+
+	/** Inject/strip the intent field on tool calls; applies from the next prompt run. */
+	get intentTracing(): boolean {
+		return this.#intentTracing;
+	}
+
+	set intentTracing(value: boolean) {
+		this.#intentTracing = value;
+	}
+
+	/** Abort the provider request on a fabricated tool result; applies from the next prompt run. */
+	get abortOnFabricatedToolResult(): boolean | undefined {
+		return this.#abortOnFabricatedToolResult;
+	}
+
+	set abortOnFabricatedToolResult(value: boolean | undefined) {
+		this.#abortOnFabricatedToolResult = value;
+	}
+
 	/**
 	 * Get the current max retry delay in milliseconds.
 	 */
@@ -822,7 +889,9 @@ export class Agent {
 	): Promise<Context> {
 		const model = this.#state.model;
 		if (!model) throw new Error("No active model on agent");
-		const ownedDialect = this.#dialect ?? resolveOwnedDialectFromEnv(Bun.env.PI_DIALECT);
+		const ownedDialect =
+			(this.#dialectResolver ? this.#dialectResolver(model) : this.#dialect) ??
+			resolveOwnedDialectFromEnv(Bun.env.PI_DIALECT);
 		const messages = normalizeMessagesForProvider(llmMessages, model);
 		const tools = ownedDialect
 			? []
@@ -832,6 +901,11 @@ export class Agent {
 				}) ?? []);
 		let context: Context = { systemPrompt, messages, tools };
 		if (this.#transformProviderContext) context = await this.#transformProviderContext(context, model);
+		// Side requests reuse the main loop's sent definitions without recording their own.
+		if (context.tools?.length) {
+			const inactiveTools = this.#sentToolDefinitions.inactiveFor(context.messages, context.tools);
+			if (inactiveTools) context = { ...context, inactiveTools };
+		}
 		return context;
 	}
 
@@ -932,8 +1006,14 @@ export class Agent {
 	}
 
 	#restoreUndeliveredQueuedMessages(controller: AbortController): void {
-		if (this.#queuedMessageDeliveries.size === 0) return;
+		if (this.#queuedMessageDeliveries.size === 0 && this.#liveSteered.length === 0) return;
 		const restored: Record<QueuedMessageQueue, AgentMessage[]> = { steering: [], followUp: [] };
+		// Live steering was taken before anything the run still holds undelivered.
+		this.#liveSteered = this.#liveSteered.filter(entry => {
+			if (entry.controller !== controller) return true;
+			restored.steering.push(entry.message);
+			return false;
+		});
 		for (const delivery of this.#queuedMessageDeliveries) {
 			if (delivery.controller !== controller) continue;
 			this.#queuedMessageDeliveries.delete(delivery);
@@ -948,6 +1028,40 @@ export class Agent {
 		if (restored.followUp.length > 0) this.#followUpQueue = [...restored.followUp, ...this.#followUpQueue];
 	}
 
+	/** Move steering live steering took out of the queue-delivery records into {@link #liveSteered}. */
+	#adoptLiveSteering(taken: readonly AgentMessage[]): void {
+		for (const delivery of this.#queuedMessageDeliveries) {
+			const pending = delivery.messages.slice(delivery.next);
+			const kept = pending.filter(message => !taken.includes(message));
+			if (kept.length === pending.length) continue;
+			for (const message of pending) {
+				if (taken.includes(message)) this.#liveSteered.push({ message, controller: delivery.controller });
+			}
+			if (kept.length === 0) {
+				this.#queuedMessageDeliveries.delete(delivery);
+			} else {
+				delivery.messages = kept;
+				delivery.next = 0;
+			}
+		}
+	}
+
+	/**
+	 * Take back live-steered messages ahead of an abort (Esc restores them to the editor):
+	 * the aborted run then neither records nor requeues them.
+	 */
+	withdrawLiveSteering(): AgentMessage[] {
+		const messages = this.peekLiveSteeredMessages();
+		this.#liveSteered = [];
+		return messages;
+	}
+
+	/** Steering live steering took for the streaming response; the transcript records it once
+	 *  that response (or its tool batch) ends, which is when the model switches to it. */
+	peekLiveSteeredMessages(): AgentMessage[] {
+		return this.#liveSteered.map(entry => entry.message);
+	}
+
 	setProviderResponseInterceptor(fn: SimpleStreamOptions["onResponse"] | undefined): void {
 		this.#onResponse = fn;
 	}
@@ -1087,6 +1201,11 @@ export class Agent {
 
 	appendMessage(m: AgentMessage) {
 		this.#state.messages.push(m);
+		const live = this.#liveSteered.findIndex(entry => entry.message === m);
+		if (live >= 0) {
+			this.#liveSteered.splice(live, 1);
+			return;
+		}
 		for (const delivery of this.#queuedMessageDeliveries) {
 			if (delivery.messages[delivery.next] !== m) continue;
 			if (++delivery.next === delivery.messages.length) this.#queuedMessageDeliveries.delete(delivery);
@@ -1142,6 +1261,7 @@ export class Agent {
 	clearAllQueues() {
 		this.#steeringQueue = [];
 		this.#followUpQueue = [];
+		this.#liveSteered = [];
 		this.#cancelQueuedMessagePreparation("steering");
 		this.#cancelQueuedMessagePreparation("followUp");
 		this.#notifySteeringWaiters();
@@ -1167,6 +1287,18 @@ export class Agent {
 		return claim ? [...claim.messages, ...this.#steeringQueue] : this.#steeringQueue;
 	}
 
+	/** Dequeued messages not yet in the transcript, e.g. steering a provider
+	 *  took into its in-flight response via live steering. Aborting the run
+	 *  requeues them, so the session's empty-submit interrupt counts them as
+	 *  pending input even though {@link peekSteeringQueue} no longer does. */
+	peekUndeliveredQueuedMessages(): AgentMessage[] {
+		const messages = this.peekLiveSteeredMessages();
+		for (const delivery of this.#queuedMessageDeliveries) {
+			for (let i = delivery.next; i < delivery.messages.length; i++) messages.push(delivery.messages[i]);
+		}
+		return messages;
+	}
+
 	/** Non-consuming view of the pending follow-up queue. See
 	 *  {@link peekSteeringQueue}. */
 	peekFollowUpQueue(): readonly AgentMessage[] {
@@ -1506,7 +1638,10 @@ export class Agent {
 			// that, a transformer resolving after the swap would patch a detached
 			// object while the persisted result kept the original payload — the
 			// rewrite silently lost.
-			const entry: CursorToolResultEntry = { toolResult: message };
+			const entry: CursorToolResultEntry = {
+				toolResult: message,
+				additionalContext: (message as ToolResultWithAdditionalContext)[TOOL_RESULT_ADDITIONAL_CONTEXT],
+			};
 			this.#cursorToolResultBuffer.push(entry);
 			const transform = this.#cursorOnToolResult;
 			if (transform) {
@@ -1574,6 +1709,7 @@ export class Agent {
 			preferWebsockets: this.#preferWebsockets,
 			convertToLlm: this.#convertToLlm,
 			transformProviderContext: this.#transformProviderContext,
+			sentToolDefinitions: this.#sentToolDefinitions,
 			transformContext: this.#transformContext,
 			onPayload: this.#onPayload,
 			onResponse: this.#onResponse,
@@ -1611,6 +1747,7 @@ export class Agent {
 			intentTracing: this.#intentTracing,
 			pruneToolDescriptions: this.#pruneToolDescriptions,
 			dialect: this.#dialect,
+			getDialect: this.#dialectResolver,
 			abortOnFabricatedToolResult: this.#abortOnFabricatedToolResult,
 			appendOnlyContext: this.#appendOnlyContext,
 			beforeToolCall: this.beforeToolCall ? (ctx, signal) => this.beforeToolCall?.(ctx, signal) : undefined,
@@ -1618,6 +1755,7 @@ export class Agent {
 			transformAssistantMessage: this.transformAssistantMessage
 				? (message, signal) => this.transformAssistantMessage?.(message, signal)
 				: undefined,
+			transformAssistantMessagePreservesToolCalls: this.transformAssistantMessagePreservesToolCalls,
 			onAssistantMessageEvent: this.#onAssistantMessageEvent,
 			onHarmonyLeak: this.#onHarmonyLeak,
 			onTurnEnd: (messages, signal, context) => this.#onTurnEnd?.(messages, signal, context),
@@ -1637,29 +1775,17 @@ export class Agent {
 				}
 				return this.#dequeueSteeringMessagesAfterHooks(signal ?? loopSignal);
 			},
-			hasSteeringMessages: () => {
-				if (this.#steeringQueue.length === 0) {
-					return { queued: false };
-				}
-				const messageCount = this.#steeringMode === "one-at-a-time" ? 1 : this.#steeringQueue.length;
-				let hasAgentSteering = false;
-				for (let i = 0; i < messageCount; i++) {
-					const message = this.#steeringQueue[i];
-					const role = "role" in message ? message.role : undefined;
-					const attribution = "attribution" in message ? message.attribution : undefined;
-					if (attribution === "user") {
-						return { queued: true, source: "user" };
-					}
-					if (role !== "user") continue;
-					if (attribution !== "agent") {
-						return { queued: true, source: "user" };
-					}
-					hasAgentSteering = true;
-				}
-				return { queued: true, source: hasAgentSteering ? "agent" : "system" };
-			},
+			hasSteeringMessages: () =>
+				steeringQueueState(
+					this.#steeringQueue,
+					this.#steeringMode === "one-at-a-time"
+						? Math.min(1, this.#steeringQueue.length)
+						: this.#steeringQueue.length,
+				),
 			waitForSteeringMessages: signal => this.#waitForSteeringMessages(signal),
+			onLiveSteeringTaken: messages => this.#adoptLiveSteering(messages),
 			hasIrcInterrupts: this.hasIrcInterrupts,
+			hasBackgroundCompletions: this.hasBackgroundCompletions,
 			getFollowUpMessages: signal => this.#dequeueFollowUpMessagesAfterHooks(signal ?? loopSignal),
 			getAsideMessages: async () => (await this.#asideMessageProvider?.()) ?? [],
 			onBeforeYield: () => this.#onBeforeYield?.(),
@@ -1767,6 +1893,9 @@ export class Agent {
 				.map(entry => entry.pending);
 			if (pendingTransforms.length > 0) await Promise.all(pendingTransforms);
 			const bufferedCursorResults = this.#cursorToolResultBuffer.map(({ toolResult }) => toolResult);
+			const bufferedCursorContext = joinAdditionalContext(
+				this.#cursorToolResultBuffer.map(({ additionalContext }) => additionalContext),
+			);
 			const retainedToolCallIds = new Set(completedToolCallIds);
 			for (const { toolCallId } of bufferedCursorResults) retainedToolCallIds.add(toolCallId);
 			const errorMsg: AssistantMessage =
@@ -1843,9 +1972,13 @@ export class Agent {
 					this.#emit({ type: "message_end", message: toolResult });
 					toolResults.push(toolResult);
 				}
+				const agentEndMessages: AgentMessage[] = [errorMsg, ...toolResults];
+				if (bufferedCursorContext !== undefined) {
+					agentEndMessages.push(this.#emitCursorAdditionalContext(bufferedCursorContext));
+				}
 				this.#emit({ type: "turn_end", message: errorMsg, toolResults });
 				turnOpen = false;
-				this.#emit({ type: "agent_end", messages: [errorMsg, ...toolResults] });
+				this.#emit({ type: "agent_end", messages: agentEndMessages });
 			} else {
 				this.appendMessage(errorMsg);
 				this.#state.error = errorMessage;
@@ -1917,8 +2050,24 @@ export class Agent {
 				this.appendMessage(toolResult);
 				this.#emit({ type: "message_end", message: toolResult });
 			}
+			const additionalContext = joinAdditionalContext(buffer.map(entry => entry.additionalContext));
+			if (additionalContext !== undefined) this.#emitCursorAdditionalContext(additionalContext);
 		} finally {
 			this.#cursorToolResultDrain = undefined;
 		}
 	}
+
+	/**
+	 * Append passive context reported by Cursor exec-channel tools after their
+	 * results, mirroring the loop's post-batch developer message. Cursor runs
+	 * those tools server-side mid-stream, so the context reaches the next
+	 * provider request instead of the current one.
+	 */
+	#emitCursorAdditionalContext(text: string): AgentMessage {
+		const message = createAdditionalContextMessage(text);
+		this.#emit({ type: "message_start", message });
+		this.appendMessage(message);
+		this.#emit({ type: "message_end", message });
+		return message;
+	}
 }

package/src/compaction/anthropic.ts

@@ -1,21 +1,14 @@
 /**
- * Anthropic server-side compaction (`compact-2026-01-12` beta).
+ * Anthropic on-demand compaction (`compact-2026-09-04` 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.
+ * The request sends only the prefix to summarize, with the live conversation's
+ * system prompt, tools and thinking settings. The returned signed block
+ * replaces that prefix; the retained tail is replayed from session entries.
  */
 
 import type {
 	AnthropicCompactionPayload,
 	ApiKey,
-	AssistantMessage,
 	Effort,
 	Message,
 	Model,
@@ -24,29 +17,21 @@ import type {
 	Usage,
 } from "@linxiraos/pi-ai";
 import * as AIError from "@linxiraos/pi-ai/error";
-import { supportsAnthropicCompaction } from "@linxiraos/pi-ai/providers/anthropic";
+import { supportsAnthropicCompaction } from "@linxiraos/pi-ai/providers/anthropic-compaction";
 import { isRecord, prompt } from "@linxiraos/pi-utils";
 import { type InstrumentedChatSpanOptions, instrumentedCompleteSimple } from "../telemetry";
+import type { AgentMessage } from "../types";
 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. */
+	/** Signature attached to an on-demand block; replayed verbatim. */
+	signature?: string;
+	/** Legacy threshold block state; replay-only. */
 	encryptedContent?: string;
 	/** Harness file metadata (`<files>` section) replayed after the native block. */
 	filesText?: string;
@@ -82,6 +67,9 @@ export function getPreservedAnthropicCompactionData(
 	return {
 		provider: candidate.provider,
 		content: candidate.content,
+		...(typeof candidate.signature === "string" && candidate.signature.length > 0
+			? { signature: candidate.signature }
+			: {}),
 		...(typeof candidate.encryptedContent === "string" && candidate.encryptedContent.length > 0
 			? { encryptedContent: candidate.encryptedContent }
 			: {}),
@@ -118,93 +106,63 @@ export function getAnthropicCompactionPayload(
 		type: "anthropicCompaction",
 		provider: preserved.provider,
 		content: preserved.content,
+		...(preserved.signature ? { signature: preserved.signature } : {}),
 		...(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.
+ * Move the existing keep-tail boundary forward until the summary/tail boundary
+ * alternates wire roles and no tool call is separated from its result. If no
+ * boundary is safe, the request summarizes the entire snapshot (empty 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;
+export function findAnthropicCompactionCut(
+	messages: readonly (AgentMessage | { role: "system"; content: string; timestamp: number })[],
+	initialCut: number,
+): number {
+	let calls: Map<string, number> | undefined;
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		if (message.role !== "assistant") continue;
+		for (const block of message.content) {
+			if (block.type === "toolCall") (calls ??= new Map()).set(block.id, i);
+		}
 	}
-	// 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;
+	let lastResult: Int32Array | undefined;
+	if (calls) {
+		lastResult = new Int32Array(messages.length);
+		for (let i = 0; i < messages.length; i++) {
+			const message = messages[i];
+			if (message.role !== "toolResult") continue;
+			const callIndex = calls.get(message.toolCallId);
+			if (callIndex !== undefined) lastResult[callIndex] = i;
+		}
 	}
-	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;
+	let protectedThrough = -1;
+	for (let i = 0; i < initialCut; i++) protectedThrough = Math.max(protectedThrough, lastResult?.[i] ?? -1);
+	for (let cut = initialCut; cut < messages.length; cut++) {
+		protectedThrough = Math.max(protectedThrough, lastResult?.[cut - 1] ?? -1);
+		if (cut <= protectedThrough) continue;
+		const first = messages[cut];
+		if (first.role === "system" || first.role === "developer") continue;
+		const previous = messages[cut - 1];
+		if (!previous) continue;
+		if ((previous.role === "assistant") !== (first.role === "assistant")) return cut;
 	}
+	return messages.length;
 }
 
-/**
- * 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).
- */
+/** Instructions replace the API default; the request contains only summarized messages. */
 export function buildAnthropicCompactionInstructions(
 	basePrompt: string,
 	customInstructions: string | undefined,
 	extraContext: string | undefined,
-	retainedTail: RetainedTailScope | undefined,
 ): string {
 	return prompt.render(anthropicCompactionInstructionsPrompt, {
 		basePrompt,
 		customInstructions,
 		extraContext,
-		retainedTail,
 	});
 }
 
@@ -219,7 +177,7 @@ export interface AnthropicNativeCompactionRequest {
 
 export interface AnthropicNativeCompactionResponse {
 	content: string;
-	encryptedContent?: string;
+	signature: string;
 	usage: Usage;
 	model: string;
 }
@@ -239,15 +197,13 @@ export interface AnthropicNativeCompactionOptions
 		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`
+ * Run one compaction request and return the summary and signature the API wrote. `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.
+ * without a summary is a native failure, including tool use, refusals and
+ * output limits; the configured method order can then choose a fallback.
  */
 export async function requestAnthropicNativeCompaction(
 	model: Model<"anthropic-messages">,
@@ -271,11 +227,7 @@ export async function requestAnthropicNativeCompaction(
 			promptCacheKey: options.promptCacheKey,
 			providerSessionState: options.providerSessionState,
 			maxInFlightRequests: options.maxInFlightRequests,
-			anthropicCompaction: {
-				triggerInputTokens: ANTHROPIC_COMPACTION_MIN_TRIGGER_TOKENS,
-				pauseAfterCompaction: true,
-				instructions: request.instructions,
-			},
+			anthropicCompaction: { instructions: request.instructions },
 		},
 		{
 			telemetry: options.telemetry,
@@ -294,16 +246,21 @@ export async function requestAnthropicNativeCompaction(
 			: new AIError.ProviderHttpError(message, response.errorStatus);
 	}
 	const payload = response.providerPayload;
-	if (payload?.type !== "anthropicCompaction" || payload.content.length === 0) {
+	if (
+		response.stopDetails?.type !== "compaction" ||
+		payload?.type !== "anthropicCompaction" ||
+		!payload.content ||
+		!payload.signature
+	) {
 		throw new Error(
 			response.stopDetails?.type === "compaction"
-				? "Anthropic compaction returned no summary"
-				: "Anthropic compaction response carried no compaction block",
+				? "Anthropic compaction returned no signed summary"
+				: `Anthropic compaction response carried no compaction block (stop reason: ${response.stopDetails?.type ?? response.stopReason})`,
 		);
 	}
 	return {
 		content: payload.content,
-		encryptedContent: payload.encryptedContent,
+		signature: payload.signature,
 		usage: response.usage,
 		model: response.model,
 	};

package/src/compaction/branch-summarization.ts

@@ -86,7 +86,7 @@ export interface GenerateBranchSummaryOptions {
 	convertToLlm?: ConvertToLlm;
 	/**
 	 * Optional telemetry handle. When provided, the branch summary LLM call is
-	 * wrapped in an OTEL chat span tagged with `pi.gen_ai.oneshot.kind = "branch_summary"`.
+	 * wrapped in an OTEL chat span tagged with `omp.gen_ai.oneshot.kind = "branch_summary"`.
 	 */
 	telemetry?: AgentTelemetry;
 	/**