promptfoo 0.125.0 → 0.125.1

package/dist/src/modelslab-DZ6BFlDv.js

@@ -0,0 +1,170 @@
+import { Z as getProviderEnvString, o as logger, q as getEnvString } from "./logger-CNHLbG5Y.js";
+import { t as fetchWithProxy } from "./fetch-BG_Jl7ty.js";
+import { a as getRequestTimeoutMs } from "./shared-BnN4RWgk.js";
+import { i as fetchWithCache } from "./cache-DeF5zIEN.js";
+import { i as storeBlob } from "./blobs-rEnZnOz1.js";
+import { n as isBlobStorageEnabled } from "./extractor-wLjTmXQ-.js";
+import { t as ellipsize } from "./text-Fd7EOhdv.js";
+//#region src/providers/modelslab.ts
+/**
+* ModelsLab provider for text-to-image generation.
+*
+* Handles async polling: initial response may return {status: "processing"},
+* in which case we poll the fetch endpoint until completion.
+*
+* API docs: https://docs.modelslab.com
+*
+* NOTE: ModelsLab uses key-in-body authentication (not Bearer header).
+* The API key is sent as the "key" field in the JSON request body.
+*/
+const MODELSLAB_BASE_URL = "https://modelslab.com/api/v6";
+const POLL_INTERVAL_MS = 3e3;
+const MAX_POLL_ATTEMPTS = 60;
+var ModelsLabImageProvider = class {
+	modelName;
+	apiKey;
+	config;
+	constructor(modelName, options = {}) {
+		const { config, id, env } = options;
+		this.modelName = modelName;
+		this.apiKey = config?.apiKey || getProviderEnvString(env, "MODELSLAB_API_KEY") || getEnvString("MODELSLAB_API_KEY");
+		const { apiKey: _apiKey, ...restConfig } = config ?? {};
+		this.config = restConfig;
+		this.id = id ? () => id : this.id;
+	}
+	id() {
+		return `modelslab:image:${this.modelName}`;
+	}
+	toString() {
+		return `[ModelsLab Image Provider ${this.modelName}]`;
+	}
+	async callApi(prompt, context, _callApiOptions) {
+		if (!this.apiKey) return { error: "ModelsLab API key is not set. Set the MODELSLAB_API_KEY environment variable or add `apiKey` to the provider config." };
+		const config = {
+			...this.config,
+			...context?.prompt?.config
+		};
+		const requestBody = {
+			key: this.apiKey,
+			model_id: this.modelName,
+			prompt,
+			width: config.width ?? 512,
+			height: config.height ?? 512,
+			num_inference_steps: config.num_inference_steps ?? 30,
+			guidance_scale: config.guidance_scale ?? 7.5,
+			samples: config.samples ?? 1,
+			safety_checker: config.safety_checker ?? "no",
+			enhance_prompt: config.enhance_prompt ?? "no"
+		};
+		if (config.negative_prompt) requestBody.negative_prompt = config.negative_prompt;
+		if (config.seed !== void 0) requestBody.seed = config.seed;
+		try {
+			logger.debug("[ModelsLab] Image generation request", {
+				model: this.modelName,
+				prompt: ellipsize(prompt, 50)
+			});
+			const response = await fetchWithCache(`${MODELSLAB_BASE_URL}/images/text2img`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(requestBody)
+			}, getRequestTimeoutMs(), "json", true);
+			let data = response.data;
+			let cached = response.cached;
+			if (data.status === "processing") {
+				const requestId = data.request_id ?? String(data.id);
+				logger.debug("[ModelsLab] Image is processing, polling for result", {
+					model: this.modelName,
+					requestId
+				});
+				data = await this.pollForCompletion(requestId);
+				cached = false;
+			}
+			if (data.status === "error") return {
+				cached,
+				error: `ModelsLab API error: ${data.message || "Unknown error"}`
+			};
+			if (data.status === "success") {
+				if (!data.output || data.output.length === 0) return { error: "ModelsLab returned no image URLs" };
+				const imageUrl = data.output[0];
+				const { url: resolvedUrl, blobRef } = await this.maybeDownloadToBlob(imageUrl, context);
+				const sanitizedPrompt = prompt.replace(/\r?\n|\r/g, " ").replace(/\[/g, "(").replace(/\]/g, ")");
+				return {
+					output: `![${ellipsize(sanitizedPrompt, 50)}](${resolvedUrl})`,
+					cached,
+					...blobRef && { metadata: {
+						blobRef,
+						blobHash: blobRef.hash
+					} }
+				};
+			}
+			return { error: `Unexpected ModelsLab response status: ${data.status}` };
+		} catch (err) {
+			return { error: `ModelsLab API call error: ${String(err)}` };
+		}
+	}
+	async maybeDownloadToBlob(imageUrl, context) {
+		if (!isBlobStorageEnabled()) return { url: imageUrl };
+		try {
+			const response = await fetchWithProxy(imageUrl);
+			if (!response.ok) {
+				logger.warn("[ModelsLab] Failed to download image for blob storage", {
+					url: imageUrl,
+					status: response.status
+				});
+				return { url: imageUrl };
+			}
+			const buffer = Buffer.from(await response.arrayBuffer());
+			const mimeType = response.headers.get("content-type")?.split(";")[0] || "image/png";
+			const { ref } = await storeBlob(buffer, mimeType, {
+				evalId: context?.evaluationId,
+				location: "response.output",
+				kind: "image",
+				promptIdx: context?.promptIdx,
+				testIdx: context?.testIdx
+			});
+			return {
+				url: ref.uri,
+				blobRef: ref
+			};
+		} catch (error) {
+			logger.warn("[ModelsLab] Failed to store image as blob, using URL", {
+				url: imageUrl,
+				error: String(error)
+			});
+			return { url: imageUrl };
+		}
+	}
+	async pollForCompletion(requestId) {
+		const fetchUrl = `${MODELSLAB_BASE_URL}/images/fetch/${requestId}`;
+		for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt++) {
+			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+			try {
+				const data = (await fetchWithCache(fetchUrl, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({ key: this.apiKey })
+				}, getRequestTimeoutMs(), "json", true)).data;
+				logger.debug("[ModelsLab] Poll attempt", {
+					attempt: attempt + 1,
+					requestId,
+					status: data.status
+				});
+				if (data.status === "success" || data.status === "error") return data;
+			} catch (error) {
+				logger.warn("[ModelsLab] Poll attempt failed", {
+					attempt: attempt + 1,
+					requestId,
+					error: String(error)
+				});
+			}
+		}
+		return {
+			status: "error",
+			message: `ModelsLab image generation timed out after ${MAX_POLL_ATTEMPTS * POLL_INTERVAL_MS / 1e3}s`
+		};
+	}
+};
+//#endregion
+export { ModelsLabImageProvider };
+
+//# sourceMappingURL=modelslab-DZ6BFlDv.js.map

