@prometheus-ai/ai 0.5.4 → 0.5.8

package/src/providers/google-shared.ts

@@ -2,8 +2,10 @@
  * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
  */
 
+import { scheduler } from "node:timers/promises";
+import { calculateCost } from "@prometheus-ai/catalog/models";
 import { extractHttpStatusFromError, readSseJson } from "@prometheus-ai/utils";
-import { calculateCost } from "../models";
+import { ProviderHttpError } from "../errors";
 import type {
 	Api,
 	AssistantMessage,
@@ -20,7 +22,7 @@ import type {
 } from "../types";
 import { normalizeSystemPrompts } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
-import { finalizeErrorMessage, type RawHttpRequestDump, withHttpStatus } from "../utils/http-inspector";
+import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
 import { normalizeSchemaForCCA, normalizeSchemaForGoogle, toolWireSchema } from "../utils/schema";
 import type {
 	Content,
@@ -45,6 +47,11 @@ export type {
 } from "./google-types";
 export { normalizeSchemaForGoogle };
 
+/** Non-2xx response (or in-stream error chunk) from the Google Generative Language / Vertex API. */
+export class GoogleApiError extends ProviderHttpError {
+	override readonly name = "GoogleApiError";
+}
+
 type GoogleApiType = "google-generative-ai" | "google-gemini-cli" | "google-vertex";
 
 /**
@@ -160,7 +167,19 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 
 	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
 
+	// Gemini < 3 image tool results go in a separate user turn, but parallel tool results must
+	// stay a single contiguous functionResponse turn ("number of function response parts is not
+	// equal to number of function call parts"). Buffer image turns and flush them only after the
+	// merged functionResponse turn is complete.
+	let pendingToolImageParts: Part[] = [];
+	const flushPendingToolImages = () => {
+		if (pendingToolImageParts.length === 0) return;
+		contents.push({ role: "user", parts: pendingToolImageParts });
+		pendingToolImageParts = [];
+	};
+
 	for (const msg of transformedMessages) {
+		if (msg.role !== "toolResult") flushPendingToolImages();
 		if (msg.role === "user" || msg.role === "developer") {
 			if (typeof msg.content === "string") {
 				// Skip empty user messages
@@ -314,15 +333,13 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 				});
 			}
 
-			// For Gemini < 3, add images in a separate user message
+			// For Gemini < 3, buffer images for a separate user message after the functionResponse turn
 			if (hasImages && !modelSupportsMultimodalFunctionResponse) {
-				contents.push({
-					role: "user",
-					parts: [{ text: "Tool result image:" }, ...imageParts],
-				});
+				pendingToolImageParts.push({ text: "Tool result image:" }, ...imageParts);
 			}
 		}
 	}
+	flushPendingToolImages();
 
 	return contents;
 }
@@ -355,7 +372,7 @@ export function convertTools(
 				description: tool.description || "",
 				...(useParameters
 					? { parameters: normalizeSchemaForCCA(toolWireSchema(tool)) }
-					: { parametersJsonSchema: toolWireSchema(tool) }),
+					: { parametersJsonSchema: normalizeSchemaForGoogle(toolWireSchema(tool)) }),
 			})),
 		},
 	];
@@ -422,6 +439,47 @@ export function mapStopReasonString(reason: string): StopReason {
 	}
 }
 
+/**
+ * Bounded retries for the well-known Gemini "empty response" failure: a benign
+ * `finishReason: STOP` carrying only an empty/whitespace text part and no tool call.
+ * Shared by the public/Vertex `streamGoogleGenAI` path and the Cloud Code Assist
+ * (`google-gemini-cli`/`google-antigravity`) provider so both apply the same policy.
+ */
+export const MAX_EMPTY_STREAM_RETRIES = 2;
+export const EMPTY_STREAM_BASE_DELAY_MS = 500;
+
+/**
+ * Whether a completed Google assistant message carries content worth delivering.
+ *
+ * A tool call or any non-whitespace text counts as meaningful. An empty/whitespace-only
+ * text part — or thinking that never produced an answer — is the "empty response" failure:
+ * delivered as-is the agent loop has nothing to act on and silently halts, so the request
+ * must be retried instead of surfaced.
+ */
+export function hasMeaningfulGoogleContent(output: AssistantMessage): boolean {
+	for (const block of output.content) {
+		if (block.type === "toolCall") return true;
+		if (block.type === "text" && block.text.trim().length > 0) return true;
+	}
+	return false;
+}
+
+/** Wipe a streamed message between empty-response retries so the next attempt starts clean. */
+function resetGoogleStreamOutputForRetry(output: AssistantMessage): void {
+	output.content = [];
+	output.usage = {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	};
+	output.stopReason = "stop";
+	output.errorMessage = undefined;
+	output.timestamp = Date.now();
+}
+
 /**
  * Module-local counter for generating unique tool call IDs across Google providers.
  * Shared so that a single monotonically-increasing sequence is used regardless of which
@@ -527,6 +585,7 @@ export async function consumeGoogleStream<T extends GoogleApiType>(args: {
 	const blockIndex = () => blocks.length - 1;
 	let currentBlock: TextContent | ThinkingContent | null = null;
 	let firstTokenSeen = false;
+	let sawFinishReason = false;
 
 	const flushCurrent = () => {
 		if (!currentBlock) return;
@@ -534,10 +593,23 @@ export async function consumeGoogleStream<T extends GoogleApiType>(args: {
 	};
 
 	for await (const chunk of googleStream) {
+		if (chunk.error) {
+			const detail = chunk.error.message || chunk.error.status || "unknown error";
+			const message = `Google API stream error: ${detail}`;
+			throw typeof chunk.error.code === "number" && chunk.error.code >= 400
+				? new GoogleApiError(message, chunk.error.code)
+				: new Error(message);
+		}
+		if (!chunk.candidates?.length && chunk.promptFeedback?.blockReason) {
+			const detail = chunk.promptFeedback.blockReasonMessage;
+			throw new Error(
+				`Request blocked by Google (${chunk.promptFeedback.blockReason})${detail ? `: ${detail}` : ""}`,
+			);
+		}
 		const candidate = chunk.candidates?.[0];
 		if (candidate?.content?.parts) {
 			for (const part of candidate.content.parts) {
-				if (part.text !== undefined) {
+				if (part.text !== undefined && part.text !== "") {
 					if (!firstTokenSeen) {
 						firstTokenSeen = true;
 						onFirstToken?.();
@@ -578,6 +650,18 @@ export async function consumeGoogleStream<T extends GoogleApiType>(args: {
 							partial: output,
 						});
 					}
+				} else if (part.text === "" && part.thoughtSignature && currentBlock && !part.functionCall) {
+					if (currentBlock.type === "thinking") {
+						currentBlock.thinkingSignature = retainThoughtSignature(
+							currentBlock.thinkingSignature,
+							part.thoughtSignature,
+						);
+					} else if (retainTextSignature) {
+						currentBlock.textSignature = retainThoughtSignature(
+							currentBlock.textSignature,
+							part.thoughtSignature,
+						);
+					}
 				}
 
 				if (part.functionCall) {
@@ -606,9 +690,17 @@ export async function consumeGoogleStream<T extends GoogleApiType>(args: {
 		}
 
 		if (candidate?.finishReason) {
-			output.stopReason = mapStopReason(candidate.finishReason);
-			if (output.content.some(b => b.type === "toolCall")) {
+			sawFinishReason = true;
+			const mapped = mapStopReason(candidate.finishReason);
+			// Only let a trailing tool call upgrade benign finishes; SAFETY/MALFORMED_FUNCTION_CALL
+			// and friends must surface as errors even when earlier chunks carried valid tool calls.
+			if ((mapped === "stop" || mapped === "length") && output.content.some(b => b.type === "toolCall")) {
 				output.stopReason = "toolUse";
+			} else {
+				output.stopReason = mapped;
+				if (mapped === "error") {
+					output.errorMessage = `Generation failed with finish reason: ${candidate.finishReason}`;
+				}
 			}
 		}
 
@@ -645,6 +737,10 @@ export async function consumeGoogleStream<T extends GoogleApiType>(args: {
 		throw new Error("Request was aborted");
 	}
 
+	if (!sawFinishReason) {
+		throw new Error("Google API stream ended without a finish reason (connection dropped or response truncated)");
+	}
+
 	if (output.stopReason === "aborted" || output.stopReason === "error") {
 		throw new Error(output.errorMessage ?? "An unknown error occurred");
 	}
@@ -804,41 +900,65 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 				headers: plan.headers,
 			};
 
-			const wireBody = paramsToWireBody(params);
+			const bodyJson = JSON.stringify(paramsToWireBody(params));
 			const fetchImpl = plan.fetch ?? options?.fetch ?? (globalThis.fetch.bind(globalThis) as FetchImpl);
-			const response = await fetchImpl(plan.url, {
-				method: "POST",
-				headers: { ...plan.headers, "Content-Type": "application/json", Accept: "text/event-stream" },
-				body: JSON.stringify(wireBody),
-				signal: options?.signal,
-			});
-			if (!response.ok) {
-				const errorText = await response.text().catch(() => "");
-				throw withHttpStatus(
-					new Error(`Google API error (${response.status}): ${extractGoogleErrorMessage(errorText)}`),
-					response.status,
-				);
-			}
-			if (!response.body) {
-				throw new Error("Google API returned an empty response body");
-			}
-
-			const googleStream = readSseJson<GenerateContentResponse>(response.body, options?.signal, event =>
-				options?.onSseEvent?.({ event: event.event, data: event.data, raw: [...event.raw] }, model),
-			);
+			const openStream = async (): Promise<ReadableStream<Uint8Array>> => {
+				const response = await fetchImpl(plan.url, {
+					method: "POST",
+					headers: { ...plan.headers, "Content-Type": "application/json", Accept: "text/event-stream" },
+					body: bodyJson,
+					signal: options?.signal,
+				});
+				if (!response.ok) {
+					const errorText = await response.text().catch(() => "");
+					throw new GoogleApiError(
+						`Google API error (${response.status}): ${extractGoogleErrorMessage(errorText)}`,
+						response.status,
+						{ headers: response.headers },
+					);
+				}
+				if (!response.body) {
+					throw new Error("Google API returned an empty response body");
+				}
+				return response.body as ReadableStream<Uint8Array>;
+			};
 
+			let body = await openStream();
 			stream.push({ type: "start", partial: output });
-			await consumeGoogleStream({
-				googleStream,
-				output,
-				stream,
-				model,
-				options,
-				retainTextSignature,
-				onFirstToken: () => {
-					firstTokenTime = Date.now();
-				},
-			});
+
+			// Gemini occasionally finishes with `finishReason: STOP` while emitting only an empty
+			// text part and no tool call. Delivered as-is the agent receives a blank message and
+			// silently halts mid-task, so retry a bounded number of times before giving up.
+			for (let emptyAttempt = 0; ; emptyAttempt++) {
+				const googleStream = readSseJson<GenerateContentResponse>(body, options?.signal, event =>
+					options?.onSseEvent?.({ event: event.event, data: event.data, raw: [...event.raw] }, model),
+				);
+				await consumeGoogleStream({
+					googleStream,
+					output,
+					stream,
+					model,
+					options,
+					retainTextSignature,
+					onFirstToken: () => {
+						firstTokenTime = Date.now();
+					},
+				});
+
+				if (output.stopReason !== "stop" || hasMeaningfulGoogleContent(output)) break;
+				if (emptyAttempt >= MAX_EMPTY_STREAM_RETRIES) {
+					throw new Error(
+						`Google API returned an empty response (finishReason STOP with no content) after ${MAX_EMPTY_STREAM_RETRIES + 1} attempts`,
+					);
+				}
+				try {
+					await scheduler.wait(EMPTY_STREAM_BASE_DELAY_MS * 2 ** emptyAttempt, { signal: options?.signal });
+				} catch {
+					throw new Error("Request was aborted");
+				}
+				resetGoogleStreamOutputForRetry(output);
+				body = await openStream();
+			}
 
 			output.duration = Date.now() - startTime;
 			if (firstTokenTime) output.ttft = firstTokenTime - startTime;

package/src/providers/google-types.ts

@@ -157,11 +157,20 @@ export interface UsageMetadata {
 	cachedContentTokenCount?: number;
 }
 
+/** Prompt-level safety feedback; `blockReason` is set (with no candidates) when the prompt is blocked. */
+export interface PromptFeedback {
+	blockReason?: string;
+	blockReasonMessage?: string;
+	[key: string]: unknown;
+}
+
 /** Single SSE chunk's parsed JSON body. */
 export interface GenerateContentResponse {
 	candidates?: Candidate[];
 	usageMetadata?: UsageMetadata;
 	modelVersion?: string;
 	responseId?: string;
-	promptFeedback?: Record<string, unknown>;
+	promptFeedback?: PromptFeedback;
+	/** In-band stream failure (quota, internal error) delivered as a final JSON event. */
+	error?: { code?: number; message?: string; status?: string };
 }

package/src/providers/kimi.ts

@@ -9,9 +9,9 @@
  * Note: Kimi calculates TPM rate limits based on max_tokens, not actual output.
  */
 
+import { getKimiCommonHeaders } from "../registry/oauth/kimi";
 import type { Api, Context, Model } from "../types";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
-import { getKimiCommonHeaders } from "../utils/oauth/kimi";
 import {
 	type OpenAIAnthropicApiFormat,
 	type OpenAIAnthropicShimOptions,

package/src/providers/mock.ts

@@ -2,7 +2,7 @@
  * Mock provider for tests.
  *
  * Implements `Model<"mock">` + `streamMock` so test code can drive
- * pi-agent-core / streamSimple-shaped consumers without an HTTP client.
+ * agent-core / streamSimple-shaped consumers without an HTTP client.
  *
  * Usage:
  *
@@ -49,6 +49,7 @@ import type {
 	Context,
 	Model,
 	SimpleStreamOptions,
+	StopDetails,
 	StopReason,
 	TextContent,
 	ThinkingContent,
@@ -81,6 +82,10 @@ export interface MockResponse {
 	content?: ReadonlyArray<MockContent>;
 	/** Stop reason. Defaults to `"toolUse"` when content has tool calls, else `"stop"`. */
 	stopReason?: StopReason;
+	/** Structured terminal stop classification, e.g. Anthropic refusal metadata. */
+	stopDetails?: StopDetails | null;
+	/** Error text paired with an explicit `"error"` stop reason. */
+	errorMessage?: string;
 	/** Usage stats. Missing fields default to 0; missing `cost.total` is recomputed from components. */
 	usage?: Partial<Omit<Usage, "cost">> & { cost?: Partial<Usage["cost"]> };
 	/** Pre-set responseId. */
@@ -168,6 +173,7 @@ export class MockModel implements Model<MockApi> {
 	readonly cost: Model["cost"];
 	readonly contextWindow: number;
 	readonly maxTokens: number;
+	readonly compat = undefined;
 
 	/** Recorded calls in invocation order. */
 	readonly calls: MockCall[] = [];
@@ -226,7 +232,7 @@ export function createMockModel(options: MockModelOptions = {}): MockModel {
 	return new MockModel(options);
 }
 
-/** Stream function for `Model<"mock">`. Matches the @prometheus-ai/ai per-provider stream signature. */
+/** Stream function for `Model<"mock">`. Matches the Prometheus AI per-provider stream signature. */
 export function streamMock(
 	model: Model<Api>,
 	context: Context,
@@ -250,7 +256,7 @@ export function streamMock(
 }
 
 /** Convenience: register the mock provider with the global custom API registry. */
-export function registerMockApi(sourceId = "prometheus-ai/mock"): void {
+export function registerMockApi(sourceId = "@prometheus-ai/ai/mock"): void {
 	registerCustomApi(MOCK_API, streamMock, sourceId);
 }
 
@@ -388,6 +394,8 @@ async function runMock(
 	const reason: StopReason = response.stopReason ?? (hasToolCall ? ("toolUse" as StopReason) : ("stop" as StopReason));
 
 	partial.stopReason = reason;
+	partial.stopDetails = response.stopDetails;
+	partial.errorMessage = response.errorMessage;
 	partial.usage = mergeUsage(response.usage);
 	partial.duration = Date.now() - startedAt;
 

package/src/providers/ollama.ts

@@ -1,4 +1,5 @@
 import { extractHttpStatusFromError, fetchWithRetry } from "@prometheus-ai/utils";
+import { ProviderHttpError } from "../errors";
 import { getEnvApiKey } from "../stream";
 import type {
 	Api,
@@ -16,7 +17,8 @@ import type {
 } from "../types";
 import { normalizeSystemPrompts } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
-import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
+import { type CapturedHttpErrorResponse, finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
+import { getOpenAIStreamFirstEventTimeoutMs, getOpenAIStreamIdleTimeoutMs } from "../utils/idle-iterator";
 import { parseStreamingJson } from "../utils/json-parse";
 import { toolWireSchema } from "../utils/schema/wire";
 import {
@@ -27,8 +29,14 @@ import {
 } from "../utils/stream-markup-healing";
 import { transformMessages } from "./transform-messages";
 
+/** Non-2xx response from the Ollama `/api/chat` endpoint. */
+export class OllamaApiError extends ProviderHttpError {
+	override readonly name = "OllamaApiError";
+}
+
 export interface OllamaChatOptions extends StreamOptions {
 	reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
+	disableReasoning?: boolean;
 	toolChoice?: ToolChoice;
 }
 
@@ -91,7 +99,14 @@ function normalizeBaseUrl(baseUrl?: string): string {
 	return trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed;
 }
 
-function mapReasoning(reasoning: OllamaChatOptions["reasoning"]): boolean | "low" | "medium" | "high" | undefined {
+function mapReasoning(
+	reasoning: OllamaChatOptions["reasoning"],
+	disableReasoning: boolean | undefined,
+	modelReasoning: boolean,
+): boolean | "low" | "medium" | "high" | undefined {
+	if (disableReasoning && modelReasoning) {
+		return false;
+	}
 	switch (reasoning) {
 		case "minimal":
 		case "low":
@@ -258,7 +273,7 @@ function convertTools(tools: Tool[] | undefined): OllamaFunctionTool[] | undefin
 }
 
 function createChatBody(model: Model<"ollama-chat">, context: Context, options: OllamaChatOptions | undefined) {
-	const think = mapReasoning(options?.reasoning);
+	const think = mapReasoning(options?.reasoning, options?.disableReasoning, model.reasoning);
 	const toolChoice = mapToolChoice(options?.toolChoice);
 	const selectedTools = selectToolsForToolChoice(context.tools, options?.toolChoice);
 	const tools = convertTools(selectedTools);
@@ -268,11 +283,32 @@ function createChatBody(model: Model<"ollama-chat">, context: Context, options:
 		...(tools ? { tools } : {}),
 		...(think !== undefined ? { think } : {}),
 		...(toolChoice !== undefined ? { tool_choice: toolChoice } : {}),
-		...(options?.maxTokens !== undefined ? { options: { num_predict: options.maxTokens } } : {}),
+		...(options?.maxTokens !== undefined && !model.omitMaxOutputTokens
+			? { options: { num_predict: options.maxTokens } }
+			: {}),
 		stream: true,
 	};
 }
 
+async function captureHttpErrorResponse(response: Response): Promise<CapturedHttpErrorResponse> {
+	let bodyText: string | undefined;
+	let bodyJson: unknown;
+	try {
+		bodyText = await response.text();
+		if (bodyText.trim()) {
+			try {
+				bodyJson = JSON.parse(bodyText) as unknown;
+			} catch {}
+		}
+	} catch {}
+	return {
+		status: response.status,
+		headers: response.headers,
+		bodyText,
+		bodyJson,
+	};
+}
+
 async function* iterateNdjson(stream: ReadableStream<Uint8Array>): AsyncGenerator<OllamaChatChunk> {
 	const reader = stream.getReader();
 	const decoder = new TextDecoder();
@@ -376,6 +412,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 		let firstTokenTime: number | undefined;
 		const output = createEmptyOutput(model);
 		let rawRequestDump: RawHttpRequestDump | undefined;
+		let capturedErrorResponse: CapturedHttpErrorResponse | undefined;
 		let activeThinkingIndex: number | undefined;
 		let activeTextIndex: number | undefined;
 		const activeToolIndices = new Set<number>();
@@ -489,6 +526,22 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 				url: `${baseUrl}/api/chat`,
 				body,
 			};
+			// Direct callers that bypass `register-builtins` (which installs
+			// the iterator-level watchdog) need a pre-response timer alongside
+			// `timeout: false`; otherwise an Ollama server that accepts the
+			// POST and never streams headers would hang forever (issue #2422).
+			const idleTimeoutMs = options.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs();
+			const firstEventTimeoutMs =
+				options.streamFirstEventTimeoutMs ?? getOpenAIStreamFirstEventTimeoutMs(idleTimeoutMs);
+			const preResponseWatchdog =
+				firstEventTimeoutMs !== undefined && firstEventTimeoutMs > 0
+					? AbortSignal.timeout(firstEventTimeoutMs)
+					: undefined;
+			const fetchSignal = preResponseWatchdog
+				? options.signal
+					? AbortSignal.any([options.signal, preResponseWatchdog])
+					: preResponseWatchdog
+				: options.signal;
 			const response = await fetchWithRetry(`${baseUrl}/api/chat`, {
 				method: "POST",
 				headers: {
@@ -498,12 +551,16 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 					"Content-Type": "application/json",
 				},
 				body: JSON.stringify(body),
-				signal: options.signal,
+				signal: fetchSignal,
 				defaultDelayMs: OLLAMA_RETRY_DELAYS_MS,
 				fetch: options.fetch,
+				timeout: false,
 			});
 			if (!response.ok) {
-				throw new Error(`HTTP ${response.status} from ${baseUrl}/api/chat`);
+				capturedErrorResponse = await captureHttpErrorResponse(response);
+				throw new OllamaApiError(`HTTP ${response.status} from ${baseUrl}/api/chat`, response.status, {
+					headers: response.headers,
+				});
 			}
 			if (!response.body) {
 				throw new Error("Ollama returned an empty response body");
@@ -631,7 +688,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 			}
 			output.stopReason = options.signal?.aborted ? "aborted" : "error";
 			output.errorStatus = extractHttpStatusFromError(error);
-			output.errorMessage = await finalizeErrorMessage(error, rawRequestDump);
+			output.errorMessage = await finalizeErrorMessage(error, rawRequestDump, capturedErrorResponse);
 			output.duration = Date.now() - startTime;
 			if (firstTokenTime) {
 				output.ttft = firstTokenTime - startTime;

package/src/providers/openai-anthropic-shim.ts

@@ -8,8 +8,9 @@
  * here once.
  */
 
+import { buildModel } from "@prometheus-ai/catalog/build";
 import { ANTHROPIC_THINKING } from "../stream";
-import type { Context, Model, SimpleStreamOptions } from "../types";
+import type { Context, Model, ModelSpec, SimpleStreamOptions } from "../types";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { createProviderErrorMessage } from "./error-message";
 import { streamAnthropic, streamOpenAICompletions } from "./register-builtins";
@@ -44,6 +45,9 @@ export function streamOpenAIAnthropicShim(
 ): AssistantMessageEventStream {
 	const stream = new AssistantMessageEventStream();
 	const format = options?.format ?? config.defaultFormat;
+	// The resolver form of `apiKey` is resolved upstream in `streamSimple`;
+	// this shim only ever receives a static bearer string.
+	const apiKey = typeof options?.apiKey === "string" ? options.apiKey : undefined;
 
 	(async () => {
 		try {
@@ -53,7 +57,7 @@ export function streamOpenAIAnthropicShim(
 			};
 
 			if (format === "anthropic") {
-				const anthropicModel: Model<"anthropic-messages"> = {
+				const anthropicModel = buildModel({
 					id: model.id,
 					name: model.name,
 					api: "anthropic-messages",
@@ -65,7 +69,7 @@ export function streamOpenAIAnthropicShim(
 					reasoning: model.reasoning,
 					input: model.input,
 					cost: model.cost,
-				};
+				} as ModelSpec<"anthropic-messages">);
 
 				const reasoningEffort = options?.reasoning;
 				const thinkingEnabled = !!reasoningEffort && model.reasoning;
@@ -74,14 +78,14 @@ export function streamOpenAIAnthropicShim(
 					: undefined;
 
 				const innerStream = streamAnthropic(anthropicModel, context, {
-					apiKey: options?.apiKey,
+					apiKey,
 					temperature: options?.temperature,
 					topP: options?.topP,
 					topK: options?.topK,
 					minP: options?.minP,
 					presencePenalty: options?.presencePenalty,
 					repetitionPenalty: options?.repetitionPenalty,
-					maxTokens: options?.maxTokens ?? model.maxTokens,
+					maxTokens: options?.maxTokens ?? model.maxTokens ?? undefined,
 					signal: options?.signal,
 					headers: mergedHeaders,
 					sessionId: options?.sessionId,
@@ -98,19 +102,24 @@ export function streamOpenAIAnthropicShim(
 				}
 			} else {
 				const openaiModel: Model<"openai-completions"> = config.openaiBaseUrl
-					? { ...model, baseUrl: config.openaiBaseUrl, headers: mergedHeaders }
+					? buildModel({
+							...model,
+							baseUrl: config.openaiBaseUrl,
+							headers: mergedHeaders,
+							compat: model.compatConfig,
+						} as ModelSpec<"openai-completions">)
 					: model;
 
 				const reasoningEffort = options?.reasoning;
 				const innerStream = streamOpenAICompletions(openaiModel, context, {
-					apiKey: options?.apiKey,
+					apiKey,
 					temperature: options?.temperature,
 					topP: options?.topP,
 					topK: options?.topK,
 					minP: options?.minP,
 					presencePenalty: options?.presencePenalty,
 					repetitionPenalty: options?.repetitionPenalty,
-					maxTokens: options?.maxTokens ?? model.maxTokens,
+					maxTokens: options?.maxTokens ?? model.maxTokens ?? undefined,
 					signal: options?.signal,
 					headers: mergedHeaders,
 					sessionId: options?.sessionId,

package/src/providers/openai-chat-server-schema.ts

@@ -7,6 +7,8 @@
  * non-strict defaults (e.g. `stream_options.include_obfuscation`) — does not
  * trip 400s on shapes we simply ignore.
  */
+
+import { z } from "zod/v4";
 import type {
 	ChatCompletionContentPart,
 	ChatCompletionCreateParams,
@@ -14,8 +16,7 @@ import type {
 	ChatCompletionMessageToolCall,
 	ChatCompletionTool,
 	ChatCompletionToolChoiceOption,
-} from "openai/resources/chat/completions";
-import * as z from "zod/v4";
+} from "./openai-chat-wire";
 
 // ─── User-message content parts ─────────────────────────────────────────────
 
@@ -27,7 +28,7 @@ export const textPartSchema = z.object({
 /**
  * OpenAI documents `image_url` as either `{ url: string, detail?: ... }` or —
  * older clients — a bare string. Accept both shapes; downstream we extract a
- * URL. `detail` is accepted for forward-compat but currently dropped (@prometheus-ai/ai's
+ * URL. `detail` is accepted for forward-compat but currently dropped (Prometheus AI's
  * `ImageContent` has no detail field — TODO: plumb through if/when added).
  */
 export const imagePartSchema = z.object({
@@ -145,6 +146,11 @@ export const assistantMessageSchema = z.object({
 	role: z.literal("assistant"),
 	content: baseContent.optional(),
 	tool_calls: z.array(toolCallSchema).optional(),
+	// DeepSeek-style reasoning channel. The gateway emits it on the way out
+	// (encodeResponse/encodeStream); accept it back so thinking-mode
+	// continuations replay the model's actual reasoning instead of a
+	// synthesized placeholder.
+	reasoning_content: z.string().nullish(),
 });
 
 export const toolMessageSchema = z.object({