promptfoo 0.125.0 → 0.125.1

package/dist/src/util-qzBqirBH.js

@@ -0,0 +1,2050 @@
+import { o as InvalidToolCallError } from "./shared-DS0YmCOx.js";
+import { F as getAjv, K as getEnvOverrides, Z as getProviderEnvString, it as getExplicitProviderEnv, o as logger, q as getEnvString } from "./logger-CNHLbG5Y.js";
+import { n as isDataUrl, r as parseDataUrl, t as extractBase64FromDataUrl } from "./dataUrl-DUSr-ZvI.js";
+import { i as isJavascriptFile } from "./fileExtensions-D1LbB4Aa.js";
+import { _ as transformToolChoice, f as parseChatPrompt, n as calculateCost, r as clampCachedTokens, v as transformTools } from "./shared-BnN4RWgk.js";
+import { _ as parseFileUrl, a as maybeLoadFromExternalFile, c as maybeLoadToolsFromExternalFile, t as getLoadedFileMimeType } from "./file-BPc_9IQ5.js";
+import { n as renderVarsInObject, o as getNunjucksEngine } from "./render-DrCSgzhR.js";
+import { t as resolveProviderEnv } from "./env-DG25rpzi.js";
+import { t as InvalidToolSchemaError } from "./toolSchemaError-CmpqIHQW.js";
+import { z as z$1 } from "zod";
+import path from "path";
+import crypto from "crypto";
+import Clone from "rfdc";
+//#region src/providers/google/auth.ts
+/**
+* Centralized authentication manager for Google AI providers.
+*
+* This module handles authentication for both Google AI Studio and Vertex AI,
+* with support for API keys, OAuth/ADC, and service account credentials.
+*
+* Environment variable priority is aligned with the Python SDK:
+* 1. config.apiKey (explicit)
+* 2. VERTEX_API_KEY (Vertex mode only)
+* 3. GOOGLE_API_KEY (primary - Python SDK alignment)
+* 4. GEMINI_API_KEY (secondary)
+*/
+const EXPECTED_GCP_METADATA_LOOKUP_WARNING_PREFIX = "received unexpected error = ";
+let activeGcpMetadataLookupWarningSuppressions = 0;
+let restoreEmitWarning;
+async function suppressExpectedGcpMetadataLookupWarning(action) {
+	if (activeGcpMetadataLookupWarningSuppressions === 0) {
+		const originalEmitWarning = process.emitWarning;
+		const wrappedEmitWarning = ((warning, ...args) => {
+			const message = warning instanceof Error ? warning.message : warning;
+			if ((warning instanceof Error ? warning.name : args[0]) === "MetadataLookupWarning" && typeof message === "string" && message.startsWith(EXPECTED_GCP_METADATA_LOOKUP_WARNING_PREFIX)) return;
+			Reflect.apply(originalEmitWarning, process, [warning, ...args]);
+		});
+		process.emitWarning = wrappedEmitWarning;
+		restoreEmitWarning = () => {
+			if (process.emitWarning === wrappedEmitWarning) process.emitWarning = originalEmitWarning;
+		};
+	}
+	activeGcpMetadataLookupWarningSuppressions += 1;
+	try {
+		return await action();
+	} finally {
+		activeGcpMetadataLookupWarningSuppressions -= 1;
+		if (activeGcpMetadataLookupWarningSuppressions === 0) {
+			restoreEmitWarning?.();
+			restoreEmitWarning = void 0;
+		}
+	}
+}
+/**
+* Centralized authentication manager for Google AI providers.
+*
+* Handles:
+* - API key resolution with proper priority
+* - OAuth client creation for Vertex AI
+* - Service account credential loading
+* - Conflict detection and warnings
+*/
+var GoogleAuthManager = class {
+	static cachedHasDefaultCredentials;
+	static pendingHasDefaultCredentials;
+	/**
+	* Get API key with proper priority order.
+	*
+	* Environment scope takes priority; aliases are checked in this order within each scope.
+	* Priority (aligned with Python SDK):
+	* 1. config.apiKey (explicit)
+	* 2. VERTEX_API_KEY (Vertex mode only)
+	* 3. GOOGLE_API_KEY (primary - Python SDK alignment)
+	* 4. GEMINI_API_KEY (secondary)
+	* 5. PALM_API_KEY (legacy)
+	*
+	* @param config - Provider configuration
+	* @param env - Environment overrides
+	* @param isVertexMode - Whether in Vertex AI mode
+	* @returns The resolved API key and its source
+	*/
+	static getApiKey(config, env, isVertexMode = false) {
+		if (config.apiKey) return {
+			apiKey: config.apiKey,
+			source: "config"
+		};
+		const keys = isVertexMode ? ["VERTEX_API_KEY", "GOOGLE_API_KEY"] : [
+			"GOOGLE_API_KEY",
+			"GEMINI_API_KEY",
+			"PALM_API_KEY"
+		];
+		const masked = /* @__PURE__ */ new Set();
+		for (const layer of [
+			getExplicitProviderEnv(env),
+			getEnvOverrides("provider"),
+			env,
+			getEnvOverrides(),
+			getEnvOverrides("file"),
+			Object.fromEntries(keys.map((key) => [key, getEnvString(key)]))
+		]) for (const source of keys) {
+			const apiKey = layer?.[source];
+			if (masked.has(source) || apiKey === void 0) continue;
+			masked.add(source);
+			if (!apiKey) continue;
+			if (source === "VERTEX_API_KEY") logger.warn("[Google] VERTEX_API_KEY is not a standard SDK env var. Use GOOGLE_API_KEY instead.");
+			else if (source === "PALM_API_KEY") logger.warn("[Google] PALM_API_KEY is deprecated. Use GOOGLE_API_KEY instead.");
+			else if (source === "GEMINI_API_KEY") logger.debug("[Google] GEMINI_API_KEY is not a standard SDK env var. Consider using GOOGLE_API_KEY.");
+			else if (!isVertexMode && layer?.GEMINI_API_KEY) logger.debug("[Google] Both GOOGLE_API_KEY and GEMINI_API_KEY are set. Using GOOGLE_API_KEY.");
+			return {
+				apiKey,
+				source
+			};
+		}
+		return {
+			apiKey: void 0,
+			source: "none"
+		};
+	}
+	/**
+	* Validate authentication configuration and emit warnings or throw errors for issues.
+	*
+	* @param config - Authentication configuration
+	* @param env - Environment overrides
+	* @throws Error if strictMutualExclusivity is true and mutual exclusivity violation detected
+	*/
+	static validateAndWarn(config, env) {
+		const { apiKey, credentials, projectId, region, vertexai, strictMutualExclusivity } = config;
+		const isStrict = strictMutualExclusivity === true;
+		const useVertexEnv = getProviderEnvString(env, "GOOGLE_GENAI_USE_VERTEXAI") ?? getEnvString("GOOGLE_GENAI_USE_VERTEXAI");
+		const cloudProject = env?.GOOGLE_CLOUD_PROJECT ?? getEnvString("GOOGLE_CLOUD_PROJECT");
+		const hasProjectEnvironment = Boolean(resolveProviderEnv(env, [
+			"VERTEX_PROJECT_ID",
+			"GOOGLE_PROJECT_ID",
+			"GOOGLE_CLOUD_PROJECT"
+		])?.value);
+		if ((projectId || region) && apiKey) {
+			const message = "[Google] Project/location and API key are mutually exclusive in the client initializer. Use either apiKey for express mode OR projectId/region for OAuth mode, not both.";
+			if (isStrict) throw new Error(message);
+			else logger.warn(message);
+		}
+		if (useVertexEnv && vertexai === false) logger.warn("[Google] GOOGLE_GENAI_USE_VERTEXAI is set but vertexai: false was specified in config. Config takes precedence.");
+		if (cloudProject && projectId && cloudProject !== projectId) logger.warn("[Google] Both GOOGLE_CLOUD_PROJECT and config.projectId are set with different values. Using config.projectId.");
+		if (apiKey && credentials) logger.debug("[Google] Both apiKey and credentials are set. Using API key (express mode). Set expressMode: false to use OAuth/ADC instead.");
+		if (vertexai && !apiKey && !projectId && !hasProjectEnvironment && !credentials) {
+			if (!Boolean(env?.GOOGLE_APPLICATION_CREDENTIALS ?? getEnvString("GOOGLE_APPLICATION_CREDENTIALS"))) logger.debug("[Google] Vertex AI mode enabled but no projectId, credentials, or ADC detected. Authentication may fail.");
+		}
+	}
+	/**
+	* Determine if Vertex AI mode should be used.
+	*
+	* Priority:
+	* 1. Explicit vertexai config flag
+	* 2. GOOGLE_GENAI_USE_VERTEXAI env var (Python SDK compatibility)
+	* 3. Auto-detect from projectId/credentials presence
+	* 4. Default: false (Google AI Studio)
+	*
+	* @param config - Provider configuration
+	* @param env - Environment overrides
+	* @returns Whether to use Vertex AI mode
+	*/
+	static determineVertexMode(config, env) {
+		if (config.vertexai !== void 0) return config.vertexai;
+		const useVertexEnv = getProviderEnvString(env, "GOOGLE_GENAI_USE_VERTEXAI") ?? getEnvString("GOOGLE_GENAI_USE_VERTEXAI");
+		if (useVertexEnv === "true" || useVertexEnv === "1") {
+			logger.debug("[Google] Vertex AI mode enabled via GOOGLE_GENAI_USE_VERTEXAI");
+			return true;
+		}
+		if (useVertexEnv === "false" || useVertexEnv === "0") return false;
+		const hasProjectId = Boolean(config.projectId || resolveProviderEnv(env, [
+			"VERTEX_PROJECT_ID",
+			"GOOGLE_PROJECT_ID",
+			"GOOGLE_CLOUD_PROJECT"
+		])?.value);
+		const hasCredentials = Boolean(config.credentials);
+		if (hasProjectId || hasCredentials) {
+			logger.debug("[Google] Auto-detected Vertex AI mode from projectId/credentials. Set vertexai: true/false explicitly to suppress this message.");
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Load credentials from file or return as-is.
+	*
+	* Supports:
+	* - file:// prefix to load from external file
+	* - Raw JSON string
+	* - Pre-parsed object (from config loading pipeline)
+	*
+	* @param credentials - Credentials string, file path, or pre-parsed object
+	* @returns Processed credentials JSON string
+	*/
+	static loadCredentials(credentials) {
+		if (!credentials) return;
+		if (typeof credentials === "object") return JSON.stringify(credentials);
+		if (credentials.startsWith("file://")) try {
+			const loaded = maybeLoadFromExternalFile(credentials);
+			if (typeof loaded === "object") return JSON.stringify(loaded);
+			return loaded;
+		} catch (error) {
+			throw new Error(`Failed to load credentials from file: ${error}`);
+		}
+		return credentials;
+	}
+	/**
+	* Get or create a Google OAuth client.
+	*
+	* Supports googleAuthOptions passthrough for advanced configuration
+	* like custom scopes, keyFilename, universeDomain, etc.
+	*
+	* @param options - OAuth client options (can also pass string for backward compatibility)
+	* @returns OAuth client and detected project ID
+	*/
+	static async getOAuthClient(options = {}) {
+		const { credentials, googleAuthOptions, scopes, keyFilename } = typeof options === "string" ? { credentials: options } : options;
+		const resolvedScopes = scopes ?? googleAuthOptions?.scopes ?? "https://www.googleapis.com/auth/cloud-platform";
+		const authOptions = {
+			...googleAuthOptions,
+			scopes: resolvedScopes
+		};
+		if (keyFilename && !authOptions.keyFilename) authOptions.keyFilename = keyFilename;
+		let GoogleAuthClass;
+		try {
+			GoogleAuthClass = (await import("google-auth-library")).GoogleAuth;
+		} catch {
+			throw new Error("The google-auth-library package is required for Vertex AI. Please install it: npm install google-auth-library");
+		}
+		const auth = new GoogleAuthClass(authOptions);
+		const processedCredentials = this.loadCredentials(credentials);
+		let client;
+		if (processedCredentials) {
+			let parsedCredentials;
+			try {
+				parsedCredentials = JSON.parse(processedCredentials);
+			} catch (parseError) {
+				const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+				throw new Error(`[Google] Invalid credentials JSON format: ${errorMsg}`);
+			}
+			try {
+				client = await auth.fromJSON(parsedCredentials);
+			} catch (error) {
+				const errorMsg = error instanceof Error ? error.message : String(error);
+				logger.error(`[Google] Could not load credentials: ${errorMsg}`);
+				throw new Error(`[Google] Could not load credentials: ${errorMsg}`);
+			}
+		} else client = await auth.getClient();
+		let projectId;
+		try {
+			projectId = await auth.getProjectId();
+		} catch {
+			projectId = void 0;
+		}
+		return {
+			client,
+			projectId
+		};
+	}
+	/**
+	* Resolve project ID from multiple sources.
+	*
+	* Priority:
+	* 1. config.projectId
+	* 2. Provider-scoped VERTEX_PROJECT_ID / GOOGLE_PROJECT_ID / GOOGLE_CLOUD_PROJECT
+	* 3. Process-wide VERTEX_PROJECT_ID / GOOGLE_PROJECT_ID / GOOGLE_CLOUD_PROJECT
+	* 4. Auto-detected from OAuth credentials
+	*
+	* @param config - Provider configuration
+	* @param env - Environment overrides
+	* @returns Resolved project ID
+	*/
+	static async resolveProjectId(config, env) {
+		const project = resolveProviderEnv(env, [
+			"VERTEX_PROJECT_ID",
+			"GOOGLE_PROJECT_ID",
+			"GOOGLE_CLOUD_PROJECT"
+		]);
+		if (project && project.name !== "GOOGLE_CLOUD_PROJECT" && !config.projectId) logger.debug(`[Google] ${project.name} is not a standard SDK env var. Consider using GOOGLE_CLOUD_PROJECT.`);
+		const configuredProjectId = config.projectId || project?.value;
+		if (configuredProjectId) return configuredProjectId;
+		const { projectId: authProjectId } = await this.getOAuthClient({
+			credentials: config.credentials,
+			googleAuthOptions: config.googleAuthOptions,
+			keyFilename: config.keyFilename,
+			scopes: config.scopes
+		});
+		return authProjectId || "";
+	}
+	/**
+	* Resolve region from multiple sources.
+	*
+	* Priority:
+	* 1. config.region
+	* 2. Provider-scoped VERTEX_REGION / GOOGLE_CLOUD_LOCATION overrides
+	* 3. Process-wide VERTEX_REGION / GOOGLE_CLOUD_LOCATION env vars
+	* 4. Model-specific fallback region
+	* 5. Default: 'global' for Vertex AI without API key (SDK aligned), 'us-central1' otherwise
+	*
+	* @param config - Provider configuration
+	* @param env - Environment overrides
+	* @param hasApiKey - Whether an API key is configured (affects default region)
+	* @param modelDefaultRegion - Model-specific fallback region
+	* @returns Resolved region
+	*/
+	static resolveRegion(config, env, hasApiKey, modelDefaultRegion) {
+		const region = resolveProviderEnv(env, ["VERTEX_REGION", "GOOGLE_CLOUD_LOCATION"]);
+		if (region?.name === "VERTEX_REGION" && !config.region) logger.debug("[Google] VERTEX_REGION is not a standard SDK env var. Consider using GOOGLE_CLOUD_LOCATION.");
+		const configuredRegion = config.region || region?.value;
+		if (configuredRegion) return configuredRegion;
+		if (modelDefaultRegion) return modelDefaultRegion;
+		if (hasApiKey === false) return "global";
+		return "us-central1";
+	}
+	/**
+	* Check if Application Default Credentials are available.
+	*
+	* @returns True if ADC is available
+	*/
+	static async hasDefaultCredentials() {
+		if (this.cachedHasDefaultCredentials !== void 0) return this.cachedHasDefaultCredentials;
+		if (!this.pendingHasDefaultCredentials) {
+			const probe = (async () => {
+				try {
+					await suppressExpectedGcpMetadataLookupWarning(() => this.getOAuthClient());
+					return true;
+				} catch {
+					return false;
+				}
+			})();
+			this.pendingHasDefaultCredentials = probe;
+			probe.then((result) => {
+				if (this.pendingHasDefaultCredentials === probe) this.cachedHasDefaultCredentials = result;
+				return result;
+			}).finally(() => {
+				if (this.pendingHasDefaultCredentials === probe) this.pendingHasDefaultCredentials = void 0;
+			});
+		}
+		return this.pendingHasDefaultCredentials;
+	}
+	/**
+	* Clear internal auth detection caches (useful for testing).
+	*/
+	static clearCache() {
+		this.cachedHasDefaultCredentials = void 0;
+		this.pendingHasDefaultCredentials = void 0;
+	}
+};
+const loadCredentials = GoogleAuthManager.loadCredentials.bind(GoogleAuthManager);
+const getGoogleClient = GoogleAuthManager.getOAuthClient.bind(GoogleAuthManager);
+const resolveProjectId = GoogleAuthManager.resolveProjectId.bind(GoogleAuthManager);
+const getGoogleApiKey = GoogleAuthManager.getApiKey.bind(GoogleAuthManager);
+const determineGoogleVertexMode = GoogleAuthManager.determineVertexMode.bind(GoogleAuthManager);
+const hasGoogleDefaultCredentials = GoogleAuthManager.hasDefaultCredentials.bind(GoogleAuthManager);
+GoogleAuthManager.clearCache.bind(GoogleAuthManager);
+//#endregion
+//#region src/providers/google/shared.ts
+const VERTEX_GLOBAL_DEFAULT_MODELS = /* @__PURE__ */ new Set([
+	"gemini-3.8-flash-tts",
+	"gemini-3.8-flash-lite-tts",
+	"gemini-3.8-flash",
+	"gemini-3.8-flash-cyber",
+	"gemini-3.7-flash",
+	"gemini-3.6-flash",
+	"gemini-3.5-flash",
+	"gemini-flash-latest",
+	"gemini-3.5-flash-lite",
+	"gemini-3.1-pro-preview",
+	"gemini-3.1-pro-preview-customtools",
+	"gemini-3.1-flash-lite",
+	"gemini-flash-lite-latest",
+	"gemini-3-flash-preview"
+]);
+const VERTEX_US_EAST5_DEFAULT_MODELS = /* @__PURE__ */ new Set(["llama-4-maverick-17b-128e-instruct-maas", "llama-4-scout-17b-16e-instruct-maas"]);
+function getVertexModelDefaultRegion(modelName) {
+	if (VERTEX_GLOBAL_DEFAULT_MODELS.has(modelName)) return "global";
+	if (VERTEX_US_EAST5_DEFAULT_MODELS.has(modelName)) return "us-east5";
+}
+const GEMINI_FLASH_MODELS = [
+	{
+		id: "gemini-3.8-flash",
+		name: "Gemini 3.8 Flash"
+	},
+	{
+		id: "gemini-3.7-flash",
+		name: "Gemini 3.7 Flash"
+	},
+	{
+		id: "gemini-3.6-flash",
+		name: "Gemini 3.6 Flash"
+	},
+	{
+		id: "gemini-3.5-flash-lite",
+		name: "Gemini 3.5 Flash-Lite"
+	}
+];
+function getVertexApiHostForRegion(region) {
+	if (region === "global") return "aiplatform.googleapis.com";
+	if (region === "us" || region === "eu") return `aiplatform.${region}.rep.googleapis.com`;
+	return `${region}-aiplatform.googleapis.com`;
+}
+const GEMINI_3_PRO_COST = {
+	input: 2 / 1e6,
+	output: 12 / 1e6,
+	cacheRead: .2 / 1e6
+};
+const GEMINI_3_PRO_TIERED_COST = {
+	threshold: 2e5,
+	above: {
+		input: 4 / 1e6,
+		output: 18 / 1e6,
+		cacheRead: .4 / 1e6
+	}
+};
+const GEMINI_2_5_PRO_COST = {
+	input: 1.25 / 1e6,
+	output: 10 / 1e6,
+	cacheRead: .125 / 1e6
+};
+const GEMINI_2_5_PRO_TIERED_COST = {
+	threshold: 2e5,
+	above: {
+		input: 2.5 / 1e6,
+		output: 15 / 1e6,
+		cacheRead: .25 / 1e6
+	}
+};
+const GEMINI_FLASH_INTRODUCTORY_PRICING = {
+	expiresAt: Date.UTC(2027, 0, 1),
+	multiplier: .5
+};
+const GEMINI_3_5_FLASH_LITE_COST = {
+	input: .3 / 1e6,
+	output: 2.5 / 1e6,
+	cacheRead: .03 / 1e6,
+	priorityMultiplier: 1.8,
+	flexMultiplier: .5
+};
+/**
+* Google AI Studio model pricing used for current requests and saved-evaluation cost scoring.
+* Prices are per token (from Google AI pricing page, converted from per-million).
+*
+* Selected retired IDs remain here so historical results can still be scored. Membership in this
+* table does not imply that Google still serves the endpoint.
+*
+* Note: Vertex AI may have different pricing for some models.
+* @see https://ai.google.dev/gemini-api/docs/pricing
+* @see https://cloud.google.com/vertex-ai/generative-ai/pricing
+*/
+const GOOGLE_MODELS = [
+	{
+		id: "gemini-3.8-flash-cyber",
+		vertexCost: {
+			input: 1.5 / 1e6,
+			output: 7.5 / 1e6,
+			cacheRead: .15 / 1e6,
+			priorityMultiplier: 1.8,
+			flexMultiplier: .5
+		},
+		vertexRegionalPremium: 1.1
+	},
+	...[
+		"gemini-3.8-flash",
+		"gemini-3.7-flash",
+		"gemini-3.6-flash",
+		"gemini-flash-latest"
+	].map((id) => ({
+		id,
+		cost: {
+			input: 1.5 / 1e6,
+			output: 7.5 / 1e6,
+			cacheRead: .15 / 1e6,
+			priorityMultiplier: 1.8,
+			flexMultiplier: .5
+		},
+		introductoryPricing: GEMINI_FLASH_INTRODUCTORY_PRICING,
+		vertexRegionalPremium: 1.1
+	})),
+	...[{
+		id: "gemini-3.8-flash-tts",
+		audioOutput: 18 / 1e6
+	}, {
+		id: "gemini-3.8-flash-lite-tts",
+		audioOutput: 12 / 1e6
+	}].map(({ id, audioOutput }) => ({
+		id,
+		cost: {
+			input: 1 / 1e6,
+			output: audioOutput,
+			audioOutput,
+			priorityMultiplier: 1.8,
+			flexMultiplier: .5
+		},
+		vertexCost: {
+			input: 1 / 1e6,
+			output: audioOutput,
+			audioOutput
+		},
+		introductoryPricing: GEMINI_FLASH_INTRODUCTORY_PRICING
+	})),
+	{
+		id: "gemini-3.5-flash",
+		cost: {
+			input: 1.5 / 1e6,
+			output: 9 / 1e6,
+			cacheRead: .15 / 1e6,
+			audioInput: 1.5 / 1e6,
+			priorityMultiplier: 1.8,
+			flexMultiplier: .5,
+			flexCacheRead: .08 / 1e6
+		},
+		vertexCost: {
+			input: 1.5 / 1e6,
+			output: 9 / 1e6,
+			cacheRead: .15 / 1e6,
+			audioInput: 1.5 / 1e6,
+			priorityMultiplier: 1.8,
+			flexMultiplier: .5,
+			flexCacheRead: .075 / 1e6
+		},
+		vertexRegionalCost: {
+			input: 1.65 / 1e6,
+			output: 9.9 / 1e6,
+			cacheRead: .165 / 1e6,
+			audioInput: 1.65 / 1e6,
+			priorityMultiplier: 1.8,
+			flexMultiplier: .5,
+			flexCacheRead: .0825 / 1e6
+		},
+		vertexRegionalPremium: 1.1
+	},
+	...["gemini-3.5-flash-lite", "gemini-flash-lite-latest"].map((id) => ({
+		id,
+		cost: {
+			...GEMINI_3_5_FLASH_LITE_COST,
+			priorityCacheRead: .05 / 1e6,
+			flexCacheRead: .02 / 1e6
+		},
+		vertexCost: GEMINI_3_5_FLASH_LITE_COST,
+		vertexRegionalPremium: 1.1
+	})),
+	...modelsWithCost([
+		"gemini-omni-flash-preview",
+		"gemini-omni-1.1-flash",
+		"gemini-omni-1.1-flash-preview"
+	], {
+		input: 1.5 / 1e6,
+		output: 9 / 1e6,
+		audioInput: 1.5 / 1e6,
+		videoOutput: 17.5 / 1e6
+	}),
+	...modelsWithCost(["gemini-3.5-live-translate-preview"], {
+		input: 3.5 / 1e6,
+		output: 21 / 1e6,
+		audioInput: 3.5 / 1e6,
+		audioOutput: 21 / 1e6
+	}),
+	...[
+		"gemini-3.1-pro-preview",
+		"gemini-3.1-pro-preview-customtools",
+		"gemini-pro-latest"
+	].map((id) => ({
+		id,
+		cost: {
+			...GEMINI_3_PRO_COST,
+			priorityMultiplier: 1.8,
+			flexMultiplier: .5,
+			flexCacheRead: GEMINI_3_PRO_COST.cacheRead
+		},
+		tieredCost: {
+			...GEMINI_3_PRO_TIERED_COST,
+			above: {
+				...GEMINI_3_PRO_TIERED_COST.above,
+				priorityMultiplier: 1.8,
+				flexMultiplier: .5,
+				flexCacheRead: GEMINI_3_PRO_TIERED_COST.above.cacheRead
+			}
+		}
+	})),
+	...["gemini-3.1-flash-lite", "gemini-3.1-flash-lite-preview"].map((id) => ({
+		id,
+		cost: {
+			input: .25 / 1e6,
+			output: 1.5 / 1e6,
+			cacheRead: .025 / 1e6,
+			cacheReadAudio: .05 / 1e6,
+			audioInput: .5 / 1e6,
+			...id === "gemini-3.1-flash-lite-preview" ? {} : {
+				priorityMultiplier: 1.8,
+				priorityAudioInput: .9 / 1e6,
+				flexMultiplier: .5,
+				flexAudioInput: .25 / 1e6
+			}
+		},
+		...id === "gemini-3.1-flash-lite-preview" ? {} : { vertexRegionalPremium: 1.1 }
+	})),
+	...modelsWithCost([
+		"gemini-3.8-live",
+		"gemini-3.8-live-extended-thinking",
+		"gemini-3.1-flash-live-preview"
+	], {
+		input: .75 / 1e6,
+		output: 4.5 / 1e6,
+		audioInput: 3 / 1e6,
+		audioOutput: 12 / 1e6,
+		imageInput: 1 / 1e6,
+		videoInputPerSecond: 33333333333333335e-21
+	}),
+	...modelsWithCost(["gemini-live-2.5-flash-native-audio"], {
+		input: .5 / 1e6,
+		output: 2 / 1e6,
+		audioInput: 3 / 1e6,
+		audioOutput: 12 / 1e6,
+		imageInput: 3 / 1e6
+	}),
+	...modelsWithCost(["gemini-3.1-flash-tts-preview"], {
+		input: 1 / 1e6,
+		output: 20 / 1e6,
+		audioOutput: 20 / 1e6
+	}),
+	...modelsWithCost(["gemini-live-2.5-flash-preview-native-audio-09-2025"], {
+		input: .3 / 1e6,
+		output: 2 / 1e6,
+		cacheRead: .075 / 1e6,
+		audioInput: 3 / 1e6,
+		audioOutput: 12 / 1e6
+	}),
+	...modelsWithCost(["gemini-2.5-flash-native-audio-latest", "gemini-2.5-flash-native-audio-preview-12-2025"], {
+		input: .5 / 1e6,
+		output: 2 / 1e6,
+		audioInput: 3 / 1e6,
+		audioOutput: 12 / 1e6
+	}),
+	...modelsWithCost(["gemini-2.5-flash-native-audio-preview-09-2025"], {
+		input: .3 / 1e6,
+		output: 2.5 / 1e6,
+		audioInput: 1 / 1e6
+	}),
+	...modelsWithCost(["gemini-3-flash-preview"], {
+		input: .5 / 1e6,
+		output: 3 / 1e6,
+		cacheRead: .05 / 1e6,
+		cacheReadAudio: .1 / 1e6,
+		audioInput: 1 / 1e6,
+		priorityMultiplier: 1.8,
+		flexMultiplier: .5,
+		flexCacheRead: .05 / 1e6,
+		flexCacheReadAudio: .1 / 1e6
+	}),
+	{
+		id: "gemini-3-pro-preview",
+		cost: {
+			...GEMINI_3_PRO_COST,
+			priorityMultiplier: 1.8
+		},
+		tieredCost: {
+			...GEMINI_3_PRO_TIERED_COST,
+			above: {
+				...GEMINI_3_PRO_TIERED_COST.above,
+				priorityMultiplier: 1.8
+			}
+		}
+	},
+	...["gemini-2.5-pro", "gemini-2.5-computer-use-preview-10-2025"].map((id) => ({
+		id,
+		cost: id === "gemini-2.5-computer-use-preview-10-2025" ? {
+			input: 1.25 / 1e6,
+			output: 10 / 1e6
+		} : GEMINI_2_5_PRO_COST,
+		tieredCost: id === "gemini-2.5-computer-use-preview-10-2025" ? {
+			threshold: 2e5,
+			above: {
+				input: 2.5 / 1e6,
+				output: 15 / 1e6
+			}
+		} : GEMINI_2_5_PRO_TIERED_COST
+	})),
+	...modelsWithCost(["gemini-2.5-pro-preview-tts"], {
+		input: 1 / 1e6,
+		output: 20 / 1e6,
+		audioOutput: 20 / 1e6
+	}),
+	...modelsWithCost(["gemini-2.5-flash-preview-tts"], {
+		input: .5 / 1e6,
+		output: 10 / 1e6,
+		audioOutput: 10 / 1e6
+	}),
+	...modelsWithCost(["gemini-2.5-flash", "gemini-2.5-flash-preview-04-17"], {
+		input: .3 / 1e6,
+		output: 2.5 / 1e6,
+		cacheRead: .03 / 1e6,
+		cacheReadAudio: .1 / 1e6,
+		audioInput: 1 / 1e6
+	}),
+	...modelsWithCost(["gemini-2.5-flash-lite"], {
+		input: .1 / 1e6,
+		output: .4 / 1e6,
+		cacheRead: .01 / 1e6,
+		cacheReadAudio: .03 / 1e6,
+		audioInput: .3 / 1e6
+	}),
+	...["gemini-2.0-flash", "gemini-2.0-flash-001"].map((id) => ({
+		id,
+		cost: {
+			input: .1 / 1e6,
+			output: .4 / 1e6,
+			cacheRead: .025 / 1e6,
+			cacheReadAudio: .175 / 1e6,
+			audioInput: .7 / 1e6
+		},
+		vertexCost: {
+			input: .15 / 1e6,
+			output: .6 / 1e6,
+			cacheRead: .0375 / 1e6,
+			audioInput: 1 / 1e6
+		}
+	})),
+	...modelsWithCost(["gemini-2.0-flash-lite", "gemini-2.0-flash-lite-001"], {
+		input: .075 / 1e6,
+		output: .3 / 1e6,
+		cacheRead: .01875 / 1e6,
+		audioInput: .075 / 1e6
+	}),
+	{
+		id: "gemini-1.5-pro",
+		cost: {
+			input: 1.25 / 1e6,
+			output: 5 / 1e6
+		},
+		tieredCost: {
+			threshold: 128e3,
+			above: {
+				input: 2.5 / 1e6,
+				output: 10 / 1e6
+			}
+		}
+	},
+	...[
+		"gemini-1.5-pro-001",
+		"gemini-1.5-pro-002",
+		"gemini-1.5-pro-latest"
+	].map((id) => ({
+		id,
+		cost: {
+			input: 1.25 / 1e6,
+			output: 5 / 1e6
+		},
+		tieredCost: {
+			threshold: 128e3,
+			above: {
+				input: 2.5 / 1e6,
+				output: 10 / 1e6
+			}
+		}
+	})),
+	...["gemini-1.5-pro-preview-0409", "gemini-1.5-pro-preview-0514"].map((id) => ({
+		id,
+		cost: {
+			input: 1.25 / 1e6,
+			output: 5 / 1e6
+		},
+		tieredCost: {
+			threshold: 128e3,
+			above: {
+				input: 2.5 / 1e6,
+				output: 10 / 1e6
+			}
+		}
+	})),
+	...[
+		"gemini-1.5-flash",
+		"gemini-1.5-flash-001",
+		"gemini-1.5-flash-002",
+		"gemini-1.5-flash-latest",
+		"gemini-1.5-flash-preview-0514"
+	].map((id) => ({
+		id,
+		cost: {
+			input: .075 / 1e6,
+			output: .3 / 1e6
+		},
+		tieredCost: {
+			threshold: 128e3,
+			above: {
+				input: .15 / 1e6,
+				output: .6 / 1e6
+			}
+		}
+	})),
+	...[
+		"gemini-1.5-flash-8b",
+		"gemini-1.5-flash-8b-001",
+		"gemini-1.5-flash-8b-latest"
+	].map((id) => ({
+		id,
+		cost: {
+			input: .0375 / 1e6,
+			output: .15 / 1e6
+		},
+		tieredCost: {
+			threshold: 128e3,
+			above: {
+				input: .075 / 1e6,
+				output: .3 / 1e6
+			}
+		}
+	})),
+	...modelsWithCost([
+		"gemini-1.0-pro",
+		"gemini-1.0-pro-001",
+		"gemini-1.0-pro-002",
+		"gemini-1.0-pro-vision",
+		"gemini-1.0-pro-vision-001"
+	], {
+		input: .5 / 1e6,
+		output: 1.5 / 1e6
+	}),
+	...modelsWithCost(["gemini-pro"], {
+		input: .5 / 1e6,
+		output: 1.5 / 1e6
+	}),
+	...modelsWithCost(["gemini-pro-vision"], {
+		input: .5 / 1e6,
+		output: 1.5 / 1e6
+	}),
+	...modelsWithCost(["gemini-robotics-er-1.6-preview"], {
+		input: 1 / 1e6,
+		output: 5 / 1e6,
+		audioInput: 2 / 1e6
+	}),
+	...modelsWithCost(["gemini-robotics-er-2-preview"], {
+		input: 2 / 1e6,
+		output: 10 / 1e6,
+		cacheRead: .2 / 1e6
+	}),
+	...modelsWithCost(["gemini-robotics-er-2-streaming-preview"], {
+		input: 2 / 1e6,
+		output: 10 / 1e6
+	}),
+	...modelsWithCost([
+		"gemini-embedding-2",
+		"embedding-2-preview",
+		"gemini-embedding-2-preview"
+	], {
+		input: .2 / 1e6,
+		output: 0
+	}),
+	...modelsWithCost(["gemini-embedding-001"], {
+		input: .15 / 1e6,
+		output: 0
+	}),
+	{ id: "aqa" },
+	{ id: "chat-bison" },
+	{ id: "chat-bison-32k" },
+	{ id: "chat-bison-32k@001" },
+	{ id: "chat-bison-32k@002" },
+	{ id: "chat-bison@001" },
+	{ id: "chat-bison@002" },
+	{ id: "codechat-bison" },
+	{ id: "codechat-bison-32k" },
+	{ id: "codechat-bison-32k@001" },
+	{ id: "codechat-bison-32k@002" },
+	{ id: "codechat-bison@001" },
+	{ id: "codechat-bison@002" },
+	{ id: "gemini-ultra" },
+	{ id: "gemma" },
+	{ id: "gemma-4-31b-it" },
+	{ id: "gemma-4-26b-a4b-it" },
+	{ id: "codegemma" },
+	{ id: "paligemma" },
+	{ id: "medlm-medium" },
+	{ id: "medlm-large" }
+];
+/**
+* List of chat model IDs for backwards compatibility.
+* Used for model validation in ai.studio.ts.
+*/
+const CHAT_MODELS = GOOGLE_MODELS.map((m) => m.id);
+function modelsWithCost(ids, cost) {
+	return ids.map((id) => ({
+		id,
+		cost: { ...cost }
+	}));
+}
+//#endregion
+//#region src/providers/google/types.ts
+const VALID_SCHEMA_TYPES = [
+	"TYPE_UNSPECIFIED",
+	"STRING",
+	"NUMBER",
+	"INTEGER",
+	"BOOLEAN",
+	"ARRAY",
+	"OBJECT"
+];
+//#endregion
+//#region src/providers/google/util.ts
+/**
+* Normalizes safety settings to use the correct Google API field name `threshold`.
+* Accepts the legacy `probability` field for backwards compatibility and maps it to `threshold`.
+*/
+function normalizeSafetySettings(safetySettings) {
+	if (!safetySettings) return;
+	return safetySettings.map(({ category, threshold, probability }) => ({
+		category,
+		threshold: threshold || probability || ""
+	}));
+}
+/** Normalize supported tier names, including legacy prefixed configuration values. */
+function normalizeGoogleServiceTier(serviceTier) {
+	if (typeof serviceTier !== "string") return;
+	const normalized = serviceTier.toLowerCase().replace(/^service_tier_/, "");
+	if (normalized !== "standard" && normalized !== "priority" && normalized !== "flex") return serviceTier;
+	return normalized;
+}
+/** Add the documented Vertex PayGo tier without overriding an explicit custom header. */
+function getVertexServiceTierHeaders(serviceTier, headers = {}) {
+	const headerName = "X-Vertex-AI-LLM-Shared-Request-Type";
+	if (Object.keys(headers).some((name) => name.toLowerCase() === headerName.toLowerCase())) return headers;
+	const normalized = normalizeGoogleServiceTier(serviceTier);
+	return normalized === "priority" || normalized === "flex" ? {
+		[headerName]: normalized,
+		...headers
+	} : headers;
+}
+/** Read the actual processing tier before estimating costs for a downgraded request. */
+function getGoogleResponseServiceTier(headers, usageMetadata, vertexai = false) {
+	let headerValue;
+	if (headers && typeof headers === "object") {
+		const headerCollection = headers;
+		headerValue = typeof headerCollection.get === "function" ? headerCollection.get("x-gemini-service-tier") : Object.entries(headerCollection).find(([name]) => name.toLowerCase() === "x-gemini-service-tier")?.[1];
+	}
+	const metadata = usageMetadata;
+	if (headerValue == null && vertexai && metadata?.trafficType !== void 0) switch (metadata.trafficType) {
+		case "ON_DEMAND": return "standard";
+		case "ON_DEMAND_PRIORITY": return "priority";
+		case "ON_DEMAND_FLEX": return "flex";
+		default: return;
+	}
+	const normalized = normalizeGoogleServiceTier(headerValue ?? metadata?.serviceTier ?? metadata?.service_tier);
+	return normalized === "standard" || normalized === "priority" || normalized === "flex" ? normalized : void 0;
+}
+function normalizeGoogleToolMode(mode) {
+	if (typeof mode !== "string") return;
+	switch (mode.toUpperCase()) {
+		case "MODE_UNSPECIFIED":
+		case "AUTO":
+		case "VALIDATED":
+		case "ANY":
+		case "NONE": return mode.toUpperCase();
+		default: return;
+	}
+}
+function normalizeCamelCaseGoogleToolConfig(config) {
+	const { functionCallingConfig: rawFunctionCallingConfig, ...restToolConfig } = config;
+	const normalizedToolConfig = { ...restToolConfig };
+	if (rawFunctionCallingConfig) {
+		const { mode: rawMode, allowedFunctionNames, ...restFunctionCallingConfig } = rawFunctionCallingConfig;
+		const mode = normalizeGoogleToolMode(rawMode);
+		const functionCallingConfig = {
+			...restFunctionCallingConfig,
+			...mode ? { mode } : {},
+			...allowedFunctionNames?.length ? { allowedFunctionNames } : {}
+		};
+		if (Object.keys(functionCallingConfig).length > 0) normalizedToolConfig.functionCallingConfig = functionCallingConfig;
+	}
+	return Object.keys(normalizedToolConfig).length > 0 ? normalizedToolConfig : void 0;
+}
+function normalizeSnakeCaseGoogleToolConfig(config) {
+	const { function_calling_config: rawFunctionCallingConfig, retrieval_config: retrievalConfig, include_server_side_tool_invocations: includeServerSideToolInvocations } = config;
+	const normalizedToolConfig = {
+		...retrievalConfig ? { retrievalConfig: {
+			...retrievalConfig.lat_lng ? { latLng: retrievalConfig.lat_lng } : {},
+			...retrievalConfig.language_code ? { languageCode: retrievalConfig.language_code } : {}
+		} } : {},
+		...includeServerSideToolInvocations === void 0 ? {} : { includeServerSideToolInvocations }
+	};
+	if (rawFunctionCallingConfig) {
+		const { mode: rawMode, allowed_function_names: allowedFunctionNames, stream_function_call_arguments: streamFunctionCallArguments } = rawFunctionCallingConfig;
+		const mode = normalizeGoogleToolMode(rawMode);
+		const functionCallingConfig = {
+			...mode ? { mode } : {},
+			...allowedFunctionNames?.length ? { allowedFunctionNames } : {},
+			...streamFunctionCallArguments === void 0 ? {} : { streamFunctionCallArguments }
+		};
+		if (Object.keys(functionCallingConfig).length > 0) normalizedToolConfig.functionCallingConfig = functionCallingConfig;
+	}
+	return Object.keys(normalizedToolConfig).length > 0 ? normalizedToolConfig : void 0;
+}
+function normalizeGoogleToolConfig(config) {
+	if (config.toolConfig) return normalizeCamelCaseGoogleToolConfig(config.toolConfig);
+	return config.tool_config ? normalizeSnakeCaseGoogleToolConfig(config.tool_config) : void 0;
+}
+function resolveGoogleToolConfig(config) {
+	const explicitConfig = normalizeGoogleToolConfig(config);
+	const passthrough = config.passthrough;
+	const passthroughConfig = passthrough ? normalizeGoogleToolConfig(passthrough) : void 0;
+	const transformedToolChoice = transformToolChoice(config.tool_choice, "google");
+	const toolChoiceConfig = transformedToolChoice && typeof transformedToolChoice === "object" ? transformedToolChoice : void 0;
+	const toolConfig = {
+		...toolChoiceConfig,
+		...explicitConfig,
+		...passthroughConfig
+	};
+	const functionCallingConfig = {
+		...toolChoiceConfig?.functionCallingConfig,
+		...explicitConfig?.functionCallingConfig,
+		...passthroughConfig?.functionCallingConfig
+	};
+	if (Object.keys(functionCallingConfig).length > 0) toolConfig.functionCallingConfig = functionCallingConfig;
+	return {
+		...Object.keys(toolConfig).length > 0 ? { toolConfig } : {},
+		toolsDisabled: functionCallingConfig.mode === "NONE"
+	};
+}
+/** Merge configured tools with single-object or array passthrough tools. */
+function mergeGoogleRequestTools(configuredTools, passthroughTools) {
+	if (passthroughTools === void 0) return configuredTools.length > 0 ? configuredTools : void 0;
+	return [...configuredTools, ...Array.isArray(passthroughTools) ? passthroughTools : [passthroughTools]];
+}
+/** Resolve native Gemini endpoints consistently across text and image adapters. */
+function getGoogleApiBaseUrl(config, env) {
+	if (config.apiHost) return `https://${getNunjucksEngine().renderString(config.apiHost, {})}`;
+	if (config.apiBaseUrl) return config.apiBaseUrl;
+	const endpoint = resolveProviderEnv(env, [
+		"GOOGLE_API_HOST",
+		"PALM_API_HOST",
+		"GOOGLE_API_BASE_URL"
+	]);
+	if (endpoint?.name === "GOOGLE_API_BASE_URL") return endpoint.value;
+	return `https://${getNunjucksEngine().renderString(endpoint?.value || "generativelanguage.googleapis.com", {})}`;
+}
+function mergeGoogleCompletionOptions(baseConfig, promptConfig) {
+	const mergedConfig = {
+		...baseConfig,
+		...promptConfig
+	};
+	const promptHasToolChoice = promptConfig?.tool_choice !== void 0;
+	const promptHasToolConfig = promptConfig?.toolConfig !== void 0;
+	const promptHasSnakeToolConfig = promptConfig?.tool_config !== void 0;
+	if (promptHasToolChoice || promptHasToolConfig || promptHasSnakeToolConfig) {
+		delete mergedConfig.tool_choice;
+		delete mergedConfig.toolConfig;
+		delete mergedConfig.tool_config;
+		if (promptHasToolChoice) mergedConfig.tool_choice = promptConfig.tool_choice;
+		if (promptHasToolConfig) mergedConfig.toolConfig = promptConfig.toolConfig;
+		if (promptHasSnakeToolConfig) mergedConfig.tool_config = promptConfig.tool_config;
+		if (promptHasToolChoice && !promptHasToolConfig && !promptHasSnakeToolConfig) {
+			const baseToolConfig = normalizeGoogleToolConfig(baseConfig);
+			if (baseToolConfig) {
+				const { functionCallingConfig: _functionCallingConfig, ...nonFunctionToolConfig } = baseToolConfig;
+				if (Object.keys(nonFunctionToolConfig).length > 0) mergedConfig.toolConfig = nonFunctionToolConfig;
+			}
+		}
+		if (promptConfig?.passthrough === void 0 && baseConfig.passthrough) {
+			const passthrough = { ...baseConfig.passthrough };
+			const inheritedToolConfig = normalizeGoogleToolConfig(passthrough);
+			delete passthrough.toolConfig;
+			delete passthrough.tool_config;
+			if (inheritedToolConfig) {
+				const { functionCallingConfig: _functionCallingConfig, ...nonFunctionToolConfig } = inheritedToolConfig;
+				if (Object.keys(nonFunctionToolConfig).length > 0) passthrough.toolConfig = nonFunctionToolConfig;
+			}
+			mergedConfig.passthrough = passthrough;
+		}
+	}
+	return mergedConfig;
+}
+function removeGoogleFunctionDeclarations(tools) {
+	return (Array.isArray(tools) ? tools : [tools]).flatMap((rawTool) => {
+		if (!rawTool || typeof rawTool !== "object" || Array.isArray(rawTool)) return [];
+		const { functionDeclarations, function_declarations, ...tool } = rawTool;
+		return (functionDeclarations || function_declarations) && Object.keys(tool).length === 0 ? [] : [tool];
+	});
+}
+/**
+* Current Gemini Flash models ignore sampling parameters and reject penalties
+* and candidate counts. Remove typed and passthrough spellings.
+*/
+function removeDeprecatedGeminiGenerationParams(modelName, generationConfig) {
+	if (!GEMINI_FLASH_MODELS.some(({ id }) => modelName.startsWith(id)) && modelName !== "gemini-flash-latest" && modelName !== "gemini-flash-lite-latest") return generationConfig;
+	if (!generationConfig || typeof generationConfig !== "object" || Array.isArray(generationConfig)) return generationConfig;
+	const sanitized = { ...generationConfig };
+	for (const field of [
+		"temperature",
+		"topP",
+		"top_p",
+		"topK",
+		"top_k",
+		"candidateCount",
+		"candidate_count",
+		"presencePenalty",
+		"presence_penalty",
+		"frequencyPenalty",
+		"frequency_penalty"
+	]) delete sanitized[field];
+	if (modelName.startsWith("gemini-3.8-flash") || modelName.startsWith("gemini-3.7-flash") || modelName === "gemini-flash-latest") for (const config of [sanitized.thinkingConfig, sanitized.thinking_config]) {
+		const thinkingConfig = config;
+		if (thinkingConfig?.thinkingBudget !== void 0 || thinkingConfig?.thinking_budget !== void 0) throw new Error(`${modelName} does not support thinkingBudget. Use thinkingLevel (LOW, MEDIUM, or HIGH).`);
+		const thinkingLevel = thinkingConfig?.thinkingLevel ?? thinkingConfig?.thinking_level;
+		if (typeof thinkingLevel === "string" && thinkingLevel.toUpperCase() === "MINIMAL") throw new Error(`${modelName} does not support MINIMAL thinking. Use LOW, MEDIUM, or HIGH.`);
+	}
+	return sanitized;
+}
+function stripExecutableToolFileReferencesFromValue(tools) {
+	if (typeof tools === "string" && tools.startsWith("file://")) {
+		const { filePath } = parseFileUrl(tools);
+		if (filePath.endsWith(".py") || isJavascriptFile(filePath)) return;
+	}
+	if (Array.isArray(tools)) return tools.flatMap((tool) => {
+		const strippedTool = stripExecutableToolFileReferencesFromValue(tool);
+		return strippedTool === void 0 ? [] : [strippedTool];
+	});
+	return tools;
+}
+function stripExecutableToolFileReferences(tools, vars) {
+	return stripExecutableToolFileReferencesFromValue(renderVarsInObject(tools, vars));
+}
+/** Load and normalize configured tools using the shared file and variable handling. */
+async function loadGoogleTools(tools, vars, options = {}) {
+	const requestTools = options.skipExecutableToolFiles ? stripExecutableToolFileReferences(tools, vars) : tools;
+	const loadedTools = requestTools ? await maybeLoadToolsFromExternalFile(requestTools, options.skipExecutableToolFiles ? void 0 : vars, options.abortSignal) : [];
+	return normalizeTools(Array.isArray(loadedTools) ? transformTools(loadedTools, "google") : loadedTools ? [loadedTools] : []);
+}
+function getServiceTierCacheRead(modelCost, serviceTier, modality = "default") {
+	if (serviceTier === "priority") return modality === "audio" ? modelCost.priorityCacheReadAudio ?? modelCost.priorityCacheRead : modelCost.priorityCacheRead;
+	if (serviceTier === "flex") return modality === "audio" ? modelCost.flexCacheReadAudio ?? modelCost.flexCacheRead : modelCost.flexCacheRead;
+}
+function resolveServiceTierCacheCost(defaultCost, exactTierCost, serviceTierMultiplier) {
+	return exactTierCost === void 0 ? defaultCost : exactTierCost / serviceTierMultiplier;
+}
+function resolveGoogleServiceTierCosts(modelCost, serviceTier, cachedInputCost, cachedAudioInputCost, cachedImageInputCost, audioInputCost) {
+	let serviceTierMultiplier = 1;
+	if (serviceTier === "priority") serviceTierMultiplier = modelCost.priorityMultiplier ?? 1;
+	else if (serviceTier === "flex") serviceTierMultiplier = modelCost.flexMultiplier ?? 1;
+	const tierCacheRead = getServiceTierCacheRead(modelCost, serviceTier);
+	const tierAudioCacheRead = getServiceTierCacheRead(modelCost, serviceTier, "audio");
+	const serviceTierCachedInputCost = resolveServiceTierCacheCost(cachedInputCost, tierCacheRead, serviceTierMultiplier);
+	const serviceTierCachedAudioInputCost = resolveServiceTierCacheCost(cachedAudioInputCost, tierAudioCacheRead, serviceTierMultiplier);
+	const serviceTierCachedImageInputCost = resolveServiceTierCacheCost(cachedImageInputCost, tierCacheRead, serviceTierMultiplier);
+	let serviceTierAudioInputCost = audioInputCost;
+	if (serviceTier === "priority" && modelCost.priorityAudioInput !== void 0) serviceTierAudioInputCost = modelCost.priorityAudioInput / serviceTierMultiplier;
+	else if (serviceTier === "flex" && modelCost.flexAudioInput !== void 0) serviceTierAudioInputCost = modelCost.flexAudioInput / serviceTierMultiplier;
+	return {
+		serviceTierMultiplier,
+		serviceTierCachedInputCost,
+		serviceTierCachedAudioInputCost,
+		serviceTierCachedImageInputCost,
+		serviceTierAudioInputCost
+	};
+}
+function applyGoogleRegionalPremium(modelCost, multiplier) {
+	const scale = (value) => value === void 0 ? void 0 : value * multiplier;
+	return {
+		...modelCost,
+		input: modelCost.input * multiplier,
+		output: modelCost.output * multiplier,
+		cacheRead: scale(modelCost.cacheRead),
+		cacheReadAudio: scale(modelCost.cacheReadAudio),
+		audioInput: scale(modelCost.audioInput),
+		audioOutput: scale(modelCost.audioOutput),
+		imageInput: scale(modelCost.imageInput),
+		videoInputPerSecond: scale(modelCost.videoInputPerSecond),
+		videoOutput: scale(modelCost.videoOutput),
+		priorityCacheRead: scale(modelCost.priorityCacheRead),
+		priorityCacheReadAudio: scale(modelCost.priorityCacheReadAudio),
+		priorityAudioInput: scale(modelCost.priorityAudioInput),
+		flexCacheRead: scale(modelCost.flexCacheRead),
+		flexCacheReadAudio: scale(modelCost.flexCacheReadAudio),
+		flexAudioInput: scale(modelCost.flexAudioInput)
+	};
+}
+function getGoogleCatalogCost(model, promptTokens, isVertexMode, usesNonGlobalVertexEndpoint) {
+	if (model?.tieredCost && promptTokens > model.tieredCost.threshold) return model.tieredCost.above;
+	if (usesNonGlobalVertexEndpoint && model?.vertexRegionalCost) return model.vertexRegionalCost;
+	if (isVertexMode && model?.vertexCost) return model.vertexCost;
+	return model?.cost;
+}
+/**
+* Calculates the cost for a Google API call.
+*
+* Handles tiered pricing for models where cost varies by prompt size.
+* For example, Gemini Pro models have higher rates for prompts >200k tokens.
+* Some models (e.g. Gemini 2.0 Flash) have different pricing on Vertex AI.
+*
+* @param modelName - The name of the model used
+* @param config - Provider configuration (may contain custom cost override)
+* @param promptTokens - Number of tokens in the prompt
+* @param completionTokens - Number of tokens in the completion
+* @param isVertexMode - Whether the call was made via Vertex AI (uses Vertex pricing when available)
+* @param audioPromptTokens - Number of audio tokens included in the prompt token count
+* @param audioCompletionTokens - Number of audio tokens included in the completion token count
+* @param videoCompletionTokens - Number of video tokens included in the completion token count
+* @param imagePromptTokens - Number of image tokens included in the prompt token count
+* @param cachedPromptTokens - Number of cached tokens included in the prompt token count
+* @param cachedAudioPromptTokens - Number of cached audio tokens included in the prompt token count
+* @param cachedImagePromptTokens - Number of cached image tokens included in the prompt token count
+* @returns The calculated cost in dollars, or undefined if it cannot be calculated
+*/
+function calculateGoogleCost(modelName, config, promptTokens, completionTokens, isVertexMode, audioPromptTokens, audioCompletionTokens, videoCompletionTokens, imagePromptTokens, cachedPromptTokens, cachedAudioPromptTokens, cachedImagePromptTokens, actualServiceTier, vertexRegion, requestedServiceTier, pricingTime = Date.now()) {
+	const timestamp = Number.isFinite(pricingTime) ? pricingTime : Date.now();
+	const pricingModelName = !isVertexMode && modelName === "gemini-3.5-flash" && timestamp >= Date.UTC(2026, 9, 8) ? "gemini-3.6-flash" : modelName;
+	const model = GOOGLE_MODELS.find((m) => m.id === pricingModelName);
+	if (typeof promptTokens !== "number" || typeof completionTokens !== "number" || !Number.isFinite(promptTokens) || !Number.isFinite(completionTokens)) return calculateCost(modelName, config, promptTokens, completionTokens, GOOGLE_MODELS);
+	const effectiveVertexRegion = vertexRegion ?? config.region;
+	const usesNonGlobalVertexEndpoint = isVertexMode && effectiveVertexRegion !== void 0 && effectiveVertexRegion !== "global";
+	const baseModelCost = getGoogleCatalogCost(model, promptTokens, isVertexMode, usesNonGlobalVertexEndpoint);
+	if (!baseModelCost) return;
+	const vertexRegionalMultiplier = usesNonGlobalVertexEndpoint && model?.vertexRegionalCost === void 0 && model?.vertexRegionalPremium !== void 0 ? model.vertexRegionalPremium : 1;
+	const catalogMultiplier = model?.introductoryPricing && timestamp < model.introductoryPricing.expiresAt ? model.introductoryPricing.multiplier : 1;
+	const applyCatalogMultiplier = (rate) => rate === void 0 ? void 0 : rate * catalogMultiplier;
+	const modelCost = vertexRegionalMultiplier === 1 ? baseModelCost : applyGoogleRegionalPremium(baseModelCost, vertexRegionalMultiplier);
+	const serviceTier = normalizeGoogleServiceTier(actualServiceTier ?? (isVertexMode ? requestedServiceTier : void 0) ?? config.passthrough?.service_tier ?? config.passthrough?.serviceTier ?? config.service_tier);
+	const catalogInputCost = modelCost.input * catalogMultiplier;
+	const catalogOutputCost = modelCost.output * catalogMultiplier;
+	const catalogAudioInputCost = applyCatalogMultiplier(modelCost.audioInput) ?? catalogInputCost;
+	const catalogImageInputCost = applyCatalogMultiplier(modelCost.imageInput) ?? catalogInputCost;
+	const catalogCacheRead = applyCatalogMultiplier(modelCost.cacheRead);
+	const tierCosts = resolveGoogleServiceTierCosts(applyGoogleRegionalPremium(modelCost, catalogMultiplier), serviceTier, catalogCacheRead ?? catalogInputCost, applyCatalogMultiplier(modelCost.cacheReadAudio) ?? catalogCacheRead ?? catalogAudioInputCost, catalogCacheRead ?? catalogImageInputCost, catalogAudioInputCost);
+	const multiplier = tierCosts.serviceTierMultiplier;
+	const inputCost = config.inputCost ?? config.cost ?? catalogInputCost * multiplier;
+	const outputCost = config.outputCost ?? config.cost ?? catalogOutputCost * multiplier;
+	const audioInputTokens = clampCachedTokens(audioPromptTokens, promptTokens);
+	const imageInputTokens = clampCachedTokens(imagePromptTokens, Math.max(promptTokens - audioInputTokens, 0));
+	const textInputTokens = Math.max(promptTokens - audioInputTokens - imageInputTokens, 0);
+	const cachedTokens = clampCachedTokens(cachedPromptTokens, promptTokens);
+	let cachedAudioTokens = clampCachedTokens(cachedAudioPromptTokens, Math.min(cachedTokens, audioInputTokens));
+	let cachedImageTokens = clampCachedTokens(cachedImagePromptTokens, Math.min(Math.max(cachedTokens - cachedAudioTokens, 0), imageInputTokens));
+	if (cachedAudioTokens === 0 && cachedImageTokens === 0) {
+		const cachedNonTextTokens = Math.max(cachedTokens - textInputTokens, 0);
+		if (imageInputTokens === 0) cachedAudioTokens = Math.min(cachedNonTextTokens, audioInputTokens);
+		else if (audioInputTokens === 0) cachedImageTokens = Math.min(cachedNonTextTokens, imageInputTokens);
+	}
+	const cachedTextTokens = Math.min(Math.max(cachedTokens - cachedAudioTokens - cachedImageTokens, 0), textInputTokens);
+	const audioOutputTokens = clampCachedTokens(audioCompletionTokens, completionTokens);
+	const videoOutputTokens = clampCachedTokens(videoCompletionTokens, Math.max(completionTokens - audioOutputTokens, 0));
+	const audioInputCost = config.audioInputCost ?? config.audioCost ?? config.inputCost ?? config.cost ?? tierCosts.serviceTierAudioInputCost * multiplier;
+	const audioOutputCost = config.audioOutputCost ?? config.audioCost ?? config.outputCost ?? config.cost ?? (applyCatalogMultiplier(modelCost.audioOutput) ?? catalogOutputCost) * multiplier;
+	const videoOutputCost = config.videoOutputCost ?? config.outputCost ?? config.cost ?? (applyCatalogMultiplier(modelCost.videoOutput) ?? catalogOutputCost) * multiplier;
+	const imageInputCost = config.imageInputCost ?? config.inputCost ?? config.cost ?? catalogImageInputCost * multiplier;
+	const cachedInputCost = config.inputCost ?? config.cost ?? tierCosts.serviceTierCachedInputCost * multiplier;
+	const cachedAudioInputCost = config.audioInputCost ?? config.audioCost ?? config.inputCost ?? config.cost ?? tierCosts.serviceTierCachedAudioInputCost * multiplier;
+	const cachedImageInputCost = config.imageInputCost ?? config.inputCost ?? config.cost ?? tierCosts.serviceTierCachedImageInputCost * multiplier;
+	return (textInputTokens - cachedTextTokens) * inputCost + cachedTextTokens * cachedInputCost + (audioInputTokens - cachedAudioTokens) * audioInputCost + cachedAudioTokens * cachedAudioInputCost + (imageInputTokens - cachedImageTokens) * imageInputCost + cachedImageTokens * cachedImageInputCost + (completionTokens - audioOutputTokens - videoOutputTokens) * outputCost + audioOutputTokens * audioOutputCost + videoOutputTokens * videoOutputCost;
+}
+const getGoogleModalityTokenCount = (details, modalities) => {
+	if (!Array.isArray(details)) return 0;
+	return details.reduce((total, detail) => {
+		const tokenCount = detail?.tokenCount ?? detail?.token_count;
+		return modalities.includes(detail?.modality) && typeof tokenCount === "number" && Number.isFinite(tokenCount) ? total + Math.max(tokenCount, 0) : total;
+	}, 0);
+};
+function calculateGoogleCostFromUsage(modelName, config, promptTokens, completionTokens, isVertexMode, usageMetadata, responseServiceTier, vertexRegion, requestedServiceTier, pricingTime) {
+	const promptDetails = usageMetadata?.promptTokensDetails ?? usageMetadata?.prompt_tokens_details;
+	const toolPromptDetails = usageMetadata?.toolUsePromptTokensDetails ?? usageMetadata?.tool_use_prompt_tokens_details;
+	const responseDetails = usageMetadata?.candidatesTokensDetails ?? usageMetadata?.responseTokensDetails ?? usageMetadata?.candidates_tokens_details ?? usageMetadata?.response_tokens_details;
+	const cacheDetails = usageMetadata?.cacheTokensDetails ?? usageMetadata?.cache_tokens_details;
+	const toolPromptTokens = usageMetadata?.toolUsePromptTokenCount ?? usageMetadata?.tool_use_prompt_token_count ?? 0;
+	const promptTokensForCost = typeof promptTokens === "number" && typeof toolPromptTokens === "number" && Number.isFinite(toolPromptTokens) ? promptTokens + Math.max(toolPromptTokens, 0) : promptTokens;
+	const audioPromptTokens = getGoogleModalityTokenCount(promptDetails, ["AUDIO"]) + getGoogleModalityTokenCount(toolPromptDetails, ["AUDIO"]);
+	const imagePromptTokens = getGoogleModalityTokenCount(promptDetails, [
+		"IMAGE",
+		"VIDEO",
+		"DOCUMENT"
+	]) + getGoogleModalityTokenCount(toolPromptDetails, [
+		"IMAGE",
+		"VIDEO",
+		"DOCUMENT"
+	]);
+	return calculateGoogleCost(modelName, config, promptTokensForCost, completionTokens, isVertexMode, audioPromptTokens, getGoogleModalityTokenCount(responseDetails, ["AUDIO"]), getGoogleModalityTokenCount(responseDetails, ["VIDEO"]), imagePromptTokens, usageMetadata?.cachedContentTokenCount ?? usageMetadata?.cached_content_token_count, getGoogleModalityTokenCount(cacheDetails, ["AUDIO"]), getGoogleModalityTokenCount(cacheDetails, [
+		"IMAGE",
+		"VIDEO",
+		"DOCUMENT"
+	]), getGoogleResponseServiceTier(responseServiceTier ? { "x-gemini-service-tier": responseServiceTier } : void 0, usageMetadata, isVertexMode), vertexRegion, requestedServiceTier, pricingTime);
+}
+const clone = Clone();
+const PartSchema = z$1.object({
+	text: z$1.string().optional(),
+	inline_data: z$1.object({
+		mime_type: z$1.string(),
+		data: z$1.string()
+	}).optional()
+}).passthrough();
+const ContentSchema = z$1.object({
+	role: z$1.enum(["user", "model"]).optional(),
+	parts: z$1.array(PartSchema)
+});
+const GeminiFormatSchema = z$1.array(ContentSchema);
+function maybeCoerceToGeminiFormat(contents, options) {
+	let coerced = false;
+	const parseResult = GeminiFormatSchema.safeParse(contents);
+	if (parseResult.success) {
+		let systemInst = void 0;
+		if (typeof contents === "object" && "system_instruction" in contents) {
+			systemInst = contents.system_instruction;
+			coerced = true;
+		}
+		return {
+			contents: parseResult.data,
+			coerced,
+			systemInstruction: systemInst
+		};
+	}
+	let coercedContents;
+	if (typeof contents === "object" && contents !== null && !Array.isArray(contents) && "system_instruction" in contents) {
+		const systemInst = contents.system_instruction;
+		if ("contents" in contents) coercedContents = contents.contents;
+		else coercedContents = [];
+		return {
+			contents: coercedContents,
+			coerced: true,
+			systemInstruction: systemInst
+		};
+	}
+	if (typeof contents === "string") {
+		coercedContents = [{ parts: [{ text: contents }] }];
+		coerced = true;
+	} else if (Array.isArray(contents) && contents.every((item) => typeof item.content === "string")) {
+		const targetRole = options?.useAssistantRole ? "assistant" : "model";
+		coercedContents = contents.map((item) => ({
+			role: item.role === "assistant" ? targetRole : item.role,
+			parts: [{ text: item.content }]
+		}));
+		coerced = true;
+	} else if (Array.isArray(contents) && contents.every((item) => item.role && item.content)) {
+		const targetRole = options?.useAssistantRole ? "assistant" : "model";
+		coercedContents = contents.map((item) => {
+			const mappedRole = item.role === "assistant" ? targetRole : item.role;
+			if (Array.isArray(item.content)) return {
+				role: mappedRole,
+				parts: item.content.map((contentItem) => {
+					if (typeof contentItem === "string") return { text: contentItem };
+					else if (contentItem.type === "text") return { text: contentItem.text };
+					else return contentItem;
+				})
+			};
+			else if (typeof item.content === "object") return {
+				role: mappedRole,
+				parts: [item.content]
+			};
+			else return {
+				role: mappedRole,
+				parts: [{ text: item.content }]
+			};
+		});
+		coerced = true;
+	} else if (typeof contents === "object" && contents !== null && "parts" in contents) {
+		coercedContents = [contents];
+		coerced = true;
+	} else {
+		logger.warn(`Unknown format for Gemini: ${JSON.stringify(contents)}`);
+		return {
+			contents: Array.isArray(contents) ? contents : [],
+			coerced: false,
+			systemInstruction: void 0
+		};
+	}
+	let systemPromptParts = [];
+	coercedContents = coercedContents.filter((message) => {
+		if (message.role === "system" && message.parts.length > 0) {
+			systemPromptParts.push(...message.parts.filter((part) => "text" in part && typeof part.text === "string"));
+			return false;
+		}
+		return true;
+	});
+	if (coercedContents.length === 0 && systemPromptParts.length > 0) {
+		coercedContents = [{
+			role: "user",
+			parts: systemPromptParts
+		}];
+		coerced = true;
+		systemPromptParts = [];
+	}
+	return {
+		contents: coercedContents,
+		coerced,
+		systemInstruction: systemPromptParts.length > 0 ? { parts: systemPromptParts } : void 0
+	};
+}
+let cachedGenerativeLanguageAuth = null;
+/**
+* Gets an OAuth2 access token for Google APIs.
+* Used by providers that need to authenticate via OAuth2 instead of API keys.
+* @param credentials - Optional credentials JSON string or file:// path
+* @param scopes - Optional scopes to use. Defaults to cloud-platform + generative-language scopes
+* @returns The access token string, or undefined if authentication fails
+*/
+async function getGoogleAccessToken(credentials) {
+	try {
+		if (!cachedGenerativeLanguageAuth) {
+			let GoogleAuth;
+			try {
+				GoogleAuth = (await import("google-auth-library")).GoogleAuth;
+				cachedGenerativeLanguageAuth = new GoogleAuth({ scopes: [
+					"https://www.googleapis.com/auth/cloud-platform",
+					"https://www.googleapis.com/auth/generative-language.retriever",
+					"https://www.googleapis.com/auth/generative-language.tuning"
+				] });
+			} catch {
+				throw new Error("The google-auth-library package is required as a peer dependency. Please install it in your project or globally.");
+			}
+		}
+		const processedCredentials = loadCredentials(credentials);
+		let client;
+		if (processedCredentials) client = await cachedGenerativeLanguageAuth.fromJSON(JSON.parse(processedCredentials));
+		else client = await cachedGenerativeLanguageAuth.getClient();
+		return (await client.getAccessToken()).token || void 0;
+	} catch (error) {
+		logger.debug("[GoogleAuth] Could not get access token", { error: error instanceof Error ? error.message : String(error) });
+		return;
+	}
+}
+function getCandidate(data) {
+	if (!data || !data.candidates || data.candidates.length < 1) {
+		let errorDetails = "No candidates returned in API response.";
+		if (data?.promptFeedback?.blockReason) {
+			errorDetails = `Response blocked: ${data.promptFeedback.blockReason}`;
+			if (data.promptFeedback.safetyRatings) {
+				const flaggedCategories = data.promptFeedback.safetyRatings.filter((rating) => rating.probability !== "NEGLIGIBLE").map((rating) => `${rating.category}: ${rating.probability}`);
+				if (flaggedCategories.length > 0) errorDetails += ` (Safety ratings: ${flaggedCategories.join(", ")})`;
+			}
+		} else if (data?.promptFeedback?.safetyRatings) {
+			const flaggedCategories = data.promptFeedback.safetyRatings.filter((rating) => rating.probability !== "NEGLIGIBLE").map((rating) => `${rating.category}: ${rating.probability}`);
+			if (flaggedCategories.length > 0) errorDetails = `Response may have been blocked due to safety filters: ${flaggedCategories.join(", ")}`;
+		}
+		errorDetails += `\n\nGot response: ${JSON.stringify(data)}`;
+		throw new Error(errorDetails);
+	}
+	if (data.candidates.length > 1) logger.debug(`Expected one candidate in AI Studio API response, but got ${data.candidates.length}: ${JSON.stringify(data)}`);
+	const candidate = data.candidates[0];
+	if (!candidate) throw new Error(`No candidates returned in API response.\n\nGot response: ${JSON.stringify(data)}`);
+	return candidate;
+}
+function isNonCandidateStreamChunk(datum) {
+	return !datum.candidates?.length && (Boolean(datum.usageMetadata) && !datum.promptFeedback || Boolean(datum.promptFeedback?.safetyRatings) && !datum.promptFeedback?.blockReason);
+}
+function getLastPromptSafetyRatings(data) {
+	let safetyRatings;
+	for (const datum of data) if (datum.promptFeedback?.safetyRatings) safetyRatings = datum.promptFeedback.safetyRatings;
+	return safetyRatings;
+}
+/** Normalize Google's prompt and candidate ratings for guardrails assertions. */
+function getGoogleGuardrails(promptSafetyRatings, candidateSafetyRatings) {
+	if (!promptSafetyRatings && !candidateSafetyRatings) return;
+	const flaggedInput = promptSafetyRatings?.some((rating) => rating.probability !== "NEGLIGIBLE");
+	const flaggedOutput = candidateSafetyRatings?.some((rating) => rating.probability !== "NEGLIGIBLE");
+	return {
+		flaggedInput,
+		flaggedOutput,
+		flagged: flaggedInput || flaggedOutput
+	};
+}
+function collectThoughtSignatures(data) {
+	return data.flatMap((datum) => (datum.candidates ?? []).flatMap((candidate) => (candidate.content?.parts ?? []).flatMap((part) => typeof part.thoughtSignature === "string" ? [part.thoughtSignature] : [])));
+}
+function collectGroundingMetadata(data) {
+	const candidates = data.filter((d) => d.candidates?.length).map((d) => getCandidate(d));
+	const flatChunks = candidates.flatMap((c) => c.groundingChunks ?? []);
+	const flatSupports = candidates.flatMap((c) => c.groundingSupports ?? []);
+	const flatQueries = candidates.flatMap((c) => c.webSearchQueries ?? []);
+	const metas = candidates.map((c) => c.groundingMetadata).filter((m) => Boolean(m));
+	let groundingMetadata;
+	if (metas.length === 1) groundingMetadata = metas[0];
+	else if (metas.length > 1) {
+		const merged = {};
+		for (const m of metas) for (const [key, value] of Object.entries(m)) {
+			if (key === "groundingChunks" || key === "groundingSupports" || key === "webSearchQueries") continue;
+			if (value !== void 0) merged[key] = value;
+		}
+		const innerChunks = metas.flatMap((m) => m.groundingChunks ?? []);
+		const innerSupports = metas.flatMap((m) => m.groundingSupports ?? []);
+		const innerQueries = metas.flatMap((m) => m.webSearchQueries ?? []);
+		if (innerChunks.length) merged.groundingChunks = innerChunks;
+		if (innerSupports.length) merged.groundingSupports = innerSupports;
+		if (innerQueries.length) merged.webSearchQueries = innerQueries;
+		groundingMetadata = merged;
+	}
+	return {
+		...groundingMetadata && { groundingMetadata },
+		...flatChunks.length > 0 && { groundingChunks: flatChunks },
+		...flatSupports.length > 0 && { groundingSupports: flatSupports },
+		...flatQueries.length > 0 && { webSearchQueries: flatQueries }
+	};
+}
+function formatCandidateContents(candidate) {
+	if (candidate.finishReason && [
+		"SAFETY",
+		"RECITATION",
+		"PROHIBITED_CONTENT",
+		"BLOCKLIST",
+		"SPII"
+	].includes(candidate.finishReason)) {
+		let errorMessage = `Response was blocked with finish reason: ${candidate.finishReason}`;
+		if (candidate.safetyRatings) {
+			const flaggedCategories = candidate.safetyRatings.filter((rating) => rating.probability !== "NEGLIGIBLE" || rating.blocked).map((rating) => `${rating.category}: ${rating.probability}${rating.blocked ? " (BLOCKED)" : ""}`);
+			if (flaggedCategories.length > 0) errorMessage += `\nSafety ratings: ${flaggedCategories.join(", ")}`;
+		}
+		if (candidate.finishReason === "RECITATION") errorMessage += "\n\nThis typically occurs when the response is too similar to content from the model's training data.";
+		else if (candidate.finishReason === "SAFETY") errorMessage += "\n\nThe response was blocked due to safety filters. Consider adjusting safety settings or modifying your prompt.";
+		throw new Error(errorMessage);
+	}
+	if (candidate.content?.parts) {
+		let output = "";
+		let is_text = true;
+		for (const part of candidate.content.parts) if ("text" in part) output += part.text;
+		else is_text = false;
+		if (is_text) return output;
+		else return candidate.content.parts;
+	} else throw new Error(`No output found in response: ${JSON.stringify(candidate)}`);
+}
+function mergeParts(parts1, parts2) {
+	if (parts1 === void 0) return typeof parts2 === "string" ? parts2 : [...parts2];
+	if (typeof parts1 === "string" && typeof parts2 === "string") return parts1 + parts2;
+	const array1 = typeof parts1 === "string" ? [{ text: parts1 }] : parts1;
+	const array2 = typeof parts2 === "string" ? [{ text: parts2 }] : parts2;
+	array1.push(...array2);
+	return array1;
+}
+function normalizeGeminiAudio(output) {
+	if (!Array.isArray(output)) return;
+	const audioParts = output.filter((part) => part.inlineData?.mimeType?.startsWith("audio/"));
+	if (audioParts.length === 0) return;
+	const mimeType = audioParts[0].inlineData.mimeType;
+	const audioData = Buffer.concat(audioParts.map((part) => Buffer.from(part.inlineData.data, "base64")));
+	if (!/^audio\/(?:L16|pcm)(?:;|$)/i.test(mimeType)) return {
+		data: audioData.toString("base64"),
+		format: mimeType.split(/[;/]/)[1]
+	};
+	const sampleRate = Number(mimeType.match(/(?:^|;)\s*rate=(\d+)/i)?.[1] ?? 24e3);
+	const header = Buffer.alloc(44);
+	header.write("RIFF", 0);
+	header.writeUInt32LE(36 + audioData.length, 4);
+	header.write("WAVE", 8);
+	header.write("fmt ", 12);
+	header.writeUInt32LE(16, 16);
+	header.writeUInt16LE(1, 20);
+	header.writeUInt16LE(1, 22);
+	header.writeUInt32LE(sampleRate, 24);
+	header.writeUInt32LE(sampleRate * 2, 28);
+	header.writeUInt16LE(2, 32);
+	header.writeUInt16LE(16, 34);
+	header.write("data", 36);
+	header.writeUInt32LE(audioData.length, 40);
+	return {
+		data: Buffer.concat([header, audioData]).toString("base64"),
+		format: "wav",
+		sampleRate,
+		channels: 1
+	};
+}
+/**
+* Normalizes and sanitizes tools configuration for Gemini API compatibility.
+* - Canonicalizes snake_case aliases to camelCase for backwards compatibility
+* - Sanitizes function declaration schemas to remove unsupported JSON Schema properties
+*   (e.g., additionalProperties, $schema, default) that Gemini doesn't support
+*/
+function normalizeTools(tools) {
+	const canonicalNames = new Set(tools.flatMap((tool) => tool.functionDeclarations?.map(({ name }) => name) ?? []));
+	const seenNames = /* @__PURE__ */ new Set();
+	return tools.flatMap((tool) => {
+		const { code_execution, google_search, google_search_retrieval, ...canonicalTool } = tool;
+		const normalizedTool = { ...canonicalTool };
+		if (normalizedTool.codeExecution === void 0 && code_execution !== void 0) normalizedTool.codeExecution = code_execution;
+		if (normalizedTool.googleSearch === void 0 && google_search !== void 0) normalizedTool.googleSearch = google_search;
+		if (normalizedTool.googleSearchRetrieval === void 0 && google_search_retrieval !== void 0) normalizedTool.googleSearchRetrieval = google_search_retrieval;
+		if (tool.functionDeclarations || tool.function_declarations) {
+			normalizedTool.functionDeclarations = [...tool.functionDeclarations ?? [], ...(tool.function_declarations ?? []).filter(({ name }) => !canonicalNames.has(name))].filter(({ name }) => {
+				if (seenNames.has(name)) return false;
+				seenNames.add(name);
+				return true;
+			});
+			delete normalizedTool.function_declarations;
+			if (normalizedTool.functionDeclarations.length === 0 && (tool.functionDeclarations?.length || tool.function_declarations?.length)) {
+				delete normalizedTool.functionDeclarations;
+				if (Object.keys(normalizedTool).length === 0) return [];
+			}
+		}
+		if (normalizedTool.functionDeclarations) normalizedTool.functionDeclarations = normalizedTool.functionDeclarations.map((fd) => ({
+			...fd,
+			parameters: fd.parameters ? sanitizeSchemaForGemini(fd.parameters) : void 0
+		}));
+		return [normalizedTool];
+	});
+}
+function loadFile(config_var, context_vars) {
+	const fileContents = maybeLoadFromExternalFile(renderVarsInObject(config_var, context_vars));
+	if (typeof fileContents === "string") try {
+		const parsedContents = JSON.parse(fileContents);
+		return Array.isArray(parsedContents) ? normalizeTools(parsedContents) : parsedContents;
+	} catch (err) {
+		logger.debug(`ERROR: failed to convert file contents to JSON:\n${JSON.stringify(err)}`);
+		return fileContents;
+	}
+	if (Array.isArray(fileContents)) return normalizeTools(fileContents);
+	return fileContents;
+}
+function getMimeTypeFromFtypBrand(brand) {
+	if ([
+		"avif",
+		"avis",
+		"crx "
+	].includes(brand)) return;
+	if ([
+		"M4A ",
+		"M4B ",
+		"M4P ",
+		"F4A ",
+		"F4B "
+	].includes(brand)) return "audio/mp4";
+	else if ([
+		"heic",
+		"heix",
+		"hevc",
+		"hevx"
+	].includes(brand)) return "image/heic";
+	else if (["mif1", "msf1"].includes(brand)) return "image/heif";
+	else if (brand === "qt  ") return "video/quicktime";
+	else if (brand.startsWith("3g")) return "video/3gpp";
+	return "video/mp4";
+}
+const ASF_HEADER_GUID = Buffer.from("3026b2758e66cf11a6d900aa0062ce6c", "hex");
+const ASF_STREAM_PROPERTIES_GUID = Buffer.from("9107dcb7b7a9cf118ee600c00c205365", "hex");
+const ASF_AUDIO_STREAM_GUID = Buffer.from("409e69f84d5bcf11a8fd00805f5c442b", "hex");
+const ASF_VIDEO_STREAM_GUID = Buffer.from("c0ef19bc4d5bcf11a8fd00805f5c442b", "hex");
+const EBML_DOCTYPE_ID = Buffer.from([66, 130]);
+const MAX_MEDIA_SNIFF_BYTES = 65536;
+const SUPPORTED_INLINE_MEDIA_MIME_TYPES = /* @__PURE__ */ new Set([
+	"application/pdf",
+	"image/jpeg",
+	"image/png",
+	"image/webp",
+	"image/heic",
+	"image/heif",
+	"audio/wav",
+	"audio/mpeg",
+	"audio/aiff",
+	"audio/aac",
+	"audio/ogg",
+	"audio/flac",
+	"audio/mp4",
+	"video/mp4",
+	"video/mpeg",
+	"video/quicktime",
+	"video/avi",
+	"video/x-flv",
+	"video/webm",
+	"video/wmv",
+	"video/3gpp"
+]);
+function getAsfMimeType(bytes) {
+	let streamOffset = bytes.indexOf(ASF_STREAM_PROPERTIES_GUID, ASF_HEADER_GUID.length);
+	let hasAudio = false;
+	while (streamOffset !== -1) {
+		const streamTypeOffset = streamOffset + ASF_STREAM_PROPERTIES_GUID.length + 8;
+		const streamType = bytes.subarray(streamTypeOffset, streamTypeOffset + 16);
+		if (streamType.equals(ASF_VIDEO_STREAM_GUID)) return "video/wmv";
+		if (streamType.equals(ASF_AUDIO_STREAM_GUID)) hasAudio = true;
+		streamOffset = bytes.indexOf(ASF_STREAM_PROPERTIES_GUID, streamTypeOffset);
+	}
+	return hasAudio ? "audio/x-ms-wma" : void 0;
+}
+function getEbmlMimeType(bytes) {
+	const doctypeOffset = bytes.indexOf(EBML_DOCTYPE_ID, 4);
+	if (doctypeOffset < 0) return;
+	const sizeOffset = doctypeOffset + EBML_DOCTYPE_ID.length;
+	const encodedLength = bytes[sizeOffset];
+	if (encodedLength === void 0 || encodedLength === 0) return;
+	let width = 1;
+	let marker = 128;
+	while ((encodedLength & marker) === 0) {
+		marker >>= 1;
+		width++;
+	}
+	if (sizeOffset + width > bytes.length) return;
+	let doctypeLength = encodedLength & marker - 1;
+	for (let index = 1; index < width; index++) {
+		doctypeLength = doctypeLength * 256 + bytes[sizeOffset + index];
+		if (doctypeLength > 4) return;
+	}
+	const doctypeOffsetStart = sizeOffset + width;
+	if (doctypeLength !== 4 || doctypeOffsetStart + doctypeLength > bytes.length) return;
+	return bytes.subarray(doctypeOffsetStart, doctypeOffsetStart + doctypeLength).equals(Buffer.from("webm")) ? "video/webm" : void 0;
+}
+function getOggMimeType(bytes) {
+	let offset = 0;
+	let hasAudio = false;
+	while (offset + 27 <= bytes.length) {
+		if (bytes.toString("utf8", offset, offset + 4) !== "OggS" || bytes[offset + 4] !== 0) return;
+		const flags = bytes[offset + 5];
+		if ((flags & 2) === 0) return hasAudio ? "audio/ogg" : void 0;
+		const segmentCount = bytes[offset + 26];
+		const payloadOffset = offset + 27 + segmentCount;
+		if ((flags & 1) !== 0 || segmentCount === 0 || payloadOffset > bytes.length) return;
+		const segments = bytes.subarray(offset + 27, payloadOffset);
+		const packetEnd = segments.findIndex((length) => length < 255);
+		if (packetEnd < 0) return;
+		const packetLength = segments.subarray(0, packetEnd + 1).reduce((sum, length) => sum + length, 0);
+		const pageEnd = payloadOffset + segments.reduce((sum, length) => sum + length, 0);
+		if (pageEnd > bytes.length) return;
+		const packet = bytes.subarray(payloadOffset, payloadOffset + packetLength);
+		if (packet.length >= 64 && packet.subarray(0, 8).equals(Buffer.from("fishead\0"))) {
+			offset = pageEnd;
+			continue;
+		}
+		if (packet.subarray(0, 7).equals(Buffer.from("€theora", "latin1"))) return "video/ogg";
+		if (![
+			"OpusHead",
+			"
vorbis",
+			"Speex   ",
+			"FLAC"
+		].some((header) => packet.subarray(0, header.length).equals(Buffer.from(header)))) return;
+		hasAudio = true;
+		offset = pageEnd;
+	}
+	return offset === bytes.length && hasAudio ? "audio/ogg" : void 0;
+}
+function getMimeTypeFromMediaBytes(bytes) {
+	const riffType = bytes.subarray(8, 12).toString("ascii");
+	if (bytes.subarray(0, 4).toString("ascii") === "RIFF") {
+		if (riffType === "WEBP") return "image/webp";
+		else if (riffType === "WAVE") return "audio/wav";
+		else if (riffType === "AVI ") return "video/avi";
+	} else if (bytes.subarray(0, 4).toString("ascii") === "FORM" && ["AIFF", "AIFC"].includes(riffType)) return "audio/aiff";
+	else if (bytes.subarray(4, 8).toString("ascii") === "ftyp") return getMimeTypeFromFtypBrand(bytes.subarray(8, 12).toString("ascii"));
+	else if ([
+		"moov",
+		"mdat",
+		"wide"
+	].includes(bytes.subarray(4, 8).toString("ascii"))) return "video/quicktime";
+	else if (bytes.subarray(0, 4).toString("hex") === "1a45dfa3") return getEbmlMimeType(bytes);
+	else if (["000001ba", "000001b3"].includes(bytes.subarray(0, 4).toString("hex"))) return "video/mpeg";
+	else if (bytes.subarray(0, 3).toString("ascii") === "FLV") return "video/x-flv";
+	else if (bytes.subarray(0, ASF_HEADER_GUID.length).equals(ASF_HEADER_GUID)) return getAsfMimeType(bytes);
+	else if (bytes[0] === 255 && (bytes[1] & 246) === 240) return "audio/aac";
+	else if (bytes.subarray(0, 3).toString("ascii") === "ID3" || bytes[0] === 255 && (bytes[1] & 224) === 224) return "audio/mpeg";
+	else if (bytes.subarray(0, 4).toString("ascii") === "fLaC") return "audio/flac";
+	else if (bytes.subarray(0, 4).toString("ascii") === "OggS") return getOggMimeType(bytes);
+}
+function getMimeTypeFromBase64(data) {
+	const parsed = parseDataUrl(data);
+	const base64Data = parsed ? parsed.base64Data : data;
+	if (!base64Data || base64Data.length < 20 || !/^[A-Za-z0-9+/]+={0,2}$/.test(base64Data)) return;
+	if (parsed) {
+		const normalizedMimeType = parsed.mimeType.toLowerCase();
+		const mimeType = {
+			"audio/mp3": "audio/mpeg",
+			"audio/m4a": "audio/mp4",
+			"video/mpg": "video/mpeg",
+			"video/mov": "video/quicktime"
+		}[normalizedMimeType] ?? normalizedMimeType;
+		return SUPPORTED_INLINE_MEDIA_MIME_TYPES.has(mimeType) ? mimeType : void 0;
+	}
+	if (base64Data.startsWith("/9j/")) return "image/jpeg";
+	else if (base64Data.startsWith("iVBORw0KGgo")) return "image/png";
+	else if (base64Data.startsWith("JVBER")) return "application/pdf";
+	const sniffBase64Length = Math.ceil(MAX_MEDIA_SNIFF_BYTES / 3) * 4;
+	const inferredMimeType = getMimeTypeFromMediaBytes(Buffer.from(base64Data.slice(0, sniffBase64Length), "base64"));
+	return inferredMimeType && SUPPORTED_INLINE_MEDIA_MIME_TYPES.has(inferredMimeType) ? inferredMimeType : void 0;
+}
+function processImagesInContents(contents, contextVars) {
+	if (!contextVars) return contents;
+	if (!Array.isArray(contents)) {
+		logger.warn("[Google] contents is not an array in processImagesInContents", {
+			contentsType: typeof contents,
+			contentsValue: contents
+		});
+		return [];
+	}
+	const base64ToMimeType = /* @__PURE__ */ new Map();
+	for (const value of Object.values(contextVars)) if (typeof value === "string") {
+		let mimeType = getMimeTypeFromBase64(value);
+		if (mimeType === "video/mp4" && !isDataUrl(value) && getLoadedFileMimeType(contextVars, value) === "audio/mp4") mimeType = "audio/mp4";
+		if (mimeType && (mimeType !== "video/mp4" || base64ToMimeType.get(value) !== "audio/mp4")) base64ToMimeType.set(value, mimeType);
+	}
+	return contents.map((content) => {
+		if (content.parts) {
+			const newParts = [];
+			for (const part of content.parts) if (part.text) {
+				const lines = part.text.split("\n");
+				let foundValidMedia = false;
+				let currentTextBlock = "";
+				const processedParts = [];
+				for (const line of lines) {
+					const trimmedLine = line.trim();
+					const mimeType = base64ToMimeType.get(trimmedLine);
+					if (mimeType) {
+						foundValidMedia = true;
+						if (currentTextBlock.length > 0) {
+							processedParts.push({ text: currentTextBlock });
+							currentTextBlock = "";
+						}
+						const base64Data = isDataUrl(trimmedLine) ? extractBase64FromDataUrl(trimmedLine) : trimmedLine;
+						processedParts.push({ inlineData: {
+							mimeType,
+							data: base64Data
+						} });
+					} else {
+						if (currentTextBlock.length > 0) currentTextBlock += "\n";
+						currentTextBlock += line;
+					}
+				}
+				if (currentTextBlock.length > 0) processedParts.push({ text: currentTextBlock });
+				if (foundValidMedia) newParts.push(...processedParts);
+				else newParts.push(part);
+			} else newParts.push(part);
+			return {
+				...content,
+				parts: newParts
+			};
+		}
+		return content;
+	});
+}
+/**
+* Parses and processes config-level systemInstruction.
+* Handles file loading, string-to-Content conversion, and Nunjucks template rendering.
+*
+* @param configSystemInstruction - The systemInstruction from config (can be string, Content, or undefined)
+* @param contextVars - Variables for Nunjucks template rendering
+* @param basePath - Optional base directory for resolving relative instruction file references
+* @returns Processed Content object or undefined
+*/
+function parseConfigSystemInstruction(configSystemInstruction, contextVars, basePath) {
+	if (!configSystemInstruction) return;
+	let configInstruction = clone(configSystemInstruction);
+	let renderInstructionParts = true;
+	if (typeof configSystemInstruction === "string") {
+		const instructionReference = resolveGoogleConfigFileReference(renderVarsInObject(configSystemInstruction, contextVars), basePath);
+		configInstruction = loadFile(instructionReference, void 0);
+		renderInstructionParts = instructionReference.startsWith("file://");
+	}
+	if (typeof configInstruction === "string") configInstruction = { parts: [{ text: configInstruction }] };
+	if (renderInstructionParts && contextVars && configInstruction) {
+		const nunjucks = getNunjucksEngine();
+		for (const part of configInstruction.parts) if (part.text) try {
+			part.text = nunjucks.renderString(part.text, contextVars);
+		} catch (err) {
+			throw new Error(`Unable to render nunjucks in systemInstruction: ${err}`);
+		}
+	}
+	return configInstruction;
+}
+/**
+* Loads, parses, and renders a config-level response schema.
+*
+* @param configResponseSchema - Inline JSON or a reference to an external schema file
+* @param contextVars - Variables for template rendering
+* @param basePath - Optional base directory for resolving relative schema file references
+* @returns The parsed and rendered response schema
+*/
+function parseConfigResponseSchema(configResponseSchema, contextVars, basePath) {
+	const renderedSchema = renderVarsInObject(configResponseSchema, contextVars);
+	const schemaReference = typeof renderedSchema === "string" ? resolveGoogleConfigFileReference(renderedSchema, basePath) : renderedSchema;
+	let responseSchema = maybeLoadFromExternalFile(schemaReference);
+	if (typeof responseSchema === "string") try {
+		responseSchema = JSON.parse(responseSchema);
+	} catch (error) {
+		throw new Error(`Invalid JSON in responseSchema: ${error}`);
+	}
+	return typeof schemaReference === "string" && schemaReference.startsWith("file://") ? renderVarsInObject(responseSchema, contextVars) : responseSchema;
+}
+/** Resolve only relative Google config file references against their owning base path. */
+function resolveGoogleConfigFileReference(reference, basePath) {
+	if (!basePath || !reference.startsWith("file://")) return reference;
+	const { filePath } = parseFileUrl(reference);
+	return `file://${path.isAbsolute(filePath) || path.win32.isAbsolute(filePath) ? filePath : path.resolve(basePath, filePath)}`;
+}
+function geminiFormatAndSystemInstructions(prompt, contextVars, configSystemInstruction, options) {
+	let contents = parseChatPrompt(prompt, [{
+		parts: [{ text: prompt }],
+		role: "user"
+	}]);
+	const { contents: updatedContents, coerced, systemInstruction: parsedSystemInstruction } = maybeCoerceToGeminiFormat(contents, options);
+	if (coerced) {
+		logger.debug(`Coerced JSON prompt to Gemini format: ${JSON.stringify(contents)}`);
+		contents = updatedContents;
+	}
+	let systemInstruction = parsedSystemInstruction;
+	const parsedConfigInstruction = parseConfigSystemInstruction(configSystemInstruction, contextVars, options?.basePath);
+	if (parsedConfigInstruction) systemInstruction = systemInstruction ? { parts: [...parsedConfigInstruction.parts, ...systemInstruction.parts] } : parsedConfigInstruction;
+	contents = processImagesInContents(contents, contextVars);
+	return {
+		contents,
+		systemInstruction
+	};
+}
+/**
+* Recursively traverses a JSON schema object and converts
+* uppercase type keywords (string values) to lowercase.
+* Handles nested objects and arrays within the schema.
+* Creates a deep copy to avoid modifying the original schema.
+*
+* @param {object | any} schemaNode - The current node (object or value) being processed.
+* @returns {object | any} - The processed node with type keywords lowercased.
+*/
+function normalizeSchemaTypes(schemaNode) {
+	if (typeof schemaNode !== "object" || schemaNode === null) return schemaNode;
+	if (Array.isArray(schemaNode)) return schemaNode.map(normalizeSchemaTypes);
+	const newNode = {};
+	for (const key in schemaNode) if (Object.prototype.hasOwnProperty.call(schemaNode, key)) {
+		const value = schemaNode[key];
+		if (key === "type") {
+			if (typeof value === "string" && VALID_SCHEMA_TYPES.includes(value)) newNode[key] = value.toLowerCase();
+			else if (Array.isArray(value)) newNode[key] = value.map((t) => typeof t === "string" && VALID_SCHEMA_TYPES.includes(t) ? t.toLowerCase() : t);
+			else newNode[key] = normalizeSchemaTypes(value);
+		} else newNode[key] = normalizeSchemaTypes(value);
+	}
+	return newNode;
+}
+function parseStringObject(input) {
+	if (typeof input === "string") return JSON.parse(input);
+	return input;
+}
+function validateFunctionCall(output, functions, vars) {
+	let functionCalls;
+	try {
+		let parsedOutput = parseStringObject(output);
+		if ("toolCall" in parsedOutput) {
+			parsedOutput = parsedOutput.toolCall;
+			functionCalls = parsedOutput.functionCalls;
+		} else if (Array.isArray(parsedOutput)) functionCalls = parsedOutput.filter((obj) => Object.prototype.hasOwnProperty.call(obj, "functionCall")).map((obj) => obj.functionCall);
+		else throw new Error("Unrecognized function call format");
+		if (!Array.isArray(functionCalls) || functionCalls.length === 0 || functionCalls.some((call) => !call || typeof call.name !== "string")) throw new Error("Expected at least one function call");
+	} catch {
+		throw new InvalidToolCallError(`Google did not return a valid-looking function call: ${JSON.stringify(output)}`);
+	}
+	let interpolatedFunctions;
+	try {
+		interpolatedFunctions = loadFile(functions, vars);
+	} catch (err) {
+		throw new InvalidToolSchemaError(err.message);
+	}
+	if (interpolatedFunctions !== void 0 && !Array.isArray(interpolatedFunctions)) throw new InvalidToolSchemaError("Expected the loaded functions to be an array");
+	if (interpolatedFunctions?.some((tool) => !tool || typeof tool !== "object" || tool.functionDeclarations !== void 0 && (!Array.isArray(tool.functionDeclarations) || tool.functionDeclarations.some((declaration) => !declaration || typeof declaration.name !== "string" || !declaration.name.trim())))) throw new InvalidToolSchemaError("Expected valid function declarations in each tool");
+	const declarations = interpolatedFunctions?.flatMap((tool) => tool.functionDeclarations ?? []);
+	if (!declarations?.length) throw new InvalidToolSchemaError(`Called "${functionCalls[0].name}", but there is no function with that name`);
+	const ajv = getAjv();
+	for (const functionCall of functionCalls) {
+		const functionName = functionCall.name;
+		let functionArgs;
+		try {
+			functionArgs = functionCall.args === void 0 ? {} : parseStringObject(functionCall.args);
+		} catch (err) {
+			throw new InvalidToolCallError(err.message);
+		}
+		const functionSchema = declarations.find((declaration) => declaration.name === functionName);
+		if (!functionSchema) throw new InvalidToolCallError(`Called "${functionName}", but there is no function with that name`);
+		if (functionSchema.parameters) {
+			const parameterSchema = normalizeSchemaTypes(functionSchema.parameters);
+			let validate;
+			try {
+				validate = ajv.compile(parameterSchema);
+			} catch (err) {
+				throw new InvalidToolSchemaError(`Tool schema doesn't compile with ajv: ${err}. If this is a valid tool schema you may need to reformulate your assertion without is-valid-function-call.`);
+			}
+			if (!validate(functionArgs)) throw new InvalidToolCallError(`Call to "${functionName}":\n${JSON.stringify(functionCall)}\ndoes not match schema:\n${JSON.stringify(validate.errors)}`);
+		} else if (!(JSON.stringify(functionArgs) === "{}" && !functionSchema?.parameters)) throw new InvalidToolCallError(`Call to "${functionName}":\n${JSON.stringify(functionCall)}\ndoes not match schema:\n${JSON.stringify(functionSchema)}`);
+	}
+}
+/**
+* Properties supported by Gemini's function calling API.
+* Based on Google's Schema type definition and API documentation.
+* @see https://ai.google.dev/api/caching#Schema
+*/
+const GEMINI_SUPPORTED_SCHEMA_PROPERTIES = /* @__PURE__ */ new Set([
+	"type",
+	"format",
+	"description",
+	"nullable",
+	"enum",
+	"maxItems",
+	"minItems",
+	"properties",
+	"required",
+	"propertyOrdering",
+	"items"
+]);
+/**
+* Valid JSON Schema types mapped to Gemini's expected format (uppercase).
+*/
+const JSON_SCHEMA_TYPE_MAP = {
+	string: "STRING",
+	number: "NUMBER",
+	integer: "INTEGER",
+	boolean: "BOOLEAN",
+	array: "ARRAY",
+	object: "OBJECT",
+	null: "STRING"
+};
+/**
+* Recursively sanitizes a JSON Schema for Gemini API compatibility.
+*
+* - Removes unsupported properties (additionalProperties, $schema, default, title, etc.)
+* - Converts type values to uppercase (string → STRING, object → OBJECT)
+* - Recursively processes nested schemas in 'properties' and 'items'
+*
+* @param schema - The JSON Schema object to sanitize
+* @returns A sanitized schema compatible with Gemini's function calling API
+*/
+function sanitizeSchemaForGemini(schema) {
+	if (!schema || typeof schema !== "object") return schema;
+	const result = {};
+	for (const [key, value] of Object.entries(schema)) {
+		if (!GEMINI_SUPPORTED_SCHEMA_PROPERTIES.has(key)) continue;
+		if (key === "type") {
+			if (typeof value === "string") {
+				const lowerType = value.toLowerCase();
+				result[key] = JSON_SCHEMA_TYPE_MAP[lowerType] || value.toUpperCase();
+			} else result[key] = value;
+		} else if (key === "properties" && typeof value === "object" && value !== null) {
+			result[key] = {};
+			for (const [propName, propSchema] of Object.entries(value)) if (typeof propSchema === "object" && propSchema !== null) result[key][propName] = sanitizeSchemaForGemini(propSchema);
+			else result[key][propName] = propSchema;
+		} else if (key === "items" && typeof value === "object" && value !== null) result[key] = sanitizeSchemaForGemini(value);
+		else result[key] = value;
+	}
+	return result;
+}
+/**
+* Create a cache discriminator from auth headers.
+*
+* This is used to ensure different API keys/credentials don't share cached responses.
+* The discriminator is included as a custom property in fetchWithCache options,
+* which gets included in the cache key automatically.
+*
+* Security note: We hash auth headers rather than using them directly to avoid
+* exposing sensitive credentials in cache keys or logs. The hash is truncated
+* to 16 hex characters (64 bits) for brevity - collision probability is acceptably
+* low for cache key differentiation (birthday problem: ~4 billion entries needed
+* for 50% collision probability).
+*
+* @param headers - Request headers containing auth info
+* @returns A short hash string for cache key differentiation
+*/
+function createAuthCacheDiscriminator(headers) {
+	const authValues = [];
+	for (const name of [
+		"authorization",
+		"x-goog-api-key",
+		"x-api-key",
+		"api-key",
+		"x-goog-user-project"
+	]) {
+		const value = headers[name] || headers[name.toLowerCase()];
+		if (value) authValues.push(`${name}:${value}`);
+	}
+	if (authValues.length === 0) return "";
+	return crypto.createHash("sha256").update(authValues.join("|")).digest("hex").substring(0, 16);
+}
+//#endregion
+export { stripExecutableToolFileReferences as A, hasGoogleDefaultCredentials as B, normalizeTools as C, removeGoogleFunctionDeclarations as D, removeDeprecatedGeminiGenerationParams as E, getVertexModelDefaultRegion as F, resolveProjectId as H, GoogleAuthManager as I, determineGoogleVertexMode as L, CHAT_MODELS as M, GOOGLE_MODELS as N, resolveGoogleToolConfig as O, getVertexApiHostForRegion as P, getGoogleApiKey as R, normalizeSafetySettings as S, parseConfigSystemInstruction as T, loadCredentials as V, mergeGoogleCompletionOptions as _, createAuthCacheDiscriminator as a, normalizeGeminiAudio as b, getCandidate as c, getGoogleGuardrails as d, getGoogleResponseServiceTier as f, loadGoogleTools as g, isNonCandidateStreamChunk as h, collectThoughtSignatures as i, validateFunctionCall as j, sanitizeSchemaForGemini as k, getGoogleAccessToken as l, getVertexServiceTierHeaders as m, calculateGoogleCostFromUsage as n, formatCandidateContents as o, getLastPromptSafetyRatings as p, collectGroundingMetadata as r, geminiFormatAndSystemInstructions as s, calculateGoogleCost as t, getGoogleApiBaseUrl as u, mergeGoogleRequestTools as v, parseConfigResponseSchema as w, normalizeGoogleServiceTier as x, mergeParts as y, getGoogleClient as z };
+
+//# sourceMappingURL=util-qzBqirBH.js.map