package/dist/src/modelslab-DhRr-vyo.cjs

@@ -0,0 +1,170 @@
+const require_logger = require("./logger-DXUHJBHJ.cjs");
+const require_fetch = require("./fetch-BKlgUg08.cjs");
+const require_shared = require("./shared-D9Bf3UgD.cjs");
+const require_cache = require("./cache-iG87oYan.cjs");
+const require_blobs = require("./blobs-CwaJ7l1g.cjs");
+const require_extractor = require("./extractor-q61MtrkD.cjs");
+const require_text = require("./text-513KmH8t.cjs");
+//#region src/providers/modelslab.ts
+/**
+* ModelsLab provider for text-to-image generation.
+*
+* Handles async polling: initial response may return {status: "processing"},
+* in which case we poll the fetch endpoint until completion.
+*
+* API docs: https://docs.modelslab.com
+*
+* NOTE: ModelsLab uses key-in-body authentication (not Bearer header).
+* The API key is sent as the "key" field in the JSON request body.
+*/
+const MODELSLAB_BASE_URL = "https://modelslab.com/api/v6";
+const POLL_INTERVAL_MS = 3e3;
+const MAX_POLL_ATTEMPTS = 60;
+var ModelsLabImageProvider = class {
+	modelName;
+	apiKey;
+	config;
+	constructor(modelName, options = {}) {
+		const { config, id, env } = options;
+		this.modelName = modelName;
+		this.apiKey = config?.apiKey || require_logger.getProviderEnvString(env, "MODELSLAB_API_KEY") || require_logger.getEnvString("MODELSLAB_API_KEY");
+		const { apiKey: _apiKey, ...restConfig } = config ?? {};
+		this.config = restConfig;
+		this.id = id ? () => id : this.id;
+	}
+	id() {
+		return `modelslab:image:${this.modelName}`;
+	}
+	toString() {
+		return `[ModelsLab Image Provider ${this.modelName}]`;
+	}
+	async callApi(prompt, context, _callApiOptions) {
+		if (!this.apiKey) return { error: "ModelsLab API key is not set. Set the MODELSLAB_API_KEY environment variable or add `apiKey` to the provider config." };
+		const config = {
+			...this.config,
+			...context?.prompt?.config
+		};
+		const requestBody = {
+			key: this.apiKey,
+			model_id: this.modelName,
+			prompt,
+			width: config.width ?? 512,
+			height: config.height ?? 512,
+			num_inference_steps: config.num_inference_steps ?? 30,
+			guidance_scale: config.guidance_scale ?? 7.5,
+			samples: config.samples ?? 1,
+			safety_checker: config.safety_checker ?? "no",
+			enhance_prompt: config.enhance_prompt ?? "no"
+		};
+		if (config.negative_prompt) requestBody.negative_prompt = config.negative_prompt;
+		if (config.seed !== void 0) requestBody.seed = config.seed;
+		try {
+			require_logger.logger.debug("[ModelsLab] Image generation request", {
+				model: this.modelName,
+				prompt: require_text.ellipsize(prompt, 50)
+			});
+			const response = await require_cache.fetchWithCache(`${MODELSLAB_BASE_URL}/images/text2img`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(requestBody)
+			}, require_shared.getRequestTimeoutMs(), "json", true);
+			let data = response.data;
+			let cached = response.cached;
+			if (data.status === "processing") {
+				const requestId = data.request_id ?? String(data.id);
+				require_logger.logger.debug("[ModelsLab] Image is processing, polling for result", {
+					model: this.modelName,
+					requestId
+				});
+				data = await this.pollForCompletion(requestId);
+				cached = false;
+			}
+			if (data.status === "error") return {
+				cached,
+				error: `ModelsLab API error: ${data.message || "Unknown error"}`
+			};
+			if (data.status === "success") {
+				if (!data.output || data.output.length === 0) return { error: "ModelsLab returned no image URLs" };
+				const imageUrl = data.output[0];
+				const { url: resolvedUrl, blobRef } = await this.maybeDownloadToBlob(imageUrl, context);
+				const sanitizedPrompt = prompt.replace(/\r?\n|\r/g, " ").replace(/\[/g, "(").replace(/\]/g, ")");
+				return {
+					output: `![${require_text.ellipsize(sanitizedPrompt, 50)}](${resolvedUrl})`,
+					cached,
+					...blobRef && { metadata: {
+						blobRef,
+						blobHash: blobRef.hash
+					} }
+				};
+			}
+			return { error: `Unexpected ModelsLab response status: ${data.status}` };
+		} catch (err) {
+			return { error: `ModelsLab API call error: ${String(err)}` };
+		}
+	}
+	async maybeDownloadToBlob(imageUrl, context) {
+		if (!require_extractor.isBlobStorageEnabled()) return { url: imageUrl };
+		try {
+			const response = await require_fetch.fetchWithProxy(imageUrl);
+			if (!response.ok) {
+				require_logger.logger.warn("[ModelsLab] Failed to download image for blob storage", {
+					url: imageUrl,
+					status: response.status
+				});
+				return { url: imageUrl };
+			}
+			const buffer = Buffer.from(await response.arrayBuffer());
+			const mimeType = response.headers.get("content-type")?.split(";")[0] || "image/png";
+			const { ref } = await require_blobs.storeBlob(buffer, mimeType, {
+				evalId: context?.evaluationId,
+				location: "response.output",
+				kind: "image",
+				promptIdx: context?.promptIdx,
+				testIdx: context?.testIdx
+			});
+			return {
+				url: ref.uri,
+				blobRef: ref
+			};
+		} catch (error) {
+			require_logger.logger.warn("[ModelsLab] Failed to store image as blob, using URL", {
+				url: imageUrl,
+				error: String(error)
+			});
+			return { url: imageUrl };
+		}
+	}
+	async pollForCompletion(requestId) {
+		const fetchUrl = `${MODELSLAB_BASE_URL}/images/fetch/${requestId}`;
+		for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt++) {
+			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+			try {
+				const data = (await require_cache.fetchWithCache(fetchUrl, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({ key: this.apiKey })
+				}, require_shared.getRequestTimeoutMs(), "json", true)).data;
+				require_logger.logger.debug("[ModelsLab] Poll attempt", {
+					attempt: attempt + 1,
+					requestId,
+					status: data.status
+				});
+				if (data.status === "success" || data.status === "error") return data;
+			} catch (error) {
+				require_logger.logger.warn("[ModelsLab] Poll attempt failed", {
+					attempt: attempt + 1,
+					requestId,
+					error: String(error)
+				});
+			}
+		}
+		return {
+			status: "error",
+			message: `ModelsLab image generation timed out after ${MAX_POLL_ATTEMPTS * POLL_INTERVAL_MS / 1e3}s`
+		};
+	}
+};
+//#endregion
+exports.ModelsLabImageProvider = ModelsLabImageProvider;
+
+//# sourceMappingURL=modelslab-DhRr-vyo.cjs.map

