@ai-sdk/google 4.0.108 → 4.0.109

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @ai-sdk/google
 
+## 4.0.109
+
+### Patch Changes
+
+- 7716e18: Support promises and synchronous or asynchronous callbacks in provider API key and token settings. Resolve credentials per authenticated request while preserving existing authentication behavior and synchronous credential serialization.
+
+  The experimental OpenAI Live `getServerWebSocketConfig()` method can now resolve asynchronously. Await its result before using the connection settings.
+
+- dfed8e8: Consolidate Google language model capabilities and request policies into a model catalog shared by runtime resolution and generated documentation, preserving existing Google and Vertex request behavior.
+- Updated dependencies [7716e18]
+- Updated dependencies [5c247e9]
+- Updated dependencies [dcd2f8d]
+  - @ai-sdk/provider-utils@5.0.72
+  - @ai-sdk/provider@4.0.35
+
 ## 4.0.108
 
 ### Patch Changes

package/dist/index.d.ts

@@ -754,7 +754,7 @@ interface GoogleProviderSettings {
    * API key that is being send using the `x-goog-api-key` header.
    * It defaults to the `GOOGLE_GENERATIVE_AI_API_KEY` environment variable.
    */
-  apiKey?: string;
+  apiKey?: Resolvable<string>;
   /**
    * Custom headers to include in the requests.
    */
@@ -792,7 +792,7 @@ export declare const google: GoogleProvider;
 type GoogleRealtimeModelConfig = {
   provider: string;
   baseURL: string;
-  headers: () => Record<string, string | undefined>;
+  headers: Resolvable<Record<string, string | undefined>>;
   fetch?: FetchFunction;
 };
 declare class GoogleRealtimeModel implements Experimental_RealtimeModelV4 {
@@ -908,7 +908,7 @@ export declare class GoogleTranscriptionModel implements TranscriptionModelV4 {
 type GoogleSpeechTranslationModelConfig = {
   provider: string;
   baseURL: string;
-  headers: () => Record<string, string | undefined>;
+  headers: Resolvable<Record<string, string | undefined>>;
   webSocket?: WebSocketConstructor;
   _internal?: {
     currentDate?: () => Date;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["DecisionModelV4","BatchV4","SpeechTranslationModelV4","RealtimeFactoryV4","RealtimeModelV4ClientSecretOptions","RealtimeModelV4ClientSecretResult","RealtimeModelV4ServerEvent","RealtimeModelV4ClientEvent","RealtimeModelV4","RealtimeModelV4SessionConfig","TranscriptionModelV4StreamOptions","SpeechTranslationModelV4StreamOptions","SpeechTranslationModelV4"],"sources":["../src/google-error.ts","../src/google-language-model-options.ts","../src/google-language-model.ts","../src/google-prompt.ts","../src/tool/google-search.ts","../src/google-image-model-options.ts","../src/google-embedding-model-options.ts","../src/google-video-model-options.ts","../src/google-video-settings.ts","../src/google-speech-model-options.ts","../src/google-files.ts","../src/interactions/google-interactions-language-model-options.ts","../src/interactions/google-interactions-provider-metadata.ts","../src/interactions/google-interactions-agent.ts","../src/google-tools.ts","../src/google-image-settings.ts","../src/transcription/google-transcription-model-options.ts","../src/speech-translation/google-speech-translation-model-options.ts","../src/google-provider.ts","../src/realtime/google-realtime-model.ts","../src/realtime/google-realtime-model-options.ts","../src/transcription/google-transcription-model.ts","../src/speech-translation/google-speech-translation-model.ts","../src/version.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["DecisionModelV4","BatchV4","SpeechTranslationModelV4","RealtimeFactoryV4","RealtimeModelV4ClientSecretOptions","RealtimeModelV4ClientSecretResult","RealtimeModelV4ServerEvent","RealtimeModelV4ClientEvent","RealtimeModelV4","RealtimeModelV4SessionConfig","TranscriptionModelV4StreamOptions","SpeechTranslationModelV4StreamOptions","SpeechTranslationModelV4"],"sources":["../src/google-error.ts","../src/google-language-model-options.ts","../src/google-language-model.ts","../src/google-prompt.ts","../src/tool/google-search.ts","../src/google-image-model-options.ts","../src/google-embedding-model-options.ts","../src/google-video-model-options.ts","../src/google-video-settings.ts","../src/google-speech-model-options.ts","../src/google-files.ts","../src/interactions/google-interactions-language-model-options.ts","../src/interactions/google-interactions-provider-metadata.ts","../src/interactions/google-interactions-agent.ts","../src/google-tools.ts","../src/google-image-settings.ts","../src/transcription/google-transcription-model-options.ts","../src/speech-translation/google-speech-translation-model-options.ts","../src/google-provider.ts","../src/realtime/google-realtime-model.ts","../src/realtime/google-realtime-model-options.ts","../src/transcription/google-transcription-model.ts","../src/speech-translation/google-speech-translation-model.ts","../src/version.ts"],"mappings":"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"}

package/dist/index.js

@@ -1,9 +1,9 @@
-import { EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, connectToWebSocket, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertInlineFileDataToUint8Array, convertJsonResponseToolStream, convertToBase64, convertUint8ArrayToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonLinesResponseHandler, createJsonResponseHandler, createNullLanguageModelUsage, createProviderExecutedToolFactory, createProviderStreamError, createToolNameMapping, delay, detectMediaType, downloadBlob, encodePathSegment, generateId, getFromApi, getRuntimeEnvironmentUserAgent, getTopLevelMediaType, isAbortError, isCustomReasoning, isFullMediaType, isRecord, isSameOrigin, isUrlSupported, lazySchema, loadApiKey, mapReasoningToProviderBudget, mapReasoningToProviderEffort, normalizeBatchRequestCounts, parseProviderOptions, postJsonToApi, postToApi, resolve, resolveFullMediaType, resolveProviderReference, safeParseJSON, safeValidateTypes, secureJsonParse, serializeModelOptions, waitForWebSocketBufferDrain, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
+import { EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, connectToWebSocket, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertInlineFileDataToUint8Array, convertJsonResponseToolStream, convertToBase64, convertUint8ArrayToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonLinesResponseHandler, createJsonResponseHandler, createNullLanguageModelUsage, createProviderExecutedToolFactory, createProviderStreamError, createToolNameMapping, delay, detectMediaType, downloadBlob, encodePathSegment, generateId, getFromApi, getRuntimeEnvironmentUserAgent, getTopLevelMediaType, isAbortError, isCustomReasoning, isFullMediaType, isRecord, isSameOrigin, isUrlSupported, lazySchema, loadApiKey, mapReasoningToProviderBudget, mapReasoningToProviderEffort, normalizeBatchRequestCounts, parseProviderOptions, postJsonToApi, postToApi, resolve, resolveFullMediaType, resolveProviderReference, resolveWith, safeParseJSON, safeValidateTypes, secureJsonParse, serializeModelOptions, waitForWebSocketBufferDrain, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
 import { Experimental_DecisionLanguageModel } from "@ai-sdk/provider-utils/experimental-decision";
 import { AISDKError, InvalidArgumentError, InvalidResponseDataError, TooManyEmbeddingValuesForCallError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
 import { z } from "zod/v4";
 //#region src/version.ts
-const VERSION = "4.0.108";
+const VERSION = "4.0.109";
 //#endregion
 //#region src/google-error.ts
 const getGoogleErrorSchema = () => z.object({
@@ -1030,11 +1030,129 @@ const googleLanguageModelOptions = lazySchema(() => zodSchema(z.object({
 	requestType: z.enum(["shared"]).optional()
 })));
 //#endregion
-//#region src/google-model-capabilities.ts
+//#region src/google-model-catalog.ts
 const gemini1ModelPattern = /(^|[/.])gemini-1(?:[.-]|$)/i;
 const gemini2ModelPattern = /(^|[/.])gemini-2(?:[.-]|$)/i;
-const gemini25ModelPattern$1 = /(^|[/.])gemini-2\.5(?:[.-]|$)/i;
+const gemini25ModelPattern = /(^|[/.])gemini-2\.5(?:[.-]|$)/i;
 const geminiModelPattern = /(^|[/.])gemini-/i;
+/** Options accepted under providerOptions.google (or googleVertex on Vertex). */
+const googleProviderOptions = { language: {
+	responseModalities: { description: "Response modalities to generate." },
+	thinkingConfig: { description: "Thinking budget, level, and thought output." },
+	cachedContent: { description: "Cached content to use as request context." },
+	structuredOutputs: { description: "Whether to send the JSON response schema." },
+	safetySettings: { description: "Safety settings for the request." },
+	threshold: { description: "Default threshold for configurable safety categories." },
+	audioTimestamp: { description: "Enable timestamp understanding for audio." },
+	labels: { description: "Billing labels. Vertex AI only." },
+	mediaResolution: { description: "Resolution used to process media inputs." },
+	imageConfig: { description: "Image generation configuration." },
+	retrievalConfig: { description: "Retrieval configuration for tools." },
+	streamFunctionCallArguments: { description: "Stream function arguments. Vertex AI only." },
+	serviceTier: { description: "Service tier. Gemini API only." },
+	continuationToken: { description: "Resume a response using its continuation token." },
+	sharedRequestType: { description: "Shared PayGo tier. Vertex AI only." },
+	requestType: { description: "Request routing type. Vertex AI only." }
+} };
+const standard = {
+	image: true,
+	objectGeneration: true,
+	tools: true,
+	streaming: true,
+	googleSearch: true,
+	urlContext: true
+};
+const googleModelCatalog = Object.fromEntries(Object.entries({
+	"gemini-nano-banana-2.1": {
+		image: true,
+		objectGeneration: false,
+		tools: false,
+		streaming: false,
+		googleSearch: true,
+		urlContext: false
+	},
+	"gemini-4-argon": standard,
+	"gemini-3.8-flash": standard,
+	"gemini-3.7-flash": standard,
+	"gemini-3.6-flash": standard,
+	"gemini-3.5-flash": standard,
+	"gemini-3.5-flash-lite": standard,
+	"gemini-3.1-pro-preview": standard,
+	"gemini-3.1-flash-image-preview": standard,
+	"gemini-3.1-flash-lite-preview": standard,
+	"gemini-3-pro-preview": standard,
+	"gemini-3-pro-image-preview": standard,
+	"gemini-3-flash-preview": standard,
+	"gemini-2.5-pro": standard,
+	"gemini-2.5-flash": standard,
+	"gemini-2.5-flash-lite": standard,
+	"gemini-2.5-flash-lite-preview-06-17": standard,
+	"gemini-2.0-flash": standard
+}).map(([modelId, documented]) => [modelId, createGoogleLanguageModelEntry(modelId, documented)]));
+function getGoogleLanguageModelEntry(modelId) {
+	return Object.prototype.hasOwnProperty.call(googleModelCatalog, modelId) ? googleModelCatalog[modelId] : createGoogleLanguageModelEntry(modelId);
+}
+function createGoogleLanguageModelEntry(modelId, documented) {
+	const runtime = resolveRuntimeDefinition(modelId);
+	const declared = documented != null;
+	const id = modelId.toLowerCase();
+	const thinkingFormat = runtime.usesGemini3Features && !modelId.includes("gemini-3-pro-image") ? "level" : "budget";
+	const minLevel = getMinimumThinkingLevelForGemini3Model(modelId);
+	return {
+		capabilities: { language: {
+			inputs: {
+				image: documented?.image ?? "unknown",
+				audio: "unknown"
+			},
+			objectGeneration: documented?.objectGeneration ?? "unknown",
+			tools: {
+				usage: documented?.tools ?? "unknown",
+				streaming: documented?.streaming ?? "unknown",
+				gemini2: runtime.supportsGemini2Tools,
+				googleSearch: documented?.googleSearch ?? "unknown",
+				urlContext: documented?.urlContext ?? "unknown",
+				fileSearch: runtime.supportsFileSearch,
+				mixed: runtime.usesGemini3Features,
+				functionResponseParts: runtime.usesGemini3Features
+			},
+			reasoning: {
+				support: "unknown",
+				efforts: thinkingFormat === "level" ? [
+					...minLevel === "minimal" ? ["minimal"] : [],
+					"low",
+					"medium",
+					"high"
+				] : void 0,
+				minBudget: id.includes("2.5-pro") ? 128 : 0,
+				maxBudget: id.includes("2.5-pro") || id.includes("gemini-3-pro-image") ? 32768 : 24576
+			},
+			sampling: {
+				temperature: "unknown",
+				topP: "unknown",
+				topK: "unknown",
+				logprobs: false,
+				penalties: gemini25ModelPattern.test(modelId) ? { condition: "Only supported on the Vertex AI API." } : true
+			},
+			structuredOutput: { withFunctionTools: runtime.usesGemini3Features }
+		} },
+		providerOptions: { language: declareProviderOptions(declared ? true : "unknown", {
+			labels: { condition: "Only supported on the Vertex AI API." },
+			sharedRequestType: { condition: "Only supported on the Vertex AI API." },
+			requestType: { condition: "Only supported on the Vertex AI API." },
+			serviceTier: { condition: "Only supported on the Gemini API." },
+			streamFunctionCallArguments: { condition: "Only supported for streaming requests on the Vertex AI API with Gemini 3 or newer." }
+		}) },
+		requestConfig: { language: {
+			systemInstruction: id.startsWith("gemma-") ? "user" : "system",
+			thinkingFormat,
+			reasoningMaxOutputTokens: 65536,
+			jsonResponseTool: /(^|\/)gemini-/i.test(modelId)
+		} }
+	};
+}
+function declareProviderOptions(support, exceptions) {
+	return Object.fromEntries(Object.keys(googleProviderOptions.language).map((option) => [option, exceptions[option] ?? support]));
+}
 function isKnownPreGemini2Model(modelId) {
 	return gemini1ModelPattern.test(modelId) || /(^|[/.])gemini-pro(?:-vision)?$/i.test(modelId) || /(^|[/.])gemini-robotics-er-1\.5(?:[.-]|$)/i.test(modelId);
 }
@@ -1045,17 +1163,39 @@ function isKnownPreGemini2Model(modelId) {
 * intentionally inherit the newest supported behavior. Add exceptions here
 * only when a model is known to require a legacy request shape.
 */
-function getGoogleModelCapabilities(modelId) {
+function resolveRuntimeDefinition(modelId) {
 	const isGeminiModel = geminiModelPattern.test(modelId);
 	const isGemini2Model = gemini2ModelPattern.test(modelId);
 	const isKnownPreGemini2 = isKnownPreGemini2Model(modelId);
 	const usesGemini3Features = isGeminiModel && !(isKnownPreGemini2 || isGemini2Model);
 	return {
 		supportsGemini2Tools: isGeminiModel && !isKnownPreGemini2 || modelId.toLowerCase().includes("nano-banana"),
-		supportsFileSearch: gemini25ModelPattern$1.test(modelId) || usesGemini3Features,
+		supportsFileSearch: gemini25ModelPattern.test(modelId) || usesGemini3Features,
 		usesGemini3Features
 	};
 }
+function getMinimumThinkingLevelForGemini3Model(modelId) {
+	const modelName = /(?:^|[/.])(gemini-[^/]*)$/i.exec(modelId)?.[1].toLowerCase();
+	if (modelName === "gemini-flash-latest") return "low";
+	const proVersionMatch = /^gemini-(\d+)(?:\.\d+)?-pro(?:$|-)/.exec(modelName ?? "");
+	if (Number(proVersionMatch?.[1]) >= 3) return "low";
+	const versionMatch = /^gemini-(\d+)\.(\d+)-flash(?:$|-(?!lite(?:-|$)))/.exec(modelName ?? "");
+	if (versionMatch == null) return "minimal";
+	const majorVersion = Number(versionMatch[1]);
+	const minorVersion = Number(versionMatch[2]);
+	return majorVersion > 3 || majorVersion === 3 && minorVersion >= 7 ? "low" : "minimal";
+}
+//#endregion
+//#region src/google-model-capabilities.ts
+/** Compatibility projection of the resolved catalog for existing request code. */
+function getGoogleModelCapabilities(modelId) {
+	const { tools } = getGoogleLanguageModelEntry(modelId).capabilities.language;
+	return {
+		supportsGemini2Tools: tools.gemini2,
+		supportsFileSearch: tools.fileSearch,
+		usesGemini3Features: tools.mixed
+	};
+}
 //#endregion
 //#region src/google-prepare-tools.ts
 function prepareTools({ tools, toolChoice, modelId, isVertexProvider = false }) {
@@ -1537,7 +1677,6 @@ const configurableSafetySettingCategories = [
 	"HARM_CATEGORY_HARASSMENT",
 	"HARM_CATEGORY_SEXUALLY_EXPLICIT"
 ];
-const gemini25ModelPattern = /(^|[/.])gemini-2\.5(?:[.-]|$)/i;
 const googleCloudStorageFunctionResponseUrls = {
 	"image/png": [/^gs:\/\/.*$/],
 	"image/jpeg": [/^gs:\/\/.*$/],
@@ -1622,8 +1761,9 @@ var GoogleLanguageModel = class GoogleLanguageModel {
 				imageConfig = geminiApiImageConfig;
 			}
 		}
-		const isGemmaModel = modelId.toLowerCase().startsWith("gemma-");
-		const isGemini25DeveloperApiModel = !isVertexProvider && gemini25ModelPattern.test(modelId);
+		const entry = getGoogleLanguageModelEntry(modelId);
+		const isGemmaModel = entry.requestConfig.language.systemInstruction === "user";
+		const isGemini25DeveloperApiModel = !isVertexProvider && entry.capabilities.language.sampling.penalties !== true;
 		if (isGemini25DeveloperApiModel && frequencyPenalty != null) warnings.push({
 			type: "unsupported",
 			feature: "frequencyPenalty"
@@ -1632,7 +1772,7 @@ var GoogleLanguageModel = class GoogleLanguageModel {
 			type: "unsupported",
 			feature: "presencePenalty"
 		});
-		const { usesGemini3Features } = getGoogleModelCapabilities(modelId);
+		const usesGemini3Features = entry.capabilities.language.tools.functionResponseParts;
 		const supportedFunctionResponseUrls = usesGemini3Features && config.downloadToolResultFiles?.supportsGoogleCloudStorageUrls ? googleCloudStorageFunctionResponseUrls : void 0;
 		const { contents, systemInstruction } = convertToGoogleMessages(config.downloadToolResultFiles ? await downloadToolResultFiles(prompt, {
 			abortSignal,
@@ -1717,8 +1857,10 @@ var GoogleLanguageModel = class GoogleLanguageModel {
 	}
 	async getArgs(options, { isStreaming = false } = {}) {
 		const { responseFormat, tools, toolChoice } = options;
+		const entry = getGoogleLanguageModelEntry(this.modelId);
+		const { structuredOutput } = entry.capabilities.language;
 		let jsonResponseTool;
-		if (responseFormat?.type === "json" && responseFormat.schema != null && tools?.some((tool) => tool.type === "function") && /(^|\/)gemini-/i.test(this.modelId) && (!getGoogleModelCapabilities(this.modelId).usesGemini3Features || toolChoice?.type === "required" || toolChoice?.type === "tool")) {
+		if (responseFormat?.type === "json" && responseFormat.schema != null && tools?.some((tool) => tool.type === "function") && entry.requestConfig.language.jsonResponseTool && (!structuredOutput.withFunctionTools || toolChoice?.type === "required" || toolChoice?.type === "tool")) {
 			let name = "json";
 			for (let suffix = 1; tools.some((tool) => tool.name === name); suffix++) name = `json_${suffix}`;
 			jsonResponseTool = {
@@ -1888,10 +2030,9 @@ var GoogleLanguageModel = class GoogleLanguageModel {
 	}
 	async doGenerate(options) {
 		const { args, warnings, providerOptionsNames, extraHeaders, toolNameMapping, jsonResponseToolName } = await this.getArgs(options);
-		const mergedHeaders = combineHeaders(this.config.headers ? await resolve(this.config.headers) : void 0, options.headers, extraHeaders);
-		const generateContent = (body) => postJsonToApi({
+		const generateContent = async (body) => postJsonToApi({
 			url: `${this.config.baseURL}/${getModelPath(this.modelId)}:generateContent`,
-			headers: mergedHeaders,
+			headers: combineHeaders(await resolve(this.config.headers), options.headers, extraHeaders),
 			body,
 			failedResponseHandler: googleFailedResponseHandler,
 			successfulResponseHandler: createJsonResponseHandler(responseSchema),
@@ -1954,10 +2095,9 @@ var GoogleLanguageModel = class GoogleLanguageModel {
 	async doStream(options) {
 		const { args, warnings, providerOptionsNames, extraHeaders, toolNameMapping, jsonResponseToolName } = await this.getArgs(options, { isStreaming: true });
 		const wrapProviderMetadata = (payload) => Object.fromEntries(providerOptionsNames.map((name) => [name, payload]));
-		const headers = combineHeaders(this.config.headers ? await resolve(this.config.headers) : void 0, options.headers, extraHeaders);
-		const streamGenerateContent = (body) => postJsonToApi({
+		const streamGenerateContent = async (body) => postJsonToApi({
 			url: `${this.config.baseURL}/${getModelPath(this.modelId)}:streamGenerateContent?alt=sse`,
-			headers,
+			headers: combineHeaders(await resolve(this.config.headers), options.headers, extraHeaders),
 			body,
 			failedResponseHandler: googleFailedResponseHandler,
 			successfulResponseHandler: createEventSourceResponseHandler(chunkSchema),
@@ -2410,25 +2550,9 @@ var GoogleLanguageModel = class GoogleLanguageModel {
 		};
 	}
 };
-function getMaxOutputTokensForGemini25Model() {
-	return 65536;
-}
-function getMaxThinkingTokensForGemini25Model(modelId) {
-	const id = modelId.toLowerCase();
-	if (id.includes("2.5-pro") || id.includes("gemini-3-pro-image")) return 32768;
-	return 24576;
-}
-/**
-* Gemini 2.5 Pro cannot disable thinking and requires a thinking budget of at
-* least 128 tokens. Other Gemini 2.5 models can disable thinking with a budget
-* of 0.
-*/
-function getMinThinkingTokensForGemini25Model(modelId) {
-	return modelId.toLowerCase().includes("2.5-pro") ? 128 : 0;
-}
 function resolveThinkingConfig({ reasoning, modelId, warnings }) {
 	if (!isCustomReasoning(reasoning)) return;
-	if (getGoogleModelCapabilities(modelId).usesGemini3Features && !modelId.includes("gemini-3-pro-image")) return resolveGemini3ThinkingConfig({
+	if (getGoogleLanguageModelEntry(modelId).requestConfig.language.thinkingFormat === "level") return resolveGemini3ThinkingConfig({
 		reasoning,
 		modelId,
 		warnings
@@ -2440,7 +2564,7 @@ function resolveThinkingConfig({ reasoning, modelId, warnings }) {
 	});
 }
 function resolveGemini3ThinkingConfig({ reasoning, modelId, warnings }) {
-	const minimumThinkingLevel = getMinimumThinkingLevelForGemini3Model(modelId);
+	const minimumThinkingLevel = getGoogleLanguageModelEntry(modelId).capabilities.language.reasoning.efforts?.[0];
 	const thinkingLevel = mapReasoningToProviderEffort({
 		reasoning,
 		effortMap: {
@@ -2454,24 +2578,14 @@ function resolveGemini3ThinkingConfig({ reasoning, modelId, warnings }) {
 	if (thinkingLevel == null) return;
 	return { thinkingLevel };
 }
-function getMinimumThinkingLevelForGemini3Model(modelId) {
-	const modelName = /(?:^|[/.])(gemini-[^/]*)$/i.exec(modelId)?.[1].toLowerCase();
-	if (modelName === "gemini-flash-latest") return "low";
-	const proVersionMatch = /^gemini-(\d+)(?:\.\d+)?-pro(?:$|-)/.exec(modelName ?? "");
-	if (Number(proVersionMatch?.[1]) >= 3) return "low";
-	const versionMatch = /^gemini-(\d+)\.(\d+)-flash(?:$|-(?!lite(?:-|$)))/.exec(modelName ?? "");
-	if (versionMatch == null) return "minimal";
-	const majorVersion = Number(versionMatch[1]);
-	const minorVersion = Number(versionMatch[2]);
-	return majorVersion > 3 || majorVersion === 3 && minorVersion >= 7 ? "low" : "minimal";
-}
 function resolveGemini25ThinkingConfig({ reasoning, modelId, warnings }) {
-	const minThinkingBudget = getMinThinkingTokensForGemini25Model(modelId);
+	const entry = getGoogleLanguageModelEntry(modelId);
+	const minThinkingBudget = entry.capabilities.language.reasoning.minBudget;
 	if (reasoning === "none" && minThinkingBudget === 0) return { thinkingBudget: 0 };
 	return { thinkingBudget: mapReasoningToProviderBudget({
 		reasoning,
-		maxOutputTokens: getMaxOutputTokensForGemini25Model(),
-		maxReasoningBudget: getMaxThinkingTokensForGemini25Model(modelId),
+		maxOutputTokens: entry.requestConfig.language.reasoningMaxOutputTokens,
+		maxReasoningBudget: entry.capabilities.language.reasoning.maxBudget,
 		minReasoningBudget: minThinkingBudget,
 		warnings
 	}) };
@@ -2887,12 +3001,11 @@ var GoogleBatch = class {
 				warning
 			});
 		}
-		const headers = await this.getHeaders(options.headers);
 		const createUrl = `${this.batchConfig.baseURL}/${getModelPath(modelId)}:batchGenerateContent`;
 		if (fileParts == null) {
 			const { value: operation } = await postJsonToApi({
 				url: createUrl,
-				headers,
+				headers: await this.getHeaders(options.headers),
 				body: inlineBatchBody,
 				failedResponseHandler: googleFailedResponseHandler,
 				successfulResponseHandler: createJsonResponseHandler(googleBatchOperationSchema),
@@ -2913,7 +3026,7 @@ var GoogleBatch = class {
 		});
 		const { value: uploadUrl } = await postJsonToApi({
 			url: `${this.getBaseOrigin()}/upload/v1beta/files`,
-			headers: combineHeaders(headers, {
+			headers: combineHeaders(await this.getHeaders(options.headers), {
 				"X-Goog-Upload-Protocol": "resumable",
 				"X-Goog-Upload-Command": "start",
 				"X-Goog-Upload-Header-Content-Length": String(inputFile.size),
@@ -2946,7 +3059,7 @@ var GoogleBatch = class {
 		});
 		const { value: operation } = await postJsonToApi({
 			url: createUrl,
-			headers,
+			headers: await this.getHeaders(options.headers),
 			body: { batch: {
 				displayName,
 				...options.webhookUrl != null && { webhookConfig: { uris: [options.webhookUrl] } },
@@ -3568,7 +3681,7 @@ var GoogleFiles = class {
 			providerOptions: options.providerOptions,
 			schema: googleFilesUploadOptionsSchema
 		});
-		const resolvedHeaders = combineHeaders(this.config.headers(), options.headers);
+		const getHeaders = async () => combineHeaders(await resolve(this.config.headers), options.headers);
 		const fetchFn = this.config.fetch ?? globalThis.fetch;
 		const warnings = [];
 		if (options.filename != null) warnings.push({
@@ -3581,7 +3694,7 @@ var GoogleFiles = class {
 		const initResponse = await fetchFn(`${this.config.baseURL.replace(/\/v1beta$/, "")}/upload/v1beta/files`, {
 			method: "POST",
 			headers: {
-				...resolvedHeaders,
+				...await getHeaders(),
 				"X-Goog-Upload-Protocol": "resumable",
 				"X-Goog-Upload-Command": "start",
 				"X-Goog-Upload-Header-Content-Length": String(fileBytes.length),
@@ -3634,7 +3747,7 @@ var GoogleFiles = class {
 			const { value: fileStatus } = await getFromApi({
 				url: `${this.config.baseURL}/${filePath}`,
 				validateUrl: false,
-				headers: combineHeaders(resolvedHeaders),
+				headers: await getHeaders(),
 				successfulResponseHandler: createJsonResponseHandler(googleFileResponseSchema),
 				failedResponseHandler: googleFailedResponseHandler,
 				abortSignal: options.abortSignal,
@@ -6148,7 +6261,7 @@ async function cancelGoogleInteraction({ baseURL, interactionId, headers, fetch
 	try {
 		const response = await fetch(url, {
 			method: "POST",
-			headers: withUserAgentSuffix(combineHeaders({ "Content-Type": "application/json" }, headers), getRuntimeEnvironmentUserAgent()),
+			headers: withUserAgentSuffix(combineHeaders({ "Content-Type": "application/json" }, await resolve(headers)), getRuntimeEnvironmentUserAgent()),
 			body: "{}"
 		});
 		try {
@@ -6198,7 +6311,7 @@ async function pollGoogleInteractionUntilTerminal({ baseURL, interactionId, head
 			const { value: response, rawValue: rawResponse, responseHeaders } = await getFromApi({
 				url,
 				validateUrl: false,
-				headers,
+				headers: await resolve(headers),
 				failedResponseHandler: googleFailedResponseHandler,
 				successfulResponseHandler: createJsonResponseHandler(googleInteractionsResponseSchema),
 				abortSignal,
@@ -6393,10 +6506,6 @@ const DEFAULT_RETRY_DELAY_MS = 500;
 */
 function streamGoogleInteractionEvents({ baseURL, interactionId, headers, fetch, abortSignal, maxRetries = DEFAULT_MAX_RETRIES, retryDelayMs = DEFAULT_RETRY_DELAY_MS }) {
 	if (interactionId.length === 0) throw new Error("google.interactions: cannot stream a background interaction without an id.");
-	const eventSourceHeaders = {
-		...headers,
-		accept: "text/event-stream"
-	};
 	let lastEventId;
 	let complete = false;
 	let attempt = 0;
@@ -6419,7 +6528,10 @@ function streamGoogleInteractionEvents({ baseURL, interactionId, headers, fetch,
 		const { value: stream } = await getFromApi({
 			url: buildUrl(),
 			validateUrl: false,
-			headers: eventSourceHeaders,
+			headers: {
+				...await resolve(headers),
+				accept: "text/event-stream"
+			},
 			failedResponseHandler: googleFailedResponseHandler,
 			successfulResponseHandler: createEventSourceResponseHandler(googleInteractionsEventSchema),
 			abortSignal: effectiveSignal,
@@ -6890,10 +7002,10 @@ var GoogleInteractionsLanguageModel = class GoogleInteractionsLanguageModel {
 	async doGenerate(options) {
 		const { args, warnings, isAgent, isBackground, pollingTimeoutMs } = await this.getArgs(options);
 		const url = `${this.config.baseURL}/interactions`;
-		const mergedHeaders = combineHeaders(this.config.headers ? await resolve(this.config.headers) : void 0, options.headers);
+		const mergedHeaders = async () => combineHeaders(await resolve(this.config.headers), options.headers);
 		let { responseHeaders, value: response, rawValue: rawResponse } = await postJsonToApi({
 			url,
-			headers: mergedHeaders,
+			headers: await resolve(mergedHeaders),
 			body: args,
 			failedResponseHandler: googleFailedResponseHandler,
 			successfulResponseHandler: createJsonResponseHandler(googleInteractionsResponseSchema),
@@ -6957,7 +7069,7 @@ var GoogleInteractionsLanguageModel = class GoogleInteractionsLanguageModel {
 	async doStream(options) {
 		const { args, warnings, isBackground, pollingTimeoutMs } = await this.getArgs(options);
 		const url = `${this.config.baseURL}/interactions`;
-		const mergedHeaders = combineHeaders(this.config.headers ? await resolve(this.config.headers) : void 0, options.headers);
+		const mergedHeaders = async () => combineHeaders(await resolve(this.config.headers), options.headers);
 		if (isBackground) return this.doStreamBackground({
 			args,
 			warnings,
@@ -6972,7 +7084,7 @@ var GoogleInteractionsLanguageModel = class GoogleInteractionsLanguageModel {
 		};
 		const { responseHeaders, value: response } = await postJsonToApi({
 			url,
-			headers: mergedHeaders,
+			headers: await resolve(mergedHeaders),
 			body,
 			failedResponseHandler: googleFailedResponseHandler,
 			successfulResponseHandler: createEventSourceResponseHandler(googleInteractionsEventSchema),
@@ -6995,7 +7107,7 @@ var GoogleInteractionsLanguageModel = class GoogleInteractionsLanguageModel {
 	async doStreamBackground({ args, warnings, url, mergedHeaders, options, pollingTimeoutMs }) {
 		const { responseHeaders: postHeaders, value: postResponse } = await postJsonToApi({
 			url,
-			headers: mergedHeaders,
+			headers: await resolve(mergedHeaders),
 			body: args,
 			failedResponseHandler: googleFailedResponseHandler,
 			successfulResponseHandler: createJsonResponseHandler(googleInteractionsResponseSchema),
@@ -7429,7 +7541,7 @@ var GoogleRealtimeModel = class {
 	}
 	async doCreateClientSecret(options) {
 		const fetchFn = this.config.fetch ?? fetch;
-		const apiKey = this.config.headers()["x-goog-api-key"];
+		const apiKey = (await resolve(this.config.headers))["x-goog-api-key"];
 		if (!apiKey) throw new Error("Google Generative AI API key is required for realtime token creation.");
 		const now = Date.now();
 		const openWindowMs = (options.expiresAfterSeconds ?? 60) * 1e3;
@@ -7954,7 +8066,7 @@ var GoogleSpeechTranslationModel = class GoogleSpeechTranslationModel {
 			feature: "outputAudioFormat",
 			details: "The Gemini Live API always outputs 24kHz 16-bit PCM audio and does not accept an output audio format."
 		});
-		const headers = combineHeaders(this.config.headers(), options.headers);
+		const headers = combineHeaders(await resolve(this.config.headers), options.headers);
 		let apiKey;
 		for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === "x-goog-api-key" && value != null) apiKey = value;
 		if (apiKey == null) throw new Error("Google Generative AI API key is required for streaming translation.");
@@ -8270,14 +8382,14 @@ function supportsExternalFileUrls(modelId) {
 function createGoogle(options = {}) {
 	const baseURL = withoutTrailingSlash(options.baseURL) ?? DEFAULT_BASE_URL;
 	const providerName = options.name ?? "google.generative-ai";
-	const getHeaders = () => withUserAgentSuffix({
+	const getHeaders = () => resolveWith(options.apiKey, (apiKey) => withUserAgentSuffix({
 		"x-goog-api-key": loadApiKey({
-			apiKey: options.apiKey,
+			apiKey,
 			environmentVariableName: "GOOGLE_GENERATIVE_AI_API_KEY",
 			description: "Google Generative AI"
 		}),
 		...options.headers
-	}, `ai-sdk-google/${VERSION}`);
+	}, `ai-sdk-google/${VERSION}`));
 	const getSupportedUrls = (modelId, includeExternalUrls = modelId == null || supportsExternalFileUrls(modelId)) => ({
 		"*": [
 			googleFilesUrlPattern,