@oh-my-pi/pi-ai 16.4.8 → 16.5.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [16.5.0] - 2026-07-13
+
+### Added
+
+- Added diagnostic response headers to auth-gateway inference endpoints, including request IDs (x-request-id/request-id), LiteLLM model metadata (x-litellm-model-id/x-litellm-model-api-base), and performance/cost metrics (x-litellm-response-cost, x-litellm-response-duration-ms, openai-processing-ms) on non-streaming responses.
+
+### Changed
+
+- Updated Google and Google Vertex providers to always use streamGenerateContent requests.
+
+### Fixed
+
+- Fixed empty provider responses (such as from Cloud Code Assist API) being classified as non-retryable, allowing session retries and model-fallback chains to engage instead of failing the turn.
+
+### Removed
+
+- Removed automatic /interactions chaining for follow-up turns in Google provider calls, along with the useInteractionsApi, storeInteraction, and previousInteractionId stream options.
+
 ## [16.4.6] - 2026-07-12
 
 ### Added

package/dist/types/auth-gateway/http.d.ts

@@ -1,4 +1,21 @@
-export declare function json(status: number, body: unknown): Response;
+import type { Api, AssistantMessage, Model } from "../types.js";
+export declare function json(status: number, body: unknown, headers?: Record<string, string>): Response;
+/**
+ * Diagnostic response headers for translated inference requests, mirroring the
+ * names existing gateway-aware clients already parse: `x-request-id` /
+ * `request-id` (surfaced as `_request_id` by the OpenAI and Anthropic SDKs,
+ * matches the gateway log line), LiteLLM's model-resolution and cost headers,
+ * and OpenAI's `openai-processing-ms`. Model/request-id headers are always
+ * present; `message` — the final assistant message, available only on
+ * non-streaming responses — adds the computed cost, and `startedAt` the wall
+ * time. Streaming responses send headers before usage exists, so they carry
+ * only the identity headers.
+ */
+export declare function gatewayResponseHeaders(model: Model<Api>, info: {
+    requestId: string;
+    message?: AssistantMessage;
+    startedAt?: number;
+}): Record<string, string>;
 export declare function resolvePeer(req: Request): string;
 /**
  * Constant-time byte comparison. Falls back to a manual XOR accumulator if

package/dist/types/providers/google-auth.d.ts

@@ -22,11 +22,3 @@ export declare function getVertexAccessToken(options?: {
 }): Promise<string>;
 /** Test seam: clears every cached token. */
 export declare function __resetVertexTokenCache(): void;
-/**
- * Sync best-effort probe for a usable Vertex bearer credential source — an explicit access-token
- * env var, `GOOGLE_APPLICATION_CREDENTIALS`, a user ADC file, or a GCP runtime whose metadata
- * server can mint ADC (GCE/Cloud Run/App Engine/Functions). Lets callers prefer the bearer
- * Interactions transport only when ADC is actually reachable, without paying the async
- * metadata-probe cost for API-key-only setups.
- */
-export declare function hasVertexBearerCredentialsHint(): boolean;

package/dist/types/providers/google-shared.d.ts