package/dist/src/nova-reel-BL8DrN4_.js

@@ -0,0 +1,272 @@
+import { o as logger } from "./logger-CNHLbG5Y.js";
+import { n as sleep } from "./time-Db5rO0GY.js";
+import { i as storeBlob } from "./blobs-rEnZnOz1.js";
+import { t as ellipsize } from "./text-Fd7EOhdv.js";
+import { r as loadBedrockImageData, t as AwsBedrockGenericProvider } from "./base-CcViNwVs.js";
+//#region src/providers/bedrock/nova-reel.ts
+/**
+* Amazon Nova Reel Video Generation Provider
+*
+* Supports text-to-video and image-to-video generation using AWS Bedrock's
+* async invoke API. Videos are generated in 6-second increments up to 2 minutes.
+*/
+const MODEL_ID = "amazon.nova-reel-v1:1";
+const DEFAULT_DURATION_SECONDS = 6;
+const DEFAULT_POLL_INTERVAL_MS = 1e4;
+const DEFAULT_MAX_POLL_TIME_MS = 9e5;
+const VIDEO_DIMENSION = "1280x720";
+const VIDEO_FPS = 24;
+var NovaReelVideoProvider = class extends AwsBedrockGenericProvider {
+	videoConfig;
+	providerId;
+	constructor(modelName = MODEL_ID, options = {}) {
+		super(modelName, options);
+		this.videoConfig = options.config || {};
+		this.providerId = options.id;
+	}
+	id() {
+		return this.providerId || `bedrock:video:${this.modelName}`;
+	}
+	toString() {
+		return `[Amazon Nova Reel Video Provider ${this.modelName}]`;
+	}
+	/**
+	* Load image data from file:// path or return as-is if base64
+	*/
+	loadImageData(imagePath) {
+		return loadBedrockImageData(imagePath);
+	}
+	/**
+	* Detect image format from path or data
+	*/
+	detectImageFormat(imagePath) {
+		const lowerPath = imagePath.toLowerCase();
+		if (lowerPath.includes(".png") || lowerPath.startsWith("ivborw")) return "png";
+		return "jpeg";
+	}
+	/**
+	* Build model input based on task type
+	*/
+	buildModelInput(prompt, config) {
+		const taskType = config.taskType || "TEXT_VIDEO";
+		const durationSeconds = config.durationSeconds || DEFAULT_DURATION_SECONDS;
+		if (taskType === "TEXT_VIDEO" && durationSeconds !== 6) return { error: "TEXT_VIDEO task type only supports durationSeconds: 6" };
+		if ((taskType === "MULTI_SHOT_AUTOMATED" || taskType === "MULTI_SHOT_MANUAL") && (durationSeconds < 12 || durationSeconds > 120 || durationSeconds % 6 !== 0)) return { error: `Multi-shot videos require durationSeconds between 12-120 in multiples of 6. Got: ${durationSeconds}` };
+		const videoGenerationConfig = {
+			durationSeconds,
+			fps: VIDEO_FPS,
+			dimension: VIDEO_DIMENSION,
+			...config.seed !== void 0 && { seed: config.seed }
+		};
+		if (taskType === "TEXT_VIDEO") {
+			const textToVideoParams = { text: prompt };
+			if (config.image) {
+				const { data, error } = this.loadImageData(config.image);
+				if (error) return { error };
+				textToVideoParams.images = [{
+					format: this.detectImageFormat(config.image),
+					source: { bytes: data }
+				}];
+			}
+			return { input: {
+				taskType: "TEXT_VIDEO",
+				textToVideoParams,
+				videoGenerationConfig
+			} };
+		}
+		if (taskType === "MULTI_SHOT_AUTOMATED") {
+			if (prompt.length > 4e3) return { error: `MULTI_SHOT_AUTOMATED prompt exceeds 4000 character limit. Got: ${prompt.length}` };
+			return { input: {
+				taskType: "MULTI_SHOT_AUTOMATED",
+				multiShotAutomatedParams: { text: prompt },
+				videoGenerationConfig
+			} };
+		}
+		if (taskType === "MULTI_SHOT_MANUAL") {
+			if (!config.shots || config.shots.length === 0) return { error: "MULTI_SHOT_MANUAL requires shots array in config" };
+			return { input: {
+				taskType: "MULTI_SHOT_MANUAL",
+				multiShotManualParams: { shots: config.shots.map((shot) => {
+					const shotDef = { text: shot.text };
+					if (shot.image) shotDef.image = shot.image;
+					return shotDef;
+				}) },
+				videoGenerationConfig
+			} };
+		}
+		return { error: `Unknown task type: ${taskType}` };
+	}
+	/**
+	* Start async video generation job
+	*/
+	async startVideoGeneration(modelInput, s3OutputUri) {
+		try {
+			const { BedrockRuntimeClient, StartAsyncInvokeCommand } = await import("@aws-sdk/client-bedrock-runtime");
+			const credentials = await this.getCredentials();
+			const client = new BedrockRuntimeClient({
+				region: this.getRegion(),
+				...credentials ? { credentials } : {}
+			});
+			const command = new StartAsyncInvokeCommand({
+				modelId: this.modelName,
+				modelInput,
+				outputDataConfig: { s3OutputDataConfig: { s3Uri: s3OutputUri } }
+			});
+			return { invocationArn: (await client.send(command)).invocationArn };
+		} catch (err) {
+			const error = err;
+			logger.error("[Nova Reel] Failed to start video generation", { error });
+			return { error: `Failed to start video generation: ${error.message || String(err)}` };
+		}
+	}
+	/**
+	* Poll for job completion
+	*/
+	async pollForCompletion(invocationArn, pollIntervalMs, maxPollTimeMs) {
+		const startTime = Date.now();
+		try {
+			const { BedrockRuntimeClient, GetAsyncInvokeCommand } = await import("@aws-sdk/client-bedrock-runtime");
+			const credentials = await this.getCredentials();
+			const client = new BedrockRuntimeClient({
+				region: this.getRegion(),
+				...credentials ? { credentials } : {}
+			});
+			while (Date.now() - startTime < maxPollTimeMs) {
+				const command = new GetAsyncInvokeCommand({ invocationArn });
+				const invocation = await client.send(command);
+				logger.debug(`[Nova Reel] Job status: ${invocation.status}`, {
+					invocationArn,
+					elapsedMs: Date.now() - startTime
+				});
+				if (invocation.status === "Completed") return { response: {
+					invocationArn: invocation.invocationArn || invocationArn,
+					status: "Completed",
+					submitTime: invocation.submitTime?.toISOString(),
+					endTime: invocation.endTime?.toISOString(),
+					outputDataConfig: invocation.outputDataConfig
+				} };
+				if (invocation.status === "Failed") return { error: `Video generation failed: ${invocation.failureMessage}` };
+				await sleep(pollIntervalMs);
+			}
+			return { error: `Video generation timed out after ${maxPollTimeMs / 1e3} seconds` };
+		} catch (err) {
+			const error = err;
+			logger.error("[Nova Reel] Polling error", {
+				error,
+				invocationArn
+			});
+			return { error: `Polling error: ${error.message || String(err)}` };
+		}
+	}
+	/**
+	* Download video from S3 and store to blob storage
+	*/
+	async downloadAndStoreVideo(s3Uri, context) {
+		try {
+			const match = s3Uri.match(/^s3:\/\/([^/]+)\/(.+)$/);
+			if (!match) return { error: `Invalid S3 URI: ${s3Uri}` };
+			const [, bucket, keyPrefix] = match;
+			const { S3Client, GetObjectCommand } = await import("@aws-sdk/client-s3");
+			const credentials = await this.getCredentials();
+			const s3 = new S3Client({
+				region: this.getRegion(),
+				...credentials ? { credentials } : {}
+			});
+			const videoKey = keyPrefix.endsWith("/") ? `${keyPrefix}output.mp4` : `${keyPrefix}/output.mp4`;
+			logger.debug("[Nova Reel] Downloading video from S3", {
+				bucket,
+				key: videoKey
+			});
+			const response = await s3.send(new GetObjectCommand({
+				Bucket: bucket,
+				Key: videoKey
+			}));
+			if (!response.Body) return { error: "Empty response from S3" };
+			const buffer = Buffer.from(await response.Body.transformToByteArray());
+			const { ref } = await storeBlob(buffer, "video/mp4", {
+				evalId: context?.evaluationId,
+				kind: "video",
+				location: "response.video",
+				promptIdx: context?.promptIdx,
+				testIdx: context?.testIdx
+			});
+			logger.debug(`[Nova Reel] Stored video to blob storage`, {
+				uri: ref.uri,
+				hash: ref.hash
+			});
+			return { blobRef: ref };
+		} catch (err) {
+			const error = err;
+			logger.error("[Nova Reel] S3 download error", {
+				error,
+				s3Uri
+			});
+			if (error.name === "MODULE_NOT_FOUND" || String(err).includes("Cannot find module")) return { error: "The @aws-sdk/client-s3 package is required for Nova Reel video downloads. Install it with: npm install @aws-sdk/client-s3" };
+			return { error: `S3 download error: ${error.message || String(err)}` };
+		}
+	}
+	async callApi(prompt, context) {
+		const s3OutputUri = this.videoConfig.s3OutputUri;
+		if (!s3OutputUri) return { error: "Nova Reel requires s3OutputUri in provider config. Example: s3://my-bucket/videos" };
+		if (!s3OutputUri.startsWith("s3://")) return { error: `Invalid s3OutputUri: ${s3OutputUri}. Must start with s3://` };
+		if (!prompt || prompt.trim() === "") return { error: "Prompt is required for video generation" };
+		const config = {
+			...this.videoConfig,
+			...context?.prompt?.config
+		};
+		const startTime = Date.now();
+		const { input: modelInput, error: buildError } = this.buildModelInput(prompt, config);
+		if (buildError || !modelInput) return { error: buildError || "Failed to build model input" };
+		logger.info(`[Nova Reel] Starting video generation job...`, {
+			taskType: config.taskType || "TEXT_VIDEO",
+			durationSeconds: config.durationSeconds || DEFAULT_DURATION_SECONDS,
+			s3OutputUri
+		});
+		const { invocationArn, error: startError } = await this.startVideoGeneration(modelInput, s3OutputUri);
+		if (startError || !invocationArn) return { error: startError || "Failed to start video generation" };
+		logger.info(`[Nova Reel] Job started`, { invocationArn });
+		const pollIntervalMs = config.pollIntervalMs || DEFAULT_POLL_INTERVAL_MS;
+		const maxPollTimeMs = config.maxPollTimeMs || DEFAULT_MAX_POLL_TIME_MS;
+		const { response, error: pollError } = await this.pollForCompletion(invocationArn, pollIntervalMs, maxPollTimeMs);
+		if (pollError || !response) return { error: pollError || "Polling failed" };
+		const outputS3Uri = response.outputDataConfig?.s3OutputDataConfig?.s3Uri;
+		if (!outputS3Uri) return { error: "No output location in response" };
+		let blobRef;
+		const outputUrl = `${outputS3Uri}/output.mp4`;
+		if (config.downloadFromS3 !== false) {
+			const { blobRef: ref, error: downloadError } = await this.downloadAndStoreVideo(outputS3Uri, context);
+			if (downloadError) logger.warn(`[Nova Reel] Failed to download video: ${downloadError}. Using S3 URL.`);
+			else blobRef = ref;
+		}
+		const latencyMs = Date.now() - startTime;
+		const durationSeconds = config.durationSeconds || DEFAULT_DURATION_SECONDS;
+		const sanitizedPrompt = prompt.replace(/\r?\n|\r/g, " ").replace(/\[/g, "(").replace(/\]/g, ")");
+		return {
+			output: `[Video: ${ellipsize(sanitizedPrompt, 50)}](${blobRef?.uri || outputUrl})`,
+			cached: false,
+			latencyMs,
+			video: {
+				id: invocationArn,
+				blobRef,
+				url: blobRef ? void 0 : outputUrl,
+				format: "mp4",
+				size: VIDEO_DIMENSION,
+				duration: durationSeconds,
+				model: this.modelName,
+				resolution: VIDEO_DIMENSION
+			},
+			metadata: {
+				invocationArn,
+				model: this.modelName,
+				taskType: config.taskType || "TEXT_VIDEO",
+				durationSeconds,
+				s3OutputUri: outputS3Uri,
+				...blobRef && { blobHash: blobRef.hash }
+			}
+		};
+	}
+};
+//#endregion
+export { NovaReelVideoProvider };
+
+//# sourceMappingURL=nova-reel-BL8DrN4_.js.map