@gajae-code/ai 0.11.1 → 0.11.2

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.11.2] - 2026-07-19
+
+### Fixed
+
+- `transportFailureFacts` now reduces transport headers to a plain record containing only the retained retry signals (`retry-after`, `retry-after-ms`). Providers attach these facts to error `AssistantMessage`s, and the previous shape carried the live fetch/SDK `Headers` instance — which is not structured-cloneable (`structuredClone` throws `DataCloneError`, "The object can not be cloned." under Bun) and not JSON-serializable (persisted as `{}` in session files, silently dropping the retry hint). Under a managed model fallback chain, snapshotting such an error message replaced the real provider failure with the local clone error and exhausted the whole chain. Normalization is idempotent (re-running facts on facts is structurally stable; errors carrying only unretained headers with no status/code now yield no facts instead of an empty facts object), Retry-After classification (`classifyFallbackTrigger`) is unchanged, and arbitrary response headers no longer reach persisted facts.
+
 ## [0.11.0] - 2026-07-15
 ### Added
 

package/dist/types/auth-storage.d.ts

@@ -410,6 +410,8 @@ export declare class AuthStorage {
      * Remove a runtime API key override.
      */
     removeRuntimeApiKey(provider: string): void;
+    /** Whether a provider is currently authenticated by a runtime API-key override. */
+    hasRuntimeApiKey(provider: string): boolean;
     /**
      * Register a per-provider API key sourced from user configuration
      * (e.g. `models.yml` `providers.<name>.apiKey`). Higher priority than

package/dist/types/model-manager.d.ts

@@ -30,6 +30,8 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
     modelsDev?: ModelsDevFallback<TApi, TModelsDevPayload>;
     /** Clock override for deterministic tests. */
     now?: () => number;
+    /** Optional guard that must permit cache publication. Default: writes are permitted. */
+    canPublishCache?: () => boolean;
 }
 /**
  * Resolution result.

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

@@ -1,5 +1,5 @@
 import Anthropic, { type ClientOptions as AnthropicSdkClientOptions } from "@anthropic-ai/sdk";
-import type { MessageParam } from "@anthropic-ai/sdk/resources/messages";
+import type { MessageCreateParamsStreaming, MessageParam } from "@anthropic-ai/sdk/resources/messages";
 import type { FetchImpl, Message, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, StreamFunction, StreamOptions, Usage } from "../types";
 export type AnthropicHeaderOptions = {
     apiKey: string;
@@ -181,6 +181,7 @@ type SystemBlockOptions = {
 export declare function buildAnthropicSystemBlocks(systemPrompt: readonly string[] | undefined, options?: SystemBlockOptions): AnthropicSystemBlock[] | undefined;
 export declare function normalizeExtraBetas(betas?: string[] | string): string[];
 export declare function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): AnthropicClientOptionsResult;
+export declare function normalizeCacheControlTtlOrdering(params: MessageCreateParamsStreaming): void;
 export declare function convertAnthropicMessages(messages: Message[], model: Model<"anthropic-messages">, isOAuthToken: boolean, options?: {
     repairLatestAssistantThinking?: boolean;
 }): MessageParam[];

package/dist/types/providers/pi-native-server.d.ts

@@ -10,13 +10,12 @@
  * translations impose on first-class pi-ai fields (service tier, cache
  * markers, thinking budgets, tool-choice variants, …).
  *
- * The streaming wire is {@link AssistantMessageEvent} serialized verbatim and
- * SSE-framed. Same type pi-ai already produces internally; the client feeds
- * each parsed event straight into `AssistantMessageEventStream.push()` with
- * no translation. Including `partial: AssistantMessage` on every delta is
- * O(N²) in turn length on the wire — acceptable for the loopback / sidecar
- * topology this transport is designed for; provider latency dominates the
- * actual cost.
+ * The streaming wire is {@link AssistantMessageEvent} serialized as SSE. Public
+ * projections omit private raw reasoning and serialized Responses reasoning
+ * signatures while preserving provider-displayable summaries and genuine opaque
+ * signatures. Including `partial: AssistantMessage` on every delta is O(N²) in
+ * turn length on the wire — acceptable for the loopback / sidecar topology this
+ * transport is designed for; provider latency dominates the actual cost.
  *
  * Endpoint contract:
  *   POST /v1/pi/stream
@@ -45,16 +44,9 @@ export interface PiNativeParsedRequest {
  */
 export declare function parseRequest(body: unknown, _headers?: Headers): PiNativeParsedRequest;
 /**
- * Ship every {@link AssistantMessageEvent} verbatim, SSE-framed.
- *
- * No per-event re-shaping: the pi-native client is pi-ai itself, so the
- * canonical event type IS the wire type. Including the rolling
- * `partial: AssistantMessage` on every delta is quadratic in turn length
- * on the wire, but for the loopback / sidecar topology this transport
- * targets (containerized GJC → host gateway) the bandwidth cost is negligible
- * compared to provider latency —
- * and the client gets to feed the events straight into its existing
- * `AssistantMessageEventStream.push()` plumbing with zero translation.
+ * Ship only public-safe {@link AssistantMessageEvent} projections. Unknown
+ * thinking blocks remain buffered until their terminal partial establishes that
+ * the provider-native block is safe; raw and mixed blocks never reach SSE.
  */
 export declare function encodeStream(events: AssistantMessageEventStream): ReadableStream<Uint8Array>;
 /**

package/dist/types/types.d.ts

@@ -319,6 +319,9 @@ export interface ThinkingContent {
     thinking: string;
     thinkingSignature?: string;
     itemId?: string;
+    readonly provenance?: "summary" | "raw" | "mixed";
+    readonly summaryText?: string;
+    readonly rawText?: string;
 }
 export interface RedactedThinkingContent {
     type: "redactedThinking";
@@ -542,6 +545,16 @@ export interface Tool<TParameters extends TSchema = TSchema> {
      * calls route correctly. Absent for regular JSON function tools.
      */
     customWireName?: string;
