promptfoo 0.125.0 → 0.125.1

package/dist/src/vertex-CBAMfRz3.js

@@ -0,0 +1,854 @@
+import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.js";
+import { B as loadYaml, o as logger, rt as state } from "./logger-CNHLbG5Y.js";
+import { t as fetchWithProxy } from "./fetch-BG_Jl7ty.js";
+import { a as getRequestTimeoutMs, b as withResponseCacheMetadata, f as parseChatPrompt, m as shouldBustProviderCache, y as waitForPromiseWithAbort } from "./shared-BnN4RWgk.js";
+import { t as resolveProviderEnv } from "./env-DG25rpzi.js";
+import { h as withGenAISpan, s as extractGenAIResponse } from "./genaiTracer-QTyx3Q-T.js";
+import { o as getCache, u as isCacheEnabled } from "./cache-DeF5zIEN.js";
+import { D as removeGoogleFunctionDeclarations, E as removeDeprecatedGeminiGenerationParams, H as resolveProjectId, I as GoogleAuthManager, O as resolveGoogleToolConfig, P as getVertexApiHostForRegion, S as normalizeSafetySettings, T as parseConfigSystemInstruction, V as loadCredentials, _ as mergeGoogleCompletionOptions, b as normalizeGeminiAudio, c as getCandidate, f as getGoogleResponseServiceTier, h as isNonCandidateStreamChunk, i as collectThoughtSignatures, m as getVertexServiceTierHeaders, n as calculateGoogleCostFromUsage, o as formatCandidateContents, r as collectGroundingMetadata, s as geminiFormatAndSystemInstructions, t as calculateGoogleCost, v as mergeGoogleRequestTools, w as parseConfigResponseSchema, x as normalizeGoogleServiceTier, y as mergeParts, z as getGoogleClient } from "./util-qzBqirBH.js";
+import { A as parseMessages, M as resolveClaudeSamplingParams, O as normalizeClaudeThinkingConfig, a as calculateAnthropicCost, c as claudeThinkingConsumesTokens, f as getTokenUsage, i as applyClaudeRegionalPremium, k as outputFromMessage, s as clampMaxTokensForThinkingBudget, w as isSamplingParamsDeprecatedClaudeModel, x as isClaudeThinkingEnabled } from "./util-LEbeiYw_.js";
+import { t as GoogleGenericProvider } from "./base-CaWlBkVz.js";
+import { createHmac } from "crypto";
+//#region src/providers/google/vertex.ts
+var vertex_exports = /* @__PURE__ */ __exportAll({
+	VertexChatProvider: () => VertexChatProvider,
+	VertexEmbeddingProvider: () => VertexEmbeddingProvider,
+	getGoogleVertexEmbeddingProvider: () => getGoogleVertexEmbeddingProvider,
+	getGoogleVertexProviders: () => getGoogleVertexProviders
+});
+const VERTEX_CLAUDE_SONNET_4_5_MODELS = /* @__PURE__ */ new Set([
+	"claude-sonnet-4-5",
+	"claude-sonnet-4-5-20250929",
+	"claude-sonnet-4-5-latest"
+]);
+const VERTEX_CLAUDE_SONNET_4_5_LONG_CONTEXT_PRICING = {
+	threshold: 2e5,
+	input: 6 / 1e6,
+	output: 22.5 / 1e6
+};
+const VERTEX_LLAMA_4_MODELS = /* @__PURE__ */ new Set(["llama-4-maverick-17b-128e-instruct-maas", "llama-4-scout-17b-16e-instruct-maas"]);
+function getRequiredVertexLlamaRegion(modelName) {
+	return VERTEX_LLAMA_4_MODELS.has(modelName) ? "us-east5" : "us-central1";
+}
+function getVertexLlamaRegionError(modelName, region) {
+	const requiredRegion = getRequiredVertexLlamaRegion(modelName);
+	if (region === requiredRegion) return;
+	return `${VERTEX_LLAMA_4_MODELS.has(modelName) ? `Llama model ${modelName} is` : "Llama models are"} only available in the ${requiredRegion} region. Current region: ${region}. Please set region: '${requiredRegion}' in your configuration.`;
+}
+function getVertexLlamaSafetyRequestConfig(modelName, llamaConfig) {
+	if (VERTEX_LLAMA_4_MODELS.has(modelName)) {
+		if (llamaConfig?.safetySettings?.enabled === true || llamaConfig?.safetySettings?.llama_guard_settings !== void 0) return { error: `Llama model ${modelName} does not support Llama Guard safety settings. Remove llamaConfig.safetySettings or set enabled: false without llama_guard_settings.` };
+		return {
+			bodyFields: {},
+			enabled: false,
+			settingCount: 0
+		};
+	}
+	const llamaGuardSettings = llamaConfig?.safetySettings?.llama_guard_settings;
+	if (llamaGuardSettings !== void 0 && (typeof llamaGuardSettings !== "object" || llamaGuardSettings === null)) return { error: `Invalid llama_guard_settings: must be an object, received ${typeof llamaGuardSettings}` };
+	const modelSafetySettings = {
+		enabled: llamaConfig?.safetySettings?.enabled !== false,
+		llama_guard_settings: llamaGuardSettings || {}
+	};
+	return {
+		bodyFields: { extra_body: { google: { model_safety_settings: modelSafetySettings } } },
+		enabled: modelSafetySettings.enabled,
+		settingCount: Object.keys(modelSafetySettings.llama_guard_settings).length
+	};
+}
+function applyVertexClaudeLongContextPricing(modelName, config, inputTokens, cacheReadTokens, cacheCreationTokens) {
+	const effectiveInputTokens = (inputTokens ?? 0) + (cacheReadTokens ?? 0) + (cacheCreationTokens ?? 0);
+	if (!VERTEX_CLAUDE_SONNET_4_5_MODELS.has(modelName) || effectiveInputTokens <= VERTEX_CLAUDE_SONNET_4_5_LONG_CONTEXT_PRICING.threshold) return config;
+	if (config.cost != null) return config;
+	return {
+		...config,
+		inputCost: config.inputCost ?? VERTEX_CLAUDE_SONNET_4_5_LONG_CONTEXT_PRICING.input,
+		outputCost: config.outputCost ?? VERTEX_CLAUDE_SONNET_4_5_LONG_CONTEXT_PRICING.output
+	};
+}
+function getVertexApiHost(region, configApiHost, envOverrides) {
+	return configApiHost || resolveProviderEnv(envOverrides, ["VERTEX_API_HOST"])?.value || getVertexApiHostForRegion(region);
+}
+function getVertexBodyCacheKey(prefix, body, apiHost) {
+	const serialized = typeof body === "string" ? body : JSON.stringify(body);
+	return `${prefix}:${createHmac("sha256", "promptfoo:vertex:cache-key:v1").update(apiHost).update("\0").update(serialized).digest("hex")}`;
+}
+function getVertexClientOptions(provider) {
+	return {
+		credentials: loadCredentials(provider.config.credentials),
+		googleAuthOptions: provider.config.googleAuthOptions,
+		scopes: provider.config.scopes,
+		keyFilename: provider.config.keyFilename
+	};
+}
+/**
+* Vertex AI provider for Gemini, Claude, Llama, and Palm2 models.
+*
+* Extends GoogleGenericProvider for shared functionality like MCP integration,
+* authentication management, and resource cleanup.
+*/
+var VertexChatProvider = class extends GoogleGenericProvider {
+	constructor(modelName, options = {}) {
+		super(modelName, {
+			...options,
+			config: {
+				...options.config,
+				vertexai: true
+			}
+		});
+	}
+	/**
+	* Get the Vertex AI API host based on region.
+	* Public for use by integrations like Adaline Gateway.
+	*/
+	getApiHost() {
+		return getVertexApiHost(this.getRegion(), this.config.apiHost, this.env);
+	}
+	/**
+	* Get the API version for Vertex AI.
+	*/
+	getApiVersion() {
+		return this.config.apiVersion || resolveProviderEnv(this.env, ["VERTEX_API_VERSION"])?.value || "v1";
+	}
+	/**
+	* Get the publisher for the model.
+	*/
+	getPublisher() {
+		return this.config.publisher || resolveProviderEnv(this.env, ["VERTEX_PUBLISHER"])?.value || "google";
+	}
+	/**
+	* Get the API endpoint URL for Vertex AI.
+	* Note: For Gemini, the actual endpoint is constructed dynamically based on mode.
+	*/
+	getApiEndpoint(action) {
+		const actionSuffix = action ? `:${action}` : "";
+		return `https://${this.getApiHost()}/${this.getApiVersion()}/publishers/${this.getPublisher()}/models/${this.modelName}${actionSuffix}`;
+	}
+	/**
+	* Get authentication headers for Vertex AI.
+	* For OAuth mode, this returns minimal headers; the client handles auth.
+	* For express mode, the API key is passed via x-goog-api-key header for improved security.
+	*/
+	async getAuthHeaders() {
+		const headers = {
+			"Content-Type": "application/json",
+			...this.config.headers
+		};
+		if (this.isExpressMode()) {
+			const apiKey = this.getApiKey();
+			if (apiKey) headers["x-goog-api-key"] = apiKey;
+		}
+		return headers;
+	}
+	/**
+	* Helper method to get Google client with credentials support.
+	* Public for use by integrations like Adaline Gateway.
+	*/
+	async getClientWithCredentials() {
+		const { client } = await getGoogleClient(getVertexClientOptions(this));
+		return client;
+	}
+	async callApi(prompt, context, options) {
+		const spanContext = {
+			system: this.modelName.includes("claude") ? "vertex:anthropic" : this.modelName.includes("gemini") ? "vertex:gemini" : this.modelName.includes("llama") ? "vertex:llama" : "vertex:palm2",
+			operationName: "chat",
+			model: this.modelName,
+			providerId: this.id(),
+			temperature: this.config.temperature,
+			topP: this.config.topP,
+			maxTokens: this.config.maxOutputTokens || this.config.max_tokens,
+			testIndex: context?.testIdx ?? context?.test?.vars?.__testIdx,
+			promptLabel: context?.prompt?.label,
+			traceparent: context?.traceparent
+		};
+		return withGenAISpan(spanContext, () => this.callApiInternal(prompt, context, options), extractGenAIResponse);
+	}
+	async callApiInternal(prompt, context, options) {
+		if (this.modelName.includes("claude")) return this.callClaudeApi(prompt, context);
+		else if (this.modelName.includes("gemini")) return this.callGeminiApi(prompt, context, options);
+		else if (this.modelName.includes("llama")) return this.callLlamaApi(prompt, context);
+		return this.callPalm2Api(prompt, context);
+	}
+	async callClaudeApi(prompt, context) {
+		let normalizedPrompt = prompt;
+		if (prompt.trim().startsWith("- role:")) try {
+			const parsed = loadYaml(prompt);
+			normalizedPrompt = JSON.stringify(parsed);
+		} catch (err) {
+			return { error: `Chat Completion prompt is not a valid YAML string: ${err}` };
+		}
+		const { system, extractedMessages, thinking } = parseMessages(normalizedPrompt);
+		let mergedSystem = system;
+		const promptConfig = context?.prompt?.config;
+		const effectiveConfig = mergeGoogleCompletionOptions(this.config, promptConfig);
+		const promptBasePath = promptConfig?.basePath ?? this.config.basePath;
+		const parsedConfigInstruction = parseConfigSystemInstruction(effectiveConfig.systemInstruction, context?.vars, promptConfig?.systemInstruction === void 0 ? this.config.basePath : promptBasePath);
+		if (parsedConfigInstruction) {
+			const configSystemBlocks = [];
+			for (const part of parsedConfigInstruction.parts) if (part.text) configSystemBlocks.push({
+				type: "text",
+				text: part.text
+			});
+			if (configSystemBlocks.length > 0) mergedSystem = [...configSystemBlocks, ...mergedSystem || []];
+		}
+		const apiHost = this.getApiHost();
+		const apiHostUrl = `https://${apiHost}`;
+		const normalizedApiHostname = URL.canParse(apiHostUrl) ? new URL(apiHostUrl).hostname : "";
+		const allowGenerationFallback = /^(?:[a-z0-9-]+-)?aiplatform(?:\.mtls)?\.googleapis\.com$/i.test(normalizedApiHostname);
+		const samplingParamsDeprecated = isSamplingParamsDeprecatedClaudeModel(this.modelName, { allowGenerationFallback });
+		const requestedThinkingConfig = this.config.thinking || thinking;
+		const effort = this.config.effort;
+		const thinkingConfig = normalizeClaudeThinkingConfig(this.modelName, requestedThinkingConfig, effort, { allowGenerationFallback });
+		const thinkingConsumesTokens = claudeThinkingConsumesTokens(this.modelName, thinkingConfig);
+		let maxTokens = this.config.max_tokens || this.config.maxOutputTokens || 0;
+		if (!maxTokens) maxTokens = thinkingConsumesTokens ? 2048 : 512;
+		maxTokens = clampMaxTokensForThinkingBudget(maxTokens, thinkingConfig);
+		const resolvedTemperature = samplingParamsDeprecated ? void 0 : this.config.temperature;
+		const resolvedTopP = samplingParamsDeprecated ? void 0 : this.config.top_p ?? this.config.topP;
+		const resolvedTopK = samplingParamsDeprecated ? void 0 : this.config.top_k ?? this.config.topK;
+		const { sampling, warnings: samplingWarnings } = resolveClaudeSamplingParams({
+			temperature: resolvedTemperature,
+			top_p: resolvedTopP,
+			top_k: resolvedTopK
+		}, {
+			thinkingEnabled: isClaudeThinkingEnabled(thinkingConfig),
+			samplingParamsDeprecated
+		});
+		for (const warning of samplingWarnings) logger.warn(warning);
+		const body = {
+			anthropic_version: this.config.anthropicVersion || this.config.anthropic_version || "vertex-2023-10-16",
+			stream: false,
+			max_tokens: maxTokens,
+			...sampling,
+			...mergedSystem ? { system: mergedSystem } : {},
+			...thinkingConfig ? { thinking: thinkingConfig } : {},
+			...effort ? { output_config: { effort } } : {},
+			messages: extractedMessages
+		};
+		const showThinking = this.config.showThinking ?? (thinkingConsumesTokens || thinkingConfig?.type === "between_tools");
+		const cache = isCacheEnabled() && !shouldBustProviderCache(context) ? await getCache() : void 0;
+		const cacheKey = cache ? getVertexBodyCacheKey(`vertex:claude:${this.modelName}:showThinking=${showThinking}`, body, apiHost) : void 0;
+		if (cache && cacheKey) {
+			const cachedResponse = await cache.get(cacheKey);
+			if (cachedResponse) {
+				logger.debug("Returning cached Vertex Claude response", {
+					model: this.modelName,
+					cacheKey
+				});
+				return withResponseCacheMetadata(JSON.parse(cachedResponse), true);
+			}
+		}
+		let data;
+		try {
+			const client = await this.getClientWithCredentials();
+			const url = `https://${apiHost}/v1/projects/${await this.getProjectId()}/locations/${this.getRegion()}/publishers/anthropic/models/${this.modelName}:rawPredict`;
+			data = (await client.request({
+				url,
+				method: "POST",
+				headers: { "Content-Type": "application/json; charset=utf-8" },
+				data: body,
+				timeout: getRequestTimeoutMs()
+			})).data;
+		} catch (err) {
+			const error = err;
+			if (error.response && error.response.data) {
+				logger.debug(`Claude API error:\n${JSON.stringify(error.response.data)}`);
+				return { error: `API call error: ${JSON.stringify(error.response.data)}` };
+			}
+			logger.debug(`Claude API error:\n${JSON.stringify(err)}`);
+			return { error: `API call error: ${String(err)}` };
+		}
+		try {
+			const output = outputFromMessage(data, showThinking);
+			if (!output) return { error: `No output found in Claude API response: ${JSON.stringify(data)}` };
+			const tokenUsage = {
+				...getTokenUsage(data, false),
+				numRequests: 1
+			};
+			const normalizedModelName = this.modelName.replace(/-v\d+@/, "-").replace("@", "-");
+			const pricingModelName = normalizedModelName === "claude-sonnet-4-5-latest" ? "claude-sonnet-4-5" : normalizedModelName;
+			const effectivePricingConfig = applyVertexClaudeLongContextPricing(pricingModelName, this.getRegion() === "global" ? this.config : applyClaudeRegionalPremium(pricingModelName, this.config), data.usage?.input_tokens, data.usage?.cache_read_input_tokens, data.usage?.cache_creation_input_tokens);
+			const response = {
+				cached: false,
+				output,
+				tokenUsage,
+				cost: calculateAnthropicCost(pricingModelName, effectivePricingConfig, data.usage?.input_tokens, data.usage?.output_tokens, data.usage?.cache_read_input_tokens, data.usage?.cache_creation_input_tokens, data.usage?.cache_creation?.ephemeral_1h_input_tokens)
+			};
+			if (cache && cacheKey) await cache.set(cacheKey, JSON.stringify(response));
+			return response;
+		} catch (err) {
+			return { error: `Claude API response error: ${String(err)}. Response data: ${JSON.stringify(data)}` };
+		}
+	}
+	/**
+	* Check if express mode should be used (API key without OAuth).
+	* Express mode uses a simplified endpoint format without project/location.
+	*
+	* Express mode is automatic when an API key is available - users don't need
+	* to think about it. Just provide an API key and it works.
+	*
+	* Express mode is used when:
+	* 1. API key is available (VERTEX_API_KEY, GOOGLE_API_KEY, or config.apiKey)
+	* 2. User hasn't explicitly disabled it with `expressMode: false`
+	* 3. No OAuth/ADC credentials are configured (OAuth takes priority)
+	*/
+	isExpressMode() {
+		const hasApiKey = Boolean(this.getApiKey());
+		const explicitlyDisabled = this.config.expressMode === false;
+		const hasOAuthConfig = Boolean(this.config.credentials || this.config.keyFilename || this.config.googleAuthOptions?.keyFilename || this.config.googleAuthOptions?.credentials);
+		return hasApiKey && !explicitlyDisabled && !hasOAuthConfig;
+	}
+	async callGeminiApi(prompt, context, options) {
+		await this.initializeMCP(options?.abortSignal);
+		const promptConfig = context?.prompt?.config;
+		const config = mergeGoogleCompletionOptions(this.config, promptConfig);
+		const promptBasePath = promptConfig?.basePath ?? this.config.basePath;
+		const { contents, systemInstruction } = geminiFormatAndSystemInstructions(prompt, context?.vars, config.systemInstruction, {
+			basePath: promptConfig?.systemInstruction === void 0 ? this.config.basePath : promptBasePath,
+			useAssistantRole: config.useAssistantRole
+		});
+		const { toolConfig, toolsDisabled } = resolveGoogleToolConfig(config);
+		const allTools = await this.getAllTools(context, { skipExecutableToolFiles: toolsDisabled });
+		const requestTools = toolsDisabled ? removeGoogleFunctionDeclarations(allTools) : allTools;
+		const { service_tier: passthroughServiceTier, serviceTier: camelCasePassthroughServiceTier, tools: passthroughTools, toolConfig: _passthroughToolConfig, tool_config: _passthroughToolConfigSnakeCase, ...passthrough } = config.passthrough || {};
+		const serviceTier = normalizeGoogleServiceTier(passthroughServiceTier ?? camelCasePassthroughServiceTier ?? config.service_tier);
+		const tierHeaders = getVertexServiceTierHeaders(serviceTier, this.config.headers);
+		const opaqueServiceTier = serviceTier && ![
+			"standard",
+			"priority",
+			"flex"
+		].includes(serviceTier) ? serviceTier : void 0;
+		const requestPassthroughTools = toolsDisabled && passthroughTools !== void 0 ? removeGoogleFunctionDeclarations(passthroughTools) : passthroughTools;
+		const mergedTools = mergeGoogleRequestTools(requestTools, requestPassthroughTools);
+		const body = {
+			contents,
+			generationConfig: {
+				context: config.context,
+				examples: config.examples,
+				stopSequences: config.stopSequences,
+				temperature: config.temperature,
+				maxOutputTokens: config.maxOutputTokens,
+				topP: config.topP,
+				topK: config.topK,
+				...config.generationConfig,
+				...this.modelName.includes("-tts") && {
+					response_modalities: void 0,
+					responseModalities: config.generationConfig?.responseModalities ?? config.generationConfig?.response_modalities?.map((modality) => modality.toUpperCase()) ?? ["AUDIO"],
+					speechConfig: config.generationConfig?.speechConfig ?? { voiceConfig: this.modelName.startsWith("gemini-3.8-") ? { voice: "Kore" } : { prebuiltVoiceConfig: { voiceName: "Kore" } } }
+				}
+			},
+			...config.safetySettings ? { safetySettings: normalizeSafetySettings(config.safetySettings) } : {},
+			...toolConfig ? { toolConfig } : {},
+			...mergedTools ? { tools: mergedTools } : {},
+			...systemInstruction ? { systemInstruction } : {},
+			...opaqueServiceTier ? { serviceTier: opaqueServiceTier } : {},
+			...passthrough,
+			...config.modelArmor && (config.modelArmor.promptTemplate || config.modelArmor.responseTemplate) && { model_armor_config: {
+				...config.modelArmor.promptTemplate && { prompt_template_name: config.modelArmor.promptTemplate },
+				...config.modelArmor.responseTemplate && { response_template_name: config.modelArmor.responseTemplate }
+			} }
+		};
+		if (["gemini-3.8-flash-tts", "gemini-3.8-flash-lite-tts"].includes(this.modelName) && (body.systemInstruction || "system_instruction" in body && body.system_instruction)) return { error: `${this.modelName} on Vertex does not support system instructions. Put delivery instructions in speechMetadata.style.` };
+		body.generationConfig = removeDeprecatedGeminiGenerationParams(this.modelName, body.generationConfig);
+		if (config.responseSchema) {
+			if (body.generationConfig.response_schema) throw new Error("`responseSchema` provided but `generationConfig.response_schema` already set.");
+			const schema = parseConfigResponseSchema(config.responseSchema, context?.vars, promptConfig?.responseSchema === void 0 ? this.config.basePath : promptBasePath);
+			body.generationConfig.response_schema = schema;
+			body.generationConfig.response_mime_type = "application/json";
+		}
+		const useCache = isCacheEnabled() && !shouldBustProviderCache(context);
+		const apiHost = this.getApiHost();
+		const tierHeader = Object.entries(tierHeaders).find(([name]) => name.toLowerCase() === "x-vertex-ai-llm-shared-request-type")?.[1];
+		const cacheBody = tierHeader === void 0 ? body : {
+			requestBody: body,
+			serviceTierHeader: tierHeader
+		};
+		const cache = useCache && Object.keys(this.config.headers ?? {}).every((name) => name.toLowerCase() === "x-vertex-ai-llm-shared-request-type") ? await getCache() : void 0;
+		const cacheKey = cache ? getVertexBodyCacheKey(`vertex:${this.modelName}`, cacheBody, apiHost) : void 0;
+		let response;
+		let cachedResponse;
+		if (cache && cacheKey) {
+			cachedResponse = await cache.get(cacheKey);
+			if (cachedResponse) {
+				const parsedCachedResponse = JSON.parse(cachedResponse);
+				logger.debug("Returning cached Vertex Gemini response", {
+					model: this.modelName,
+					cacheKey
+				});
+				response = withResponseCacheMetadata(parsedCachedResponse, true);
+			}
+		}
+		if (response === void 0) {
+			let data;
+			let responseHeaders;
+			let requestedServiceTier;
+			try {
+				const endpoint = config.streaming === true ? "streamGenerateContent" : "generateContent";
+				const requestHeaders = {
+					...tierHeaders,
+					...await this.getAuthHeaders()
+				};
+				requestedServiceTier = Object.entries(requestHeaders).find(([name]) => name.toLowerCase() === "x-vertex-ai-llm-shared-request-type")?.[1];
+				if (this.isExpressMode()) {
+					const url = `https://${apiHost}/${this.getApiVersion()}/publishers/${this.getPublisher()}/models/${this.modelName}:${endpoint}`;
+					const res = await fetchWithProxy(url, {
+						method: "POST",
+						headers: requestHeaders,
+						body: JSON.stringify(body),
+						signal: AbortSignal.timeout(getRequestTimeoutMs())
+					});
+					if (!res.ok) {
+						const errorData = await res.json().catch(() => null);
+						logger.debug(`Gemini API express mode error:\n${JSON.stringify(errorData)}`);
+						return { error: `API call error: ${res.status} ${res.statusText}${errorData ? `: ${JSON.stringify(errorData)}` : ""}` };
+					}
+					data = await res.json();
+					responseHeaders = res.headers;
+				} else {
+					const client = await this.getClientWithCredentials();
+					const projectId = await this.getProjectId();
+					const url = `https://${apiHost}/${this.getApiVersion()}/projects/${projectId}/locations/${this.getRegion()}/publishers/${this.getPublisher()}/models/${this.modelName}:${endpoint}`;
+					const res = await client.request({
+						url,
+						method: "POST",
+						data: body,
+						headers: requestHeaders,
+						timeout: getRequestTimeoutMs()
+					});
+					data = res.data;
+					responseHeaders = res.headers;
+				}
+			} catch (err) {
+				const geminiError = err;
+				if (geminiError.response && geminiError.response.data && geminiError.response.data[0] && geminiError.response.data[0].error) {
+					const errorDetails = geminiError.response.data[0].error;
+					const code = errorDetails.code;
+					const message = errorDetails.message;
+					const status = errorDetails.status;
+					logger.error(`Gemini API error:\n${JSON.stringify(errorDetails)}`);
+					return { error: `API call error: Status ${status}, Code ${code}, Message:\n\n${message}` };
+				}
+				logger.debug(`Gemini API error:\n${JSON.stringify(err)}`);
+				return { error: `API call error: ${String(err)}` };
+			}
+			try {
+				const normalizedData = Array.isArray(data) ? data : [data];
+				const error = normalizedData[0]?.error;
+				if (error) return { error: `Error ${error.code}: ${error.message}` };
+				const dataWithResponse = normalizedData;
+				let output;
+				for (const datum of dataWithResponse) {
+					if (datum.promptFeedback?.blockReason) {
+						const isModelArmor = datum.promptFeedback.blockReason === "MODEL_ARMOR";
+						const blockReasonMessage = datum.promptFeedback.blockReasonMessage || `Content was blocked due to ${isModelArmor ? "Model Armor" : "safety settings"}: ${datum.promptFeedback.blockReason}`;
+						return {
+							output: blockReasonMessage,
+							tokenUsage: {
+								total: datum.usageMetadata?.totalTokenCount || 0,
+								prompt: datum.usageMetadata?.promptTokenCount || 0,
+								completion: datum.usageMetadata?.candidatesTokenCount || 0
+							},
+							guardrails: {
+								flagged: true,
+								flaggedInput: true,
+								flaggedOutput: false,
+								reason: blockReasonMessage
+							},
+							metadata: { modelArmor: isModelArmor ? {
+								blockReason: datum.promptFeedback.blockReason,
+								...datum.promptFeedback.blockReasonMessage && { blockReasonMessage: datum.promptFeedback.blockReasonMessage }
+							} : void 0 }
+						};
+					}
+					if (Array.isArray(data) && isNonCandidateStreamChunk(datum)) continue;
+					const candidate = getCandidate(datum);
+					if (candidate.finishReason && [
+						"SAFETY",
+						"PROHIBITED_CONTENT",
+						"RECITATION",
+						"BLOCKLIST",
+						"SPII",
+						"IMAGE_SAFETY"
+					].includes(candidate.finishReason)) {
+						const finishReason = `Content was blocked due to safety settings with finish reason: ${candidate.finishReason}.`;
+						const tokenUsage = {
+							total: datum.usageMetadata?.totalTokenCount || 0,
+							prompt: datum.usageMetadata?.promptTokenCount || 0,
+							completion: datum.usageMetadata?.candidatesTokenCount || 0
+						};
+						const guardrails = {
+							flagged: true,
+							flaggedInput: false,
+							flaggedOutput: true,
+							reason: finishReason
+						};
+						if (state.config?.redteam) return {
+							output: finishReason,
+							tokenUsage,
+							guardrails
+						};
+						return {
+							error: finishReason,
+							guardrails
+						};
+					} else if (candidate.finishReason && candidate.finishReason === "MAX_TOKENS") {
+						if (candidate.content?.parts) output = mergeParts(output, formatCandidateContents(candidate));
+						const outputTokens = datum.usageMetadata?.candidatesTokenCount || 0;
+						logger.debug(`Gemini API: MAX_TOKENS reached`, {
+							finishReason: candidate.finishReason,
+							outputTokens,
+							totalTokens: datum.usageMetadata?.totalTokenCount || 0
+						});
+					} else if (candidate.finishReason && candidate.finishReason !== "STOP") {
+						logger.error(`Gemini API error due to finish reason: ${candidate.finishReason}.`);
+						return { error: `Finish reason ${candidate.finishReason}: ${JSON.stringify(data)}` };
+					} else if (candidate.content?.parts) output = mergeParts(output, formatCandidateContents(candidate));
+					else if (candidate.finishReason !== "STOP") return { error: `No output found in response: ${JSON.stringify(data)}` };
+				}
+				if (output === void 0 || output === "") return { error: `No output found in response: ${JSON.stringify(data)}` };
+				const lastData = dataWithResponse[dataWithResponse.length - 1];
+				const promptTokenCount = lastData.usageMetadata?.promptTokenCount;
+				const completionTokenCount = lastData.usageMetadata?.candidatesTokenCount;
+				const thoughtsTokenCount = lastData.usageMetadata?.thoughtsTokenCount;
+				const tokenUsage = {
+					total: lastData.usageMetadata?.totalTokenCount || 0,
+					prompt: (promptTokenCount || 0) + (lastData.usageMetadata?.toolUsePromptTokenCount ?? 0),
+					completion: completionTokenCount || 0,
+					...lastData.usageMetadata?.cachedContentTokenCount !== void 0 && { cached: lastData.usageMetadata.cachedContentTokenCount },
+					...thoughtsTokenCount !== void 0 && { completionDetails: {
+						reasoning: thoughtsTokenCount,
+						acceptedPrediction: 0,
+						rejectedPrediction: 0
+					} }
+				};
+				const completionForCost = completionTokenCount == null ? void 0 : completionTokenCount + (thoughtsTokenCount ?? 0);
+				const actualServiceTier = getGoogleResponseServiceTier(responseHeaders, lastData.usageMetadata, true);
+				const cost = calculateGoogleCostFromUsage(this.modelName, config, promptTokenCount, completionForCost, true, lastData.usageMetadata, actualServiceTier, this.getRegion(), requestedServiceTier);
+				const audio = normalizeGeminiAudio(output);
+				const thoughtSignatures = collectThoughtSignatures(dataWithResponse);
+				response = {
+					cached: false,
+					output,
+					...audio && { audio },
+					tokenUsage,
+					cost,
+					metadata: {
+						...thoughtSignatures.length > 0 && { thoughtSignatures },
+						...actualServiceTier && { serviceTier: actualServiceTier },
+						...typeof lastData.usageMetadata?.trafficType === "string" && { trafficType: lastData.usageMetadata.trafficType }
+					}
+				};
+				const grounding = collectGroundingMetadata(dataWithResponse);
+				if (Object.keys(grounding).length > 0) response.metadata = {
+					...response.metadata,
+					...grounding
+				};
+				if (cache && cacheKey) await cache.set(cacheKey, JSON.stringify(response));
+			} catch (err) {
+				return { error: `Gemini API response error: ${String(err)}. Response data: ${JSON.stringify(data)}` };
+			}
+		}
+		try {
+			response.output = await this.executeFunctionToolCallbacks(response.output, {
+				...config,
+				basePath: promptConfig?.functionToolCallbacks === void 0 ? this.config.basePath : promptBasePath
+			}, toolsDisabled);
+		} catch (error) {
+			return {
+				...response,
+				output: void 0,
+				error: String(error)
+			};
+		}
+		return response;
+	}
+	async callPalm2Api(prompt, context) {
+		const body = {
+			instances: parseChatPrompt(prompt, [{ messages: [{
+				author: "user",
+				content: prompt
+			}] }]),
+			parameters: {
+				context: this.config.context,
+				examples: this.config.examples,
+				safetySettings: normalizeSafetySettings(this.config.safetySettings),
+				stopSequences: this.config.stopSequences,
+				temperature: this.config.temperature,
+				maxOutputTokens: this.config.maxOutputTokens,
+				topP: this.config.topP,
+				topK: this.config.topK
+			}
+		};
+		const apiHost = this.getApiHost();
+		const cache = isCacheEnabled() && !shouldBustProviderCache(context) ? await getCache() : void 0;
+		const cacheKey = cache ? getVertexBodyCacheKey(`vertex:palm2:${this.modelName}`, body, apiHost) : void 0;
+		if (cache && cacheKey) {
+			const cachedResponse = await cache.get(cacheKey);
+			if (cachedResponse) {
+				logger.debug("Returning cached Vertex Palm2 response", {
+					model: this.modelName,
+					cacheKey
+				});
+				return withResponseCacheMetadata(JSON.parse(cachedResponse), true);
+			}
+		}
+		let data;
+		try {
+			const client = await this.getClientWithCredentials();
+			const projectId = await this.getProjectId();
+			const url = `https://${apiHost}/${this.getApiVersion()}/projects/${projectId}/locations/${this.getRegion()}/publishers/${this.getPublisher()}/models/${this.modelName}:predict`;
+			data = (await client.request({
+				url,
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				data: body,
+				timeout: getRequestTimeoutMs()
+			})).data;
+		} catch (err) {
+			return { error: `API call error: ${JSON.stringify(err)}` };
+		}
+		try {
+			if (data.error) return { error: `Error ${data.error.code}: ${data.error.message}` };
+			const prediction = data.predictions?.[0];
+			if (!prediction?.candidates?.length) return { error: `No valid predictions returned from API: ${JSON.stringify(data)}` };
+			const response = {
+				output: prediction.candidates[0].content,
+				cached: false
+			};
+			if (cache && cacheKey) await cache.set(cacheKey, JSON.stringify(response));
+			return response;
+		} catch (err) {
+			return { error: `API response error: ${String(err)}: ${JSON.stringify(data)}` };
+		}
+	}
+	async callLlamaApi(prompt, context) {
+		const region = this.getRegion();
+		const regionError = getVertexLlamaRegionError(this.modelName, region);
+		if (regionError) return { error: regionError };
+		const messages = parseChatPrompt(prompt, [{
+			role: "user",
+			content: prompt
+		}]);
+		const safetyRequestConfig = getVertexLlamaSafetyRequestConfig(this.modelName, this.config.llamaConfig);
+		if ("error" in safetyRequestConfig) return { error: safetyRequestConfig.error };
+		const body = {
+			model: `meta/${this.modelName}`,
+			messages,
+			max_tokens: this.config.maxOutputTokens || 1024,
+			stream: false,
+			temperature: this.config.temperature,
+			top_p: this.config.topP,
+			top_k: this.config.topK,
+			...safetyRequestConfig.bodyFields
+		};
+		const apiHost = this.getApiHost();
+		const cache = isCacheEnabled() && !shouldBustProviderCache(context) ? await getCache() : void 0;
+		const cacheKey = cache ? getVertexBodyCacheKey(`vertex:llama:${this.modelName}`, body, apiHost) : void 0;
+		logger.debug("Preparing to call Llama API", {
+			model: this.modelName,
+			region,
+			messageCount: messages.length,
+			maxTokens: body.max_tokens,
+			temperature: body.temperature,
+			topP: body.top_p,
+			topK: body.top_k,
+			safetySettingsEnabled: safetyRequestConfig.enabled,
+			llamaGuardSettingCount: safetyRequestConfig.settingCount,
+			cacheKey
+		});
+		if (cache && cacheKey) {
+			const cachedResponse = await cache.get(cacheKey);
+			if (cachedResponse) {
+				logger.debug("Returning cached Vertex Llama response", {
+					model: this.modelName,
+					cacheKey
+				});
+				return withResponseCacheMetadata(JSON.parse(cachedResponse), true);
+			}
+		}
+		let data;
+		try {
+			const client = await this.getClientWithCredentials();
+			const url = `https://${apiHost}/v1beta1/projects/${await this.getProjectId()}/locations/${region}/endpoints/openapi/chat/completions`;
+			data = (await client.request({
+				url,
+				method: "POST",
+				headers: { "Content-Type": "application/json; charset=utf-8" },
+				data: body,
+				timeout: getRequestTimeoutMs()
+			})).data;
+			logger.debug("Llama API response", {
+				choiceCount: data.choices?.length ?? 0,
+				hasUsage: data.usage !== void 0,
+				totalTokens: data.usage?.total_tokens,
+				promptTokens: data.usage?.prompt_tokens,
+				completionTokens: data.usage?.completion_tokens
+			});
+		} catch (err) {
+			const error = err;
+			if (error.response && error.response.data) {
+				logger.debug("Llama API error", {
+					status: error.response.status,
+					statusText: error.response.statusText,
+					hasResponseData: error.response.data !== void 0
+				});
+				return { error: `API call error: ${JSON.stringify(error.response.data)}` };
+			}
+			logger.debug("Llama API error", { error: err instanceof Error ? err.message : String(err) });
+			return { error: `API call error: ${String(err)}` };
+		}
+		try {
+			let output = "";
+			if (data.choices && data.choices.length > 0) output = data.choices[0].message.content;
+			if (!output) return { error: `No output found in Llama API response: ${JSON.stringify(data)}` };
+			const tokenUsage = {
+				total: data.usage?.total_tokens || 0,
+				prompt: data.usage?.prompt_tokens || 0,
+				completion: data.usage?.completion_tokens || 0,
+				numRequests: 1
+			};
+			const response = {
+				cached: false,
+				output,
+				tokenUsage
+			};
+			if (cache && cacheKey) await cache.set(cacheKey, JSON.stringify(response));
+			return response;
+		} catch (err) {
+			return { error: `Llama API response error: ${String(err)}. Response data: ${JSON.stringify(data)}` };
+		}
+	}
+};
+var VertexEmbeddingProvider = class {
+	supportsEmbeddingCancellation = true;
+	modelName;
+	config;
+	env;
+	constructor(modelName, options = {}) {
+		this.modelName = modelName;
+		this.config = options.config || {};
+		this.env = options.env;
+	}
+	/**
+	* Helper method to get Google client with credentials support
+	*/
+	async getClientWithCredentials() {
+		const { client } = await getGoogleClient(getVertexClientOptions(this));
+		return client;
+	}
+	id() {
+		return `vertex:${this.modelName}`;
+	}
+	getRegion() {
+		if (this.usesEmbedContent()) return GoogleAuthManager.resolveRegion(this.config, this.env, void 0, "global");
+		return GoogleAuthManager.resolveRegion(this.config, this.env);
+	}
+	usesEmbedContent() {
+		return /^gemini-embedding-2(?:$|-)/.test(this.modelName);
+	}
+	getApiVersion() {
+		return this.config.apiVersion || "v1";
+	}
+	getApiHost() {
+		return getVertexApiHost(this.getRegion(), this.config.apiHost, this.env);
+	}
+	async getProjectId() {
+		return await resolveProjectId(this.config, this.env);
+	}
+	async callApi() {
+		throw new Error("Vertex API does not provide text inference.");
+	}
+	async callEmbeddingApi(input, _context, options) {
+		const abortSignal = options?.abortSignal;
+		abortSignal?.throwIfAborted();
+		const embedContent = this.usesEmbedContent();
+		if (embedContent) {
+			for (const key of [
+				"taskType",
+				"title",
+				"autoTruncate"
+			]) if (this.config[key] !== void 0) throw new Error(`${this.modelName} does not support ${key}. Use instructions in the input text for embedding tasks.`);
+		}
+		const dimensions = this.config.outputDimensionality;
+		const body = embedContent ? {
+			content: { parts: [{ text: input }] },
+			...dimensions !== void 0 && { embedContentConfig: { outputDimensionality: dimensions } }
+		} : {
+			instances: [{
+				content: input,
+				...this.config.taskType !== void 0 && { task_type: this.config.taskType },
+				...this.config.title !== void 0 && { title: this.config.title }
+			}],
+			parameters: {
+				autoTruncate: this.config.autoTruncate ?? false,
+				...dimensions !== void 0 && { outputDimensionality: dimensions }
+			}
+		};
+		let data = {};
+		try {
+			const client = await waitForPromiseWithAbort(this.getClientWithCredentials(), abortSignal);
+			const projectId = await waitForPromiseWithAbort(this.getProjectId(), abortSignal);
+			const url = `https://${this.getApiHost()}/${this.getApiVersion()}/projects/${projectId}/locations/${this.getRegion()}/publishers/google/models/${this.modelName}:${embedContent ? "embedContent" : "predict"}`;
+			data = (await waitForPromiseWithAbort(client.request({
+				url,
+				method: "POST",
+				data: body,
+				timeout: client.transporter.defaults.timeout ?? getRequestTimeoutMs(),
+				...abortSignal && {
+					signal: abortSignal,
+					adapter: ((requestOptions, defaultAdapter) => {
+						abortSignal.throwIfAborted();
+						requestOptions.signal = requestOptions.signal ? AbortSignal.any([abortSignal, requestOptions.signal]) : abortSignal;
+						const adapter = client.transporter.defaults.adapter;
+						return adapter ? adapter(requestOptions, defaultAdapter) : defaultAdapter(requestOptions);
+					})
+				}
+			}), abortSignal)).data;
+		} catch (err) {
+			abortSignal?.throwIfAborted();
+			logger.error(`Vertex API call error: ${err}`);
+			throw err;
+		}
+		logger.debug(`Vertex embeddings API response: ${JSON.stringify(data)}`);
+		const embeddingData = (data.predictions?.[0])?.embeddings;
+		const values = embedContent ? data.embedding?.values : embeddingData?.values;
+		if (!values?.length) {
+			const errorMsg = `No valid embeddings returned from API: ${JSON.stringify(data)}`;
+			logger.error(errorMsg);
+			throw new Error(errorMsg);
+		}
+		const promptTokens = embedContent ? data.usageMetadata?.promptTokenCount : void 0;
+		return {
+			embedding: values,
+			...embedContent && { cost: promptTokens === void 0 ? void 0 : calculateGoogleCost(this.modelName, this.config, promptTokens, 0, true) },
+			tokenUsage: {
+				...embedContent && { prompt: promptTokens },
+				total: embedContent ? data.usageMetadata?.totalTokenCount ?? data.usageMetadata?.promptTokenCount : embeddingData?.statistics?.token_count ?? 0,
+				numRequests: 1
+			}
+		};
+	}
+};
+const DEFAULT_VERTEX_MODEL = "gemini-3.8-flash";
+const DEFAULT_VERTEX_REGION = "global";
+const DEFAULT_VERTEX_EMBEDDING_MODEL = "gemini-embedding-001";
+function getGoogleVertexEmbeddingProvider(env) {
+	return new VertexEmbeddingProvider(DEFAULT_VERTEX_EMBEDDING_MODEL, { env });
+}
+function getGoogleVertexProviders(env) {
+	const gradingProvider = new VertexChatProvider(DEFAULT_VERTEX_MODEL, {
+		env,
+		config: { region: DEFAULT_VERTEX_REGION }
+	});
+	return {
+		embeddingProvider: getGoogleVertexEmbeddingProvider(env),
+		gradingJsonProvider: gradingProvider,
+		gradingProvider,
+		suggestionsProvider: gradingProvider,
+		synthesizeProvider: gradingProvider
+	};
+}
+//#endregion
+export { getGoogleVertexProviders as n, vertex_exports as r, getGoogleVertexEmbeddingProvider as t };
+
+//# sourceMappingURL=vertex-CBAMfRz3.js.map