@oh-my-pi/pi-ai 16.2.6 → 16.2.7

package/src/providers/google-shared.ts

@@ -14,6 +14,7 @@ import type {
 	FetchImpl,
 	ImageContent,
 	Model,
+	ServiceTier,
 	StopReason,
 	StreamOptions,
 	TextContent,
@@ -21,6 +22,7 @@ import type {
 	Tool,
 	ToolCall,
 } from "../types";
+import { shouldSendServiceTier } from "../types";
 import { normalizeSystemPrompts } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import type { RawHttpRequestDump } from "../utils/http-inspector";
@@ -73,6 +75,21 @@ export interface GoogleSharedStreamOptions extends StreamOptions {
 		budgetTokens?: number;
 		level?: GoogleThinkingLevel;
 	};
+	/** Gemini/Vertex serving tier (`flex`/`priority`); other values are omitted. */
+	serviceTier?: ServiceTier;
+	/**
+	 * Continues a Gemini Interactions API conversation from a stored interaction.
+	 * When set on the direct Google provider, the request uses `/interactions`
+	 * with `previous_interaction_id` instead of the legacy generateContent stream.
+	 */
+	previousInteractionId?: string;
+	/**
+	 * Uses the Gemini Interactions API for direct Google requests, storing the
+	 * returned interaction id on the assistant response for follow-up turns.
+	 */
+	useInteractionsApi?: boolean;
+	/** Overrides Interactions API request storage; default is the API default (`true`). */
+	storeInteraction?: boolean;
 }
 
 /**
@@ -126,11 +143,9 @@ function resolveThoughtSignature(isSameProviderAndModel: boolean, signature: str
 	return isSameProviderAndModel && isValidThoughtSignature(signature) ? signature : undefined;
 }
 
-/**
- * Claude models via Google APIs require explicit tool call IDs in function calls/responses.
- */
-export function requiresToolCallId(modelId: string): boolean {
-	return modelId.startsWith("claude-");
+function supportsFunctionPartId<T extends GoogleApiType>(model: Model<T>): boolean {
+	if (model.api === "google-vertex") return false;
+	return model.id.startsWith("claude-") || (model.api === "google-generative-ai" && isGemini3Model(model.id));
 }
 
 function getGeminiMajorVersion(modelId: string): number | undefined {
@@ -156,8 +171,9 @@ function isGemini3Model(modelId: string): boolean {
  */
 export function convertMessages<T extends GoogleApiType>(model: Model<T>, context: Context): Content[] {
 	const contents: Content[] = [];
+	const emittedToolCallNames = new Map<string, string>();
+
 	const normalizeToolCallId = (id: string): string => {
-		if (!requiresToolCallId(model.id)) return id;
 		return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 	};
 
@@ -243,6 +259,7 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 						});
 					}
 				} else if (block.type === "toolCall") {
+					emittedToolCallNames.set(block.id, block.name);
 					const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature);
 					const effectiveSignature =
 						thoughtSignature || (isGemini3Model(model.id) ? SKIP_THOUGHT_SIGNATURE : undefined);
@@ -251,11 +268,11 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 						functionCall: {
 							name: block.name,
 							args: block.arguments ?? {},
-							...(requiresToolCallId(model.id) ? { id: block.id } : {}),
+							...(supportsFunctionPartId(model) ? { id: block.id } : {}),
 						},
 					};
 					if (model.provider === "google-vertex" && part?.functionCall?.id) {
-						delete part.functionCall.id; // Vertex AI does not support 'id' in functionCall
+						delete part.functionCall.id; // Vertex AI GenerateContent rejects 'id' in functionCall parts.
 					}
 					if (effectiveSignature) {
 						part.thoughtSignature = effectiveSignature;
@@ -301,10 +318,11 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 				},
 			}));
 