@@ -37,19 +37,6 @@ export interface GoogleSharedStreamOptions extends StreamOptions {
     hideThinkingSummary?: boolean;
     /** 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;
 }
 /**
  * Determines whether a streamed Gemini `Part` should be treated as "thinking".

package/dist/types/types.d.ts

@@ -264,22 +264,6 @@ export interface StreamOptions {
     providerSessionState?: Map<string, ProviderSessionState>;
     /** Canonical Codex compaction classification; ignored by other providers. */
     codexCompaction?: CodexCompactionRequestContext;
-    /**
-     * Force Gemini model-mode Interactions API transport for providers that support it.
-     * When unset, those providers may still use Interactions to continue known
-     * server-side conversation lineage via `previousInteractionId` or stored state.
-     */
-    useInteractionsApi?: boolean;
-    /**
-     * Whether supported Interactions transports should store server-side conversation
-     * state and return response ids for follow-up turns. Defaults to true.
-     */
-    storeInteraction?: boolean;
-    /**
-     * Explicit Interactions response id to continue. Mutually exclusive with
-     * `storeInteraction: false` because the follow-up itself must be storable.
-     */
-    previousInteractionId?: string;
     /**
      * Optional per-provider concurrent request cap for LLM stream calls. Keys are
      * provider ids (`model.provider`); positive numeric values cap in-flight

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.4.8",
+	"version": "16.5.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -37,15 +37,15 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.4.8",
-		"@oh-my-pi/pi-utils": "16.4.8",
-		"@oh-my-pi/pi-wire": "16.4.8",
-		"arktype": "2.2.2",
+		"@bufbuild/protobuf": "^2.12.1",
+		"@oh-my-pi/pi-catalog": "16.5.0",
+		"@oh-my-pi/pi-utils": "16.5.0",
+		"@oh-my-pi/pi-wire": "16.5.0",
+		"arktype": "2.2.3",
 		"zod": "^4"
 	},
 	"devDependencies": {
-		"@bufbuild/protoc-gen-es": "^2.12.0",
+		"@bufbuild/protoc-gen-es": "^2.12.1",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/auth-gateway/http.ts

@@ -5,19 +5,50 @@
  * and peer-resolution logic.
  */
 import { timingSafeEqual as nodeTimingSafeEqual } from "node:crypto";
+import type { Api, AssistantMessage, Model } from "../types";
 
 const JSON_HEADERS = {
 	"Content-Type": "application/json",
 	"X-Content-Type-Options": "nosniff",
 } as const;
 
-export function json(status: number, body: unknown): Response {
+export function json(status: number, body: unknown, headers?: Record<string, string>): Response {
 	return new Response(JSON.stringify(body) ?? "null", {
 		status,
-		headers: JSON_HEADERS,
+		headers: headers ? { ...JSON_HEADERS, ...headers } : JSON_HEADERS,
 	});
 }
 
+/**
+ * Diagnostic response headers for translated inference requests, mirroring the
+ * names existing gateway-aware clients already parse: `x-request-id` /
+ * `request-id` (surfaced as `_request_id` by the OpenAI and Anthropic SDKs,
+ * matches the gateway log line), LiteLLM's model-resolution and cost headers,
+ * and OpenAI's `openai-processing-ms`. Model/request-id headers are always
+ * present; `message` — the final assistant message, available only on
+ * non-streaming responses — adds the computed cost, and `startedAt` the wall
+ * time. Streaming responses send headers before usage exists, so they carry
+ * only the identity headers.
+ */
+export function gatewayResponseHeaders(
+	model: Model<Api>,
+	info: { requestId: string; message?: AssistantMessage; startedAt?: number },
+): Record<string, string> {
+	const headers: Record<string, string> = {
+		"x-request-id": info.requestId,
+		"request-id": info.requestId,
+		"x-litellm-model-id": model.id,
+	};
+	if (model.baseUrl) headers["x-litellm-model-api-base"] = model.baseUrl;
+	if (info.message) headers["x-litellm-response-cost"] = info.message.usage.cost.total.toString();
+	if (info.startedAt !== undefined) {
+		const elapsed = (performance.now() - info.startedAt).toFixed(0);
+		headers["x-litellm-response-duration-ms"] = elapsed;
+		headers["openai-processing-ms"] = elapsed;
+	}
+	return headers;
+}
+
 export function resolvePeer(req: Request): string {
 	const fwd = req.headers.get("x-forwarded-for");
 	if (fwd) return fwd.split(",")[0].trim();
@@ -165,6 +196,8 @@ const CORS_HEADERS: Record<string, string> = {
 	"Access-Control-Allow-Methods": "GET, POST, OPTIONS",
 	"Access-Control-Allow-Headers":
 		"authorization, content-type, anthropic-version, anthropic-beta, openai-organization, openai-project, x-stainless-*, x-api-key",
+	"Access-Control-Expose-Headers":
+		"x-request-id, request-id, x-litellm-model-id, x-litellm-model-api-base, x-litellm-response-cost, x-litellm-response-duration-ms, openai-processing-ms",
 	"Access-Control-Max-Age": "86400",
 };
 

package/src/auth-gateway/server.ts

@@ -32,7 +32,15 @@ import { completeSimple, streamSimple } from "../stream";
 import type { Api, AssistantMessageEventStream, Context, Model, SimpleStreamOptions } from "../types";
 import { deterministicUuid } from "../utils/deterministic-id";
 import { parseBind } from "../utils/parse-bind";
-import { captureRequestHeaders, corsHeaders, isAuthorized, json, resolvePeer, withCors } from "./http";
+import {
+	captureRequestHeaders,
+	corsHeaders,
+	gatewayResponseHeaders,
+	isAuthorized,
+	json,
+	resolvePeer,
+	withCors,
+} from "./http";
 import type {
 	AuthGatewayServerHandle,
 	AuthGatewayServerOptions,
@@ -334,6 +342,8 @@ async function handleFormatEndpoint(
 	req: Request,
 	peer: string,
 ): Promise<Response> {
+	const startedAt = performance.now();
+	const requestId = crypto.randomUUID();
 	const controller = mirrorRequestAbort(req);
 	if (controller.signal.aborted) return clientClosedResponse(route);
 
@@ -430,6 +440,7 @@ async function handleFormatEndpoint(
 	);
 
 	logger.info("auth-gateway request", {
+		requestId,
 		format: route.label,
 		model: parsed.modelId,
 		resolvedProvider: model.provider,
@@ -458,7 +469,11 @@ async function handleFormatEndpoint(
 				const classified = classifyGatewayError(errorMessage);
 				return route.module.formatError(classified.status, classified.type, errorMessage);
 			}
-			return json(200, route.module.encodeResponse(message, parsed.modelId));
+			return json(
+				200,
+				route.module.encodeResponse(message, parsed.modelId),
+				gatewayResponseHeaders(model, { requestId, message, startedAt }),
+			);
 		} catch (error) {
 			if (controller.signal.aborted) return clientClosedResponse(route);
 			const classified = classifyGatewayError(error);
@@ -493,6 +508,7 @@ async function handleFormatEndpoint(
 	return new Response(sseStream, {
 		status: 200,
 		headers: {
+			...gatewayResponseHeaders(model, { requestId }),
 			"Content-Type": "text/event-stream; charset=utf-8",
 			"Cache-Control": "no-cache",
 			Connection: "keep-alive",
@@ -519,6 +535,8 @@ async function handleFormatEndpoint(
  * path.
  */
 async function handlePiNative(bootOpts: AuthGatewayBootOptions, req: Request, peer: string): Promise<Response> {
+	const startedAt = performance.now();
+	const requestId = crypto.randomUUID();
 	const controller = mirrorRequestAbort(req);
 	const aborted = (): Response => piNative.formatError(499, "request_aborted", "client closed request");
 	if (controller.signal.aborted) return aborted();
@@ -605,6 +623,7 @@ async function handlePiNative(bootOpts: AuthGatewayBootOptions, req: Request, pe
 	streamOpts.sessionId ??= sessionId;
 
 	logger.info("auth-gateway request", {
+		requestId,
 		format: "pi-native",
 		model: parsed.modelId,
 		resolvedProvider: model.provider,
@@ -633,7 +652,7 @@ async function handlePiNative(bootOpts: AuthGatewayBootOptions, req: Request, pe
 				const classified = classifyGatewayError(errorMessage);
 				return piNative.formatError(classified.status, classified.type, errorMessage);
 			}
-			return json(200, { message });
+			return json(200, { message }, gatewayResponseHeaders(model, { requestId, message, startedAt }));
 		} catch (error) {
 			if (controller.signal.aborted) return aborted();
 			const classified = classifyGatewayError(error);
@@ -664,6 +683,7 @@ async function handlePiNative(bootOpts: AuthGatewayBootOptions, req: Request, pe
 	return new Response(sseStream, {
 		status: 200,
 		headers: {
+			...gatewayResponseHeaders(model, { requestId }),
 			"Content-Type": "text/event-stream; charset=utf-8",
 			"Cache-Control": "no-cache",
 			Connection: "keep-alive",

package/src/error/provider.ts

@@ -39,10 +39,11 @@ export class ProviderResponseError extends Error {
 		// A safety filter block is a terminal provider finish, not a transient fault.
 		if (this.kind === "content-blocked") attach(this, create(Flag.ProviderFinishError));
 		// An incomplete stream (connection dropped / truncated before any terminal
-		// event) never produced a finish reason — the request didn't complete, so it
-		// is safe to retry. The retry layer's replay-unsafe guard still blocks a
-		// retry when partial tool output was already emitted.
-		else if (this.kind === "incomplete-stream") attach(this, create(Flag.Transient));
+		// event) or an empty body never produced any content — the request didn't
+		// complete, so it is safe to retry and eligible for model fallback. The
+		// retry layer's replay-unsafe guard still blocks a retry when partial tool
+		// output was already emitted.
+		else if (this.kind === "incomplete-stream" || this.kind === "empty-body") attach(this, create(Flag.Transient));
 	}
 }
 

package/src/providers/google-auth.ts

@@ -13,7 +13,6 @@
  */
 
 import { Buffer } from "node:buffer";
-import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { $envpos, isEnoent, logger } from "@oh-my-pi/pi-utils";
@@ -329,22 +328,3 @@ export function __resetVertexTokenCache(): void {
 	tokenCache.clear();
 	inflight.clear();
 }
-
-/**
- * Sync best-effort probe for a usable Vertex bearer credential source — an explicit access-token
- * env var, `GOOGLE_APPLICATION_CREDENTIALS`, a user ADC file, or a GCP runtime whose metadata
- * server can mint ADC (GCE/Cloud Run/App Engine/Functions). Lets callers prefer the bearer
- * Interactions transport only when ADC is actually reachable, without paying the async
- * metadata-probe cost for API-key-only setups.
- */
-export function hasVertexBearerCredentialsHint(): boolean {
-	if (Bun.env.GOOGLE_CLOUD_ACCESS_TOKEN || Bun.env.CLOUDSDK_AUTH_ACCESS_TOKEN) return true;
-	if (Bun.env.GOOGLE_APPLICATION_CREDENTIALS) return true;
-	// GCP-hosted runtimes expose ADC via the metadata server; these env vars mark those runtimes.
-	if (Bun.env.K_SERVICE || Bun.env.FUNCTION_TARGET || Bun.env.GAE_ENV || Bun.env.GCE_METADATA_HOST) return true;
-	try {
-		return fs.existsSync(userAdcPath());
-	} catch {
-		return false;
-	}
-}

package/src/providers/google-shared.ts

@@ -79,19 +79,6 @@ export interface GoogleSharedStreamOptions extends StreamOptions {
 	hideThinkingSummary?: boolean;
 	/** 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;
 }
 
 /**

package/src/providers/google-vertex.ts

@@ -2,13 +2,7 @@ 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, hasVertexBearerCredentialsHint } from "./google-auth";
-import {
-	type GoogleInteractionsPlan,
-	modelSupportsInteractions,
-	resolveInteractionDispatch,
-	streamGoogleInteractions,
-} from "./google-interactions";
+import { getVertexAccessToken } from "./google-auth";
 import {
 	buildGoogleGenerateContentParams,
 	type GoogleGenAIRequestPlan,
@@ -22,126 +16,86 @@ 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 => {
-	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) {
-					// 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,
-					};
-				}
+	return 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";
+			}
 
-				const project = resolveProject(options);
-				const location = resolveLocation(options);
-				const accessToken = await getVertexAccessToken({ signal: options?.signal, fetch: options?.fetch });
+			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 url = `https://${host}/${API_VERSION}/projects/${project}/locations/${location}/publishers/google/models/${model.id}:streamGenerateContent?alt=sse`;
+				const path = `${API_VERSION}/publishers/google/models/${model.id}:streamGenerateContent?alt=sse`;
+				const useGlobalFallback = !explicitLocation && host !== "aiplatform.googleapis.com";
 				return {
 					params,
-					url,
-					headers: { ...baseHeaders, Authorization: `Bearer ${accessToken}` },
+					url: `https://${host}/${path}`,
+					fallbackUrl: useGlobalFallback ? `https://aiplatform.googleapis.com/${path}` : undefined,
+					headers: {
+						...baseHeaders,
+						"x-goog-api-key": apiKey,
+					},
 					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 {
-				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,
-				},
+				params,
+				url,
+				headers: { ...baseHeaders, Authorization: `Bearer ${accessToken}` },
 				fetch: options?.fetch,
 			};
 		},
-		fallback: auto ? runGenerateContent : undefined,
 	});
 };
 

package/src/providers/google.ts

@@ -2,7 +2,6 @@ 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,
@@ -27,61 +26,22 @@ export const streamGoogle: StreamFunction<"google-generative-ai"> = (
 		);
 	}
 
-	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({
+	return streamGoogleGenAI({
 		model,
-		context,
 		options,
 		api: "google-generative-ai",
-		anchor,
-		state,
-		prepare: () => ({
-			url: `${trimmedBase || DEFAULT_GENERATIVE_LANGUAGE_BASE}/interactions`,
-			headers: {
+		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 ?? {}),
-			},
-			fetch: options?.fetch,
-		}),
-		fallback: auto ? runGenerateContent : undefined,
+			};
+			return { params, url, headers, fetch: options?.fetch };
+		},
 	});
 };

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

@@ -425,7 +425,7 @@ export async function transformRequestBody(
 
 	body.text = {
 		...body.text,
-		verbosity: options.textVerbosity || "high",
+		verbosity: options.textVerbosity || "medium",
 	};
 
 	const include = Array.isArray(options.include) ? [...options.include] : [];