promptfoo 0.125.0 → 0.125.1

package/dist/src/video-BY7Q2Gii.cjs

@@ -0,0 +1,706 @@
+const require_rolldown_runtime = require("./rolldown-runtime-C0BPl7ul.cjs");
+const require_logger = require("./logger-DXUHJBHJ.cjs");
+const require_fetch = require("./fetch-BKlgUg08.cjs");
+const require_time = require("./time-CY7bOv6D.cjs");
+const require_env = require("./env-PwgLIVUT.cjs");
+const require_blobs = require("./blobs-CwaJ7l1g.cjs");
+const require_util = require("./util-Df7rfMGb.cjs");
+const require_text = require("./text-513KmH8t.cjs");
+const require_utils = require("./utils-DloUCs0Y.cjs");
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path, 1);
+let fs = require("fs");
+fs = require_rolldown_runtime.__toESM(fs, 1);
+let crypto = require("crypto");
+crypto = require_rolldown_runtime.__toESM(crypto, 1);
+//#region src/providers/google/video.ts
+/**
+* Default location for Vertex AI
+*/
+const DEFAULT_LOCATION = "us-central1";
+/**
+* Valid durations by model family
+*/
+const VEO_3_DURATIONS = [
+	4,
+	6,
+	8
+];
+const VEO_2_DURATIONS = [
+	5,
+	6,
+	8
+];
+const VEO_EXTENSION_DURATION = 8;
+/**
+* Default configuration values
+*/
+const DEFAULT_ASPECT_RATIO = "16:9";
+const DEFAULT_RESOLUTION = "720p";
+const DEFAULT_DURATION = 8;
+const DEFAULT_POLL_INTERVAL_MS = 1e4;
+const DEFAULT_MAX_POLL_TIME_MS = 6e5;
+const REQUEST_TIMEOUT_MS = 3e5;
+const AI_STUDIO_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+/**
+* Veo 3.1 video-with-audio output prices in USD per generated second.
+* Source: https://ai.google.dev/gemini-api/docs/pricing#veo-3.1
+*/
+const VEO_3_1_VIDEO_WITH_AUDIO_PRICES = {
+	standard: {
+		"720p": .4,
+		"1080p": .4,
+		"4k": .6
+	},
+	fast: {
+		"720p": .1,
+		"1080p": .12,
+		"4k": .3
+	},
+	lite: {
+		"720p": .05,
+		"1080p": .08
+	}
+};
+function getVertexApiHost(location) {
+	return location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
+}
+function validateAspectRatio(ratio) {
+	if (!["16:9", "9:16"].includes(ratio)) return {
+		valid: false,
+		message: `Invalid aspect ratio "${ratio}". Valid ratios: 16:9, 9:16`
+	};
+	return { valid: true };
+}
+function isVideoOperationName(value) {
+	return /^(?:(?:projects\/[^/]+\/locations\/[^/]+\/(?:publishers\/[^/]+\/models\/[^/]+\/)?)|(?:models\/[^/]+\/))?operations\/[^/]+$/.test(value);
+}
+function isReusableAiStudioVideoUri(uri) {
+	try {
+		const parsed = new URL(uri);
+		return parsed.protocol === "https:" && parsed.hostname === "generativelanguage.googleapis.com" && parsed.pathname.startsWith("/v1beta/files/");
+	} catch {
+		return false;
+	}
+}
+function getReusableGeneratedVideoUri(uri, isVertexMode) {
+	return (isVertexMode ? uri.startsWith("gs://") : isReusableAiStudioVideoUri(uri)) ? require_utils.sanitizeVideoSourceUri(uri) : void 0;
+}
+function addOptionalVideoParameter(parameters, name, value) {
+	if (value !== void 0 && value !== "") parameters[name] = value;
+}
+function validateDuration(model, duration, config = {}) {
+	const validDurations = model.includes("veo-2") ? VEO_2_DURATIONS : VEO_3_DURATIONS;
+	if (!validDurations.includes(duration)) return {
+		valid: false,
+		message: `Invalid duration ${duration}s for ${model}. Valid: ${validDurations.join(", ")}s`
+	};
+	const usesVideoExtension = Boolean(config.extendVideoId || config.sourceVideo);
+	const usesReferenceImages = Boolean(config.referenceImages?.length);
+	const usesHighResolution = config.resolution === "1080p" || config.resolution === "4k";
+	const supportsVertexLiteExtension = config.vertexai === true && model === "veo-3.1-lite-generate-001";
+	if (model.includes("veo-3.1-lite") && (usesReferenceImages || usesVideoExtension && !supportsVertexLiteExtension)) return {
+		valid: false,
+		message: "Veo 3.1 Lite does not support video extension or reference images."
+	};
+	const requiresEightSeconds = usesVideoExtension || usesReferenceImages || config.vertexai !== true && usesHighResolution;
+	if (duration !== 8 && requiresEightSeconds) return {
+		valid: false,
+		message: `This configuration requires durationSeconds: 8 when using video extension, reference images, or 1080p/4k resolution (received ${duration}).`
+	};
+	return { valid: true };
+}
+function resolveExtensionDuration(duration) {
+	if (duration !== VEO_EXTENSION_DURATION) require_logger.logger.warn(`[Google Video] durationSeconds is not used when extending a video (Veo adds a fixed 7s). Ignoring the configured ${duration}s.`);
+	return VEO_EXTENSION_DURATION;
+}
+function validateResolution(model, aspectRatio, resolution, config = {}) {
+	if (![
+		"720p",
+		"1080p",
+		"4k"
+	].includes(resolution)) return {
+		valid: false,
+		message: `Invalid resolution "${resolution}". Valid resolutions: 720p, 1080p, 4k`
+	};
+	if (config.vertexai !== true && (config.extendVideoId || config.sourceVideo) && resolution !== "720p") return {
+		valid: false,
+		message: `Video extension requires 720p resolution (received ${resolution}).`
+	};
+	if (model.includes("veo-2") && resolution !== "720p") return {
+		valid: false,
+		message: `Veo 2 only supports 720p resolution.`
+	};
+	const isStableVeo31Fast = model === "veo-3.1-fast-generate-001";
+	if (resolution === "4k" && (!model.includes("veo-3.1") || model.includes("lite") || isStableVeo31Fast)) return {
+		valid: false,
+		message: `${model} does not support 4k resolution. Use a Veo 3.1 model that supports 4k.`
+	};
+	if (model.includes("veo-3") && !model.includes("veo-3.1") && aspectRatio === "9:16") {
+		if (resolution === "1080p" || resolution === "4k") return {
+			valid: false,
+			message: `Veo 3 only supports ${resolution} for 16:9 aspect ratio. Use 720p for 9:16.`
+		};
+	}
+	return { valid: true };
+}
+function calculateVeoCost(model, resolution, generatedDurationSeconds) {
+	if (!model.includes("veo-3.1")) return;
+	const modelTier = model.includes("lite") ? "lite" : model.includes("fast") ? "fast" : "standard";
+	const pricePerSecond = VEO_3_1_VIDEO_WITH_AUDIO_PRICES[modelTier][resolution];
+	return pricePerSecond === void 0 ? void 0 : pricePerSecond * generatedDurationSeconds;
+}
+function hasOwnVideoOption(config, option) {
+	return config !== void 0 && Object.prototype.hasOwnProperty.call(config, option);
+}
+function mergeGoogleVideoRequestConfig(providerConfig, promptConfig) {
+	const promptOwnsImage = hasOwnVideoOption(promptConfig, "image");
+	const promptOwnsLastFrame = hasOwnVideoOption(promptConfig, "lastFrame") || hasOwnVideoOption(promptConfig, "lastImage");
+	const promptOwnsReferenceImages = hasOwnVideoOption(promptConfig, "referenceImages");
+	const promptOwnsSourceVideo = hasOwnVideoOption(promptConfig, "sourceVideo") || hasOwnVideoOption(promptConfig, "extendVideoId");
+	const lastFrameOwner = promptOwnsLastFrame ? promptConfig : providerConfig;
+	const sourceVideoOwner = promptOwnsSourceVideo ? promptConfig : providerConfig;
+	const promptMediaBasePath = promptConfig?.basePath ?? providerConfig.basePath;
+	return {
+		config: {
+			...providerConfig,
+			...promptConfig,
+			apiKey: providerConfig.apiKey,
+			vertexai: providerConfig.vertexai,
+			projectId: providerConfig.projectId,
+			region: providerConfig.region,
+			credentials: providerConfig.credentials,
+			storageUri: providerConfig.storageUri,
+			lastFrame: lastFrameOwner?.lastFrame,
+			lastImage: lastFrameOwner?.lastImage,
+			sourceVideo: sourceVideoOwner?.sourceVideo,
+			extendVideoId: sourceVideoOwner?.extendVideoId
+		},
+		mediaBasePaths: {
+			image: promptOwnsImage ? promptMediaBasePath : providerConfig.basePath,
+			lastFrame: promptOwnsLastFrame ? promptMediaBasePath : providerConfig.basePath,
+			referenceImages: promptOwnsReferenceImages ? promptMediaBasePath : providerConfig.basePath,
+			sourceVideo: promptOwnsSourceVideo ? promptMediaBasePath : providerConfig.basePath
+		}
+	};
+}
+var GoogleVideoProvider = class {
+	modelName;
+	config;
+	providerId;
+	env;
+	constructor(modelName, options = {}) {
+		this.modelName = modelName;
+		this.config = options.config || {};
+		this.providerId = options.id;
+		this.env = options.env;
+	}
+	id() {
+		return this.providerId || `google:video:${this.modelName}`;
+	}
+	toString() {
+		return `[Google Video Provider ${this.modelName}]`;
+	}
+	getLocation(config = this.config) {
+		return config.region || require_env.resolveProviderEnv(this.env, [
+			"VERTEX_REGION",
+			"GOOGLE_CLOUD_LOCATION",
+			"GOOGLE_LOCATION"
+		])?.value || DEFAULT_LOCATION;
+	}
+	async getProjectId(config = this.config) {
+		return await require_util.resolveProjectId(config, this.env);
+	}
+	isVertexMode(config = this.config) {
+		return require_util.determineGoogleVertexMode(config, this.env);
+	}
+	requiresApiKey() {
+		return false;
+	}
+	getApiKey(config = this.config) {
+		const { apiKey } = require_util.getGoogleApiKey(config, this.env, this.isVertexMode(config));
+		return apiKey;
+	}
+	async getClientWithCredentials(config) {
+		const credentials = require_util.loadCredentials(config.credentials);
+		const { client } = await require_util.getGoogleClient({ credentials });
+		return client;
+	}
+	async getVertexEndpoint(action = "predictLongRunning", model = this.modelName, config = this.config) {
+		const location = this.getLocation(config);
+		const projectId = await this.getProjectId(config);
+		return `https://${getVertexApiHost(location)}/v1/projects/${projectId}/locations/${location}/publishers/google/models/${model}:${action}`;
+	}
+	getAiStudioEndpoint(pathSuffix) {
+		return `${AI_STUDIO_BASE_URL}/${pathSuffix}`;
+	}
+	async getAiStudioHeaders(config) {
+		const apiKey = this.getApiKey(config);
+		if (!apiKey && config.apiKeyRequired !== false) throw new Error("Google API key is not set. Set GOOGLE_API_KEY or GEMINI_API_KEY, or add `apiKey` to the provider config.");
+		return {
+			"Content-Type": "application/json",
+			...apiKey ? { "x-goog-api-key": apiKey } : {}
+		};
+	}
+	/**
+	* Load image data from file:// path or return as-is if base64
+	*/
+	loadImageData(imagePath, config = this.config) {
+		if (imagePath.startsWith("file://")) {
+			const filePath = path.default.resolve(config.basePath || process.cwd(), imagePath.slice(7));
+			if (!fs.default.existsSync(filePath)) return { error: `Image file not found: ${filePath}` };
+			return { data: fs.default.readFileSync(filePath).toString("base64") };
+		}
+		return { data: imagePath };
+	}
+	loadVideoData(videoPath, config = this.config) {
+		if (videoPath.startsWith("file://")) {
+			const filePath = path.default.resolve(config.basePath || process.cwd(), videoPath.slice(7));
+			if (!fs.default.existsSync(filePath)) return { error: `Video file not found: ${filePath}` };
+			return { data: fs.default.readFileSync(filePath).toString("base64") };
+		}
+		return { data: videoPath };
+	}
+	/**
+	* Create a new video generation job
+	*/
+	async createVideoJob(prompt, config, mediaBasePaths) {
+		if (this.isVertexMode(config)) return this.createVertexVideoJob(prompt, config, mediaBasePaths);
+		return this.createAiStudioVideoJob(prompt, config, mediaBasePaths);
+	}
+	addVertexSourceVideo(instance, sourceVideo, basePath) {
+		if (!sourceVideo) return;
+		if (isVideoOperationName(sourceVideo)) return "Vertex AI Veo does not accept operation IDs for video extension. Set sourceVideo to a gs:// URI, base64 video data, or a file:// path.";
+		if (/\.(avi|mov|mkv|webm|mpeg|mpg|wmv|flv|3gp|3gpp)(?:[?#]|$)/i.test(sourceVideo)) return "Vertex Veo video extension requires an MP4 source video.";
+		if (sourceVideo.startsWith("gs://")) {
+			instance.video = {
+				gcsUri: sourceVideo,
+				mimeType: "video/mp4"
+			};
+			return;
+		}
+		if (/^data:/i.test(sourceVideo) || sourceVideo.includes("://") && !sourceVideo.startsWith("file://") || !sourceVideo.startsWith("file://") && !/^[A-Za-z0-9+/]+={0,2}$/.test(sourceVideo)) return "Vertex AI Veo video extension requires a gs:// URI, base64 video data, or a file:// path.";
+		const { data, error } = this.loadVideoData(sourceVideo, { basePath });
+		if (error) return error;
+		instance.video = {
+			bytesBase64Encoded: data,
+			mimeType: "video/mp4"
+		};
+	}
+	buildVertexRequestBody(prompt, config, mediaBasePaths = {
+		image: config.basePath,
+		lastFrame: config.basePath,
+		referenceImages: config.basePath,
+		sourceVideo: config.basePath
+	}) {
+		const instance = { prompt };
+		const parameters = {};
+		if (config.aspectRatio) parameters.aspectRatio = config.aspectRatio;
+		if (config.resolution) parameters.resolution = config.resolution;
+		if (config.durationSeconds && !config.sourceVideo && !config.extendVideoId) parameters.durationSeconds = config.durationSeconds;
+		if (config.negativePrompt) parameters.negativePrompt = config.negativePrompt;
+		if (config.personGeneration) parameters.personGeneration = config.personGeneration;
+		if (config.seed !== void 0) parameters.seed = config.seed;
+		addOptionalVideoParameter(parameters, "storageUri", config.storageUri);
+		if (config.image) {
+			const { data: imageData, error } = this.loadImageData(config.image, { basePath: mediaBasePaths.image });
+			if (error) return { error };
+			instance.image = {
+				bytesBase64Encoded: imageData,
+				mimeType: "image/png"
+			};
+		}
+		const lastFrame = config.lastFrame || config.lastImage;
+		if (lastFrame) {
+			const { data: lastFrameData, error } = this.loadImageData(lastFrame, { basePath: mediaBasePaths.lastFrame });
+			if (error) return { error };
+			instance.lastFrame = {
+				bytesBase64Encoded: lastFrameData,
+				mimeType: "image/png"
+			};
+		}
+		if (config.referenceImages && config.referenceImages.length > 0) {
+			const refs = [];
+			for (const ref of config.referenceImages.slice(0, 3)) {
+				const imagePath = typeof ref === "string" ? ref : ref.image;
+				const referenceType = typeof ref === "string" ? "asset" : ref.referenceType || "asset";
+				const { data: imageData, error } = this.loadImageData(imagePath, { basePath: mediaBasePaths.referenceImages });
+				if (error) return { error };
+				refs.push({
+					image: {
+						bytesBase64Encoded: imageData,
+						mimeType: "image/png"
+					},
+					referenceType
+				});
+			}
+			instance.referenceImages = refs;
+		}
+		const sourceVideoError = this.addVertexSourceVideo(instance, config.sourceVideo || config.extendVideoId, mediaBasePaths.sourceVideo);
+		if (sourceVideoError) return { error: sourceVideoError };
+		const body = { instances: [instance] };
+		if (Object.keys(parameters).length > 0) body.parameters = parameters;
+		return { body };
+	}
+	buildAiStudioRequestBody(prompt, config, mediaBasePaths = {
+		image: config.basePath,
+		lastFrame: config.basePath,
+		referenceImages: config.basePath,
+		sourceVideo: config.basePath
+	}) {
+		const instance = { prompt };
+		const parameters = {};
+		if (config.aspectRatio) parameters.aspectRatio = config.aspectRatio;
+		if (config.resolution) parameters.resolution = config.resolution;
+		if (config.durationSeconds) parameters.durationSeconds = config.durationSeconds;
+		if (config.negativePrompt) parameters.negativePrompt = config.negativePrompt;
+		if (config.personGeneration) parameters.personGeneration = config.personGeneration;
+		if (config.seed !== void 0) parameters.seed = config.seed;
+		if (config.image) {
+			const { data: imageData, error } = this.loadImageData(config.image, { basePath: mediaBasePaths.image });
+			if (error) return { error };
+			instance.image = {
+				mimeType: "image/png",
+				bytesBase64Encoded: imageData
+			};
+		}
+		const lastFrame = config.lastFrame || config.lastImage;
+		if (lastFrame) {
+			const { data: lastFrameData, error } = this.loadImageData(lastFrame, { basePath: mediaBasePaths.lastFrame });
+			if (error) return { error };
+			instance.lastFrame = {
+				mimeType: "image/png",
+				bytesBase64Encoded: lastFrameData
+			};
+		}
+		if (config.referenceImages && config.referenceImages.length > 0) {
+			const refs = [];
+			for (const ref of config.referenceImages.slice(0, 3)) {
+				const imagePath = typeof ref === "string" ? ref : ref.image;
+				const referenceType = typeof ref === "string" ? "asset" : ref.referenceType || "asset";
+				const { data: imageData, error } = this.loadImageData(imagePath, { basePath: mediaBasePaths.referenceImages });
+				if (error) return { error };
+				refs.push({
+					image: {
+						mimeType: "image/png",
+						bytesBase64Encoded: imageData
+					},
+					referenceType
+				});
+			}
+			instance.referenceImages = refs;
+		}
+		const sourceVideo = config.sourceVideo || config.extendVideoId;
+		if (sourceVideo) {
+			if (isVideoOperationName(sourceVideo)) return { error: "Google AI Studio Veo does not accept operation IDs for video extension. Provide a previous Veo video URI, file:// path, or base64 bytes via `sourceVideo`." };
+			if (isReusableAiStudioVideoUri(sourceVideo)) instance.video = { uri: sourceVideo };
+			else if (sourceVideo.startsWith("file://") || !sourceVideo.includes("://")) {
+				const { data, error } = this.loadVideoData(sourceVideo, { basePath: mediaBasePaths.sourceVideo });
+				if (error) return { error };
+				instance.video = { inlineData: {
+					mimeType: "video/mp4",
+					data
+				} };
+			} else return { error: "Google AI Studio Veo video extension requires a previous Veo video URI, file:// path, or base64 bytes." };
+		}
+		const body = { instances: [instance] };
+		if (Object.keys(parameters).length > 0) body.parameters = parameters;
+		return { body };
+	}
+	async createVertexVideoJob(prompt, config, mediaBasePaths) {
+		const model = config.model || this.modelName;
+		const { body, error: bodyError } = this.buildVertexRequestBody(prompt, config, mediaBasePaths);
+		if (bodyError || !body) return { error: bodyError || "Failed to build Vertex Veo request" };
+		try {
+			const client = await this.getClientWithCredentials(config);
+			const url = await this.getVertexEndpoint("predictLongRunning", model, config);
+			require_logger.logger.debug("[Google Video] Creating video job", {
+				url,
+				model
+			});
+			return { operation: (await client.request({
+				url,
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(body)
+			})).data };
+		} catch (err) {
+			const error = err;
+			return { error: `Failed to create video job: ${error.response?.data?.error?.message || error.message || String(err)}` };
+		}
+	}
+	async createAiStudioVideoJob(prompt, config, mediaBasePaths) {
+		const { body, error: bodyError } = this.buildAiStudioRequestBody(prompt, config, mediaBasePaths);
+		if (bodyError || !body) return { error: bodyError || "Failed to build Google AI Studio Veo request" };
+		try {
+			const headers = await this.getAiStudioHeaders(config);
+			const model = config.model || this.modelName;
+			const url = this.getAiStudioEndpoint(`models/${model}:predictLongRunning`);
+			require_logger.logger.debug("[Google Video] Creating video job", {
+				url,
+				model,
+				transport: "google-ai-studio"
+			});
+			const response = await require_fetch.fetchWithTimeout(url, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(body)
+			}, REQUEST_TIMEOUT_MS);
+			const data = await response.json();
+			if (!response.ok) return { error: `Failed to create video job: ${data.error?.message || response.statusText}` };
+			return { operation: data };
+		} catch (err) {
+			return { error: `Failed to create video job: ${err.message || String(err)}` };
+		}
+	}
+	/**
+	* Poll for video job completion using fetchPredictOperation endpoint
+	*/
+	async pollOperationStatus(operationName, pollIntervalMs, maxPollTimeMs, config) {
+		if (this.isVertexMode(config)) return this.pollVertexOperationStatus(operationName, pollIntervalMs, maxPollTimeMs, config);
+		return this.pollAiStudioOperationStatus(operationName, pollIntervalMs, maxPollTimeMs, config);
+	}
+	async pollVertexOperationStatus(operationName, pollIntervalMs, maxPollTimeMs, config) {
+		const startTime = Date.now();
+		const location = this.getLocation(config);
+		const projectId = await this.getProjectId(config);
+		const model = config.model || this.modelName;
+		const url = `https://${getVertexApiHost(location)}/v1/projects/${projectId}/locations/${location}/publishers/google/models/${model}:fetchPredictOperation`;
+		require_logger.logger.debug(`[Google Video] Polling operation via fetchPredictOperation: ${url}`);
+		const client = await this.getClientWithCredentials(config);
+		while (Date.now() - startTime < maxPollTimeMs) try {
+			const operation = (await client.request({
+				url,
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ operationName })
+			})).data;
+			require_logger.logger.debug(`[Google Video] Operation status: done=${operation.done}, progress=${operation.metadata?.progress}%`);
+			if (operation.done) {
+				if (operation.error) return { error: `Video generation failed: ${operation.error.message}` };
+				return { operation };
+			}
+			await require_time.sleep(pollIntervalMs);
+		} catch (err) {
+			const error = err;
+			return { error: `Polling error: ${error.response?.data?.error?.message || error.message || String(err)}` };
+		}
+		return { error: `Video generation timed out after ${maxPollTimeMs / 1e3} seconds` };
+	}
+	async pollAiStudioOperationStatus(operationName, pollIntervalMs, maxPollTimeMs, config) {
+		const startTime = Date.now();
+		const url = this.getAiStudioEndpoint(operationName);
+		const headers = await this.getAiStudioHeaders(config);
+		require_logger.logger.debug(`[Google Video] Polling operation via Google AI Studio: ${url}`);
+		while (Date.now() - startTime < maxPollTimeMs) try {
+			const response = await require_fetch.fetchWithTimeout(url, {
+				method: "GET",
+				headers
+			}, REQUEST_TIMEOUT_MS);
+			const operation = await response.json();
+			if (!response.ok) return { error: `Polling error: ${operation.error?.message || response.statusText}` };
+			require_logger.logger.debug(`[Google Video] Operation status: done=${operation.done}, progress=${operation.metadata?.progress}%`);
+			if (operation.done) {
+				if (operation.error) return { error: `Video generation failed: ${operation.error.message}` };
+				return { operation };
+			}
+			await require_time.sleep(pollIntervalMs);
+		} catch (err) {
+			return { error: `Polling error: ${err.message || String(err)}` };
+		}
+		return { error: `Video generation timed out after ${maxPollTimeMs / 1e3} seconds` };
+	}
+	/**
+	* Download video from URI and store to blob storage
+	*/
+	async downloadVideoToBlob(videoUri, config, context) {
+		if (this.isVertexMode(config)) return this.downloadVertexVideoToBlob(videoUri, config, context);
+		return this.downloadAiStudioVideoToBlob(videoUri, config, context);
+	}
+	async downloadVertexVideoToBlob(videoUri, config, context) {
+		try {
+			const client = await this.getClientWithCredentials(config);
+			let downloadUrl = videoUri;
+			if (videoUri.startsWith("gs://")) {
+				const parsedUri = new URL(videoUri);
+				downloadUrl = `https://storage.googleapis.com/download/storage/v1/b/${encodeURIComponent(parsedUri.hostname)}/o/${encodeURIComponent(decodeURIComponent(parsedUri.pathname.slice(1)))}?alt=media`;
+			}
+			const response = await client.request({
+				url: downloadUrl,
+				method: "GET",
+				responseType: "arraybuffer"
+			});
+			const buffer = Buffer.from(response.data);
+			const { ref } = await require_blobs.storeBlob(buffer, "video/mp4", {
+				evalId: context?.evaluationId,
+				kind: "video",
+				location: "response.video",
+				promptIdx: context?.promptIdx,
+				testIdx: context?.testIdx
+			});
+			require_logger.logger.debug(`[Google Video] Stored video to blob storage: ${ref.uri}`);
+			return { blobRef: ref };
+		} catch (err) {
+			return { error: `Download error: ${err.message || String(err)}` };
+		}
+	}
+	async downloadAiStudioVideoToBlob(videoUri, config, context) {
+		try {
+			const headers = await this.getAiStudioHeaders(config);
+			const response = await require_fetch.fetchWithTimeout(videoUri, {
+				method: "GET",
+				headers
+			}, REQUEST_TIMEOUT_MS);
+			if (!response.ok) return { error: `Download error: ${response.statusText}` };
+			const buffer = Buffer.from(await response.arrayBuffer());
+			const { ref } = await require_blobs.storeBlob(buffer, "video/mp4", {
+				evalId: context?.evaluationId,
+				kind: "video",
+				location: "response.video",
+				promptIdx: context?.promptIdx,
+				testIdx: context?.testIdx
+			});
+			require_logger.logger.debug(`[Google Video] Stored video to blob storage: ${ref.uri}`);
+			return { blobRef: ref };
+		} catch (err) {
+			return { error: `Download error: ${err.message || String(err)}` };
+		}
+	}
+	/**
+	* Store base64 encoded video to blob storage
+	*/
+	async storeBase64VideoToBlob(base64Data, context) {
+		try {
+			const buffer = Buffer.from(base64Data, "base64");
+			const { ref, deduplicated } = await require_blobs.storeBlob(buffer, "video/mp4", {
+				evalId: context?.evaluationId,
+				kind: "video",
+				location: "response.video",
+				promptIdx: context?.promptIdx,
+				testIdx: context?.testIdx
+			});
+			require_logger.logger.debug(`[Google Video] Stored video to blob storage: ${ref.uri} (deduplicated: ${deduplicated})`);
+			return { blobRef: ref };
+		} catch (err) {
+			return { error: `Save error: ${err.message || String(err)}` };
+		}
+	}
+	async callApi(prompt, context) {
+		if (!prompt || prompt.trim() === "") return { error: "Prompt is required for video generation" };
+		const { config, mediaBasePaths } = mergeGoogleVideoRequestConfig(this.config, context?.prompt?.config);
+		let effectiveConfig = config;
+		if (this.isVertexMode(effectiveConfig)) {
+			let projectId;
+			try {
+				projectId = await require_util.resolveProjectId(effectiveConfig, this.env);
+			} catch {
+				return { error: "Google Veo video generation via Vertex AI requires a project ID. Set GOOGLE_CLOUD_PROJECT or add `projectId` to the provider config, then run \"gcloud auth application-default login\"." };
+			}
+			if (!projectId) return { error: "Google Veo video generation via Vertex AI requires a project ID. Set GOOGLE_CLOUD_PROJECT or add `projectId` to the provider config, then run \"gcloud auth application-default login\"." };
+			effectiveConfig = {
+				...effectiveConfig,
+				vertexai: true,
+				projectId
+			};
+		} else if (!this.getApiKey(effectiveConfig) && effectiveConfig.apiKeyRequired !== false) {
+			const missingApiKeyError = "Google Veo video generation via Google AI Studio requires an API key. Set GOOGLE_API_KEY or GEMINI_API_KEY, or add `apiKey` to the provider config.";
+			const useVertexEnv = require_env.resolveProviderEnv(this.env, ["GOOGLE_GENAI_USE_VERTEXAI"])?.value;
+			if (effectiveConfig.vertexai === false || useVertexEnv === "false" || useVertexEnv === "0") return { error: missingApiKeyError };
+			try {
+				const adcProjectId = await require_util.resolveProjectId(effectiveConfig, this.env);
+				if (adcProjectId) effectiveConfig = {
+					...effectiveConfig,
+					vertexai: true,
+					projectId: adcProjectId
+				};
+				else return { error: missingApiKeyError };
+			} catch {
+				return { error: missingApiKeyError };
+			}
+		}
+		const model = effectiveConfig.model || this.modelName;
+		const aspectRatio = effectiveConfig.aspectRatio || DEFAULT_ASPECT_RATIO;
+		const resolution = effectiveConfig.resolution || DEFAULT_RESOLUTION;
+		const isVideoExtension = Boolean(effectiveConfig.sourceVideo || effectiveConfig.extendVideoId);
+		const configuredDuration = effectiveConfig.durationSeconds ?? effectiveConfig.duration ?? DEFAULT_DURATION;
+		const durationSeconds = isVideoExtension ? resolveExtensionDuration(configuredDuration) : configuredDuration;
+		const ratioValidation = validateAspectRatio(aspectRatio);
+		if (!ratioValidation.valid) return { error: ratioValidation.message };
+		const resolutionValidation = validateResolution(model, aspectRatio, resolution, effectiveConfig);
+		if (!resolutionValidation.valid) return { error: resolutionValidation.message };
+		const durationValidation = validateDuration(model, durationSeconds, effectiveConfig);
+		if (!durationValidation.valid) return { error: durationValidation.message };
+		const startTime = Date.now();
+		require_logger.logger.info(`[Google Video] Creating video job for model ${model}...`);
+		const { duration: _duration, durationSeconds: _durationSeconds, ...requestConfig } = effectiveConfig;
+		const { operation: createdOp, error: createError } = await this.createVideoJob(prompt, {
+			...requestConfig,
+			aspectRatio,
+			resolution,
+			...isVideoExtension && this.isVertexMode(effectiveConfig) ? {} : { durationSeconds }
+		}, mediaBasePaths);
+		if (createError || !createdOp) return { error: createError || "Failed to create video job" };
+		const operationName = createdOp.name;
+		require_logger.logger.info(`[Google Video] Video job created: ${operationName}`);
+		const pollIntervalMs = effectiveConfig.pollIntervalMs || DEFAULT_POLL_INTERVAL_MS;
+		const maxPollTimeMs = effectiveConfig.maxPollTimeMs || DEFAULT_MAX_POLL_TIME_MS;
+		const { operation: completedOp, error: pollError } = await this.pollOperationStatus(operationName, pollIntervalMs, maxPollTimeMs, effectiveConfig);
+		if (pollError || !completedOp) return { error: pollError || "Polling failed" };
+		let blobRef;
+		let sourceVideoUri;
+		const generatedVideo = completedOp.response?.videos?.[0];
+		const base64Video = generatedVideo?.bytesBase64Encoded;
+		if (base64Video) {
+			require_logger.logger.debug(`[Google Video] Storing base64 encoded video to blob storage...`);
+			const { blobRef: ref, error } = await this.storeBase64VideoToBlob(base64Video, context);
+			if (error) return { error };
+			blobRef = ref;
+		} else {
+			const videoUri = generatedVideo?.gcsUri ?? completedOp.response?.generateVideoResponse?.generatedSamples?.[0]?.video?.uri;
+			if (!videoUri) {
+				require_logger.logger.debug(`[Google Video] Response: ${JSON.stringify(completedOp.response)}`);
+				return { error: "No video data in response" };
+			}
+			sourceVideoUri = getReusableGeneratedVideoUri(videoUri, this.isVertexMode(effectiveConfig));
+			const { blobRef: ref, error: downloadError } = await this.downloadVideoToBlob(videoUri, effectiveConfig, context);
+			if (downloadError) return { error: downloadError };
+			blobRef = ref;
+		}
+		if (!blobRef) return { error: "Failed to store video" };
+		const latencyMs = Date.now() - startTime;
+		const sanitizedPrompt = prompt.replace(/\r?\n|\r/g, " ").replace(/\[/g, "(").replace(/\]/g, ")");
+		const output = `[Video: ${require_text.ellipsize(sanitizedPrompt, 50)}](${blobRef.uri})`;
+		const generatedDurationSeconds = isVideoExtension ? 7 : durationSeconds;
+		return {
+			output,
+			cached: false,
+			cost: calculateVeoCost(model, resolution, generatedDurationSeconds),
+			latencyMs,
+			video: {
+				id: operationName,
+				blobRef,
+				url: blobRef.uri,
+				format: "mp4",
+				size: resolution,
+				...isVideoExtension ? {} : { duration: durationSeconds },
+				model,
+				aspectRatio,
+				resolution
+			},
+			metadata: {
+				operationName,
+				...sourceVideoUri ? { videoUri: sourceVideoUri } : {},
+				model,
+				aspectRatio,
+				resolution,
+				...isVideoExtension ? { extensionSeconds: generatedDurationSeconds } : { durationSeconds },
+				blobHash: blobRef.hash,
+				...sourceVideoUri ? { sourceVideoUri } : {}
+			}
+		};
+	}
+};
+//#endregion
+exports.GoogleVideoProvider = GoogleVideoProvider;
+
+//# sourceMappingURL=video-BY7Q2Gii.cjs.map