@oh-my-pi/pi-agent-core 18.2.11 → 18.3.1

package/src/agent.ts

@@ -38,7 +38,14 @@ import {
 } 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 +72,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 +278,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`
@@ -361,6 +373,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,6 +407,7 @@ 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>> = {};
@@ -439,6 +458,7 @@ export class Agent {
 	#intentTracing: boolean;
 	#pruneToolDescriptions: boolean;
 	#dialect?: Dialect;
+	#dialectResolver?: (model: Model) => Dialect | undefined;
 	#abortOnFabricatedToolResult?: boolean;
 	#getToolChoice?: () => ToolChoiceDirective | undefined;
 	#onToolChoiceUnavailable?: () => void;
@@ -538,6 +558,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;
@@ -747,6 +768,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.
 	 */
@@ -827,7 +875,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
 			? []
@@ -837,6 +887,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;
 	}
 
@@ -1511,7 +1566,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) {
@@ -1579,6 +1637,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,
@@ -1616,6 +1675,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,
@@ -1773,6 +1833,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 =
@@ -1849,9 +1912,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;
@@ -1923,8 +1990,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,
@@ -27,26 +20,18 @@ import * as AIError from "@oh-my-pi/pi-ai/error";
 import { supportsAnthropicCompaction } from "@oh-my-pi/pi-ai/providers/anthropic-compaction";
 import { isRecord, prompt } from "@oh-my-pi/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 returned no signed summary"
 				: "Anthropic compaction response carried no compaction block",
 		);
 	}
 	return {
 		content: payload.content,
-		encryptedContent: payload.encryptedContent,
+		signature: payload.signature,
 		usage: response.usage,
 		model: response.model,
 	};