+    /**
+     * Optional safe projection for tool arguments or results. Extensions use this
+     * only for explicitly opt-in, display-safe summaries.
+     */
+    safeSummary?: (kind: "args" | "result", value: unknown) => string | undefined;
+    /** Allowlisted argument/result field names for a safe fallback summary. */
+    safeSummaryFields?: {
+        args?: string[];
+        result?: string[];
+    };
 }
 export interface Context {
     systemPrompt?: string[];
@@ -580,6 +593,20 @@ export type AssistantMessageEvent = {
     contentIndex: number;
     content: string;
     partial: AssistantMessage;
+} | {
+    type: "reasoning_summary_start";
+    contentIndex: number;
+    partial: AssistantMessage;
+} | {
+    type: "reasoning_summary_delta";
+    contentIndex: number;
+    delta: string;
+    partial: AssistantMessage;
+} | {
+    type: "reasoning_summary_end";
+    contentIndex: number;
+    content: string;
+    partial: AssistantMessage;
 } | {
     type: "toolcall_start";
     contentIndex: number;
@@ -731,6 +758,12 @@ export interface AnthropicCompat extends ToolChoiceCompat {
     supportsForcedToolChoice?: boolean;
     /** Whether long prompt-cache retention (`ttl: "1h"`) is supported. Default: true for canonical Anthropic API. */
     supportsLongCacheRetention?: boolean;
+    /**
+     * Prompt-cache transport accepted by this Anthropic-compatible endpoint.
+     * Canonical Anthropic defaults to `"automatic"`; noncanonical endpoints default
+     * to `"none"` and must explicitly opt into generated `"explicit"` markers.
+     */
+    promptCacheMode?: "none" | "explicit" | "automatic";
 }
 /**
  * OpenRouter provider routing preferences.

package/dist/types/utils/fallback-transport.d.ts

@@ -1,4 +1,4 @@
-export type FallbackTriggerClass = "rate_limit" | "quota" | "auth" | "server" | "other";
+export type FallbackTriggerClass = "rate_limit" | "quota" | "auth" | "server" | "unknown" | "other";
 export interface FallbackTrigger {
     class: FallbackTriggerClass;
     retryAfterMs?: number;
@@ -7,12 +7,23 @@ export type TransportHeaders = Headers | Record<string, string | undefined>;
 /**
  * Structured facts from an upstream HTTP or transport failure. Retry decisions
  * must use these facts rather than provider- or application-owned error text.
+ *
+ * `headers` is always a plain record limited to the retained retry-signal
+ * entries: facts travel on persisted `AssistantMessage`s and through
+ * `structuredClone` snapshots (managed fallback attempt staging), so they must
+ * never carry a live `Headers` instance — cloning one throws `DataCloneError`
+ * ("The object can not be cloned.") and masks the real provider failure.
  */
 export interface TransportFailureFacts {
     kind: "transport";
     status?: number;
+    /** Canonical provider error code used for fallback classification. */
     providerCode?: string;
-    headers?: TransportHeaders;
+    /** Anthropic's typed `error.type`, preserved separately at the transport boundary. */
+    anthropicErrorType?: string;
+    /** OpenAI's typed `error.code`, preserved separately at the transport boundary. */
+    openaiErrorCode?: string;
+    headers?: Record<string, string>;
 }
 /** Opaque per-invocation marker required by managed fallback transport calls. */
 export interface FallbackAttemptToken {

package/dist/types/utils/overflow.d.ts

@@ -1,61 +1,11 @@
 import type { AssistantMessage } from "../types";
+import type { TransportFailureFacts } from "./fallback-transport";
+export declare function classifyContextOverflow(message: AssistantMessage, transportFailure?: TransportFailureFacts, contextWindow?: number): boolean;
 /**
  * Check if an assistant message represents a context overflow error.
  *
- * This handles three cases:
- * 1. Error-based overflow: Most providers return stopReason "error" with a
- *    specific error message pattern.
- * 2. Silent overflow: Some providers accept overflow requests and return
- *    successfully. For these, we check if usage.input exceeds the context window.
- * 3. Proxy-level overflow: Some proxies (e.g. LiteLLM) return a "successful"
- *    response with empty content and a fabricated near-zero usage when the
- *    upstream model's context window is exceeded.
- *
- * ## Reliability by Provider
- *
- * **Reliable detection (returns error with detectable message):**
- * - Anthropic: "prompt is too long: X tokens > Y maximum"
- * - OpenAI (Completions & Responses): "exceeds the context window"
- * - Google Gemini: "input token count exceeds the maximum"
- * - xAI (Grok): "maximum prompt length is X but request contains Y"
- * - Groq: "reduce the length of the messages"
- * - Cerebras: 400/413 status code (no body)
- * - Mistral: 400/413 status code (no body)
- * - HTTP 413 payload/entity-too-large variants
- * - OpenRouter (all backends): "maximum context length is X tokens"
- * - llama.cpp: "exceeds the available context size"
- * - LM Studio: "greater than the context length"
- * - Kimi For Coding: "exceeded model token limit: X (requested: Y)"
- * - Anthropic 413: "request_too_large" (request body exceeds size limit)
- * - HTTP 413: "Payload Too Large" / "Request Entity Too Large"
- *
- * **Unreliable detection:**
- * - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
- *   sometimes returns rate limit errors. Pass contextWindow param to detect silent overflow.
- * - Ollama: Silently truncates input without error. Cannot be detected via this function.
- * - LiteLLM proxy: Returns a "successful" response with empty content and a
- *   fabricated near-zero usage (e.g. input: 1, output: 1) when the upstream
- *   model's context window is exceeded. Detected via Case 3 (empty content +
- *   anomalously low usage). Note: the LiteLLM proxy's context limit may differ
- *   from the underlying model's advertised contextWindow (e.g. configured via
- *   `model_info.max_tokens` in LiteLLM's config.yaml), so Case 2 (which compares
- *   usage.input against contextWindow) may not catch it.
- *   The response will have usage.input < expected, but we don't know the expected value.
- *
- * ## Custom Providers
- *
- * If you've added custom models via settings.json, this function may not detect
- * overflow errors from those providers. To add support:
- *
- * 1. Send a request that exceeds the model's context window
- * 2. Check the errorMessage in the response
- * 3. Create a regex pattern that matches the error
- * 4. The pattern should be added to OVERFLOW_PATTERNS in this file, or
- *    check the errorMessage yourself before calling this function
- *
- * @param message - The assistant message to check
- * @param contextWindow - Optional context window size for detecting silent overflow (z.ai)
- * @returns true if the message indicates a context overflow
+ * Callers with normalized transport facts should use {@link classifyContextOverflow}
+ * so typed provider codes take precedence over error prose.
  */
 export declare function isContextOverflow(message: AssistantMessage, contextWindow?: number): boolean;
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.11.1",
+	"version": "0.11.2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -40,7 +40,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/utils": "0.11.1",
+		"@gajae-code/utils": "0.11.2",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/auth-storage.ts

@@ -775,7 +775,9 @@ export class AuthStorage {
 	 */
 	static async create(dbPath: string, options: AuthStorageOptions = {}): Promise<AuthStorage> {
 		const store = await SqliteAuthCredentialStore.open(dbPath);
-		return new AuthStorage(store, options);
+		const storage = new AuthStorage(store, options);
+		await storage.reload();
+		return storage;
 	}
 
 	/**
@@ -854,6 +856,7 @@ export class AuthStorage {
 	 */
 	setRuntimeApiKey(provider: string, apiKey: string): void {
 		this.#runtimeOverrides.set(provider, apiKey);
+		this.#bumpGeneration("set-runtime-api-key");
 	}
 
 	/**
@@ -877,7 +880,12 @@ export class AuthStorage {
 	 * Remove a runtime API key override.
 	 */
 	removeRuntimeApiKey(provider: string): void {
-		this.#runtimeOverrides.delete(provider);
+		if (this.#runtimeOverrides.delete(provider)) this.#bumpGeneration("remove-runtime-api-key");
+	}
+
+	/** Whether a provider is currently authenticated by a runtime API-key override. */
+	hasRuntimeApiKey(provider: string): boolean {
+		return Boolean(this.#runtimeOverrides.get(provider));
 	}
 
 	/**
@@ -892,13 +900,14 @@ export class AuthStorage {
 	 */
 	setConfigApiKey(provider: string, apiKey: string): void {
 		this.#configOverrides.set(provider, apiKey);
+		this.#bumpGeneration("set-config-api-key");
 	}
 
 	/**
 	 * Remove a single config-sourced API key override.
 	 */
 	removeConfigApiKey(provider: string): void {
-		this.#configOverrides.delete(provider);
+		if (this.#configOverrides.delete(provider)) this.#bumpGeneration("remove-config-api-key");
 	}
 
 	/**
@@ -906,7 +915,9 @@ export class AuthStorage {
 	 * re-parsing `models.yml` so removed entries actually disappear.
 	 */
 	clearConfigApiKeys(): void {
+		if (this.#configOverrides.size === 0) return;
 		this.#configOverrides.clear();
+		this.#bumpGeneration("clear-config-api-keys");
 	}
 
 	/**

package/src/model-manager.ts

@@ -41,6 +41,8 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
 	modelsDev?: ModelsDevFallback<TApi, TModelsDevPayload>;
 	/** Clock override for deterministic tests. */
 	now?: () => number;
+	/** Optional guard that must permit cache publication. Default: writes are permitted. */
+	canPublishCache?: () => boolean;
 }
 
 /**
@@ -148,7 +150,9 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 			return { models: cachedModels, stale: false };
 		}
 		const repairedModels = mergeDynamicModels(staticModels, cachedModels);
-		writeModelCache(options.providerId, now(), repairedModels, true, staticFingerprint, dbPath);
+		if (options.canPublishCache?.() ?? true) {
+			writeModelCache(options.providerId, now(), repairedModels, true, staticFingerprint, dbPath);
+		}
 		return { models: repairedModels, stale: false };
 	}
 
@@ -169,24 +173,28 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 			const snapshotModels = applyFinalCodexGpt56ContextCap(
 				mergeDynamicModels(mergeModelSources(staticModels, modelsDevModels), dynamicModels),
 			);
-			writeModelCache(options.providerId, now(), snapshotModels, true, staticFingerprint, dbPath);
+			if (options.canPublishCache?.() ?? true) {
+				writeModelCache(options.providerId, now(), snapshotModels, true, staticFingerprint, dbPath);
+			}
 		} else {
 			// Dynamic fetch failed — update cache with a non-authoritative snapshot so
 			// stale state remains visible while retry backoff still applies.
 			const latestCache = readModelCache<TApi>(options.providerId, ttlMs, now, dbPath);
-			writeModelCache(
-				options.providerId,
-				now(),
-				applyFinalCodexGpt56ContextCap(
-					mergeDynamicModels(
-						mergeModelSources(staticModels, modelsDevModels),
-						normalizeModelList<TApi>(latestCache?.models ?? cache?.models ?? []),
+			if (options.canPublishCache?.() ?? true) {
+				writeModelCache(
+					options.providerId,
+					now(),
+					applyFinalCodexGpt56ContextCap(
+						mergeDynamicModels(
+							mergeModelSources(staticModels, modelsDevModels),
+							normalizeModelList<TApi>(latestCache?.models ?? cache?.models ?? []),
+						),
 					),
-				),
-				false,
-				staticFingerprint,
-				dbPath,
-			);
+					false,
+					staticFingerprint,
+					dbPath,
+				);
+			}
 		}
 	}
 	return {

package/src/providers/anthropic-messages-server.ts

@@ -417,6 +417,62 @@ function mapStopReasonOut(reason: StopReason): "end_turn" | "max_tokens" | "tool
 	}
 }
 
+/**
+ * True when `signature` is one of OUR serialized OpenAI Responses reasoning-item
+ * envelopes (produced by the Responses/Codex decoders as
+ * `JSON.stringify(reasoningItem)` with `type: "reasoning"`). Such an envelope is
+ * NOT a valid Anthropic thinking signature and may embed raw chain-of-thought in
+ * `content[]`, so it must never be forwarded on Anthropic egress. Genuine opaque
+ * Anthropic signatures and any non-envelope string return false (fail safe).
+ */
+function isSerializedResponsesReasoningItem(signature: string): boolean {
+	try {
+		const parsed: unknown = JSON.parse(signature);
+		return (
+			typeof parsed === "object" &&
+			parsed !== null &&
+			!Array.isArray(parsed) &&
+			(parsed as { type?: unknown }).type === "reasoning"
+		);
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * A thinking-block signature safe to emit on Anthropic egress: cross-protocol
+ * serialized Responses reasoning envelopes are omitted (they can carry raw CoT);
+ * genuine opaque Anthropic signatures round-trip unchanged.
+ */
+function safeThinkingSignature(signature: string | undefined): string | undefined {
+	if (!signature) return undefined;
+	if (isSerializedResponsesReasoningItem(signature)) return undefined;
+	return signature;
+}
+
+function isResponsesFamilyApi(api: AssistantMessage["api"]): boolean {
+	return api === "openai-responses" || api === "openai-codex-responses";
+}
+
+function safeThinkingText(content: ThinkingContent, api: AssistantMessage["api"]): string | undefined {
+	if (isResponsesFamilyApi(api) && content.provenance === undefined) return undefined;
+	if (content.provenance === "raw") return undefined;
+	if (content.provenance === "mixed") return content.summaryText;
+	if (content.provenance === "summary") return content.summaryText ?? content.thinking;
+	return content.thinking;
+}
+
+function hasRawOrMixedThinking(partial: AssistantMessage, contentIndex: number): boolean {
+	const content = partial.content[contentIndex];
+	return content?.type === "thinking" && (content.provenance === "raw" || content.provenance === "mixed");
+}
+
+/** Responses-family reasoning is untrusted until output_item.done assigns provenance. */
+function hasUnfinalizedResponsesThinking(partial: AssistantMessage, contentIndex: number): boolean {
+	const content = partial.content[contentIndex];
+	return content?.type !== "thinking" || (isResponsesFamilyApi(partial.api) && content.provenance === undefined);
+}
+
 function encodeContentBlocks(message: AssistantMessage): Record<string, unknown>[] {
 	const blocks: Record<string, unknown>[] = [];
 	for (const c of message.content) {
@@ -425,8 +481,11 @@ function encodeContentBlocks(message: AssistantMessage): Record<string, unknown>
 				blocks.push({ type: "text", text: c.text });
 				break;
 			case "thinking": {
-				const b: Record<string, unknown> = { type: "thinking", thinking: c.thinking };
-				if (c.thinkingSignature) b.signature = c.thinkingSignature;
+				const thinking = safeThinkingText(c, message.api);
+				if (thinking === undefined) break;
+				const b: Record<string, unknown> = { type: "thinking", thinking };
+				const sig = safeThinkingSignature(c.thinkingSignature);
+				if (sig) b.signature = sig;
 				blocks.push(b);
 				break;
 			}
@@ -495,6 +554,12 @@ export function encodeStream(
 			const messageId = newMessageId();
 			let started = false;
 			const open = new Map<number, OpenBlock>();
+			// contentIndexes that already streamed a reasoning summary delta, so a
+			// final-only reasoning_summary_end does not duplicate streamed summary text.
+			const summaryDeltaSeen = new Set<number>();
+			// Responses assigns reasoning provenance only at output_item.done. Keep its
+			// pre-classification bytes out of this public compatibility stream.
+			const pendingThinkingDeltas = new Map<number, string[]>();
 
 			const ensureStart = (partial: AssistantMessage) => {
 				if (started) return;
@@ -524,6 +589,30 @@ export function encodeStream(
 				open.delete(index);
 			};
 
+			const openThinking = (partial: AssistantMessage, index: number) => {
+				if (open.has(index)) return;
+				ensureStart(partial);
+				open.set(index, { index, kind: "thinking" });
+				controller.enqueue(
+					sseFrame("content_block_start", {
+						type: "content_block_start",
+						index,
+						content_block: { type: "thinking", thinking: "" },
+					}),
+				);
+			};
+
+			const writeThinkingDelta = (index: number, thinking: string) => {
+				if (thinking.length === 0) return;
+				controller.enqueue(
+					sseFrame("content_block_delta", {
+						type: "content_block_delta",
+						index,
+						delta: { type: "thinking_delta", thinking },
+					}),
+				);
+			};
+
 			try {
 				for await (const ev of events) {
 					switch (ev.type) {
@@ -555,18 +644,73 @@ export function encodeStream(
 							closeBlock(ev.contentIndex);
 							break;
 						case "thinking_start": {
-							ensureStart(ev.partial);
-							open.set(ev.contentIndex, { index: ev.contentIndex, kind: "thinking" });
-							controller.enqueue(
-								sseFrame("content_block_start", {
-									type: "content_block_start",
-									index: ev.contentIndex,
-									content_block: { type: "thinking", thinking: "" },
-								}),
-							);
+							if (hasRawOrMixedThinking(ev.partial, ev.contentIndex)) break;
+							if (hasUnfinalizedResponsesThinking(ev.partial, ev.contentIndex)) {
+								pendingThinkingDeltas.set(ev.contentIndex, []);
+								break;
+							}
+							openThinking(ev.partial, ev.contentIndex);
+							break;
+						}
+						case "thinking_delta": {
+							if (hasRawOrMixedThinking(ev.partial, ev.contentIndex)) break;
+							if (hasUnfinalizedResponsesThinking(ev.partial, ev.contentIndex)) {
+								const deltas = pendingThinkingDeltas.get(ev.contentIndex) ?? [];
+								deltas.push(ev.delta);
+								pendingThinkingDeltas.set(ev.contentIndex, deltas);
+								break;
+							}
+							writeThinkingDelta(ev.contentIndex, ev.delta);
+							break;
+						}
+						case "thinking_end": {
+							const unfinalized = hasUnfinalizedResponsesThinking(ev.partial, ev.contentIndex);
+							const rawOrMixed = hasRawOrMixedThinking(ev.partial, ev.contentIndex);
+							const pending = pendingThinkingDeltas.get(ev.contentIndex);
+							pendingThinkingDeltas.delete(ev.contentIndex);
+							if (rawOrMixed || unfinalized) {
+								closeBlock(ev.contentIndex);
+								break;
+							}
+							if (pending) {
+								openThinking(ev.partial, ev.contentIndex);
+								for (const delta of pending) writeThinkingDelta(ev.contentIndex, delta);
+							}
+							const c = ev.partial.content[ev.contentIndex];
+							const sig = c?.type === "thinking" ? safeThinkingSignature(c.thinkingSignature) : undefined;
+							if (sig) {
+								controller.enqueue(
+									sseFrame("content_block_delta", {
+										type: "content_block_delta",
+										index: ev.contentIndex,
+										delta: { type: "signature_delta", signature: sig },
+									}),
+								);
+							}
+							closeBlock(ev.contentIndex);
+							break;
+						}
+						case "reasoning_summary_start": {
+							// Provider-displayable summary reasoning surfaces as this format's
+							// native thinking channel. Open the thinking block if a thinking_start
+							// did not already (summary-only streams emit no thinking_start).
+							if (!open.has(ev.contentIndex)) {
+								ensureStart(ev.partial);
+								open.set(ev.contentIndex, { index: ev.contentIndex, kind: "thinking" });
+								controller.enqueue(
+									sseFrame("content_block_start", {
+										type: "content_block_start",
+										index: ev.contentIndex,
+										content_block: { type: "thinking", thinking: "" },
+									}),
+								);
+							}
 							break;
 						}
-						case "thinking_delta":
+						case "reasoning_summary_delta":
+							// Only a non-whitespace delta counts as a delivered summary; a bare
+							// separator ("\n\n") must not suppress a later final-only end content.
+							if (ev.delta.trim().length > 0) summaryDeltaSeen.add(ev.contentIndex);
 							controller.enqueue(
 								sseFrame("content_block_delta", {
 									type: "content_block_delta",
@@ -575,18 +719,31 @@ export function encodeStream(
 								}),
 							);
 							break;
-						case "thinking_end": {
-							const c = ev.partial.content[ev.contentIndex];
-							if (c?.type === "thinking" && c.thinkingSignature) {
+						case "reasoning_summary_end": {
+							// Final-only summary: text arrives only on the end event with no prior
+							// deltas. Ensure the thinking block is open, then surface the content as
+							// a thinking_delta (skip when deltas already streamed to avoid dup). The
+							// thinking block is closed by the subsequent thinking_end.
+							if (ev.content.length > 0 && !summaryDeltaSeen.has(ev.contentIndex)) {
+								if (!open.has(ev.contentIndex)) {
+									ensureStart(ev.partial);
+									open.set(ev.contentIndex, { index: ev.contentIndex, kind: "thinking" });
+									controller.enqueue(
+										sseFrame("content_block_start", {
+											type: "content_block_start",
+											index: ev.contentIndex,
+											content_block: { type: "thinking", thinking: "" },
+										}),
+									);
+								}
 								controller.enqueue(
 									sseFrame("content_block_delta", {
 										type: "content_block_delta",
 										index: ev.contentIndex,
-										delta: { type: "signature_delta", signature: c.thinkingSignature },
+										delta: { type: "thinking_delta", thinking: ev.content },
 									}),
 								);
 							}
-							closeBlock(ev.contentIndex);
 							break;
 						}
 						case "toolcall_start": {
@@ -621,6 +778,7 @@ export function encodeStream(
 							break;
 						case "done": {
 							for (const idx of [...open.keys()]) closeBlock(idx);
+							pendingThinkingDeltas.clear();
 							controller.enqueue(
 								sseFrame("message_delta", {
 									type: "message_delta",
@@ -636,6 +794,7 @@ export function encodeStream(
 						}
 						case "error": {
 							const msg = ev.error.errorMessage ?? "stream error";
+							pendingThinkingDeltas.clear();
 							controller.enqueue(
 								sseFrame("error", { type: "error", error: { type: "api_error", message: msg } }),
 							);
@@ -645,10 +804,12 @@ export function encodeStream(
 					}
 				}
 				// stream ended without explicit done; close gracefully
+				pendingThinkingDeltas.clear();
 				for (const idx of [...open.keys()]) closeBlock(idx);
 				controller.enqueue(sseFrame("message_stop", { type: "message_stop" }));
 				controller.close();
 			} catch (err) {
+				pendingThinkingDeltas.clear();
 				controller.enqueue(
 					sseFrame("error", {
 						type: "error",