promptfoo 0.125.0 → 0.125.1

package/dist/src/interactions-CND010Lh.cjs

@@ -0,0 +1,850 @@
+const require_logger = require("./logger-DXUHJBHJ.cjs");
+const require_fetch = require("./fetch-BKlgUg08.cjs");
+const require_shared = require("./shared-D9Bf3UgD.cjs");
+const require_time = require("./time-CY7bOv6D.cjs");
+const require_render = require("./render-j-UNQw7s.cjs");
+const require_env = require("./env-PwgLIVUT.cjs");
+const require_credentials = require("./credentials-CFfK32uY.cjs");
+const require_cache = require("./cache-iG87oYan.cjs");
+const require_blobs = require("./blobs-CwaJ7l1g.cjs");
+const require_util = require("./util-Df7rfMGb.cjs");
+//#region src/providers/google/interactions.ts
+function normalizeAudioMimeType(format) {
+	if (format?.startsWith("audio/")) return format;
+	if (format === "mp3") return "audio/mpeg";
+	if (format === "pcm16") return "audio/pcm";
+	return `audio/${format || "mpeg"}`;
+}
+function getInteractionText(value) {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.flatMap(getInteractionText);
+	if (!value || typeof value !== "object") return [];
+	const record = value;
+	if (typeof record.text === "string") return [record.text];
+	return getInteractionText(record.content ?? record.parts);
+}
+function parseInteractionInput(prompt, extractSystemInstructions) {
+	try {
+		const parsedPrompt = JSON.parse(prompt);
+		const promptEnvelope = parsedPrompt && typeof parsedPrompt === "object" && !Array.isArray(parsedPrompt) ? parsedPrompt : void 0;
+		const envelopeSystemInstruction = getInteractionText(promptEnvelope?.system_instruction ?? promptEnvelope?.systemInstruction);
+		const parsed = parsedPrompt && typeof parsedPrompt === "object" && !Array.isArray(parsedPrompt) && Array.isArray(parsedPrompt.contents) ? parsedPrompt.contents : parsedPrompt;
+		if (Array.isArray(parsed)) {
+			const systemInstructions = [...envelopeSystemInstruction];
+			const input = parsed.flatMap((content) => {
+				if (!content || typeof content !== "object") return [content];
+				const normalizePart = (part) => {
+					if (!part || typeof part !== "object") return part;
+					if (!("type" in part)) {
+						const geminiPart = part;
+						if (typeof geminiPart.text === "string") return {
+							type: "text",
+							text: geminiPart.text
+						};
+						const inlineData = geminiPart.inlineData || geminiPart.inline_data;
+						const mimeType = geminiPart.inlineData?.mimeType || geminiPart.inline_data?.mime_type || geminiPart.fileData?.mimeType || geminiPart.file_data?.mime_type;
+						if (mimeType) {
+							const type = mimeType.startsWith("video/") ? "video" : mimeType.startsWith("audio/") ? "audio" : "image";
+							return inlineData ? {
+								type,
+								mime_type: mimeType,
+								data: inlineData.data
+							} : {
+								type,
+								mime_type: mimeType,
+								uri: geminiPart.fileData?.fileUri || geminiPart.file_data?.file_uri
+							};
+						}
+						return part;
+					}
+					const imagePart = part;
+					if (imagePart.type === "input_text") return {
+						...imagePart,
+						type: "text"
+					};
+					if (imagePart.type === "input_audio") {
+						const inputAudio = part.input_audio;
+						if (inputAudio?.data) return {
+							type: "audio",
+							mime_type: normalizeAudioMimeType(inputAudio.format?.toLowerCase()),
+							data: inputAudio.data
+						};
+					}
+					if (imagePart.type !== "image_url" && imagePart.type !== "input_image") return part;
+					const imageUrl = typeof imagePart.image_url === "string" ? imagePart.image_url : imagePart.image_url?.url;
+					if (!imageUrl) return part;
+					const inlineImage = /^data:([^;,]+);base64,(.*)$/is.exec(imageUrl);
+					return inlineImage ? {
+						type: "image",
+						mime_type: inlineImage[1],
+						data: inlineImage[2]
+					} : {
+						type: "image",
+						uri: imageUrl
+					};
+				};
+				if (!("role" in content)) return [normalizePart(content)];
+				const { role, content: messageContent, parts, ...message } = content;
+				const interactionContent = messageContent ?? parts;
+				if (role === "system" && extractSystemInstructions) {
+					systemInstructions.push(...getInteractionText(interactionContent));
+					return [];
+				}
+				const normalizedContent = Array.isArray(interactionContent) ? interactionContent.map((part) => normalizePart(part)) : typeof interactionContent === "string" ? [{
+					type: "text",
+					text: interactionContent
+				}] : interactionContent && typeof interactionContent === "object" ? [normalizePart(interactionContent)] : [];
+				return [{
+					...message,
+					type: role === "assistant" || role === "model" ? "model_output" : "user_input",
+					content: normalizedContent
+				}];
+			});
+			if (input.length === 0 && systemInstructions.length > 0) return {
+				input: [{
+					type: "user_input",
+					content: systemInstructions.map((text) => ({
+						type: "text",
+						text
+					}))
+				}],
+				hasSystemInstruction: true
+			};
+			return {
+				input,
+				...systemInstructions.length > 0 ? {
+					systemInstruction: systemInstructions.join("\n"),
+					hasSystemInstruction: true
+				} : {}
+			};
+		}
+		return {
+			input: parsed && typeof parsed === "object" ? parsed : prompt,
+			...envelopeSystemInstruction.length > 0 ? {
+				systemInstruction: envelopeSystemInstruction.join("\n"),
+				hasSystemInstruction: true
+			} : {}
+		};
+	} catch {
+		return { input: prompt };
+	}
+}
+const INTERACTION_INPUT_METADATA_FIELDS = /* @__PURE__ */ new Set([
+	"mime_type",
+	"mimeType",
+	"role",
+	"type"
+]);
+function hasSemanticInteractionInput(value) {
+	if (typeof value === "string") return value.trim().length > 0;
+	if (Array.isArray(value)) return value.some(hasSemanticInteractionInput);
+	if (value && typeof value === "object") return Object.entries(value).some(([field, nestedValue]) => !INTERACTION_INPUT_METADATA_FIELDS.has(field) && hasSemanticInteractionInput(nestedValue));
+	return value !== null && value !== void 0;
+}
+function getLiveOnlyModelRouteError(modelName) {
+	if (modelName === "gemini-3.5-live-translate-preview" || modelName.startsWith("gemini-robotics-er-2-streaming-")) return `Model "${modelName}" requires the Gemini Live API. Use google:live:${modelName}.`;
+}
+const INTERACTION_GENERATION_FIELDS = /* @__PURE__ */ new Set([
+	"max_output_tokens",
+	"seed",
+	"stop_sequences",
+	"thinking_level",
+	"thinking_summaries",
+	"tool_choice",
+	"transcription_config",
+	"video_config"
+]);
+const INTERACTION_GENERATION_ALIASES = {
+	maxOutputTokens: "max_output_tokens",
+	stopSequences: "stop_sequences",
+	thinkingLevel: "thinking_level",
+	thinkingSummaries: "thinking_summaries",
+	topP: "top_p",
+	toolChoice: "tool_choice",
+	transcriptionConfig: "transcription_config",
+	videoConfig: "video_config"
+};
+const INTERACTION_SAMPLING_FIELDS = /* @__PURE__ */ new Set(["temperature", "top_p"]);
+const INTERACTION_TOP_LEVEL_GENERATION_FIELDS = /* @__PURE__ */ new Set([
+	...INTERACTION_GENERATION_FIELDS,
+	...Object.keys(INTERACTION_GENERATION_ALIASES),
+	"temperature",
+	"top_p",
+	"topP",
+	"top_k",
+	"topK",
+	"thinkingConfig",
+	"thinking_config",
+	"thinkingBudget",
+	"thinking_budget",
+	"negative_prompt",
+	"negativePrompt",
+	"responseMimeType",
+	"response_mime_type",
+	"responseSchema",
+	"response_schema"
+]);
+function normalizeInteractionThinkingLevel(value) {
+	return typeof value === "string" ? value.toLowerCase() : value;
+}
+function hasInteractionThinkingLevel(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const config = value;
+	return [config.thinkingConfig, config.thinking_config].some((thinkingConfig) => {
+		if (!thinkingConfig || typeof thinkingConfig !== "object" || Array.isArray(thinkingConfig)) return false;
+		const nestedConfig = thinkingConfig;
+		return nestedConfig.thinkingLevel !== void 0 || nestedConfig.thinking_level !== void 0;
+	}) || config.thinkingLevel !== void 0 || config.thinking_level !== void 0;
+}
+function shouldRejectInteractionThinkingBudget(value, ignoreNumericThinkingBudget) {
+	return typeof value === "number" && !ignoreNumericThinkingBudget;
+}
+function isSupportedInteractionGenerationField(field, allowSamplingControls) {
+	return INTERACTION_GENERATION_FIELDS.has(field) || allowSamplingControls && INTERACTION_SAMPLING_FIELDS.has(field);
+}
+function normalizeInteractionGenerationConfig(value, allowSamplingControls = false, ignoreNumericThinkingBudget = false) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return { config: {} };
+	const config = {};
+	for (const [field, fieldValue] of Object.entries(value)) {
+		if (field === "thinkingConfig" || field === "thinking_config") {
+			if (!fieldValue || typeof fieldValue !== "object" || Array.isArray(fieldValue)) continue;
+			const thinkingConfig = fieldValue;
+			if (shouldRejectInteractionThinkingBudget(thinkingConfig.thinkingBudget ?? thinkingConfig.thinking_budget, ignoreNumericThinkingBudget)) return {
+				config: {},
+				error: "Gemini Interactions generation_config does not support numeric thinkingBudget; use thinkingConfig.thinkingLevel instead."
+			};
+			const thinkingLevel = thinkingConfig.thinkingLevel ?? thinkingConfig.thinking_level;
+			if (thinkingLevel !== void 0) config.thinking_level = normalizeInteractionThinkingLevel(thinkingLevel);
+			continue;
+		}
+		if (field === "thinkingBudget" || field === "thinking_budget") {
+			if (shouldRejectInteractionThinkingBudget(fieldValue, ignoreNumericThinkingBudget)) return {
+				config: {},
+				error: "Gemini Interactions generation_config does not support numeric thinkingBudget; use thinking_level instead."
+			};
+			continue;
+		}
+		const normalizedField = INTERACTION_GENERATION_ALIASES[field] || field;
+		if (!isSupportedInteractionGenerationField(normalizedField, allowSamplingControls) || fieldValue === void 0) continue;
+		config[normalizedField] = normalizedField === "thinking_level" ? normalizeInteractionThinkingLevel(fieldValue) : fieldValue;
+	}
+	return { config };
+}
+function normalizeInteractionGenerationLayers(layers, allowSamplingControls = false) {
+	const hasLaterThinkingLevel = new Array(layers.length);
+	let laterThinkingLevelFound = false;
+	for (let index = layers.length - 1; index >= 0; index--) {
+		hasLaterThinkingLevel[index] = laterThinkingLevelFound;
+		laterThinkingLevelFound ||= hasInteractionThinkingLevel(layers[index]);
+	}
+	const config = {};
+	for (const [index, layer] of layers.entries()) {
+		const normalizedLayer = normalizeInteractionGenerationConfig(layer, allowSamplingControls, hasLaterThinkingLevel[index] ?? false);
+		if (normalizedLayer.error) return normalizedLayer;
+		Object.assign(config, normalizedLayer.config);
+	}
+	return { config };
+}
+function normalizeInteractionServiceTier(value) {
+	return value === "flex" || value === "standard" || value === "priority" ? value : void 0;
+}
+function resolveInteractionStructuredOutput(layers) {
+	let legacyMimeType;
+	let legacyResponseSchema;
+	for (const layer of layers) {
+		let layerMimeType;
+		let layerResponseSchema;
+		for (const generationConfig of layer.generationConfigs) {
+			if (!generationConfig || typeof generationConfig !== "object" || Array.isArray(generationConfig)) continue;
+			const config = generationConfig;
+			const responseMimeType = config.response_mime_type ?? config.responseMimeType;
+			const responseSchemaValue = config.response_schema ?? config.responseSchema;
+			if (responseMimeType !== void 0) layerMimeType = responseMimeType;
+			if (responseSchemaValue !== void 0) layerResponseSchema = responseSchemaValue;
+		}
+		if (layer.responseSchema !== void 0 && layerResponseSchema !== void 0) throw new Error("`responseSchema` provided but `generationConfig.response_schema` already set.");
+		if (layerMimeType !== void 0) legacyMimeType = layerMimeType;
+		const resolvedLayerSchema = layer.responseSchema ?? layerResponseSchema;
+		if (resolvedLayerSchema !== void 0) legacyResponseSchema = resolvedLayerSchema;
+	}
+	return {
+		...typeof legacyMimeType === "string" ? { mimeType: legacyMimeType } : {},
+		...legacyResponseSchema === void 0 ? {} : { responseSchema: legacyResponseSchema }
+	};
+}
+function normalizeInteractionSafetySettings(safetySettings) {
+	return safetySettings.map(({ category, threshold, probability }) => ({
+		type: category.replace(/^HARM_CATEGORY_/i, "").toLowerCase(),
+		...threshold || probability ? { threshold: (threshold || probability)?.toLowerCase() } : {}
+	}));
+}
+function calculateExplicitInteractionCost(config, promptTokens, completionTokens, audioPromptTokens, audioCompletionTokens, videoCompletionTokens, imagePromptTokens) {
+	const inputCost = config.inputCost ?? config.cost;
+	const outputCost = config.outputCost ?? config.cost;
+	const audioInput = Math.max(0, Math.min(audioPromptTokens, promptTokens));
+	const imageInput = Math.max(0, Math.min(imagePromptTokens, promptTokens - audioInput));
+	const audioOutput = Math.max(0, Math.min(audioCompletionTokens, completionTokens));
+	const videoOutput = Math.max(0, Math.min(videoCompletionTokens, completionTokens - audioOutput));
+	const charges = [
+		[promptTokens - audioInput - imageInput, inputCost],
+		[audioInput, config.audioInputCost ?? config.audioCost ?? inputCost],
+		[imageInput, config.imageInputCost ?? inputCost],
+		[completionTokens - audioOutput - videoOutput, outputCost],
+		[audioOutput, config.audioOutputCost ?? config.audioCost ?? outputCost],
+		[videoOutput, config.videoOutputCost ?? outputCost]
+	];
+	if (!charges.some(([, rate]) => rate !== void 0) || charges.some(([tokens, rate]) => !Number.isFinite(tokens) || tokens < 0 || tokens > 0 && (rate === void 0 || !Number.isFinite(rate)))) return;
+	return charges.reduce((total, [tokens, rate]) => total + tokens * (rate ?? 0), 0);
+}
+function getInteractionModalityTokenCount(details, modalities) {
+	return (details || []).filter((detail) => modalities.includes(detail.modality?.toLowerCase() || "")).reduce((total, detail) => total + Math.max(detail.tokens ?? 0, 0), 0);
+}
+function getModelOutputContent(data) {
+	const steps = data.steps || [];
+	const latestUserInput = steps.map((step) => step.type).lastIndexOf("user_input");
+	const latestToolStep = steps.map((step) => step.type?.endsWith("_call") || step.type?.endsWith("_result")).lastIndexOf(true);
+	return steps.slice(Math.max(latestUserInput, latestToolStep) + 1).filter((step) => step.type === "model_output").flatMap((step) => step.content || []);
+}
+function getInteractionAnnotationExcerpt(text, startIndex, endIndex) {
+	if (typeof text !== "string" || !Number.isInteger(startIndex) || !Number.isInteger(endIndex) || startIndex < 0 || endIndex < startIndex) return "";
+	const bytes = Buffer.from(text, "utf8");
+	if (endIndex > bytes.length) return "";
+	return bytes.subarray(startIndex, endIndex).toString("utf8").trim();
+}
+function getTrimmedString(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+function normalizeInteractionCitation(annotation, text) {
+	if (!annotation || typeof annotation !== "object") return [];
+	const record = annotation;
+	const excerpt = getInteractionAnnotationExcerpt(text, record.start_index ?? record.startIndex, record.end_index ?? record.endIndex);
+	if (record.type === "url_citation") {
+		const url = getTrimmedString(record.url);
+		if (!/^https?:\/\//i.test(url)) return [];
+		return [{
+			url,
+			content: [getTrimmedString(record.title), excerpt].filter(Boolean).join(": ") || url
+		}];
+	}
+	if (record.type === "file_citation") {
+		const source = [
+			record.document_uri,
+			record.source,
+			record.file_name,
+			record.media_id
+		].map(getTrimmedString).find(Boolean);
+		if (!source) return [];
+		const fileName = getTrimmedString(record.file_name);
+		const page = Number.isInteger(record.page_number) ? ` (page ${record.page_number})` : "";
+		return [{
+			source,
+			content: [`${fileName || source}${page}`, excerpt].filter(Boolean).join(": ") || source
+		}];
+	}
+	if (record.type === "place_citation") {
+		const url = getTrimmedString(record.url);
+		const name = getTrimmedString(record.name);
+		const placeId = getTrimmedString(record.place_id);
+		const source = url || placeId || name;
+		if (!source) return [];
+		return [{
+			...url ? { url } : { source },
+			content: [name, excerpt].filter(Boolean).join(": ") || source
+		}];
+	}
+	return [];
+}
+function getInteractionGroundingMetadata(data, outputContent) {
+	const annotations = outputContent.flatMap((part) => Array.isArray(part.annotations) ? part.annotations : []);
+	const citations = outputContent.flatMap((part) => {
+		if (!Array.isArray(part.annotations)) return [];
+		return part.annotations.flatMap((annotation) => normalizeInteractionCitation(annotation, part.text));
+	});
+	const steps = data.steps || [];
+	const latestUserInput = steps.map((step) => step.type).lastIndexOf("user_input");
+	const latestSteps = steps.slice(latestUserInput + 1);
+	const interactionToolCalls = latestSteps.filter((step) => step.type?.endsWith("_call"));
+	const interactionToolResults = latestSteps.filter((step) => step.type?.endsWith("_result"));
+	return {
+		...annotations.length > 0 ? { annotations } : {},
+		...citations.length > 0 ? { citations } : {},
+		...interactionToolCalls.length > 0 ? { interactionToolCalls } : {},
+		...interactionToolResults.length > 0 ? { interactionToolResults } : {}
+	};
+}
+function getInteractionsEndpoint(config, env) {
+	const endpointFromHost = (apiHost) => {
+		return `${(/^https?:\/\//i.test(apiHost) ? apiHost : `https://${apiHost}`).replace(/\/$/, "")}/v1beta/interactions`;
+	};
+	if (config.apiHost) return endpointFromHost(config.apiHost);
+	if (config.apiBaseUrl) return `${config.apiBaseUrl.replace(/\/$/, "")}/v1beta/interactions`;
+	const endpoint = require_env.resolveProviderEnv(env, [
+		"GOOGLE_API_HOST",
+		"PALM_API_HOST",
+		"GOOGLE_API_BASE_URL"
+	]);
+	if (endpoint?.name === "GOOGLE_API_BASE_URL") return `${endpoint.value.replace(/\/$/, "")}/v1beta/interactions`;
+	if (endpoint) return endpointFromHost(endpoint.value);
+	return "https://generativelanguage.googleapis.com/v1beta/interactions";
+}
+function getVertexInteractionsRegion(config, env) {
+	return config.region || require_env.resolveProviderEnv(env, ["VERTEX_REGION", "GOOGLE_CLOUD_LOCATION"])?.value || "global";
+}
+function getVertexInteractionsEndpoint(config, projectId, env) {
+	const region = getVertexInteractionsRegion(config, env);
+	const configuredHost = config.apiBaseUrl || config.apiHost || require_env.resolveProviderEnv(env, ["VERTEX_API_HOST"])?.value || (region === "global" ? "aiplatform.googleapis.com" : `${region}-aiplatform.googleapis.com`);
+	return `${(/^https?:\/\//i.test(configuredHost) ? configuredHost : `https://${configuredHost}`).replace(/\/$/, "")}/v1beta1/projects/${encodeURIComponent(projectId)}/locations/${encodeURIComponent(region)}/interactions`;
+}
+function getVertexExpressInteractionsEndpoint(config, env) {
+	const configuredHost = config.apiBaseUrl || config.apiHost || require_env.resolveProviderEnv(env, ["VERTEX_API_HOST"])?.value || "aiplatform.googleapis.com";
+	return `${(/^https?:\/\//i.test(configuredHost) ? configuredHost : `https://${configuredHost}`).replace(/\/$/, "")}/v1beta1/interactions`;
+}
+function getVertexInteractionsApiKey(config, env) {
+	return require_util.GoogleAuthManager.getApiKey(config, env, true).apiKey;
+}
+function usesVertexExpressInteractions(config, env, apiKey) {
+	const hasOAuthConfig = Boolean(config.credentials || config.keyFilename || config.googleAuthOptions?.keyFilename || config.googleAuthOptions?.keyFile || config.googleAuthOptions?.authClient || config.googleAuthOptions?.credentials);
+	const providerScopedRegion = config.region || env?.VERTEX_REGION || env?.GOOGLE_CLOUD_LOCATION;
+	const hasProviderScopedOAuthConfig = Boolean(config.projectId || config.googleAuthOptions?.projectId || env?.VERTEX_PROJECT_ID || env?.GOOGLE_PROJECT_ID || env?.GOOGLE_CLOUD_PROJECT || providerScopedRegion && providerScopedRegion !== "global");
+	const explicitlyRequestedExpress = config.expressMode === true || Boolean(config.apiKey) || Boolean(env?.VERTEX_API_KEY) && !hasProviderScopedOAuthConfig;
+	const effectiveRegion = config.region || require_env.resolveProviderEnv(env, ["VERTEX_REGION", "GOOGLE_CLOUD_LOCATION"])?.value;
+	const hasProjectScopedOAuthConfig = Boolean(config.projectId || config.googleAuthOptions?.projectId || require_env.resolveProviderEnv(env, [
+		"VERTEX_PROJECT_ID",
+		"GOOGLE_PROJECT_ID",
+		"GOOGLE_CLOUD_PROJECT"
+	])?.value || effectiveRegion && effectiveRegion !== "global");
+	return Boolean(apiKey) && config.expressMode !== false && !hasOAuthConfig && (explicitlyRequestedExpress || !hasProjectScopedOAuthConfig);
+}
+function mergeGoogleInteractionsRequestConfig(providerConfig, promptConfig) {
+	return {
+		...require_util.mergeGoogleCompletionOptions(providerConfig, promptConfig),
+		apiKey: providerConfig.apiKey,
+		apiHost: providerConfig.apiHost,
+		apiBaseUrl: providerConfig.apiBaseUrl,
+		headers: providerConfig.headers,
+		projectId: providerConfig.projectId,
+		region: providerConfig.region,
+		publisher: providerConfig.publisher,
+		apiVersion: providerConfig.apiVersion,
+		credentials: providerConfig.credentials,
+		expressMode: providerConfig.expressMode,
+		googleAuthOptions: providerConfig.googleAuthOptions,
+		keyFilename: providerConfig.keyFilename,
+		scopes: providerConfig.scopes,
+		vertexai: providerConfig.vertexai,
+		strictMutualExclusivity: providerConfig.strictMutualExclusivity
+	};
+}
+var GoogleInteractionsProvider = class {
+	modelName;
+	config;
+	env;
+	providerId;
+	constructor(modelName, options = {}) {
+		this.modelName = modelName;
+		this.config = options.config || {};
+		this.env = options.env;
+		this.providerId = options.id;
+		require_util.GoogleAuthManager.validateAndWarn(this.config, this.env);
+	}
+	id() {
+		return this.providerId || `google:${this.modelName}`;
+	}
+	toString() {
+		return `[Google Interactions Provider ${this.modelName}]`;
+	}
+	async callApi(prompt, context) {
+		const promptConfig = context?.prompt?.config;
+		const config = mergeGoogleInteractionsRequestConfig(this.config, promptConfig);
+		if (this.modelName === "gemini-omni-1.1-flash") config.vertexai = false;
+		const { toolsDisabled } = require_util.resolveGoogleToolConfig(config);
+		const promptBasePath = promptConfig?.basePath ?? this.config.basePath;
+		const providerPassthrough = this.config.passthrough || {};
+		const promptPassthrough = promptConfig?.passthrough || {};
+		const mergedPassthrough = {
+			...providerPassthrough,
+			...promptPassthrough
+		};
+		const passthroughModel = promptPassthrough.model ?? providerPassthrough.model;
+		const effectiveModel = typeof passthroughModel === "string" ? passthroughModel : this.modelName;
+		const routeError = getLiveOnlyModelRouteError(effectiveModel);
+		if (routeError) return { error: routeError };
+		const hasCatalogModel = require_util.GOOGLE_MODELS.some((model) => model.id === effectiveModel);
+		const capabilityModel = hasCatalogModel ? effectiveModel : this.modelName;
+		const isVideoModel = [
+			"gemini-omni-flash-preview",
+			"gemini-omni-1.1-flash",
+			"gemini-omni-1.1-flash-preview"
+		].includes(capabilityModel);
+		const allowSamplingControls = config.vertexai && isVideoModel;
+		const { input: interactionInput, systemInstruction: promptSystemInstruction, hasSystemInstruction: hasPromptSystemInstruction } = parseInteractionInput(prompt, !isVideoModel);
+		const requestInput = promptPassthrough.input ?? providerPassthrough.input ?? (config.vertexai && typeof interactionInput === "string" ? [{
+			type: "text",
+			text: interactionInput
+		}] : interactionInput);
+		if (!hasSemanticInteractionInput(requestInput)) return { error: "Gemini Interactions prompt must contain at least one input item." };
+		const previousInteractionId = promptPassthrough.previous_interaction_id ?? promptPassthrough.previousInteractionId ?? promptConfig?.previousInteractionId ?? providerPassthrough.previous_interaction_id ?? providerPassthrough.previousInteractionId ?? this.config.previousInteractionId;
+		const providerPassthroughResponseFormat = providerPassthrough.response_format ?? providerPassthrough.responseFormat;
+		const promptPassthroughResponseFormat = promptPassthrough.response_format ?? promptPassthrough.responseFormat;
+		const providerPassthroughSystemInstruction = providerPassthrough.system_instruction ?? providerPassthrough.systemInstruction;
+		const passthroughSystemInstruction = promptPassthrough.system_instruction ?? promptPassthrough.systemInstruction ?? (promptConfig?.systemInstruction === void 0 && !hasPromptSystemInstruction ? providerPassthroughSystemInstruction : void 0);
+		const interactionConfigTools = toolsDisabled ? void 0 : config.tools;
+		const hasConfigTools = Array.isArray(interactionConfigTools) ? interactionConfigTools.length > 0 : Boolean(interactionConfigTools);
+		const interactionTools = toolsDisabled ? void 0 : mergedPassthrough.tools;
+		const hasPassthroughTools = Array.isArray(interactionTools) ? interactionTools.length > 0 : Boolean(interactionTools);
+		const hasClientExecutedTools = Array.isArray(interactionTools) ? interactionTools.some((tool) => tool !== null && typeof tool === "object" && !Array.isArray(tool) && ["function", "computer_use"].includes(String(tool.type))) : false;
+		const hasMcpTools = !toolsDisabled && config.mcp?.enabled === true;
+		if (config.vertexai && isVideoModel && previousInteractionId) return { error: "Gemini Omni on Vertex AI does not support previousInteractionId. Use the Google AI Studio route for conversational video editing." };
+		if (isVideoModel && (hasConfigTools || hasPassthroughTools || hasMcpTools)) return { error: "Gemini Omni Flash does not support tools, including grounding, code execution, or function calling." };
+		if (!isVideoModel && (hasConfigTools || hasMcpTools)) return { error: "Gemini Interactions models require Interactions-native tool declarations in config.passthrough.tools; generateContent-style config.tools and MCP tools are not supported on this route." };
+		if (!isVideoModel && hasClientExecutedTools) return { error: "Gemini Interactions custom function and computer-use tools are not supported because Promptfoo does not yet handle requires_action responses. Use managed built-in tools in config.passthrough.tools." };
+		let apiKey;
+		let endpoint;
+		let headers;
+		const rawVertexApiKey = config.vertexai ? getVertexInteractionsApiKey(config, this.env) : void 0;
+		const vertexApiKey = rawVertexApiKey ? require_render.getNunjucksEngine().renderString(rawVertexApiKey, {}) : void 0;
+		if (config.vertexai && vertexApiKey && usesVertexExpressInteractions(config, this.env, vertexApiKey)) {
+			const region = getVertexInteractionsRegion(config, this.env);
+			if (region !== "global") return { error: `Vertex Express Interactions supports only the global endpoint, but region ${region} was configured. Set expressMode: false and use OAuth or Application Default Credentials for a regional endpoint.` };
+			apiKey = vertexApiKey;
+			endpoint = getVertexExpressInteractionsEndpoint(config, this.env);
+			headers = {
+				"Content-Type": "application/json",
+				"Api-Revision": "2026-05-20",
+				"x-goog-api-key": vertexApiKey,
+				...config.headers
+			};
+		} else if (config.vertexai) try {
+			const { client, projectId: authProjectId } = await require_util.GoogleAuthManager.getOAuthClient({
+				credentials: config.credentials,
+				googleAuthOptions: config.googleAuthOptions,
+				keyFilename: config.keyFilename,
+				scopes: config.scopes
+			});
+			const projectId = config.projectId || require_env.resolveProviderEnv(this.env, [
+				"VERTEX_PROJECT_ID",
+				"GOOGLE_PROJECT_ID",
+				"GOOGLE_CLOUD_PROJECT"
+			])?.value || authProjectId;
+			if (!projectId) return { error: "Gemini Interactions on Vertex AI requires a project ID. Set GOOGLE_CLOUD_PROJECT or add projectId to the provider config." };
+			const accessToken = await client.getAccessToken();
+			const token = typeof accessToken === "string" ? accessToken : accessToken?.token;
+			if (!token) return { error: "Gemini Interactions on Vertex AI could not obtain an OAuth access token." };
+			endpoint = getVertexInteractionsEndpoint(config, projectId, this.env);
+			const { authorization, ...authHeaders } = typeof client.getRequestHeaders === "function" ? Object.fromEntries((await client.getRequestHeaders(endpoint)).entries()) : {};
+			headers = {
+				"Content-Type": "application/json",
+				"Api-Revision": "2026-05-20",
+				Authorization: authorization || `Bearer ${token}`,
+				...authHeaders,
+				...config.headers
+			};
+		} catch (err) {
+			return { error: `Gemini Interactions on Vertex AI authentication error: ${String(err)}` };
+		}
+		else {
+			const rawApiKey = require_credentials.resolveProviderApiKey({ apiKey: config.apiKey }, this.env, [
+				"GOOGLE_API_KEY",
+				"GEMINI_API_KEY",
+				"PALM_API_KEY",
+				"GOOGLE_GENERATIVE_AI_API_KEY"
+			]);
+			apiKey = rawApiKey ? require_render.getNunjucksEngine().renderString(rawApiKey, {}) : void 0;
+			if (!apiKey) return { error: "Gemini Interactions API requires an API key. Set GOOGLE_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, GEMINI_API_KEY, or PALM_API_KEY, or add apiKey to the provider config." };
+			endpoint = getInteractionsEndpoint(config, this.env);
+			headers = {
+				"Content-Type": "application/json",
+				"Api-Revision": "2026-05-20",
+				"x-goog-api-key": apiKey,
+				...config.headers
+			};
+		}
+		const providerGenerationConfigValue = {
+			...this.config.maxOutputTokens === void 0 ? {} : { max_output_tokens: this.config.maxOutputTokens },
+			...allowSamplingControls && this.config.temperature !== void 0 ? { temperature: this.config.temperature } : {},
+			...allowSamplingControls && this.config.topP !== void 0 ? { top_p: this.config.topP } : {},
+			...this.config.stopSequences === void 0 ? {} : { stop_sequences: this.config.stopSequences },
+			...this.config.seed === void 0 ? {} : { seed: this.config.seed },
+			...this.config.generationConfig || {}
+		};
+		const promptToolMode = require_util.resolveGoogleToolConfig(promptConfig || {}).toolConfig?.functionCallingConfig?.mode;
+		const promptGenerationConfigValue = {
+			...promptConfig?.maxOutputTokens === void 0 ? {} : { max_output_tokens: promptConfig.maxOutputTokens },
+			...allowSamplingControls && promptConfig?.temperature !== void 0 ? { temperature: promptConfig.temperature } : {},
+			...allowSamplingControls && promptConfig?.topP !== void 0 ? { top_p: promptConfig.topP } : {},
+			...promptConfig?.stopSequences === void 0 ? {} : { stop_sequences: promptConfig.stopSequences },
+			...promptConfig?.seed === void 0 ? {} : { seed: promptConfig.seed },
+			...!isVideoModel && promptToolMode === "AUTO" ? { tool_choice: "auto" } : {},
+			...promptConfig?.generationConfig || {}
+		};
+		const normalizedGenerationConfig = normalizeInteractionGenerationLayers([
+			providerGenerationConfigValue,
+			providerPassthrough.generationConfig,
+			providerPassthrough.generation_config,
+			promptGenerationConfigValue,
+			promptPassthrough.generationConfig,
+			promptPassthrough.generation_config
+		], allowSamplingControls);
+		if (normalizedGenerationConfig.error) return { error: normalizedGenerationConfig.error };
+		if (isVideoModel) delete normalizedGenerationConfig.config.stop_sequences;
+		const generationConfig = {
+			...normalizedGenerationConfig.config,
+			...!isVideoModel && toolsDisabled ? { tool_choice: "none" } : {}
+		};
+		const providerServiceTier = providerPassthrough.service_tier ?? providerPassthrough.serviceTier ?? this.config.service_tier;
+		const rawServiceTier = promptPassthrough.service_tier ?? promptPassthrough.serviceTier ?? promptConfig?.service_tier ?? providerServiceTier;
+		const serviceTier = normalizeInteractionServiceTier(rawServiceTier);
+		if (rawServiceTier !== void 0 && serviceTier === void 0) return { error: "Gemini Interactions service_tier must be one of flex, standard, or priority." };
+		const billingConfig = {
+			...config,
+			service_tier: serviceTier,
+			passthrough: {
+				...config.passthrough || {},
+				service_tier: serviceTier,
+				serviceTier
+			}
+		};
+		const passthrough = {
+			...Object.fromEntries(Object.entries(mergedPassthrough).filter(([field]) => field !== "generation_config" && field !== "generationConfig" && field !== "model" && field !== "service_tier" && field !== "serviceTier" && field !== "previous_interaction_id" && field !== "previousInteractionId" && field !== "response_format" && field !== "responseFormat" && field !== "system_instruction" && field !== "systemInstruction" && field !== "input" && field !== "store" && field !== "safety_settings" && (!toolsDisabled || field !== "tools") && !INTERACTION_TOP_LEVEL_GENERATION_FIELDS.has(field))),
+			...!isVideoModel && passthroughSystemInstruction !== void 0 ? { system_instruction: passthroughSystemInstruction } : {}
+		};
+		const systemInstructionContent = !isVideoModel && passthroughSystemInstruction === void 0 ? require_util.parseConfigSystemInstruction(config.systemInstruction, context?.vars, promptConfig?.systemInstruction === void 0 ? this.config.basePath : promptBasePath) : void 0;
+		const systemInstruction = !isVideoModel && passthroughSystemInstruction === void 0 ? [...systemInstructionContent?.parts.map((part) => part.text).filter((text) => typeof text === "string") ?? [], ...promptSystemInstruction ? [promptSystemInstruction] : []].join("\n") : void 0;
+		const promptStructuredOutput = !isVideoModel && promptPassthroughResponseFormat === void 0 ? resolveInteractionStructuredOutput([{
+			generationConfigs: [promptConfig?.generationConfig],
+			responseSchema: promptConfig?.responseSchema
+		}, { generationConfigs: [promptPassthrough.generationConfig, promptPassthrough.generation_config] }]) : void 0;
+		const hasPromptStructuredOutput = promptStructuredOutput?.mimeType !== void 0 || promptStructuredOutput?.responseSchema !== void 0;
+		const passthroughResponseFormat = promptPassthroughResponseFormat ?? (hasPromptStructuredOutput ? void 0 : providerPassthroughResponseFormat);
+		const providerStructuredOutput = !isVideoModel && passthroughResponseFormat === void 0 && providerPassthroughResponseFormat === void 0 ? resolveInteractionStructuredOutput([{
+			generationConfigs: [this.config.generationConfig],
+			responseSchema: this.config.responseSchema
+		}, { generationConfigs: [providerPassthrough.generationConfig, providerPassthrough.generation_config] }]) : void 0;
+		const promptOwnsResponseSchema = promptStructuredOutput?.responseSchema !== void 0;
+		const rawResponseSchema = promptOwnsResponseSchema ? promptStructuredOutput.responseSchema : providerStructuredOutput?.responseSchema;
+		const responseMimeType = promptStructuredOutput?.mimeType ?? (promptOwnsResponseSchema ? void 0 : providerStructuredOutput?.mimeType) ?? (rawResponseSchema === void 0 ? void 0 : "application/json");
+		const structuredOutput = {
+			mimeType: responseMimeType,
+			schema: rawResponseSchema === void 0 || responseMimeType !== "application/json" ? void 0 : require_util.parseConfigResponseSchema(rawResponseSchema, context?.vars, promptOwnsResponseSchema ? promptBasePath : this.config.basePath)
+		};
+		const generatedVideoResponseFormat = config.vertexai ? [{
+			type: "video",
+			...config.aspectRatio ? { aspect_ratio: config.aspectRatio } : {}
+		}] : {
+			type: "video",
+			...config.aspectRatio ? { aspect_ratio: config.aspectRatio } : {}
+		};
+		const videoResponseFormat = promptPassthroughResponseFormat ?? (promptConfig?.aspectRatio === void 0 ? providerPassthroughResponseFormat ?? generatedVideoResponseFormat : generatedVideoResponseFormat);
+		const store = promptPassthrough.store ?? promptConfig?.store ?? providerPassthrough.store ?? this.config.store;
+		const providerSafetySettings = providerPassthrough.safety_settings ?? (this.config.safetySettings ? normalizeInteractionSafetySettings(this.config.safetySettings) : void 0);
+		const safetySettings = promptPassthrough.safety_settings ?? (promptConfig?.safetySettings ? normalizeInteractionSafetySettings(promptConfig.safetySettings) : void 0) ?? providerSafetySettings;
+		const body = {
+			model: effectiveModel,
+			input: requestInput,
+			...isVideoModel ? { response_format: videoResponseFormat } : passthroughResponseFormat === void 0 ? structuredOutput?.mimeType || structuredOutput?.schema !== void 0 ? { response_format: [{
+				type: "text",
+				...structuredOutput.mimeType ? { mime_type: structuredOutput.mimeType } : {},
+				...structuredOutput.schema === void 0 ? {} : { schema: structuredOutput.schema }
+			}] } : {} : { response_format: passthroughResponseFormat },
+			...previousInteractionId === void 0 ? {} : { previous_interaction_id: previousInteractionId },
+			...store === void 0 ? {} : { store },
+			...safetySettings === void 0 ? {} : { safety_settings: safetySettings },
+			...systemInstruction ? { system_instruction: systemInstruction } : {},
+			...Object.keys(generationConfig).length > 0 ? { generation_config: generationConfig } : {},
+			...serviceTier ? { service_tier: serviceTier } : {},
+			...passthrough,
+			background: false,
+			stream: false
+		};
+		let data;
+		let cached;
+		let httpStatus;
+		let httpStatusText;
+		try {
+			({data, cached, status: httpStatus, statusText: httpStatusText} = await require_cache.fetchWithCache(endpoint, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(body)
+			}, require_shared.getRequestTimeoutMs(), "json", true));
+		} catch (err) {
+			return { error: `Gemini Interactions API error: ${String(err)}` };
+		}
+		if (data.error?.message) return { error: `Gemini Interactions API error: ${data.error.message}` };
+		if (httpStatus && (httpStatus < 200 || httpStatus >= 300)) return {
+			error: `Gemini Interactions API error: HTTP ${httpStatus} ${httpStatusText}`.trim(),
+			raw: data
+		};
+		const pollTimeoutMs = config.timeoutMs ?? require_shared.getRequestTimeoutMs();
+		const pollStartedAt = Date.now();
+		let pollCount = 0;
+		while (data.status === "in_progress" && data.id) {
+			const elapsed = Date.now() - pollStartedAt;
+			if (elapsed >= pollTimeoutMs) return {
+				error: `Gemini interaction timed out after ${pollTimeoutMs}ms (status: ${data.status})`,
+				raw: data
+			};
+			if (pollCount > 0) await require_time.sleep(Math.min(1e3, pollTimeoutMs - elapsed));
+			try {
+				({data, status: httpStatus, statusText: httpStatusText} = await require_cache.fetchWithCache(`${endpoint}/${encodeURIComponent(data.id)}`, {
+					method: "GET",
+					headers
+				}, Math.max(pollTimeoutMs - (Date.now() - pollStartedAt), 1), "json", true));
+			} catch (err) {
+				return { error: `Gemini Interactions API polling error: ${String(err)}` };
+			}
+			pollCount++;
+			if (data.error?.message) return {
+				error: `Gemini Interactions API error: ${data.error.message}`,
+				raw: data
+			};
+			if (httpStatus && (httpStatus < 200 || httpStatus >= 300)) return {
+				error: `Gemini Interactions API polling error: HTTP ${httpStatus} ${httpStatusText}`.trim(),
+				raw: data
+			};
+		}
+		if (data.status && data.status !== "completed") return {
+			error: `Gemini interaction did not complete (status: ${data.status})`,
+			raw: data
+		};
+		const latestUserInput = (data.steps || []).map((step) => step.type).lastIndexOf("user_input");
+		const latestOutputError = (data.steps || []).slice(latestUserInput + 1).filter((step) => step.type === "model_output").find((step) => step.error?.message)?.error?.message;
+		if (latestOutputError) return {
+			error: `Gemini Interactions API error: ${latestOutputError}`,
+			raw: data
+		};
+		const outputContent = getModelOutputContent(data);
+		const groundingMetadata = getInteractionGroundingMetadata(data, outputContent);
+		const lastTextIndex = outputContent.map((part) => part.type === "text").lastIndexOf(true);
+		const lastNonTextIndex = outputContent.slice(0, lastTextIndex).map((part) => part.type !== "text").lastIndexOf(true);
+		const text = outputContent.slice(lastNonTextIndex + 1, lastTextIndex + 1).filter((part) => part.type === "text" && part.text).map((part) => part.text).join("");
+		const usage = data.usage;
+		const promptTokens = (usage?.total_input_tokens ?? 0) + (usage?.total_tool_use_tokens ?? 0);
+		const outputTokens = usage?.total_output_tokens ?? 0;
+		const thoughtTokens = usage?.total_reasoning_tokens ?? usage?.total_thought_tokens ?? 0;
+		const audioInputTokens = getInteractionModalityTokenCount(usage?.input_tokens_by_modality, ["audio"]) + getInteractionModalityTokenCount(usage?.tool_use_tokens_by_modality, ["audio"]);
+		const imageInputTokens = getInteractionModalityTokenCount(usage?.input_tokens_by_modality, [
+			"image",
+			"document",
+			"video"
+		]) + getInteractionModalityTokenCount(usage?.tool_use_tokens_by_modality, [
+			"image",
+			"document",
+			"video"
+		]);
+		const cachedAudioTokens = getInteractionModalityTokenCount(usage?.cached_tokens_by_modality, ["audio"]);
+		const cachedImageTokens = getInteractionModalityTokenCount(usage?.cached_tokens_by_modality, [
+			"image",
+			"document",
+			"video"
+		]);
+		const audioOutputTokens = getInteractionModalityTokenCount(usage?.output_tokens_by_modality, ["audio"]);
+		const videoTokens = getInteractionModalityTokenCount(usage?.output_tokens_by_modality, ["video"]);
+		const tokenUsage = {
+			prompt: promptTokens,
+			completion: outputTokens,
+			total: usage?.total_tokens ?? promptTokens + outputTokens + thoughtTokens,
+			cached: usage?.total_cached_tokens ?? 0,
+			numRequests: 1,
+			...thoughtTokens > 0 ? { completionDetails: { reasoning: thoughtTokens } } : {}
+		};
+		const cost = cached ? void 0 : hasCatalogModel ? require_util.calculateGoogleCost(effectiveModel, billingConfig, promptTokens, outputTokens + thoughtTokens, config.vertexai, audioInputTokens, audioOutputTokens, videoTokens, imageInputTokens, usage?.total_cached_tokens, cachedAudioTokens, cachedImageTokens, void 0, config.vertexai ? getVertexInteractionsRegion(config, this.env) : void 0) : calculateExplicitInteractionCost(billingConfig, promptTokens, outputTokens + thoughtTokens, audioInputTokens, audioOutputTokens, videoTokens, imageInputTokens);
+		if (!isVideoModel) {
+			if (!text) return {
+				error: "Gemini interaction did not return text output",
+				raw: data
+			};
+			return {
+				output: text,
+				cached,
+				tokenUsage,
+				cost,
+				metadata: {
+					interactionId: data.id,
+					status: data.status,
+					...groundingMetadata
+				}
+			};
+		}
+		const video = [...outputContent].reverse().find((part) => part.type === "video");
+		if (!video?.data && !video?.uri) return {
+			error: "Gemini interaction did not return video output",
+			raw: data
+		};
+		let blobRef;
+		let videoBuffer = video.data ? Buffer.from(video.data, "base64") : void 0;
+		if (!videoBuffer && video.uri) try {
+			let downloadUrl = new URL(video.uri, endpoint);
+			if (config.vertexai && downloadUrl.protocol === "gs:") {
+				const bucket = encodeURIComponent(downloadUrl.hostname);
+				const object = encodeURIComponent(decodeURIComponent(downloadUrl.pathname.slice(1)));
+				downloadUrl = new URL(`https://storage.googleapis.com/download/storage/v1/b/${bucket}/o/${object}?alt=media`);
+			}
+			const endpointOrigin = new URL(endpoint).origin;
+			const isVertexStorageDownload = config.vertexai && downloadUrl.origin === "https://storage.googleapis.com";
+			if (downloadUrl.origin === endpointOrigin || isVertexStorageDownload || downloadUrl.protocol === "https:" && downloadUrl.hostname === "generativelanguage.googleapis.com") {
+				let downloadHeaders = {};
+				if (downloadUrl.origin === endpointOrigin) downloadHeaders = headers;
+				else if (isVertexStorageDownload) downloadHeaders = Object.fromEntries(Object.entries(headers).filter(([header]) => ["authorization", "x-goog-user-project"].includes(header.toLowerCase())));
+				else if (apiKey) downloadHeaders = { "x-goog-api-key": apiKey };
+				let response = await require_fetch.fetchWithTimeout(downloadUrl.toString(), {
+					method: "GET",
+					headers: downloadHeaders,
+					redirect: "manual"
+				}, require_shared.getRequestTimeoutMs());
+				const redirectLocation = response.headers.get("location");
+				if (response.status >= 300 && response.status < 400 && redirectLocation) {
+					const redirectUrl = new URL(redirectLocation, downloadUrl);
+					if (!(redirectUrl.origin === downloadUrl.origin || redirectUrl.protocol === "https:" && (redirectUrl.hostname === "storage.googleapis.com" || redirectUrl.hostname.endsWith(".storage.googleapis.com") || redirectUrl.hostname.endsWith(".googleusercontent.com")))) return { error: `Refusing untrusted Gemini interaction video redirect: ${redirectUrl.origin}` };
+					response = await require_fetch.fetchWithTimeout(redirectUrl.toString(), {
+						method: "GET",
+						...redirectUrl.origin === downloadUrl.origin ? { headers: downloadHeaders } : {},
+						redirect: "manual"
+					}, require_shared.getRequestTimeoutMs());
+				}
+				if (!response.ok) return { error: `Failed to download Gemini interaction video: HTTP ${response.status} ${response.statusText}`.trim() };
+				videoBuffer = Buffer.from(await response.arrayBuffer());
+			} else require_logger.logger.warn("[Google Interactions] Skipping video download from untrusted origin; returning the raw URI", {
+				origin: downloadUrl.origin,
+				protocol: downloadUrl.protocol
+			});
+		} catch (err) {
+			return { error: `Failed to download Gemini interaction video: ${String(err)}` };
+		}
+		if (videoBuffer) try {
+			({ref: blobRef} = await require_blobs.storeBlob(videoBuffer, video.mime_type || "video/mp4", {
+				evalId: context?.evaluationId,
+				kind: "video",
+				location: "response.video",
+				promptIdx: context?.promptIdx,
+				testIdx: context?.testIdx
+			}));
+		} catch (err) {
+			return { error: `Failed to store Gemini interaction video: ${String(err)}` };
+		}
+		const videoUrl = blobRef?.uri ?? video.uri;
+		const sanitizedPrompt = prompt.replace(/\r?\n|\r/g, " ").replace(/\[/g, "(").replace(/\]/g, ")").slice(0, 50);
+		return {
+			output: text || `[Video: ${sanitizedPrompt}](${videoUrl})`,
+			cached,
+			tokenUsage,
+			cost,
+			video: {
+				id: data.id,
+				blobRef,
+				url: videoUrl,
+				format: video.mime_type?.split("/")[1] || "mp4",
+				model: effectiveModel,
+				aspectRatio: config.aspectRatio
+			},
+			metadata: {
+				interactionId: data.id,
+				status: data.status,
+				...groundingMetadata
+			}
+		};
+	}
+};
+//#endregion
+exports.GoogleInteractionsProvider = GoogleInteractionsProvider;
+
+//# sourceMappingURL=interactions-CND010Lh.cjs.map