@oh-my-pi/pi-ai 16.2.1 → 16.2.2

package/src/providers/openai-shared.ts

@@ -27,6 +27,7 @@ import {
 	parseStreamingJsonThrottled,
 	structuredCloneJSON,
 } from "@oh-my-pi/pi-utils";
+import * as AIError from "../error";
 import {
 	type Api,
 	type AssistantMessage,
@@ -59,6 +60,12 @@ import {
 	resolveCacheRetention,
 	sanitizeOpenAIResponsesHistoryItemsForReplay,
 } from "../utils";
+import {
+	clearStreamingPartialJson,
+	kStreamingArgumentsDone,
+	kStreamingLastParseLen,
+	kStreamingPartialJson,
+} from "../utils/block-symbols";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
 import type { CapturedHttpErrorResponse } from "../utils/http-inspector";
 import { getOpenRouterHeaders } from "../utils/openrouter-headers";
@@ -69,6 +76,7 @@ import {
 	resolveGitHubCopilotBaseUrl,
 } from "./github-copilot-headers";
 import type { ChatCompletionCreateParamsStreaming } from "./openai-chat-wire";
+import type { InputItem } from "./openai-codex/request-transformer";
 import type {
 	ResponseContentPartAddedEvent,
 	ResponseCreateParamsStreaming,
@@ -77,6 +85,7 @@ import type {
 	ResponseInput,
 	ResponseInputContent,
 	ResponseInputImage,
+	ResponseInputItem,
 	ResponseInputText,
 	ResponseOutputItem,
 	ResponseOutputMessage,
@@ -169,7 +178,8 @@ export function resolveOpenAIRequestSetup(
 	let apiKey = options.apiKey;
 	if (!apiKey) {
 		if (!$env.OPENAI_API_KEY) {
-			throw new Error(
+			throw new AIError.MissingApiKeyError(
+				undefined,
 				"OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.",
 			);
 		}
@@ -762,7 +772,7 @@ export function resolveOpenAICompatPolicy<TApi extends Api>(
 	) {
 		const minEffort = getSupportedEfforts(model)[0];
 		if (minEffort === undefined) {
-			throw new Error(`Model ${model.provider}/${model.id} has no supported reasoning efforts`);
+			throw new AIError.ConfigurationError(`Model ${model.provider}/${model.id} has no supported reasoning efforts`);
 		}
 		wireEffort = mapOpenAIReasoningEffort(model, compat, minEffort);
 	}
@@ -1615,7 +1625,7 @@ export function appendResponsesToolResultMessages<TApi extends Api>(
  * Codex uses the open item's recorded index) so the emitted stream events match
  * each decoder's existing behavior byte-for-byte.
  */
-type ResponsesToolCallBlock = ToolCall & { partialJson: string; lastParseLen?: number };
+type ResponsesToolCallBlock = ToolCall & { [kStreamingPartialJson]: string; [kStreamingLastParseLen]?: number };
 
 export function appendReasoningSummaryPart(
 	item: ResponseReasoningItem,
@@ -1702,11 +1712,11 @@ export function accumulateToolCallArgumentsDelta(
 	output: AssistantMessage,
 	contentIndex: number,
 ): void {
-	block.partialJson += delta;
-	const throttled = parseStreamingJsonThrottled(block.partialJson, block.lastParseLen ?? 0);
+	block[kStreamingPartialJson] += delta;
+	const throttled = parseStreamingJsonThrottled(block[kStreamingPartialJson], block[kStreamingLastParseLen] ?? 0);
 	if (throttled) {
 		block.arguments = throttled.value;
-		block.lastParseLen = throttled.parsedLen;
+		block[kStreamingLastParseLen] = throttled.parsedLen;
 	}
 	stream.push({ type: "toolcall_delta", contentIndex, delta, partial: output });
 }
@@ -1718,10 +1728,9 @@ export function accumulateToolCallArgumentsDelta(
  * drops the transient accumulation fields.
  */
 export function finalizeToolCallArgumentsDone(block: ResponsesToolCallBlock, args: string): void {
-	block.partialJson = args;
-	block.arguments = parseStreamingJson(block.partialJson);
-	delete (block as { partialJson?: string }).partialJson;
-	delete (block as { lastParseLen?: number }).lastParseLen;
+	block[kStreamingPartialJson] = args;
+	block.arguments = parseStreamingJson(block[kStreamingPartialJson]);
+	clearStreamingPartialJson(block);
 }
 
 export function accumulateCustomToolCallInputDelta(
@@ -1731,13 +1740,13 @@ export function accumulateCustomToolCallInputDelta(
 	output: AssistantMessage,
 	contentIndex: number,
 ): void {
-	block.partialJson += delta;
-	block.arguments = { input: block.partialJson };
+	block[kStreamingPartialJson] += delta;
+	block.arguments = { input: block[kStreamingPartialJson] };
 	stream.push({ type: "toolcall_delta", contentIndex, delta, partial: output });
 }
 
 export function finalizeCustomToolCallInputDone(block: ResponsesToolCallBlock, input: string): void {
-	block.partialJson = input;
+	block[kStreamingPartialJson] = input;
 	block.arguments = { input };
 }
 
@@ -1766,7 +1775,11 @@ export async function processResponsesStream<TApi extends Api>(
 	model: Model<TApi>,
 	options?: ProcessResponsesStreamOptions,
 ): Promise<void> {
-	type StreamingToolCallBlock = ToolCall & { partialJson: string; lastParseLen?: number; argumentsDone?: boolean };
+	type StreamingToolCallBlock = ToolCall & {
+		[kStreamingPartialJson]: string;
+		[kStreamingLastParseLen]?: number;
+		[kStreamingArgumentsDone]?: boolean;
+	};
 	interface StreamingItem {
 		item: ResponseReasoningItem | ResponseOutputMessage | ResponseFunctionToolCall | ResponseCustomToolCall;
 		block: ThinkingContent | TextContent | StreamingToolCallBlock;
@@ -1863,7 +1876,7 @@ export async function processResponsesStream<TApi extends Api>(
 			if (
 				candidate.item.type === "function_call" &&
 				candidate.block.type === "toolCall" &&
-				!candidate.block.argumentsDone
+				!candidate.block[kStreamingArgumentsDone]
 			) {
 				return candidate;
 			}
@@ -1914,7 +1927,11 @@ export async function processResponsesStream<TApi extends Api>(
 				registerOpenItem(event.output_index, item.id, { item, block });
 				stream.push({ type: "thinking_start", contentIndex: contentIndexOf(block), partial: output });
 			} else if (item.type === "message") {
-				const block: TextContent = { type: "text", text: "" };
+				const block: TextContent = {
+					type: "text",
+					text: "",
+					textSignature: encodeTextSignatureV1(item.id, item.phase ?? undefined),
+				};
 				output.content.push(block);
 				registerOpenItem(event.output_index, item.id, { item, block });
 				stream.push({ type: "text_start", contentIndex: contentIndexOf(block), partial: output });
@@ -1924,7 +1941,7 @@ export async function processResponsesStream<TApi extends Api>(
 					id: encodeResponsesToolCallId(item.call_id, item.id),
 					name: item.name,
 					arguments: {},
-					partialJson: item.arguments || "",
+					[kStreamingPartialJson]: item.arguments || "",
 				};
 				output.content.push(block);
 				registerOpenItem(
@@ -1948,7 +1965,7 @@ export async function processResponsesStream<TApi extends Api>(
 					customWireName: item.name,
 					// Custom tools stream a raw string, but we reuse `partialJson` as the
 					// accumulation buffer so later code that inspects the field still works.
-					partialJson: item.input ?? "",
+					[kStreamingPartialJson]: item.input ?? "",
 				};
 				output.content.push(block);
 				registerOpenItem(
@@ -2031,7 +2048,7 @@ export async function processResponsesStream<TApi extends Api>(
 			const entry = lookupOpenFunctionCallItem(event);
 			if (entry?.item.type === "function_call" && entry.block.type === "toolCall") {
 				finalizeToolCallArgumentsDone(entry.block, event.arguments);
-				entry.block.argumentsDone = true;
+				entry.block[kStreamingArgumentsDone] = true;
 			}
 		} else if (event.type === "response.custom_tool_call_input.delta") {
 			const entry = lookupOpenToolCallAlias(event, "custom_tool_call");
@@ -2099,10 +2116,10 @@ export async function processResponsesStream<TApi extends Api>(
 				closeOpenItem(event.output_index, item.id, entry);
 			} else if (item.type === "function_call") {
 				const block = entry?.block.type === "toolCall" ? entry.block : undefined;
-				const args = block?.argumentsDone
+				const args = block?.[kStreamingArgumentsDone]
 					? block.arguments
-					: block?.partialJson
-						? parseStreamingJson(block.partialJson)
+					: block?.[kStreamingPartialJson]
+						? parseStreamingJson(block[kStreamingPartialJson])
 						: parseStreamingJson(item.arguments || "{}");
 				const toolCall: ToolCall = {
 					type: "toolCall",
@@ -2117,9 +2134,7 @@ export async function processResponsesStream<TApi extends Api>(
 					// leaving block.arguments stale (often `{}`); the emitted toolCall
 					// and the persisted block must agree.
 					block.arguments = args;
-					delete (block as { partialJson?: string }).partialJson;
-					delete (block as { lastParseLen?: number }).lastParseLen;
-					delete (block as { argumentsDone?: boolean }).argumentsDone;
+					clearStreamingPartialJson(block);
 					contentIndex = contentIndexOf(block);
 				} else {
 					// `output_item.added` never arrived (lossy proxy) — synthesize the
@@ -2132,7 +2147,7 @@ export async function processResponsesStream<TApi extends Api>(
 				stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
 			} else if (item.type === "custom_tool_call") {
 				const block = entry?.block.type === "toolCall" ? entry.block : undefined;
-				const rawInput = block?.partialJson ? block.partialJson : (item.input ?? "");
+				const rawInput = block?.[kStreamingPartialJson] ? block[kStreamingPartialJson] : (item.input ?? "");
 				const toolCall: ToolCall = {
 					type: "toolCall",
 					id: encodeResponsesToolCallId(item.call_id, item.id),
@@ -2145,8 +2160,7 @@ export async function processResponsesStream<TApi extends Api>(
 					// Persist the final input on the stored block and drop the transient
 					// accumulation buffer, mirroring the function_call branch above.
 					block.arguments = { input: rawInput };
-					delete (block as { partialJson?: string }).partialJson;
-					delete (block as { lastParseLen?: number }).lastParseLen;
+					clearStreamingPartialJson(block);
 					contentIndex = contentIndexOf(block);
 				} else {
 					output.content.push(toolCall);
@@ -2181,13 +2195,16 @@ export async function processResponsesStream<TApi extends Api>(
 						: typeof statusDetailsReason === "string" && statusDetailsReason.length > 0
 							? `status_details: ${statusDetailsReason}`
 							: "Unknown error (no error details in response)";
-				throw new Error(message);
+				throw new AIError.ProviderResponseError(message, { provider: model.provider, kind: "output" });
 			}
 			if (response?.status === "incomplete" && response.incomplete_details?.reason === "content_filter") {
 				// A content-filtered turn is a failure, not a token-cap truncation —
 				// mapping it to "length" would route the agent loop into "shorten your
 				// output" recovery against a filtered prompt.
-				throw new Error("incomplete: content_filter");
+				throw new AIError.ProviderResponseError("incomplete: content_filter", {
+					provider: model.provider,
+					kind: "content-blocked",
+				});
 			}
 			promoteResponsesToolUseStopReason(output, (response as { end_turn?: boolean } | undefined)?.end_turn);
 			options?.onCompleted?.();
@@ -2203,7 +2220,10 @@ export async function processResponsesStream<TApi extends Api>(
 			const err = (event as any).error ?? event;
 			const code = err.code ?? "unknown";
 			const message = err.message ?? "no message";
-			throw new Error(`Error Code ${code}: ${message}`);
+			throw new AIError.ProviderResponseError(`Error Code ${code}: ${message}`, {
+				provider: model.provider,
+				kind: "output",
+			});
 		} else if (event.type === "response.failed") {
 			populateResponsesUsageFromResponse(output, event.response?.usage);
 			const error = event.response?.error ?? (event.response as any)?.status_details?.error;
@@ -2213,7 +2233,7 @@ export async function processResponsesStream<TApi extends Api>(
 				: details?.reason
 					? `incomplete: ${details.reason}`
 					: "Unknown error (no error details in response)";
-			throw new Error(message);
+			throw new AIError.ProviderResponseError(message, { provider: model.provider, kind: "output" });
 		}
 	}
 }
@@ -2253,16 +2273,18 @@ export function mapOpenAIResponsesStopReason(status: ResponseStatus | undefined)
 export function finalizePendingResponsesToolCalls(output: AssistantMessage): void {
 	for (const block of output.content) {
 		if (block.type !== "toolCall") continue;
-		const pending = block as ToolCall & { partialJson?: string; lastParseLen?: number; argumentsDone?: boolean };
-		if (pending.partialJson && !pending.argumentsDone) {
+		const pending = block as ToolCall & {
+			[kStreamingPartialJson]?: string;
+			[kStreamingLastParseLen]?: number;
+			[kStreamingArgumentsDone]?: boolean;
+		};
+		if (pending[kStreamingPartialJson] && !pending[kStreamingArgumentsDone]) {
 			pending.arguments =
 				pending.customWireName !== undefined
-					? { input: pending.partialJson }
-					: parseStreamingJson(pending.partialJson);
+					? { input: pending[kStreamingPartialJson] }
+					: parseStreamingJson(pending[kStreamingPartialJson]);
 		}
-		delete pending.partialJson;
-		delete pending.lastParseLen;
-		delete pending.argumentsDone;
+		clearStreamingPartialJson(pending);
 	}
 }
 
@@ -2514,6 +2536,45 @@ export function populateResponsesUsageFromResponse(
 	}
 }
 
+/**
+ * Structural equality for the chain prefix/option check, equivalent to the
+ * default {@link Bun.deepEquals} (own enumerable keys, `absent ≡ own-undefined`)
+ * except for two deliberate exclusions:
+ *  - **symbol-keyed properties are ignored** — `for…in` walks enumerable
+ *    *string* keys only (never symbols); these are plain wire items whose
+ *    prototype contributes no enumerable keys, so iteration is effectively
+ *    own-string-keyed. That is how the transient streaming symbols
+ *    (`block-symbols.ts`) stamped onto live request items are excluded (the
+ *    deep-cloned baseline never carries them). Do NOT add an
+ *    `Object.getOwnPropertySymbols` pass, or those symbols resurface and break
+ *    chaining.
+ *  - keys listed in `omitKeys` are skipped (the option compare omits `input`
+ *    and the per-turn `client_metadata`).
+ * A defined value differing across sides IS a difference; a key undefined or
+ * absent on both stays equal. Nested values use full {@link Bun.deepEquals}.
+ */
+function deepEqualsWithout(a: unknown, b: unknown, omitKeys?: Record<string, boolean>): boolean {
+	if (!a || !b || typeof a !== "object" || typeof b !== "object") return Bun.deepEquals(a, b);
+	const ao = a as Record<string, unknown>;
+	const bo = b as Record<string, unknown>;
+	for (const key in ao) {
+		if (omitKeys?.[key]) continue;
+		const av = ao[key];
+		const bv = bo[key];
+		if (av !== bv && !Bun.deepEquals(av, bv)) return false;
+	}
+	for (const key in bo) {
+		if (omitKeys?.[key]) continue;
+		if (bo[key] !== undefined && !(key in ao)) return false;
+	}
+	return true;
+}
+
+const TOP_LEVEL_EXCLUDE_MAP = {
+	input: true,
+	client_metadata: true,
+};
+
 /**
  * Strict-prefix delta for stateful `previous_response_id` chaining (used by the
  * platform Responses provider and the Codex provider on both transports):
@@ -2523,24 +2584,30 @@ export function populateResponsesUsageFromResponse(
  * `client_metadata` (e.g. rotating turn ids) is excluded from the option
  * comparison; codex-rs excludes it from the same check.
  */
-export function buildResponsesDeltaInput<TItem>(
-	previous: { input?: unknown } | undefined,
+export function buildResponsesDeltaInput<TItem extends ResponseInputItem | InputItem>(
+	previous: { input?: TItem[] } | undefined,
 	previousResponseItems: readonly TItem[] | undefined,
-	current: { input?: unknown },
+	current: { input?: TItem[] },
 ): TItem[] | null {
 	if (!previous) return null;
 	if (!Array.isArray(previous.input) || !Array.isArray(current.input)) return null;
-	const previousWithoutInput = { ...previous, input: undefined, client_metadata: undefined };
-	const currentWithoutInput = { ...current, input: undefined, client_metadata: undefined };
-	if (!Bun.deepEquals(previousWithoutInput, currentWithoutInput)) {
+	if (!deepEqualsWithout(previous, current, TOP_LEVEL_EXCLUDE_MAP)) {
 		return null;
 	}
-	const baseline = [...previous.input, ...(previousResponseItems ?? [])];
-	if (current.input.length <= baseline.length) return null;
-	for (let index = 0; index < baseline.length; index += 1) {
-		if (!Bun.deepEquals(baseline[index], current.input[index])) {
-			return null;
+
+	const baselineLen = (previous.input?.length ?? 0) + (previousResponseItems?.length ?? 0);
+	if (current.input.length <= baselineLen) return null;
+
+	let index = 0;
+	for (const series of [previous.input, previousResponseItems]) {
+		if (!series) continue;
+		for (const item of series) {
+			if (deepEqualsWithout(item, current.input[index])) {
+				index++;
+			} else {
+				return null;
+			}
 		}
 	}
-	return current.input.slice(baseline.length) as TItem[];
+	return current.input.slice(index) as TItem[];
 }

package/src/providers/pi-native-client.ts

@@ -16,7 +16,7 @@
  * itself stays credential-free.
  */
 import { readSseJson } from "@oh-my-pi/pi-utils";
-import { ProviderHttpError } from "../errors";
+import * as AIError from "../error";
 import type {
 	Api,
 	AssistantMessage,
@@ -59,19 +59,7 @@ function buildWireOptions(options: SimpleStreamOptions | undefined): Record<stri
 	return wire;
 }
 
-/**
- * Non-2xx response from the auth-gateway `/v1/pi/stream` endpoint. `code`
- * carries the gateway's error-type token (`authentication_error`,
- * `rate_limit_error`, `upstream_error`, ...).
- */
-export class AuthGatewayError extends ProviderHttpError {
-	constructor(message: string, status: number, headers?: Headers, code?: string) {
-		super(message, status, { headers, code });
-		this.name = "AuthGatewayError";
-	}
-}
-
-async function decodeGatewayError(response: Response): Promise<AuthGatewayError> {
+async function decodeGatewayError(response: Response): Promise<AIError.AuthGatewayError> {
 	const status = response.status;
 	let body: unknown;
 	try {
@@ -84,7 +72,7 @@ async function decodeGatewayError(response: Response): Promise<AuthGatewayError>
 		if (typeof err === "object" && err !== null) {
 			const message = (err as { message?: unknown }).message;
 			const type = (err as { type?: unknown }).type;
-			return new AuthGatewayError(
+			return new AIError.AuthGatewayError(
 				typeof message === "string" ? message : `auth-gateway ${status}`,
 				status,
 				response.headers,
@@ -93,7 +81,11 @@ async function decodeGatewayError(response: Response): Promise<AuthGatewayError>
 		}
 	}
 	const text = typeof body === "string" ? body : JSON.stringify(body);
-	return new AuthGatewayError(`auth-gateway ${status}: ${text || response.statusText}`, status, response.headers);
+	return new AIError.AuthGatewayError(
+		`auth-gateway ${status}: ${text || response.statusText}`,
+		status,
+		response.headers,
+	);
 }
 
 /**
@@ -104,7 +96,7 @@ async function decodeGatewayError(response: Response): Promise<AuthGatewayError>
  */
 function resolveStreamUrl(model: Model<Api>): string {
 	if (!model.baseUrl) {
-		throw new Error(
+		throw new AIError.ConfigurationError(
 			`pi-native transport requires \`baseUrl\` on model ${model.id} (set it on the provider config in models.yml)`,
 		);
 	}
@@ -179,7 +171,9 @@ export function streamPiNative<TApi extends Api>(
 				return;
 			}
 			if (!response.body) {
-				stream.fail(new Error("auth-gateway returned empty body"));
+				stream.fail(
+					new AIError.AuthGatewayError("auth-gateway returned empty body", response.status, response.headers),
+				);
 				return;
 			}
 

package/src/providers/pi-native-server.ts

@@ -25,7 +25,9 @@
  *   200 JSON (stream=false): { message: AssistantMessage }
  *   4xx/5xx: { error: { type, message } }
  */
+
 import type { AuthGatewayStreamControl } from "../auth-gateway/types";
+import * as AIError from "../error";
 import type { AssistantMessageEventStream, Context, SimpleStreamOptions } from "../types";
 
 export interface PiNativeParsedRequest {
@@ -72,6 +74,7 @@ const ALLOWED_OPTION_KEYS: ReadonlySet<keyof SimpleStreamOptions> = new Set([
 	"syntheticApiFormat",
 	"preferWebsockets",
 	"openrouterVariant",
+	"loopGuard",
 ] as const satisfies readonly (keyof SimpleStreamOptions)[]);
 
 // ---------------------------------------------------------------------------
@@ -91,7 +94,7 @@ const ALLOWED_OPTION_KEYS: ReadonlySet<keyof SimpleStreamOptions> = new Set([
  */
 export function parseRequest(body: unknown, _headers?: Headers): PiNativeParsedRequest {
 	if (typeof body !== "object" || body === null || Array.isArray(body)) {
-		throw new Error("Request body must be a JSON object");
+		throw new AIError.ValidationError("Request body must be a JSON object");
 	}
 	const obj = body as Record<string, unknown>;
 
@@ -104,21 +107,21 @@ export function parseRequest(body: unknown, _headers?: Headers): PiNativeParsedR
 		const m = obj.model as Record<string, unknown>;
 		if (typeof m.id === "string" && m.id.length > 0) modelId = m.id;
 	}
-	if (!modelId) throw new Error("Missing `modelId` (or `model.id`) field");
+	if (!modelId) throw new AIError.ValidationError("Missing `modelId` (or `model.id`) field");
 
 	const context = obj.context;
 	if (typeof context !== "object" || context === null || Array.isArray(context)) {
-		throw new Error("Missing `context` object");
+		throw new AIError.ValidationError("Missing `context` object");
 	}
 	const ctxObj = context as Record<string, unknown>;
 	if (!Array.isArray(ctxObj.messages)) {
-		throw new Error("`context.messages` must be an array");
+		throw new AIError.ValidationError("`context.messages` must be an array");
 	}
 	if (ctxObj.systemPrompt !== undefined && !Array.isArray(ctxObj.systemPrompt)) {
-		throw new Error("`context.systemPrompt` must be an array of strings when present");
+		throw new AIError.ValidationError("`context.systemPrompt` must be an array of strings when present");
 	}
 	if (ctxObj.tools !== undefined && !Array.isArray(ctxObj.tools)) {
-		throw new Error("`context.tools` must be an array when present");
+		throw new AIError.ValidationError("`context.tools` must be an array when present");
 	}
 
 	const options: SimpleStreamOptions = {};

package/src/providers/register-builtins.ts

@@ -10,6 +10,8 @@
  * wired into the main streaming path. It provides the infrastructure for lazy
  * loading that can be integrated when stream.ts is refactored.
  */
+
+import * as AIError from "../error";
 import type {
 	Api,
 	AssistantMessage,
@@ -248,8 +250,9 @@ function forwardStream<TApi extends Api>(
 				firstItemTimeoutMs,
 				errorMessage: LAZY_STREAM_IDLE_TIMEOUT_ERROR,
 				firstItemErrorMessage: LAZY_STREAM_FIRST_EVENT_TIMEOUT_ERROR,
-				onIdle: () => abortTracker.abortLocally(new Error(LAZY_STREAM_IDLE_TIMEOUT_ERROR)),
-				onFirstItemTimeout: () => abortTracker.abortLocally(new Error(LAZY_STREAM_FIRST_EVENT_TIMEOUT_ERROR)),
+				onIdle: () => abortTracker.abortLocally(new AIError.StreamTimeoutError(LAZY_STREAM_IDLE_TIMEOUT_ERROR)),
+				onFirstItemTimeout: () =>
+					abortTracker.abortLocally(new AIError.StreamTimeoutError(LAZY_STREAM_FIRST_EVENT_TIMEOUT_ERROR)),
 				abortSignal: options.signal,
 				// The synthetic `start` event is yielded immediately by every provider before
 				// the upstream model has emitted any tokens. Treating it as the first "real"

package/src/providers/transform-messages.ts

@@ -1,3 +1,4 @@
+import { renderDemotedThinking } from "../dialect/demotion";
 import type { Api, AssistantMessage, Message, Model, ToolCall, ToolResultMessage, UserMessage } from "../types";
 
 const enum ToolCallStatus {
@@ -226,52 +227,20 @@ function isAnthropicMessagesModel(model: Model): model is Model<"anthropic-messa
 }
 
 /**
- * Cross-API `openai-completions` targets that can replay a prior turn's
- * reasoning as a native, signature-stripped `thinking` block on the wire.
- * Anthropic's same-API path (`replayUnsignedThinking`) covers
- * `anthropic-messages` targets directly; this is the analogue for the
- * `openai-completions` branch of the cross-API path (#3433/#3434). 3p ↔ 3p
- * replays between an Anthropic-compatible source (Z.AI Anthropic, Kimi
- * Anthropic, …) and an OpenAI-compat reasoning target on the same vendor must
- * keep reasoning as structured `reasoning_content` instead of degrading it to
- * conversation text.
- *
- * `compat` MUST be the request-time RESOLVED compat that `convertMessages`
- * threads into `transformMessages`, not `model.compat`. OpenCode-hosted
- * reasoning models (`opencode-go`/`opencode-zen`) keep
- * `requiresReasoningContentForToolCalls` off on the base compat to dodge the
- * thinking-off `Extra inputs are not permitted` 400 (#1071) and reactivate it
- * on `compat.whenThinking` for thinking-engaged requests to dodge the
- * `thinking is enabled but reasoning_content is missing` 400 (#1484).
- * `resolveOpenAICompatPolicy` already swaps in `whenThinking` for thinking-on
- * requests, so basing this decision on the resolved compat keeps the predicate
- * and the encoder in lockstep; reading `model.compat` would re-open #1484 for
- * every cross-API switch into an OpenCode reasoning model.
- *
- * The downstream encoder MUST then surface the preserved block on the wire via
- * `reasoningContentField` — see `openai-completions.ts` for the matching
- * branch.
+ * Targets that have proven they read unsigned foreign thinking when replayed
+ * natively. This is a semantic-carry allowlist only: OpenAI-compatible
+ * `reasoning_content` schema requirements and llama.cpp cache-prefix replay are
+ * handled by their encoders and MUST NOT make foreign thinking look meaningful.
  */
-function openAICompletionsReplaysUnsignedThinking(model: Model, compat: Model["compat"]): boolean {
+function targetReadsForeignThinking(model: Model, compat: Model["compat"]): boolean {
+	if (compat === undefined) return false;
+	if (model.api === "anthropic-messages") {
+		return "replayUnsignedThinking" in compat && compat.replayUnsignedThinking === true;
+	}
 	if (model.api !== "openai-completions") return false;
-	if (compat === undefined || !("requiresReasoningContentForToolCalls" in compat)) return false;
+	if (!("thinkingFormat" in compat)) return false;
 	if (compat.requiresThinkingAsText) return false;
-	// Local llama.cpp-style servers (`replayReasoningContent`) need the replay
-	// for KV-cache prefix reuse — Qwen3 / DeepSeek-R1 / GLM chat templates
-	// reconstruct the prior turn's `<think>` block from `reasoning_content`
-	// (#3528). Checked BEFORE the `model.reasoning` gate: the runtime discovery
-	// paths for `llama.cpp` / `lm-studio` / `openai-models-list` hardcode
-	// `reasoning: false` even when the upstream actually emits reasoning, so
-	// gating on the spec flag here would let a cross-API switch into such a
-	// target demote the prior `thinking` block to text and lose the
-	// cache-stable prefix `replayReasoningContent` is meant to preserve.
-	if (compat.replayReasoningContent) return true;
-	if (!model.reasoning) return false;
-	// Hosts that REQUIRE `reasoning_content` on tool-call turns (DeepSeek
-	// reasoning, Kimi, OpenRouter reasoning, OpenCode thinking-on) already
-	// accept the replay; Z.AI-format hosts (Z.AI, Zhipu, Moonshot Kimi native,
-	// Xiaomi MiMo) advertise `reasoning_content` as a continuation hint.
-	return compat.requiresReasoningContentForToolCalls || compat.thinkingFormat === "zai";
+	return model.reasoning && compat.thinkingFormat === "zai";
 }
 
 const ANTHROPIC_TOOL_CALL_ID_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;
@@ -461,29 +430,29 @@ export function transformMessages<TApi extends Api>(
 					// thinking blocks before the cross-model paths.
 					if (!sanitized.thinking || sanitized.thinking.trim() === "") return [];
 					if (isSameModel) return sanitized;
-					// Cross-model + cross-API: preserve as a native, signature-stripped
-					// `thinking` block whenever the target encoder can re-emit it on the
-					// wire (today: `openai-completions` reasoning targets that accept
-					// `reasoning_content` as a continuation hint — Z.AI, Zhipu, DeepSeek
-					// reasoning, Kimi native, MiMo, OpenRouter reasoning, …). The source
-					// signature is always dropped because it is bound to the source
-					// wire-format (Anthropic crypto sig / OpenAI Responses encrypted
-					// blob) and would be rejected by the target. Without this branch
-					// every cross-API 3p ↔ 3p switch (Z.AI Anthropic → Z.AI OpenAI,
-					// Kimi Anthropic → Kimi OpenAI, etc.) demoted prior reasoning to
-					// conversation text and lost it as structured reasoning context
-					// (#3433/#3434).
-					if (openAICompletionsReplaysUnsignedThinking(model, targetCompat)) {
+					// Cross-model + cross-API: preserve native thinking only for
+					// targets proven to read unsigned foreign reasoning (Z.AI-format
+					// OpenAI-compatible targets, plus Anthropic-compatible
+					// `replayUnsignedThinking`). Tool-call schema requirements and
+					// llama.cpp cache-prefix replay are orthogonal encoder concerns;
+					// keeping inert foreign CoT native for those flags loses the
+					// canonical visible-text fallback without adding model context.
+					if (targetReadsForeignThinking(model, targetCompat)) {
 						return sanitized.thinkingSignature ? { ...sanitized, thinkingSignature: undefined } : sanitized;
 					}
 					// Other cross-API targets (openai-responses encrypted blobs, google
-					// signed thought parts, anthropic-target from a non-Anthropic source,
-					// or any reasoning-disabled target) can't usefully replay an unsigned
-					// thinking block. Demote to text so the reasoning survives at least
-					// as visible conversation context.
+					// thought parts, anthropic-target from a non-Anthropic source, or any
+					// reasoning-disabled target) can't replay an unsigned thinking block:
+					// the native reasoning slot either rejects a foreign signature or — as
+					// verified end-to-end against Gemini 3 — silently discards unsigned
+					// thought content (it is neither recalled nor influences generation).
+					// Demote to text so the reasoning survives as context, wrapped in the
+					// TARGET model's own canonical thinking-block dialect (e.g. a ```thinking
+					// fence for Gemini) so it reads as reasoning rather than bare prose the
+					// model might mimic.
 					return {
 						type: "text" as const,
-						text: sanitized.thinking,
+						text: renderDemotedThinking(model.id, sanitized.thinking),
 					};
 				}
 
@@ -514,8 +483,7 @@ export function transformMessages<TApi extends Api>(
 					let normalizedToolCall: ToolCall = toolCall;
 
 					if (!isSameModel && toolCall.thoughtSignature) {
-						normalizedToolCall = { ...toolCall };
-						delete (normalizedToolCall as { thoughtSignature?: string }).thoughtSignature;
+						normalizedToolCall = { ...toolCall, thoughtSignature: undefined };
 					}
 
 					if (isAnthropicTarget) {