@gajae-code/ai 0.15.5 → 0.16.0

package/src/providers/google-gemini-headers.ts

@@ -5,7 +5,7 @@
  */
 export const GEMINI_CLI_VERSION_ENV = "GJC_AI_GEMINI_CLI_VERSION";
 export const LEGACY_GEMINI_CLI_VERSION_ENV = "PI_AI_GEMINI_CLI_VERSION";
-export const DEFAULT_GEMINI_CLI_VERSION = "0.52.0";
+export const DEFAULT_GEMINI_CLI_VERSION = "0.58.0";
 
 export function getGeminiCliUserAgent(modelId = "gemini-3.1-pro-preview"): string {
 	const version =

package/src/providers/google-shared.ts

@@ -921,6 +921,7 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 				options.toolChoice !== "auto" &&
 				options.toolChoice !== "none";
 			const fetchImpl = plan.fetch ?? options?.fetch ?? (globalThis.fetch.bind(globalThis) as FetchImpl);
+			options?.onStreamCreated?.();
 			let response = await fetchImpl(plan.url, {
 				method: "POST",
 				headers: { ...plan.headers, "Content-Type": "application/json", Accept: "text/event-stream" },
@@ -935,6 +936,7 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 				);
 				if (
 					!options?.fallbackManaged &&
+					!options?.disableProviderRetries &&
 					firstTokenTime === undefined &&
 					isForcedToolChoiceUnsupportedError(error, true)
 				) {
@@ -957,6 +959,7 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 					params = retryParams;
 					rawRequestDump = { ...rawRequestDump, body: params };
 					wireBody = paramsToWireBody(params);
+					options?.onStreamCreated?.();
 					response = await fetchImpl(plan.url, {
 						method: "POST",
 						headers: { ...plan.headers, "Content-Type": "application/json", Accept: "text/event-stream" },

package/src/providers/kiro-api-key.ts

@@ -6,6 +6,7 @@
  * AWS SSO OIDC / CodeWhisperer streaming path used by `gjc auth-broker login kiro`.
  */
 import { $env } from "@gajae-code/utils";
+import { assertAwsRegionLabel } from "../adapter-internals/aws-region";
 import { Effort } from "../model-thinking";
 import type {
 	Api,
@@ -53,19 +54,40 @@ export function isKiroApiKey(value: string | undefined): value is string {
 
 export function kiroApiRegion(options?: { region?: string }): string {
 	return (
-		options?.region ||
-		$env.KIRO_API_REGION ||
-		$env.KIRO_REGION ||
-		$env.AWS_REGION ||
-		$env.AWS_DEFAULT_REGION ||
+		options?.region ??
+		$env.KIRO_API_REGION ??
+		$env.KIRO_REGION ??
+		$env.AWS_REGION ??
+		$env.AWS_DEFAULT_REGION ??
 		DEFAULT_REGION
 	);
 }
 
 export function kiroApiBaseUrl(region: string): string {
+	assertAwsRegionLabel(region);
 	return `https://q.${region}.amazonaws.com/`;
 }
 
+function isRegionDerivedKiroApiBaseUrl(baseUrl: string): boolean {
+	try {
+		const url = new URL(baseUrl);
+		const match = /^q\.([a-z0-9-]+)\.amazonaws\.com$/.exec(url.hostname);
+		if (!match) return false;
+		assertAwsRegionLabel(match[1]);
+		return (
+			url.protocol === "https:" &&
+			url.username === "" &&
+			url.password === "" &&
+			url.port === "" &&
+			url.pathname === "/" &&
+			url.search === "" &&
+			url.hash === ""
+		);
+	} catch {
+		return false;
+	}
+}
+
 export function toKiroModelId(modelId: string): string {
 	return modelId.replace(/(\d)-(\d)/g, "$1.$2");
 }
@@ -279,12 +301,13 @@ export async function fetchKiroApiModels(
 	apiKey: string,
 	region?: string,
 ): Promise<Model<"kiro-codewhisperer-stream">[]> {
-	const resolvedRegion = region || kiroApiRegion();
+	const resolvedRegion = region ?? kiroApiRegion();
 	const baseUrl = kiroApiBaseUrl(resolvedRegion);
 	const response = await fetch(baseUrl, {
 		method: "POST",
 		headers: kiroApiHeaders(apiKey, LIST_TARGET),
 		body: JSON.stringify({ origin: KIRO_ORIGIN }),
+		redirect: "error",
 		signal: AbortSignal.timeout(15_000),
 	});
 	if (!response.ok) {
@@ -585,8 +608,9 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 					"Kiro API key missing. Set KIRO_API_KEY to a ksk_ key from https://app.kiro.dev/settings/api-keys.",
 				);
 			}
-			const region = kiroApiRegion(options);
-			const endpoint = model.baseUrl || kiroApiBaseUrl(region);
+			const configuredBaseUrl = model.baseUrl;
+			const usesExplicitBaseUrl = Boolean(configuredBaseUrl) && !isRegionDerivedKiroApiBaseUrl(configuredBaseUrl);
+			const endpoint = configuredBaseUrl || kiroApiBaseUrl(kiroApiRegion(options));
 			const request = buildApiKeyRequest(model, context, options);
 			options?.onPayload?.(request, model, options?.attemptScope);
 
@@ -594,6 +618,7 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 				method: "POST",
 				headers: { ...kiroApiHeaders(apiKey, CHAT_TARGET), ...(options.headers ?? {}) },
 				body: JSON.stringify(request),
+				...(usesExplicitBaseUrl ? {} : { redirect: "error" as const }),
 				signal: options.signal,
 			});
 			if (!response.ok) {

package/src/providers/kiro-codewhisperer.ts

@@ -11,6 +11,7 @@
  * not from any AGPL reference implementation.
  */
 import { $credentialEnv, $env, extractHttpStatusFromError } from "@gajae-code/utils";
+import { assertAwsRegionLabel } from "../adapter-internals/aws-region";
 import type { Effort } from "../model-thinking";
 import type {
 	Api,
@@ -29,7 +30,7 @@ import { transportFailureFacts } from "../utils/fallback-transport";
 import { withHttpStatus } from "../utils/http-inspector";
 import { captureUnicodeEscapeEvidence } from "../utils/json-parse";
 import { decodeEventStream } from "./aws-eventstream";
-import { isKiroApiKey, streamKiroApiKey } from "./kiro-api-key";
+import { isKiroApiKey, streamKiroApiKey, toKiroModelId } from "./kiro-api-key";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Provider options
@@ -67,6 +68,7 @@ interface WireToolResult {
 interface WireUserMessage {
 	userInputMessage: {
 		content: string;
+		modelId?: string;
 		userInputMessageContext?: {
 			tools?: { tools: WireToolSpec[] };
 			toolResults?: { toolResults: WireToolResult[][] };
@@ -177,9 +179,10 @@ export const streamKiroCodeWhisperer: StreamFunction<"kiro-codewhisperer-stream"
 		};
 
 		const blocks = output.content as Block[];
-		const region = options.region || $env.KIRO_REGION || $env.AWS_REGION || $env.AWS_DEFAULT_REGION || DEFAULT_REGION;
+		const region = options.region ?? $env.KIRO_REGION ?? $env.AWS_REGION ?? $env.AWS_DEFAULT_REGION ?? DEFAULT_REGION;
 
 		try {
+			assertAwsRegionLabel(region);
 			// Resolve bearer token
 			const bearerToken = resolveBearerToken(options.apiKey);
 			if (!bearerToken) {
@@ -221,6 +224,7 @@ export const streamKiroCodeWhisperer: StreamFunction<"kiro-codewhisperer-stream"
 				method: "POST",
 				headers: requestHeaders,
 				body,
+				redirect: "error",
 				signal: options.signal,
 			});
 
@@ -353,7 +357,7 @@ export const streamKiroCodeWhisperer: StreamFunction<"kiro-codewhisperer-stream"
 
 function buildConversationState(
 	context: Context,
-	_model: Model<"kiro-codewhisperer-stream">,
+	model: Model<"kiro-codewhisperer-stream">,
 	options: KiroCodeWhispererOptions,
 ): ConversationState {
 	const messages = context.messages;
@@ -361,18 +365,24 @@ function buildConversationState(
 		throw new Error("Kiro CodeWhisperer requires at least one message");
 	}
 
+	// Normalize the local dashed selector/wire id (e.g. "claude-haiku-4-5") to
+	// the canonical dotted upstream Kiro model id (e.g. "claude-haiku-4.5"),
+	// matching the sibling ksk_ API-key transport (kiro-api-key.ts) so both
+	// auth methods send the same wire form for the same catalog entry.
+	const modelId = toKiroModelId(model.wireModelId || model.id);
+
 	// Build history from all messages except the last
 	const history: WireHistoryMessage[] = [];
 	const systemPrompt = context.systemPrompt?.join("\n") ?? "";
 
 	for (let i = 0; i < messages.length - 1; i++) {
 		const msg = messages[i];
-		history.push(convertToWireMessage(msg, i === 0 ? systemPrompt : undefined));
+		history.push(convertToWireMessage(msg, modelId, i === 0 ? systemPrompt : undefined));
 	}
 
 	// Convert the last message as currentMessage
 	const lastMsg = messages[messages.length - 1];
-	const currentMessage = convertToWireUserMessage(lastMsg, systemPrompt);
+	const currentMessage = convertToWireUserMessage(lastMsg, modelId, systemPrompt);
 
 	// Add tools to the current message context
 	if (context.tools && context.tools.length > 0) {
@@ -392,12 +402,16 @@ function buildConversationState(
 	};
 }
 
-function convertToWireMessage(msg: Context["messages"][number], systemPrompt?: string): WireHistoryMessage {
+function convertToWireMessage(
+	msg: Context["messages"][number],
+	modelId: string,
+	systemPrompt?: string,
+): WireHistoryMessage {
 	if (msg.role === "user") {
-		return convertToWireUserMessage(msg, systemPrompt);
+		return convertToWireUserMessage(msg, modelId, systemPrompt);
 	}
 	if (msg.role === "toolResult") {
-		return convertToWireUserMessage(msg, systemPrompt);
+		return convertToWireUserMessage(msg, modelId, systemPrompt);
 	}
 	// assistant → assistant response
 	const textParts: string[] = [];
@@ -417,7 +431,11 @@ function convertToWireMessage(msg: Context["messages"][number], systemPrompt?: s
 	};
 }
 
-function convertToWireUserMessage(msg: Context["messages"][number], systemPrompt?: string): WireUserMessage {
+function convertToWireUserMessage(
+	msg: Context["messages"][number],
+	modelId: string,
+	systemPrompt?: string,
+): WireUserMessage {
 	let content = extractTextContent(msg);
 	if (systemPrompt) {
 		content = `${systemPrompt}\n\n${content}`;
@@ -426,6 +444,7 @@ function convertToWireUserMessage(msg: Context["messages"][number], systemPrompt
 	const userMsg: WireUserMessage = {
 		userInputMessage: {
 			content,
+			modelId,
 		},
 	};
 

package/src/providers/ollama.ts

@@ -419,6 +419,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 				url: `${baseUrl}/api/chat`,
 				body,
 			};
+			options?.onStreamCreated?.();
 			let response = await fetchWithRetry(`${baseUrl}/api/chat`, {
 				method: "POST",
 				headers: {
@@ -441,6 +442,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 				if (
 					firstTokenTime === undefined &&
 					!options.fallbackManaged &&
+					!options.disableProviderRetries &&
 					isForcedToolChoiceUnsupportedError(error, true)
 				) {
 					markToolChoiceIncapability(model, "auto", error.message);
@@ -457,6 +459,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 					body = { ...body };
 					delete (body as { tool_choice?: unknown }).tool_choice;
 					rawRequestDump = { ...rawRequestDump, body };
+					options?.onStreamCreated?.();
 					response = await fetchWithRetry(`${baseUrl}/api/chat`, {
 						method: "POST",
 						headers: {

package/src/providers/openai-codex-responses.d.ts

@@ -25,6 +25,12 @@ export declare function normalizeCodexToolChoice(choice: ToolChoice | undefined,
 export declare function formatCodexUserAgent(platform: string, release: string, arch: string): string;
 export declare const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses">;
 export declare function prewarmOpenAICodexResponses(model: Model<"openai-codex-responses">, options?: Pick<OpenAICodexResponsesOptions, "apiKey" | "headers" | "sessionId" | "signal" | "preferWebsockets" | "providerSessionState">): Promise<void>;
+/**
+ * Bun 1.4.0's Windows WebSocket client can segfault during TLS handshakes.
+ * Keep the model's websocket preference available on other platforms, while
+ * requiring an explicit opt-in on Windows until the bundled runtime is fixed.
+ */
+export declare function isCodexWebSocketSafeByDefault(platform?: NodeJS.Platform): boolean;
 export interface OpenAICodexTransportDetails {
     websocketPreferred: boolean;
     lastTransport?: CodexTransport;

package/src/providers/openai-codex-responses.ts

@@ -844,6 +844,7 @@ async function openInitialCodexEventStream(
 	if (websocketState && shouldUseCodexWebSocket(model, websocketState, options?.preferWebsockets)) {
 		const websocketRetryBudget = getCodexWebSocketRetryBudget(options);
 		let websocketRetries = 0;
+		let lastWebsocketError: Error | undefined;
 		while (true) {
 			try {
 				return await openCodexWebSocketTransport(
@@ -855,6 +856,7 @@ async function openInitialCodexEventStream(
 				);
 			} catch (error) {
 				const websocketError = error instanceof Error ? error : new Error(String(error));
+				lastWebsocketError = websocketError;
 				const isFatal = isCodexWebSocketFatalError(websocketError);
 				const activateFallback = isFatal || websocketRetries >= websocketRetryBudget;
 				recordCodexWebSocketFailure(websocketState, activateFallback);
@@ -875,6 +877,9 @@ async function openInitialCodexEventStream(
 				break;
 			}
 		}
+		if (options?.fallbackManaged || options?.disableProviderRetries) {
+			throw lastWebsocketError ?? new Error("Codex websocket transport failed");
+		}
 	}
 	return openCodexSseTransport(model, requestContext, requestSetup, options, websocketState, transformedBody);
 }
@@ -1739,6 +1744,7 @@ async function tryRetryWithoutForcedToolChoice(
 ): Promise<boolean> {
 	if (
 		context.options?.fallbackManaged ||
+		context.options?.disableProviderRetries ||
 		runtime.toolChoiceFallbackAttempted ||
 		context.output.content.length > 0 ||
 		context.firstTokenTime !== undefined ||
@@ -1842,7 +1848,8 @@ async function tryReconnectCodexWebSocketOnConnectionLimit(
 		!websocketState ||
 		runtime.transport !== "websocket" ||
 		context.options?.signal?.aborted ||
-		context.options?.fallbackManaged
+		context.options?.fallbackManaged ||
+		context.options?.disableProviderRetries
 	) {
 		return false;
 	}
@@ -1905,6 +1912,7 @@ async function tryRecoverCodexPreviousResponseNotFound(
 		runtime.previousResponseRecoveryAttempted ||
 		!websocketState ||
 		context.options?.fallbackManaged ||
+		context.options?.disableProviderRetries ||
 		runtime.transport !== "websocket" ||
 		context.output.content.length > 0 ||
 		context.options?.signal?.aborted ||
@@ -1945,7 +1953,8 @@ async function tryReplayWebsocketFailureOverSse(
 		runtime.canSafelyReplayWebsocketOverSse &&
 		!runtime.sawTerminalEvent &&
 		!context.options?.signal?.aborted &&
-		!context.options?.fallbackManaged;
+		!context.options?.fallbackManaged &&
+		!context.options?.disableProviderRetries;
 	if (!canReplay) return false;
 
 	const state = websocketState;
@@ -1999,7 +2008,8 @@ async function tryRetryCodexProviderError(
 		context.output.content.length > 0 ||
 		runtime.providerRetryAttempt >= resolveRetryBudget(context.options?.streamMaxRetries, CODEX_MAX_RETRIES) ||
 		context.options?.signal?.aborted ||
-		context.options?.fallbackManaged
+		context.options?.fallbackManaged ||
+		context.options?.disableProviderRetries
 	) {
 		return false;
 	}
@@ -2119,7 +2129,7 @@ export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"
 			try {
 				initialTransport = await openInitialCodexEventStream(model, streamOptions, requestSetup, requestContext);
 			} catch (error) {
-				if (streamOptions.fallbackManaged) throw error;
+				if (streamOptions.fallbackManaged || streamOptions.disableProviderRetries) throw error;
 				initialTransport = await retryCodexInitialTransportWithoutToolChoice(
 					model,
 					streamOptions,
@@ -2297,6 +2307,15 @@ function recordCodexWebSocketFailure(state: CodexWebSocketSessionState, activate
 	}
 }
 
+/**
+ * Bun 1.4.0's Windows WebSocket client can segfault during TLS handshakes.
+ * Keep the model's websocket preference available on other platforms, while
+ * requiring an explicit opt-in on Windows until the bundled runtime is fixed.
+ */
+export function isCodexWebSocketSafeByDefault(platform: NodeJS.Platform = process.platform): boolean {
+	return platform !== "win32";
+}
+
 function shouldUseCodexWebSocket(
 	model: Model<"openai-codex-responses">,
 	state: CodexWebSocketSessionState | undefined,
@@ -2304,7 +2323,11 @@ function shouldUseCodexWebSocket(
 ): boolean {
 	if (!state || state.disableWebsocket) return false;
 	if (preferWebsockets === false) return false;
-	return isCodexWebSocketEnvEnabled() || preferWebsockets === true || model.preferWebsockets === true;
+	return (
+		isCodexWebSocketEnvEnabled() ||
+		preferWebsockets === true ||
+		(isCodexWebSocketSafeByDefault() && model.preferWebsockets === true)
+	);
 }
 
 export interface OpenAICodexTransportDetails {
@@ -2362,7 +2385,9 @@ export function getOpenAICodexTransportDetails(
 	const websocketPreferred =
 		options?.preferWebsockets === false
 			? false
-			: isCodexWebSocketEnvEnabled() || options?.preferWebsockets === true || model.preferWebsockets === true;
+			: isCodexWebSocketEnvEnabled() ||
+				options?.preferWebsockets === true ||
+				(isCodexWebSocketSafeByDefault() && model.preferWebsockets === true);
 	const state = getCodexWebSocketStateForPublicSession(model, options);
 
 	return {
@@ -2633,6 +2658,7 @@ class CodexWebSocketConnection {
 		signal?: AbortSignal,
 		firstEventTimeoutMs?: number,
 		idleTimeoutMs = this.#idleTimeoutMs,
+		onStreamCreated?: () => void,
 	): AsyncGenerator<Record<string, unknown>> {
 		if (!this.#socket || this.#socket.readyState !== WebSocket.OPEN) {
 			throw createCodexWebSocketTransportError("websocket connection is unavailable");
@@ -2654,6 +2680,7 @@ class CodexWebSocketConnection {
 		}
 
 		try {
+			onStreamCreated?.();
 			this.#socket.send(JSON.stringify(request));
 			let sawFirstProgress = false;
 			const startedAt = Date.now();
@@ -2795,7 +2822,7 @@ async function openCodexSseEventStream(
 	signal?: AbortSignal,
 	onSseEvent?: OpenAICodexResponsesOptions["onSseEvent"],
 	fetchOverride?: FetchImpl,
-	options?: Pick<OpenAICodexResponsesOptions, "requestMaxRetries">,
+	options?: Pick<OpenAICodexResponsesOptions, "requestMaxRetries" | "onStreamCreated">,
 ): Promise<AsyncGenerator<Record<string, unknown>>> {
 	const headers = createCodexHeaders(requestHeaders, accountId, apiKey, sessionId, "sse", state);
 	logCodexDebug("codex request", {
@@ -2805,6 +2832,7 @@ async function openCodexSseEventStream(
 		sentTurnStateHeader: headers.has(X_CODEX_TURN_STATE_HEADER),
 		sentModelsEtagHeader: headers.has(X_MODELS_ETAG_HEADER),
 	});
+	options?.onStreamCreated?.();
 	const response = await fetchWithRetry(url, {
 		method: "POST",
 		headers,
@@ -2845,7 +2873,7 @@ async function openCodexWebSocketEventStream(
 	request: Record<string, unknown>,
 	state: CodexWebSocketSessionState,
 	signal?: AbortSignal,
-	options?: Pick<OpenAICodexResponsesOptions, "streamFirstEventTimeoutMs" | "streamIdleTimeoutMs">,
+	options?: Pick<OpenAICodexResponsesOptions, "streamFirstEventTimeoutMs" | "streamIdleTimeoutMs" | "onStreamCreated">,
 	firstEventTimeoutMs?: number,
 ): Promise<AsyncGenerator<Record<string, unknown>>> {
 	const connection = await getOrCreateCodexWebSocketConnection(state, url, headers, signal, options);
@@ -2854,6 +2882,7 @@ async function openCodexWebSocketEventStream(
 		signal,
 		firstEventTimeoutMs,
 		getCodexWebSocketIdleTimeoutMs(options?.streamIdleTimeoutMs),
+		options?.onStreamCreated,
 	);
 }
 

package/src/providers/openai-completions.ts

@@ -636,6 +636,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 					headers: requestHeaders,
 					body: params,
 				};
+				options?.onStreamCreated?.();
 				const { data, response, request_id } = await client.chat.completions
 					.create(params as OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming, { signal: requestSignal })
 					.withResponse();
@@ -648,6 +649,8 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 					provider: model.provider,
 					signal: requestSignal,
 					fallbackManaged: options?.fallbackManaged,
+					requestMaxRetries: options?.requestMaxRetries,
+					disableProviderRetries: options?.disableProviderRetries,
 				});
 			} catch (error) {
 				const capturedErrorResponse = getCapturedErrorResponse();
@@ -656,6 +659,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				);
 				if (
 					!options?.fallbackManaged &&
+					!options?.disableProviderRetries &&
 					firstTokenTime === undefined &&
 					isForcedToolChoiceUnsupportedError(error, sentForcedToolChoice)
 				) {
@@ -675,6 +679,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 					openaiStream = await createCompletionsStream();
 				} else if (
 					!options?.fallbackManaged &&
+					!options?.disableProviderRetries &&
 					isOpenRouterAnthropicModel(model) &&
 					!disableStrictTools &&
 					isCompiledGrammarTooLargeStrictError(error, capturedErrorResponse)
@@ -689,6 +694,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				} else {
 					if (
 						options?.fallbackManaged ||
+						options?.disableProviderRetries ||
 						!shouldRetryWithoutStrictTools(error, capturedErrorResponse, appliedToolStrictMode, context.tools)
 					) {
 						throw error;
@@ -733,7 +739,11 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 							continue;
 						}
 						replaySafeChunks.push(chunk);
-						if (hasNetworkErrorFinishReason(chunk) && !options?.fallbackManaged) {
+						if (
+							hasNetworkErrorFinishReason(chunk) &&
+							!options?.fallbackManaged &&
+							!options?.disableProviderRetries
+						) {
 							retryNetworkError = true;
 							break;
 						}

package/src/providers/openai-responses.ts

@@ -402,16 +402,24 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 			};
 			const openaiStream = await callWithCopilotModelRetry(
 				async () => {
+					options?.onStreamCreated?.();
 					const { data, response, request_id } = await client.responses
 						.create(params, { signal: requestSignal })
 						.withResponse();
 					await notifyProviderResponse(options, response, model, request_id);
 					return data;
 				},
-				{ provider: model.provider, signal: requestSignal, fallbackManaged: options?.fallbackManaged },
+				{
+					provider: model.provider,
+					signal: requestSignal,
+					fallbackManaged: options?.fallbackManaged,
+					requestMaxRetries: options?.requestMaxRetries,
+					disableProviderRetries: options?.disableProviderRetries,
+				},
 			).catch(async error => {
 				if (
 					options?.fallbackManaged ||
+					options?.disableProviderRetries ||
 					!isForcedToolChoiceUnsupportedError(error, isForcedOpenAIResponsesToolChoice(params.tool_choice))
 				) {
 					throw error;
@@ -431,6 +439,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 				});
 				delete params.tool_choice;
 				if (rawRequestDump) rawRequestDump.body = params;
+				options?.onStreamCreated?.();
 				const { data, response, request_id } = await client.responses
 					.create(params, { signal: requestSignal })
 					.withResponse();

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

@@ -37,6 +37,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream";
 const NON_WIRE_KEYS = new Set<keyof SimpleStreamOptions>([
 	"signal",
 	"apiKey",
+	"onStreamCreated",
 	"fetch",
 	"onPayload",
 	"onResponse",
@@ -48,6 +49,29 @@ const NON_WIRE_KEYS = new Set<keyof SimpleStreamOptions>([
 	"fallbackAttempt",
 ]);
 
+/**
+ * Project the caller's {@link Context} onto the wire schema. Runtime tool
+ * objects routinely carry harness-only state (runners, session managers,
+ * fs-stat BigInts) that must never be serialized: BigInt fields make
+ * `JSON.stringify` throw outright, and the rest is dead weight the gateway
+ * re-derives from its own tool registry. Only the protocol-meaningful,
+ * JSON-safe `Tool` fields cross the wire.
+ */
+function buildWireContext(context: Context): Context {
+	if (!context.tools || context.tools.length === 0) return context;
+	return {
+		...context,
+		tools: context.tools.map(tool => ({
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters,
+			...(tool.strict !== undefined ? { strict: tool.strict } : {}),
+			...(tool.customFormat !== undefined ? { customFormat: tool.customFormat } : {}),
+			...(tool.customWireName !== undefined ? { customWireName: tool.customWireName } : {}),
+		})),
+	};
+}
+
 function buildWireOptions(options: SimpleStreamOptions | undefined): Record<string, unknown> {
 	if (!options) return {};
 	const wire: Record<string, unknown> = {};
@@ -165,7 +189,7 @@ export function streamPiNative<TApi extends Api>(
 			const headers = buildHeaders(model as Model<Api>, options?.apiKey);
 			const body = JSON.stringify({
 				modelId: model.id,
-				context,
+				context: buildWireContext(context),
 				options: buildWireOptions(options),
 				stream: true,
 			});

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

@@ -78,6 +78,21 @@ const ALLOWED_OPTION_KEYS: ReadonlySet<keyof SimpleStreamOptions> = new Set([
 	"preferWebsockets",
 ] as const satisfies readonly (keyof SimpleStreamOptions)[]);
 
+const CREDENTIAL_HEADER_NAMES = new Set([
+	"authorization",
+	"proxy-authorization",
+	"cookie",
+	"set-cookie",
+	"api-key",
+	"x-api-key",
+	"x-goog-api-key",
+	"anthropic-api-key",
+	"x-auth-token",
+	"x-access-token",
+	"x-api-token",
+	"x-client-secret",
+]);
+
 // ---------------------------------------------------------------------------
 // parseRequest
 // ---------------------------------------------------------------------------
@@ -132,6 +147,15 @@ export function parseRequest(body: unknown, _headers?: Headers): PiNativeParsedR
 		for (const [k, v] of Object.entries(rawOpts)) {
 			if (v === undefined || v === null) continue;
 			if (!ALLOWED_OPTION_KEYS.has(k as keyof SimpleStreamOptions)) continue;
+			if (k === "headers" && typeof v === "object" && v !== null && !Array.isArray(v)) {
+				const safeHeaders: Record<string, string> = {};
+				for (const [name, value] of Object.entries(v)) {
+					if (CREDENTIAL_HEADER_NAMES.has(name.toLowerCase())) continue;
+					if (typeof value === "string") safeHeaders[name] = value;
+				}
+				optsBag[k] = safeHeaders;
+				continue;
+			}
 			optsBag[k] = v;
 		}
 	}

package/src/providers/register-builtins.d.ts

@@ -44,16 +44,16 @@ export declare function resolveLazyStreamFirstEventFallbackMs(provider: string,
 export declare const PROVIDER_RUNTIME_DESCRIPTORS: readonly ProviderRuntimeDescriptor<Api, unknown>[];
 /** Return the lazy descriptor for a built-in API, if one is registered. */
 export declare function getProviderRuntimeDescriptor<TApi extends Api>(api: TApi): ProviderRuntimeDescriptor<TApi, unknown> | undefined;
-export declare const streamAnthropic: (model: Model<"anthropic-messages">, context: Context, options: OptionsForApi<"anthropic-messages">) => EventStreamImpl;
-export declare const streamAzureOpenAIResponses: (model: Model<"azure-openai-responses">, context: Context, options: OptionsForApi<"azure-openai-responses">) => EventStreamImpl;
-export declare const streamGoogle: (model: Model<"google-generative-ai">, context: Context, options: OptionsForApi<"google-generative-ai">) => EventStreamImpl;
-export declare const streamGoogleGeminiCli: (model: Model<"google-gemini-cli">, context: Context, options: OptionsForApi<"google-gemini-cli">) => EventStreamImpl;
-export declare const streamGoogleVertex: (model: Model<"google-vertex">, context: Context, options: OptionsForApi<"google-vertex">) => EventStreamImpl;
-export declare const streamOpenAICodexResponses: (model: Model<"openai-codex-responses">, context: Context, options: OptionsForApi<"openai-codex-responses">) => EventStreamImpl;
-export declare const streamOpenAICompletions: (model: Model<"openai-completions">, context: Context, options: OptionsForApi<"openai-completions">) => EventStreamImpl;
-export declare const streamOpenAIResponses: (model: Model<"openai-responses">, context: Context, options: OptionsForApi<"openai-responses">) => EventStreamImpl;
-export declare const streamCursor: (model: Model<"cursor-agent">, context: Context, options: OptionsForApi<"cursor-agent">) => EventStreamImpl;
-export declare const streamOllama: (model: Model<"ollama-chat">, context: Context, options: OptionsForApi<"ollama-chat">) => EventStreamImpl;
-export declare const streamBedrock: (model: Model<"bedrock-converse-stream">, context: Context, options: OptionsForApi<"bedrock-converse-stream">) => EventStreamImpl;
-export declare const streamKiroCodeWhisperer: (model: Model<"kiro-codewhisperer-stream">, context: Context, options: OptionsForApi<"kiro-codewhisperer-stream">) => EventStreamImpl;
+export declare const streamAnthropic: (model: Model<"anthropic-messages">, context: Context, options: OptionsForApi<"anthropic-messages">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamAzureOpenAIResponses: (model: Model<"azure-openai-responses">, context: Context, options: OptionsForApi<"azure-openai-responses">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamGoogle: (model: Model<"google-generative-ai">, context: Context, options: OptionsForApi<"google-generative-ai">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamGoogleGeminiCli: (model: Model<"google-gemini-cli">, context: Context, options: OptionsForApi<"google-gemini-cli">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamGoogleVertex: (model: Model<"google-vertex">, context: Context, options: OptionsForApi<"google-vertex">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamOpenAICodexResponses: (model: Model<"openai-codex-responses">, context: Context, options: OptionsForApi<"openai-codex-responses">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamOpenAICompletions: (model: Model<"openai-completions">, context: Context, options: OptionsForApi<"openai-completions">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamOpenAIResponses: (model: Model<"openai-responses">, context: Context, options: OptionsForApi<"openai-responses">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamCursor: (model: Model<"cursor-agent">, context: Context, options: OptionsForApi<"cursor-agent">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamOllama: (model: Model<"ollama-chat">, context: Context, options: OptionsForApi<"ollama-chat">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamBedrock: (model: Model<"bedrock-converse-stream">, context: Context, options: OptionsForApi<"bedrock-converse-stream">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamKiroCodeWhisperer: (model: Model<"kiro-codewhisperer-stream">, context: Context, options: OptionsForApi<"kiro-codewhisperer-stream">, onStreamCreated?: () => void) => EventStreamImpl;
 export {};