-			const includeId = requiresToolCallId(model.id);
+			const includeId = supportsFunctionPartId(model);
+			const emittedName = emittedToolCallNames.get(msg.toolCallId);
 			const functionResponsePart: Part = {
 				functionResponse: {
-					name: msg.toolName,
+					name: emittedName ?? msg.toolName,
 					response: msg.isError ? { error: responseValue } : { output: responseValue },
 					...(hasImages && modelSupportsMultimodalFunctionResponse && { parts: imageParts }),
 					...(includeId ? { id: msg.toolCallId } : {}),
@@ -312,7 +330,7 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 			};
 
 			if (model.provider === "google-vertex" && functionResponsePart.functionResponse?.id) {
-				delete functionResponsePart.functionResponse.id; // Vertex AI does not support 'id' in functionResponse
+				delete functionResponsePart.functionResponse.id; // Vertex AI GenerateContent rejects 'id' in functionResponse parts.
 			}
 
 			// Cloud Code Assist API requires all function responses to be in a single user turn.
@@ -529,6 +547,24 @@ export function pushToolCallEvents(
  * `text_start` / `thinking_start` event. `onBeforeStartEvent` lets the SSE consumer
  * inject its `ensureStarted()` first-token side effect into the canonical event order.
  */
+export function startTextOrThinkingBlock(
+	isThinking: true,
+	output: AssistantMessage,
+	stream: AssistantMessageEventStream,
+	onBeforeStartEvent?: () => void,
+): ThinkingContent;
+export function startTextOrThinkingBlock(
+	isThinking: false,
+	output: AssistantMessage,
+	stream: AssistantMessageEventStream,
+	onBeforeStartEvent?: () => void,
+): TextContent;
+export function startTextOrThinkingBlock(
+	isThinking: boolean,
+	output: AssistantMessage,
+	stream: AssistantMessageEventStream,
+	onBeforeStartEvent?: () => void,
+): TextContent | ThinkingContent;
 export function startTextOrThinkingBlock(
 	isThinking: boolean,
 	output: AssistantMessage,
@@ -791,6 +827,14 @@ export function buildGoogleGenerateContentParams<T extends "google-generative-ai
 		...(context.tools && context.tools.length > 0 && { tools: convertTools(context.tools, model) }),
 	};
 
+	// Gemini API (google-generative-ai) reads the tier from the request body;
+	// Vertex AI ignores a body field and requires the
+	// `X-Vertex-AI-LLM-Shared-Request-Type` header instead (added in
+	// streamGoogleVertex), so only emit the body field for the direct API.
+	if (model.provider === "google" && shouldSendServiceTier(options.serviceTier, model.provider)) {
+		config.serviceTier = options.serviceTier;
+	}
+
 	if (context.tools && context.tools.length > 0 && options.toolChoice) {
 		const choice = options.toolChoice;
 		if (typeof choice === "string") {
@@ -852,6 +896,8 @@ export interface GoogleGenAIRequestPlan {
 	url: string;
 	headers: Record<string, string>;
 	fetch?: FetchImpl;
+	/** Optional URL retried once when {@link url} returns 404 (regional Vertex endpoint missing a global-only model). */
+	fallbackUrl?: string;
 }
 
 export function streamGoogleGenAI<T extends "google-generative-ai" | "google-vertex">(args: {
@@ -906,8 +952,8 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 
 			const bodyJson = JSON.stringify(paramsToWireBody(params));
 			const fetchImpl = plan.fetch ?? options?.fetch ?? (globalThis.fetch.bind(globalThis) as FetchImpl);
-			const openStream = async (): Promise<ReadableStream<Uint8Array>> => {
-				const response = await fetchImpl(plan.url, {
+			const openStreamAt = async (requestUrl: string): Promise<ReadableStream<Uint8Array>> => {
+				const response = await fetchImpl(requestUrl, {
 					method: "POST",
 					headers: { ...plan.headers, "Content-Type": "application/json", Accept: "text/event-stream" },
 					body: bodyJson,
@@ -929,6 +975,20 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 				}
 				return response.body as ReadableStream<Uint8Array>;
 			};
+			// A regional Vertex endpoint 404s for models published only on the
+			// global endpoint; retry global once so a stale/ambient region never
+			// breaks a request that worked before regional routing existed.
+			const openStream = async (): Promise<ReadableStream<Uint8Array>> => {
+				if (!plan.fallbackUrl) return openStreamAt(plan.url);
+				try {
+					return await openStreamAt(plan.url);
+				} catch (error) {
+					if (error instanceof AIError.GoogleApiError && error.status === 404) {
+						return openStreamAt(plan.fallbackUrl);
+					}
+					throw error;
+				}
+			};
 
 			let body = await openStream();
 			stream.push({ type: "start", partial: output });
@@ -1007,6 +1067,7 @@ function paramsToWireBody(params: GenerateContentParameters): Record<string, unk
 	if (config.toolConfig !== undefined) body.toolConfig = config.toolConfig;
 	if (config.safetySettings !== undefined) body.safetySettings = config.safetySettings;
 	if (config.cachedContent !== undefined) body.cachedContent = config.cachedContent;
+	if (config.serviceTier !== undefined) body.serviceTier = config.serviceTier;
 
 	const gen: Record<string, unknown> = {};
 	if (config.temperature !== undefined) gen.temperature = config.temperature;

package/src/providers/google-types.ts

@@ -9,7 +9,6 @@
  *   - `POST {generativelanguage,aiplatform}.googleapis.com/.../models/{model}:streamGenerateContent?alt=sse`
  *   - The Cloud Code Assist endpoint used by `google-gemini-cli.ts`
  */
-
 /** Mirror of `@google/genai`'s `FinishReason` string enum. */
 export type FinishReason =
 	| "FINISH_REASON_UNSPECIFIED"
@@ -131,6 +130,11 @@ export interface GenerateContentConfig {
 	safetySettings?: Array<Record<string, unknown>>;
 	cachedContent?: string;
 	thinkingConfig?: ThinkingConfig;
+	/**
+	 * Gemini/Vertex serving tier. Serialized to the request body root as
+	 * `serviceTier` (camelCase) by the transformer in `google-shared.ts`.
+	 */
+	serviceTier?: "auto" | "default" | "flex" | "scale" | "priority";
 	abortSignal?: AbortSignal;
 }
 

package/src/providers/google-vertex.ts

@@ -2,7 +2,13 @@ import { $env } from "@oh-my-pi/pi-utils";
 import * as AIError from "../error";
 import type { Context, Model, StreamFunction } from "../types";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
-import { getVertexAccessToken } from "./google-auth";
+import { getVertexAccessToken, hasVertexBearerCredentialsHint } from "./google-auth";
+import {
+	type GoogleInteractionsPlan,
+	modelSupportsInteractions,
+	resolveInteractionDispatch,
+	streamGoogleInteractions,
+} from "./google-interactions";
 import {
 	buildGoogleGenerateContentParams,
 	type GoogleGenAIRequestPlan,
@@ -16,48 +22,128 @@ export interface GoogleVertexOptions extends GoogleSharedStreamOptions {
 }
 
 const API_VERSION = "v1";
+const INTERACTIONS_API_VERSION = "v1beta1";
+const INTERACTIONS_API_REVISION = "2026-05-20";
 
 export const streamGoogleVertex: StreamFunction<"google-vertex"> = (
 	model: Model<"google-vertex">,
 	context: Context,
 	options?: GoogleVertexOptions,
-): AssistantMessageEventStream =>
-	streamGoogleGenAI({
-		model,
-		options,
-		api: "google-vertex",
-		retainTextSignature: true,
-		prepare: async (): Promise<GoogleGenAIRequestPlan> => {
-			const apiKey = resolveApiKey(options);
-			const params = buildGoogleGenerateContentParams(model, context, options ?? {});
-			const baseHeaders: Record<string, string> = {
-				...(model.headers ?? {}),
-				...(options?.headers ?? {}),
-			};
+): AssistantMessageEventStream => {
+	const runGenerateContent = (): AssistantMessageEventStream =>
+		streamGoogleGenAI({
+			model,
+			options,
+			api: "google-vertex",
+			retainTextSignature: true,
+			prepare: async (): Promise<GoogleGenAIRequestPlan> => {
+				const apiKey = resolveApiKey(options);
+				const params = buildGoogleGenerateContentParams(model, context, options ?? {});
+				params.config ||= {};
+				if (!params.config.safetySettings) {
+					params.config.safetySettings = [
+						{
+							category: "HARM_CATEGORY_HATE_SPEECH",
+							threshold: "OFF",
+						},
+						{
+							category: "HARM_CATEGORY_DANGEROUS_CONTENT",
+							threshold: "OFF",
+						},
+						{
+							category: "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+							threshold: "OFF",
+						},
+						{
+							category: "HARM_CATEGORY_HARASSMENT",
+							threshold: "OFF",
+						},
+					];
+				}
+				const baseHeaders: Record<string, string> = {
+					...(model.headers ?? {}),
+					...(options?.headers ?? {}),
+				};
+				// Vertex AI ignores a `serviceTier` request-body field (unlike the direct
+				// Gemini API); priority must travel as a request header. Only `priority`
+				// has a documented Vertex request control — `flex` has none, so it's a no-op.
+				if (options?.serviceTier === "priority") {
+					baseHeaders["X-Vertex-AI-LLM-Shared-Request-Type"] = "priority";
+				}
 
-			if (apiKey) {
-				const url = `https://aiplatform.googleapis.com/${API_VERSION}/publishers/google/models/${model.id}:streamGenerateContent?alt=sse`;
+				if (apiKey) {
+					// Explicit `location` is a deliberate residency choice: honor it and let
+					// a 404 surface. An ambient env-derived region falls back to the global
+					// endpoint so a stray GOOGLE_*_LOCATION never breaks a previously-working
+					// global-only request.
+					const explicitLocation = options?.location;
+					const location = explicitLocation ?? resolveAmbientLocation() ?? "global";
+					const host = resolveEndpointHost(location);
+					const path = `${API_VERSION}/publishers/google/models/${model.id}:streamGenerateContent?alt=sse`;
+					const useGlobalFallback = !explicitLocation && host !== "aiplatform.googleapis.com";
+					return {
+						params,
+						url: `https://${host}/${path}`,
+						fallbackUrl: useGlobalFallback ? `https://aiplatform.googleapis.com/${path}` : undefined,
+						headers: {
+							...baseHeaders,
+							"x-goog-api-key": apiKey,
+						},
+						fetch: options?.fetch,
+					};
+				}
+
+				const project = resolveProject(options);
+				const location = resolveLocation(options);
+				const accessToken = await getVertexAccessToken({ signal: options?.signal, fetch: options?.fetch });
+				const host = resolveEndpointHost(location);
+				const url = `https://${host}/${API_VERSION}/projects/${project}/locations/${location}/publishers/google/models/${model.id}:streamGenerateContent?alt=sse`;
 				return {
 					params,
 					url,
-					headers: { ...baseHeaders, "x-goog-api-key": apiKey },
+					headers: { ...baseHeaders, Authorization: `Bearer ${accessToken}` },
 					fetch: options?.fetch,
 				};
-			}
+			},
+		});
 
+	// Default Gemini 3+ onto Interactions whenever a bearer credential source exists (ADC file,
+	// `GOOGLE_APPLICATION_CREDENTIALS`, or an explicit access-token env). Interactions needs bearer
+	// auth, so express API-key-only setups stay on generateContent — and an express key, when
+	// present, still serves the generateContent fallback. Interactions always targets the official
+	// global `aiplatform` host; the fallback also recovers ids the endpoint rejects.
+	const { useInteractions, auto, anchor, state } = resolveInteractionDispatch({
+		context,
+		options,
+		provider: model.provider,
+		autoEligible: modelSupportsInteractions(model) && hasVertexBearerCredentialsHint(),
+	});
+	if (!useInteractions) return runGenerateContent();
+
+	return streamGoogleInteractions({
+		model,
+		context,
+		options,
+		api: "google-vertex",
+		anchor,
+		state,
+		prepare: async (): Promise<GoogleInteractionsPlan> => {
 			const project = resolveProject(options);
-			const location = resolveLocation(options);
 			const accessToken = await getVertexAccessToken({ signal: options?.signal, fetch: options?.fetch });
-			const host = resolveEndpointHost(location);
-			const url = `https://${host}/${API_VERSION}/projects/${project}/locations/${location}/publishers/google/models/${model.id}:streamGenerateContent?alt=sse`;
 			return {
-				params,
-				url,
-				headers: { ...baseHeaders, Authorization: `Bearer ${accessToken}` },
+				url: `https://aiplatform.googleapis.com/${INTERACTIONS_API_VERSION}/projects/${project}/locations/global/interactions`,
+				headers: {
+					...(model.headers ?? {}),
+					...(options?.headers ?? {}),
+					Authorization: `Bearer ${accessToken}`,
+					"Api-Revision": INTERACTIONS_API_REVISION,
+				},
 				fetch: options?.fetch,
 			};
 		},
+		fallback: auto ? runGenerateContent : undefined,
 	});
+};
 
 function resolveApiKey(options?: GoogleVertexOptions): string | undefined {
 	// options.apiKey may contain sentinel values like "<authenticated>" or "N/A"
@@ -80,9 +166,14 @@ function resolveProject(options?: GoogleVertexOptions): string {
 function resolveEndpointHost(location: string): string {
 	return location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
 }
+function resolveAmbientLocation(): string | undefined {
+	return $env.GOOGLE_VERTEX_LOCATION || $env.GOOGLE_CLOUD_LOCATION || $env.VERTEX_LOCATION || undefined;
+}
+function resolveOptionalLocation(options?: GoogleVertexOptions): string | undefined {
+	return options?.location || resolveAmbientLocation();
+}
 function resolveLocation(options?: GoogleVertexOptions): string {
-	const location =
-		options?.location || $env.GOOGLE_VERTEX_LOCATION || $env.GOOGLE_CLOUD_LOCATION || $env.VERTEX_LOCATION;
+	const location = resolveOptionalLocation(options);
 	if (!location) {
 		throw new AIError.ConfigurationError(
 			"Vertex AI requires a location. Set GOOGLE_VERTEX_LOCATION/GOOGLE_CLOUD_LOCATION/VERTEX_LOCATION or pass location in options.",

package/src/providers/google.ts

@@ -2,6 +2,7 @@ import * as AIError from "../error";
 import { getEnvApiKey } from "../stream";
 import type { Context, Model, StreamFunction } from "../types";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
+import { modelSupportsInteractions, resolveInteractionDispatch, streamGoogleInteractions } from "./google-interactions";
 import {
 	buildGoogleGenerateContentParams,
 	type GoogleGenAIRequestPlan,
@@ -17,29 +18,70 @@ export const streamGoogle: StreamFunction<"google-generative-ai"> = (
 	model: Model<"google-generative-ai">,
 	context: Context,
 	options?: GoogleOptions,
-): AssistantMessageEventStream =>
-	streamGoogleGenAI({
+): AssistantMessageEventStream => {
+	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+	if (!apiKey) {
+		throw new AIError.MissingApiKeyError(
+			undefined,
+			"Google Generative AI requires an API key (GEMINI_API_KEY or options.apiKey).",
+		);
+	}
+
+	const runGenerateContent = (): AssistantMessageEventStream =>
+		streamGoogleGenAI({
+			model,
+			options,
+			api: "google-generative-ai",
+			prepare: (): GoogleGenAIRequestPlan => {
+				const params = buildGoogleGenerateContentParams(model, context, options ?? {});
+				// `model.baseUrl` already includes the API version segment when set (mirrors the
+				// `apiVersion: ""` reset that the SDK relied on for custom base URLs).
+				const base = model.baseUrl?.trim() || DEFAULT_GENERATIVE_LANGUAGE_BASE;
+				const url = `${base}/models/${model.id}:streamGenerateContent?alt=sse`;
+				const headers: Record<string, string> = {
+					"x-goog-api-key": apiKey,
+					...(model.headers ?? {}),
+					...(options?.headers ?? {}),
+				};
+				return { params, url, headers, fetch: options?.fetch };
+			},
+		});
+
+	// Default Gemini 3+ on the official endpoint onto Interactions (custom proxy base URLs keep
+	// generateContent, which serves the full catalog). The fallback recovers ids the endpoint rejects.
+	const trimmedBase = model.baseUrl?.trim();
+	let officialEndpoint = !trimmedBase;
+	if (trimmedBase) {
+		try {
+			officialEndpoint = new URL(trimmedBase).hostname === "generativelanguage.googleapis.com";
+		} catch {
+			officialEndpoint = false;
+		}
+	}
+	const { useInteractions, auto, anchor, state } = resolveInteractionDispatch({
+		context,
+		options,
+		provider: model.provider,
+		autoEligible: officialEndpoint && modelSupportsInteractions(model),
+	});
+	if (!useInteractions) return runGenerateContent();
+
+	return streamGoogleInteractions({
 		model,
+		context,
 		options,
 		api: "google-generative-ai",
-		prepare: (): GoogleGenAIRequestPlan => {
-			const apiKey = options?.apiKey || getEnvApiKey(model.provider);
-			if (!apiKey) {
-				throw new AIError.MissingApiKeyError(
-					undefined,
-					"Google Generative AI requires an API key (GEMINI_API_KEY or options.apiKey).",
-				);
-			}
-			const params = buildGoogleGenerateContentParams(model, context, options ?? {});
-			// `model.baseUrl` already includes the API version segment when set (mirrors the
-			// `apiVersion: ""` reset that the SDK relied on for custom base URLs).
-			const base = model.baseUrl?.trim() || DEFAULT_GENERATIVE_LANGUAGE_BASE;
-			const url = `${base}/models/${model.id}:streamGenerateContent?alt=sse`;
-			const headers: Record<string, string> = {
+		anchor,
+		state,
+		prepare: () => ({
+			url: `${trimmedBase || DEFAULT_GENERATIVE_LANGUAGE_BASE}/interactions`,
+			headers: {
 				"x-goog-api-key": apiKey,
 				...(model.headers ?? {}),
 				...(options?.headers ?? {}),
-			};
-			return { params, url, headers, fetch: options?.fetch };
-		},
+			},
+			fetch: options?.fetch,
+		}),
+		fallback: auto ? runGenerateContent : undefined,
 	});
+};

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

@@ -13,7 +13,7 @@ import type {
 	Context,
 	ImageContent,
 	Message,
-	ResolvedServiceTier,
+	ServiceTier,
 	StopReason,
 	TextContent,
 	Tool,
@@ -38,7 +38,7 @@ function isReasoningEffort(value: unknown): value is ReasoningEffort {
 	return value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh";
 }
 
-function isServiceTier(value: unknown): value is ResolvedServiceTier {
+function isServiceTier(value: unknown): value is ServiceTier {
 	return value === "auto" || value === "default" || value === "flex" || value === "scale" || value === "priority";
 }
 

package/src/providers/openai-codex/request-transformer.ts

@@ -1,4 +1,5 @@
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
+import { supportsAllTurnsReasoningContext } from "@oh-my-pi/pi-catalog/identity";
 import { requireSupportedEffort } from "@oh-my-pi/pi-catalog/model-thinking";
 import type { Api, Model } from "../../types";
 
@@ -14,7 +15,7 @@ export interface ReasoningConfig {
 export interface CodexRequestOptions {
 	reasoningEffort?: ReasoningConfig["effort"];
 	reasoningSummary?: ReasoningConfig["summary"] | null;
-	/** Explicit `reasoning.context` override; defaults to `all_turns` for every Codex request when unset. */
+	/** Explicit `reasoning.context` override; defaults to `all_turns` when unset. The `all_turns` value is gated to gpt-5.4+ Codex models — older ids reject it, so it is suppressed and `context` omitted. */
 	reasoningContext?: CodexReasoningContext;
 	textVerbosity?: "low" | "medium" | "high";
 	include?: string[];
@@ -254,9 +255,21 @@ export async function transformRequestBody(
 			...body.reasoning,
 			...reasoningConfig,
 		};
-		// Default reasoning replay to `all_turns` for every Codex request,
-		// mirroring codex-rs; an explicit `reasoningContext` overrides it.
-		body.reasoning.context = options.reasoningContext ?? "all_turns";
+		// Default reasoning replay to `all_turns`, mirroring codex-rs; an
+		// explicit `reasoningContext` overrides the default. The `all_turns`
+		// value is only accepted from gpt-5.4 onward — earlier Codex ids
+		// (gpt-5.1-codex, gpt-5.3-codex, gpt-5.3-codex-spark) reject it with
+		// "Unsupported value: 'all_turns' is not supported with this model".
+		// For those, drop `context` so the server applies its `current_turn`
+		// default. The version gate is authoritative: even an explicit
+		// `all_turns` override is suppressed on unsupported models, while
+		// `current_turn`/`auto` (universally supported) always pass through.
+		const context = options.reasoningContext ?? "all_turns";
+		if (context === "all_turns" && !supportsAllTurnsReasoningContext(model.id)) {
+			delete body.reasoning.context;
+		} else {
+			body.reasoning.context = context;
+		}
 	} else {
 		delete body.reasoning;
 	}

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

@@ -104,7 +104,7 @@ import { transformMessages } from "./transform-messages";
 export interface OpenAICodexResponsesOptions extends StreamOptions {
 	reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
 	reasoningSummary?: "auto" | "concise" | "detailed" | null;
-	/** `reasoning.context` replay scope; defaults to `all_turns` for every Codex request when unset. */
+	/** `reasoning.context` replay scope; defaults to `all_turns` when unset. The `all_turns` value is gated to gpt-5.4+ Codex models — older ids reject it, so it is suppressed and `context` omitted. */
 	reasoningContext?: CodexReasoningContext;
 	textVerbosity?: "low" | "medium" | "high";
 	include?: string[];

package/src/providers/openai-shared.ts

@@ -39,8 +39,6 @@ import {
 	type Model,
 	OPENAI_MAX_OUTPUT_TOKENS,
 	type Provider,
-	type ResolvedServiceTier,
-	resolveServiceTier,
 	type ServiceTier,
 	type StopReason,
 	type StreamOptions,
@@ -269,14 +267,13 @@ export function resolveOpenAIRequestSetup(
 }
 
 export function applyOpenAIServiceTier(
-	params: { service_tier?: ResolvedServiceTier | "auto" | "default" | null | undefined },
+	params: { service_tier?: ServiceTier | null | undefined },
 	serviceTier: ServiceTier | null | undefined,
 	provider: Provider | undefined,
 ): void {
 	if (!shouldSendServiceTier(serviceTier, provider)) return;
-	const resolved = resolveServiceTier(serviceTier, provider);
-	if (resolved === "flex" || resolved === "scale" || resolved === "priority") {
-		params.service_tier = resolved;
+	if (serviceTier === "flex" || serviceTier === "scale" || serviceTier === "priority") {
+		params.service_tier = serviceTier;
 	}
 }
 
@@ -315,10 +312,7 @@ export function applyOpenAIResponsesServiceTierCost(
 	// The response echo is authoritative when present (OpenAI may downgrade a
 	// requested priority/flex turn to default under load); only fall back to the
 	// requested tier when the response omits the echo entirely.
-	const served =
-		typeof responseServiceTier === "string"
-			? responseServiceTier
-			: resolveServiceTier(requestServiceTier, model.provider);
+	const served = typeof responseServiceTier === "string" ? responseServiceTier : (requestServiceTier ?? undefined);
 	const multiplier = getOpenAIResponsesServiceTierCostMultiplier(served);
 	if (multiplier === 1) return;
 	usage.cost.input *= multiplier;
@@ -623,7 +617,7 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
 	chat_template_kwargs?: { enable_thinking?: boolean; preserve_thinking?: boolean };
 	reasoning?: { effort?: string } | { enabled: false };
 	reasoning_effort?: string | null;
-	service_tier?: ResolvedServiceTier;
+	service_tier?: ServiceTier;
 	tool_stream?: boolean;
 	provider?: OpenAICompat["openRouterRouting"];
 	providerOptions?: { gateway?: { only?: string[]; order?: string[] } };