fengming 0.3.8 → 0.3.10

package/dist/video-generation-BgJp7UIA.d.ts

@@ -1,224 +0,0 @@
-import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
-import { s as AuthProfileStore } from "./types-BmXgNGah.js";
-import { f as VideoGenerationResult$1, p as VideoGenerationSourceAsset$1, t as GeneratedVideoAsset$1, u as VideoGenerationRequest$1 } from "./types-fwX0Z4hO.js";
-import { n as ProviderOperationTimeoutMs, u as postJsonRequest } from "./provider-http-fJ-ZA93K.js";
-
-//#region src/video-generation/dashscope-compatible.d.ts
-declare const DEFAULT_DASHSCOPE_WAN_VIDEO_MODEL = "wan2.6-t2v";
-declare const DASHSCOPE_WAN_VIDEO_MODELS: string[];
-declare const DASHSCOPE_WAN_VIDEO_CAPABILITIES: {
-  generate: {
-    maxVideos: number;
-    maxDurationSeconds: number;
-    supportsSize: true;
-    supportsAspectRatio: true;
-    supportsResolution: true;
-    supportsAudio: true;
-    supportsWatermark: true;
-  };
-  imageToVideo: {
-    enabled: true;
-    maxVideos: number;
-    maxInputImages: number;
-    maxDurationSeconds: number;
-    supportsSize: true;
-    supportsAspectRatio: true;
-    supportsResolution: true;
-    supportsAudio: true;
-    supportsWatermark: true;
-  };
-  videoToVideo: {
-    enabled: true;
-    maxVideos: number;
-    maxInputVideos: number;
-    maxDurationSeconds: number;
-    supportsSize: true;
-    supportsAspectRatio: true;
-    supportsResolution: true;
-    supportsAudio: true;
-    supportsWatermark: true;
-  };
-};
-declare const DEFAULT_VIDEO_GENERATION_DURATION_SECONDS = 5;
-declare const DEFAULT_VIDEO_GENERATION_TIMEOUT_MS = 120000;
-declare const DEFAULT_VIDEO_RESOLUTION_TO_SIZE: Record<string, string>;
-type DashscopeVideoGenerationResponse = {
-  output?: {
-    task_id?: string;
-    task_status?: string;
-    submit_time?: string;
-    results?: Array<{
-      video_url?: string;
-      orig_prompt?: string;
-      actual_prompt?: string;
-    }>;
-    video_url?: string;
-    code?: string;
-    message?: string;
-  };
-  request_id?: string;
-  code?: string;
-  message?: string;
-};
-declare function buildDashscopeVideoGenerationInput(params: {
-  providerLabel: string;
-  req: VideoGenerationRequest$1;
-}): Record<string, unknown>;
-declare function resolveVideoGenerationReferenceUrls(inputImages: VideoGenerationSourceAsset$1[] | undefined, inputVideos: VideoGenerationSourceAsset$1[] | undefined): string[];
-declare function buildDashscopeVideoGenerationParameters(req: VideoGenerationRequest$1, resolutionToSize?: Record<string, string>): Record<string, unknown> | undefined;
-declare function extractDashscopeVideoUrls(payload: DashscopeVideoGenerationResponse): string[];
-declare function pollDashscopeVideoTaskUntilComplete(params: {
-  providerLabel: string;
-  taskId: string;
-  headers: Headers;
-  timeoutMs?: number;
-  fetchFn: typeof fetch;
-  baseUrl: string;
-  defaultTimeoutMs?: number;
-}): Promise<DashscopeVideoGenerationResponse>;
-declare function runDashscopeVideoGenerationTask(params: {
-  providerLabel: string;
-  model: string;
-  req: VideoGenerationRequest$1;
-  url: string;
-  headers: Headers;
-  baseUrl: string;
-  timeoutMs?: number;
-  fetchFn: typeof fetch;
-  allowPrivateNetwork?: boolean;
-  dispatcherPolicy?: Parameters<typeof postJsonRequest>[0]["dispatcherPolicy"];
-  defaultTimeoutMs?: number;
-}): Promise<VideoGenerationResult$1>;
-declare function downloadDashscopeGeneratedVideos(params: {
-  providerLabel: string;
-  urls: string[];
-  timeoutMs?: ProviderOperationTimeoutMs;
-  fetchFn: typeof fetch;
-  defaultTimeoutMs?: number;
-  maxBytes: number;
-}): Promise<GeneratedVideoAsset$1[]>;
-//#endregion
-//#region src/plugin-sdk/video-generation.d.ts
-type GeneratedVideoAsset = {
-  /** Raw video bytes. Either buffer or url must be present. */buffer?: Buffer;
-  /** Pre-signed or provider-hosted URL for the video. When set and buffer is
-   * absent, callers can deliver or download the asset without requiring the
-   * provider to materialize the full file in memory first. */
-  url?: string;
-  mimeType: string;
-  fileName?: string;
-  metadata?: Record<string, unknown>;
-};
-type VideoGenerationResolution = "360P" | "480P" | "540P" | "720P" | "768P" | "1080P" | (string & {});
-/**
- * Canonical semantic role hints for reference assets (first/last frame,
- * reference image/video/audio). Providers may accept additional role strings;
- * the asset.role type accepts both canonical values and arbitrary strings.
- */
-type VideoGenerationAssetRole = "first_frame" | "last_frame" | "reference_image" | "reference_video" | "reference_audio";
-type VideoGenerationSourceAsset = {
-  url?: string;
-  buffer?: Buffer;
-  mimeType?: string;
-  fileName?: string;
-  /**
-   * Optional semantic role hint forwarded to the provider. Canonical values
-   * come from `VideoGenerationAssetRole`; plain strings are accepted for
-   * provider-specific extensions.
-   */
-  role?: VideoGenerationAssetRole | (string & {});
-  metadata?: Record<string, unknown>;
-};
-type VideoGenerationProviderConfiguredContext = {
-  cfg?: FengMingConfig;
-  agentDir?: string;
-};
-type VideoGenerationModelCapabilitiesContext = {
-  provider: string;
-  model: string;
-  cfg: FengMingConfig;
-  agentDir?: string;
-  authStore?: AuthProfileStore;
-  timeoutMs?: number;
-};
-type VideoGenerationRequest = {
-  provider: string;
-  model: string;
-  prompt: string;
-  cfg: FengMingConfig;
-  agentDir?: string;
-  authStore?: AuthProfileStore;
-  timeoutMs?: number;
-  size?: string;
-  aspectRatio?: string;
-  resolution?: VideoGenerationResolution;
-  durationSeconds?: number;
-  audio?: boolean;
-  watermark?: boolean;
-  inputImages?: VideoGenerationSourceAsset[];
-  inputVideos?: VideoGenerationSourceAsset[]; /** Reference audio assets (e.g. background music) forwarded to the provider. */
-  inputAudios?: VideoGenerationSourceAsset[]; /** Arbitrary provider-specific parameters forwarded as-is (e.g. seed, draft, camerafixed). */
-  providerOptions?: Record<string, unknown>;
-};
-type VideoGenerationResult = {
-  videos: GeneratedVideoAsset[];
-  model?: string;
-  metadata?: Record<string, unknown>;
-};
-type VideoGenerationMode = "generate" | "imageToVideo" | "videoToVideo";
-/**
- * Primitive type tag for a declared `providerOptions` key. Keep narrow —
- * plugins that need richer shapes should leave them out of the typed contract
- * and interpret the forwarded opaque value inside their own provider code.
- */
-type VideoGenerationProviderOptionType = "number" | "boolean" | "string";
-type VideoGenerationModeCapabilities = {
-  maxVideos?: number;
-  maxInputImages?: number;
-  maxInputImagesByModel?: Readonly<Record<string, number>>;
-  maxInputVideos?: number;
-  maxInputVideosByModel?: Readonly<Record<string, number>>; /** Max number of reference audio assets the provider accepts (e.g. background music, voice reference). */
-  maxInputAudios?: number;
-  maxInputAudiosByModel?: Readonly<Record<string, number>>;
-  maxDurationSeconds?: number;
-  supportedDurationSeconds?: readonly number[];
-  supportedDurationSecondsByModel?: Readonly<Record<string, readonly number[]>>;
-  sizes?: readonly string[];
-  aspectRatios?: readonly string[];
-  resolutions?: readonly VideoGenerationResolution[];
-  supportsSize?: boolean;
-  supportsAspectRatio?: boolean;
-  supportsResolution?: boolean;
-  supportsAudio?: boolean;
-  supportsWatermark?: boolean;
-  /**
-   * Declared typed schema for `VideoGenerationRequest.providerOptions`. Keys
-   * listed here are accepted and validated against the declared primitive
-   * type before forwarding; unknown keys or type mismatches skip the
-   * candidate provider at runtime so mis-typed or provider-specific options
-   * never silently reach the wrong provider.
-   */
-  providerOptions?: Readonly<Record<string, VideoGenerationProviderOptionType>>;
-};
-type VideoGenerationTransformCapabilities = VideoGenerationModeCapabilities & {
-  enabled: boolean;
-};
-type VideoGenerationProviderCapabilities = VideoGenerationModeCapabilities & {
-  generate?: VideoGenerationModeCapabilities;
-  imageToVideo?: VideoGenerationTransformCapabilities;
-  videoToVideo?: VideoGenerationTransformCapabilities;
-};
-type VideoGenerationProvider = {
-  id: string;
-  aliases?: string[];
-  label?: string;
-  defaultModel?: string; /** Default provider operation timeout in milliseconds when caller/config omit timeoutMs. */
-  defaultTimeoutMs?: number;
-  models?: string[];
-  capabilities: VideoGenerationProviderCapabilities;
-  isConfigured?: (ctx: VideoGenerationProviderConfiguredContext) => boolean;
-  resolveModelCapabilities?: (ctx: VideoGenerationModelCapabilitiesContext) => VideoGenerationProviderCapabilities | undefined | Promise<VideoGenerationProviderCapabilities | undefined>;
-  generateVideo: (req: VideoGenerationRequest) => Promise<VideoGenerationResult>;
-};
-//#endregion
-export { buildDashscopeVideoGenerationParameters as C, resolveVideoGenerationReferenceUrls as D, pollDashscopeVideoTaskUntilComplete as E, runDashscopeVideoGenerationTask as O, buildDashscopeVideoGenerationInput as S, extractDashscopeVideoUrls as T, DEFAULT_DASHSCOPE_WAN_VIDEO_MODEL as _, VideoGenerationModelCapabilitiesContext as a, DEFAULT_VIDEO_RESOLUTION_TO_SIZE as b, VideoGenerationProviderConfiguredContext as c, VideoGenerationResolution as d, VideoGenerationResult as f, DASHSCOPE_WAN_VIDEO_MODELS as g, DASHSCOPE_WAN_VIDEO_CAPABILITIES as h, VideoGenerationModeCapabilities as i, VideoGenerationProviderOptionType as l, VideoGenerationTransformCapabilities as m, VideoGenerationAssetRole as n, VideoGenerationProvider as o, VideoGenerationSourceAsset as p, VideoGenerationMode as r, VideoGenerationProviderCapabilities as s, GeneratedVideoAsset as t, VideoGenerationRequest as u, DEFAULT_VIDEO_GENERATION_DURATION_SECONDS as v, downloadDashscopeGeneratedVideos as w, DashscopeVideoGenerationResponse as x, DEFAULT_VIDEO_GENERATION_TIMEOUT_MS as y };

package/dist/video-generation-provider-BjiVjf40.js

@@ -1,325 +0,0 @@
-import { c as normalizeOptionalString } from "./string-coerce-DKw2K5wM.js";
-import { n as readResponseWithLimit } from "./read-response-with-limit-S6PVjcFB.js";
-import { r as extensionForMime } from "./mime-TnUOZVhx.js";
-import { n as assertOkOrThrowHttpError } from "./provider-http-errors-C--npz1E.js";
-import { a as fetchProviderOperationResponse, c as postJsonRequest, h as waitProviderOperationPollInterval, i as fetchProviderDownloadResponse, m as resolveProviderOperationTimeoutMs, n as createProviderOperationDeadline, p as resolveProviderHttpRequestConfig, r as createProviderOperationTimeoutResolver } from "./shared-C5ZakVU4.js";
-import "./string-coerce-runtime-BurriTLB.js";
-import "./media-mime-CoRc7Jth.js";
-import { r as isProviderApiKeyConfigured } from "./provider-auth-Ct8J8VHF.js";
-import { a as resolveApiKeyForProvider } from "./provider-auth-runtime-B5tYxbJM.js";
-import "./provider-http-KKX4hNG5.js";
-//#region extensions/minimax/video-generation-provider.ts
-const DEFAULT_MINIMAX_VIDEO_BASE_URL = "https://api.minimax.io";
-const DEFAULT_MINIMAX_VIDEO_MODEL = "MiniMax-Hailuo-2.3";
-const DEFAULT_TIMEOUT_MS = 12e4;
-const DEFAULT_OPERATION_TIMEOUT_MS = 12e5;
-const POLL_INTERVAL_MS = 1e4;
-const MAX_POLL_ATTEMPTS = 120;
-const DEFAULT_GENERATED_VIDEO_MAX_BYTES = 16 * 1024 * 1024;
-const MINIMAX_MODEL_ALLOWED_DURATIONS = {
-	"MiniMax-Hailuo-2.3": [6, 10],
-	"MiniMax-Hailuo-02": [6, 10]
-};
-const MINIMAX_MODEL_ALLOWED_RESOLUTIONS = {
-	"MiniMax-Hailuo-2.3": ["768P", "1080P"],
-	"MiniMax-Hailuo-2.3-Fast": ["768P", "1080P"],
-	"MiniMax-Hailuo-02": ["768P", "1080P"]
-};
-const MINIMAX_RESOLUTION_ORDER = [
-	"480P",
-	"720P",
-	"768P",
-	"1080P"
-];
-function resolveMinimaxVideoBaseUrl(cfg, providerId) {
-	const direct = normalizeOptionalString(cfg?.models?.providers?.[providerId]?.baseUrl);
-	if (!direct) return DEFAULT_MINIMAX_VIDEO_BASE_URL;
-	try {
-		return new URL(direct).origin;
-	} catch {
-		return DEFAULT_MINIMAX_VIDEO_BASE_URL;
-	}
-}
-function resolveGeneratedVideoMaxBytes(req) {
-	const configured = req.cfg.agents?.defaults?.mediaMaxMb;
-	if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) return Math.floor(configured * 1024 * 1024);
-	return DEFAULT_GENERATED_VIDEO_MAX_BYTES;
-}
-function assertMinimaxBaseResp(baseResp, context) {
-	if (!baseResp || typeof baseResp.status_code !== "number" || baseResp.status_code === 0) return;
-	throw new Error(`${context} (${baseResp.status_code}): ${baseResp.status_msg ?? "unknown error"}`);
-}
-function toDataUrl(buffer, mimeType) {
-	return `data:${mimeType};base64,${buffer.toString("base64")}`;
-}
-function resolveFirstFrameImage(req) {
-	const input = req.inputImages?.[0];
-	if (!input) return;
-	const inputUrl = normalizeOptionalString(input.url);
-	if (inputUrl) return inputUrl;
-	if (!input.buffer) throw new Error("MiniMax image-to-video input is missing image data.");
-	return toDataUrl(input.buffer, normalizeOptionalString(input.mimeType) ?? "image/png");
-}
-function resolveDurationSeconds(params) {
-	if (typeof params.durationSeconds !== "number" || !Number.isFinite(params.durationSeconds)) return;
-	const rounded = Math.max(1, Math.round(params.durationSeconds));
-	const allowed = MINIMAX_MODEL_ALLOWED_DURATIONS[params.model];
-	if (!allowed || allowed.length === 0) return rounded;
-	return allowed.reduce((best, current) => Math.abs(current - rounded) < Math.abs(best - rounded) ? current : best);
-}
-function resolveResolution(params) {
-	const requested = normalizeOptionalString(params.resolution)?.toUpperCase();
-	if (!requested) return;
-	const allowed = MINIMAX_MODEL_ALLOWED_RESOLUTIONS[params.model];
-	if (!allowed || allowed.length === 0 || allowed.includes(requested)) return requested;
-	const requestedIndex = MINIMAX_RESOLUTION_ORDER.indexOf(requested);
-	if (requestedIndex < 0) return;
-	return allowed.reduce((best, current) => {
-		const currentIndex = MINIMAX_RESOLUTION_ORDER.indexOf(current);
-		const bestIndex = MINIMAX_RESOLUTION_ORDER.indexOf(best);
-		if (currentIndex < 0) return best;
-		if (bestIndex < 0) return current;
-		return Math.abs(currentIndex - requestedIndex) < Math.abs(bestIndex - requestedIndex) ? current : best;
-	});
-}
-async function pollMinimaxVideo(params) {
-	const deadline = createProviderOperationDeadline({
-		timeoutMs: params.timeoutMs,
-		label: `MiniMax video generation task ${params.taskId}`
-	});
-	for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt += 1) {
-		const url = new URL(`${params.baseUrl}/v1/query/video_generation`);
-		url.searchParams.set("task_id", params.taskId);
-		const payload = await (await fetchProviderOperationResponse({
-			stage: "poll",
-			url: url.toString(),
-			init: {
-				method: "GET",
-				headers: params.headers
-			},
-			timeoutMs: createProviderOperationTimeoutResolver({
-				deadline,
-				defaultTimeoutMs: DEFAULT_TIMEOUT_MS
-			}),
-			fetchFn: params.fetchFn,
-			provider: "minimax",
-			requestFailedMessage: "MiniMax video status request failed"
-		})).json();
-		assertMinimaxBaseResp(payload.base_resp, "MiniMax video generation failed");
-		switch (normalizeOptionalString(payload.status)) {
-			case "Success": return payload;
-			case "Fail": throw new Error(normalizeOptionalString(payload.base_resp?.status_msg) || "MiniMax video generation failed");
-			default:
-				await waitProviderOperationPollInterval({
-					deadline,
-					pollIntervalMs: POLL_INTERVAL_MS
-				});
-				break;
-		}
-	}
-	throw new Error(`MiniMax video generation task ${params.taskId} did not finish in time`);
-}
-async function downloadVideoFromUrl(params) {
-	const response = await fetchProviderDownloadResponse({
-		url: params.url,
-		init: { method: "GET" },
-		timeoutMs: params.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-		fetchFn: params.fetchFn,
-		provider: "minimax",
-		requestFailedMessage: "MiniMax generated video download failed"
-	});
-	const mimeType = normalizeOptionalString(response.headers.get("content-type")) ?? "video/mp4";
-	return {
-		buffer: await readResponseWithLimit(response, params.maxBytes, { onOverflow: ({ maxBytes }) => /* @__PURE__ */ new Error(`MiniMax generated video download exceeds ${maxBytes} bytes`) }),
-		mimeType,
-		fileName: `video-1.${extensionForMime(mimeType)?.slice(1) ?? "mp4"}`
-	};
-}
-async function downloadVideoFromFileId(params) {
-	const url = new URL(`${params.baseUrl}/v1/files/retrieve`);
-	url.searchParams.set("file_id", params.fileId);
-	const metadata = await (await fetchProviderOperationResponse({
-		stage: "download",
-		url: url.toString(),
-		init: {
-			method: "GET",
-			headers: params.headers
-		},
-		timeoutMs: params.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-		fetchFn: params.fetchFn,
-		provider: "minimax",
-		requestFailedMessage: "MiniMax generated video metadata request failed"
-	})).json();
-	assertMinimaxBaseResp(metadata.base_resp, "MiniMax generated video metadata request failed");
-	const downloadUrl = normalizeOptionalString(metadata.file?.download_url);
-	if (!downloadUrl) throw new Error("MiniMax generated video metadata missing download_url");
-	const response = await fetchProviderDownloadResponse({
-		url: downloadUrl,
-		init: { method: "GET" },
-		timeoutMs: params.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-		fetchFn: params.fetchFn,
-		provider: "minimax",
-		requestFailedMessage: "MiniMax generated video download failed"
-	});
-	const mimeType = normalizeOptionalString(response.headers.get("content-type")) ?? "video/mp4";
-	return {
-		buffer: await readResponseWithLimit(response, params.maxBytes, { onOverflow: ({ maxBytes }) => /* @__PURE__ */ new Error(`MiniMax generated video download exceeds ${maxBytes} bytes`) }),
-		mimeType,
-		fileName: normalizeOptionalString(metadata.file?.filename) || `video-1.${extensionForMime(mimeType)?.slice(1) ?? "mp4"}`
-	};
-}
-function buildMinimaxVideoProvider(providerId) {
-	return {
-		id: providerId,
-		label: "MiniMax",
-		defaultModel: DEFAULT_MINIMAX_VIDEO_MODEL,
-		models: [
-			DEFAULT_MINIMAX_VIDEO_MODEL,
-			"MiniMax-Hailuo-2.3-Fast",
-			"MiniMax-Hailuo-02",
-			"I2V-01-Director",
-			"I2V-01-live",
-			"I2V-01"
-		],
-		isConfigured: ({ agentDir }) => isProviderApiKeyConfigured({
-			provider: providerId,
-			agentDir
-		}),
-		capabilities: {
-			generate: {
-				maxVideos: 1,
-				maxDurationSeconds: 10,
-				supportedDurationSecondsByModel: MINIMAX_MODEL_ALLOWED_DURATIONS,
-				resolutions: ["768P", "1080P"],
-				supportsResolution: true,
-				supportsWatermark: false
-			},
-			imageToVideo: {
-				enabled: true,
-				maxVideos: 1,
-				maxInputImages: 1,
-				maxDurationSeconds: 10,
-				supportedDurationSecondsByModel: MINIMAX_MODEL_ALLOWED_DURATIONS,
-				resolutions: ["768P", "1080P"],
-				supportsResolution: true,
-				supportsWatermark: false
-			},
-			videoToVideo: { enabled: false }
-		},
-		async generateVideo(req) {
-			if ((req.inputVideos?.length ?? 0) > 0) throw new Error("MiniMax video generation does not support video reference inputs.");
-			const auth = await resolveApiKeyForProvider({
-				provider: providerId,
-				cfg: req.cfg,
-				agentDir: req.agentDir,
-				store: req.authStore
-			});
-			if (!auth.apiKey) throw new Error("MiniMax API key missing");
-			const fetchFn = fetch;
-			const deadline = createProviderOperationDeadline({
-				timeoutMs: req.timeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS,
-				label: "MiniMax video generation"
-			});
-			const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveProviderHttpRequestConfig({
-				baseUrl: resolveMinimaxVideoBaseUrl(req.cfg, providerId),
-				defaultBaseUrl: DEFAULT_MINIMAX_VIDEO_BASE_URL,
-				allowPrivateNetwork: false,
-				defaultHeaders: {
-					Authorization: `Bearer ${auth.apiKey}`,
-					"Content-Type": "application/json"
-				},
-				provider: providerId,
-				capability: "video",
-				transport: "http"
-			});
-			const model = normalizeOptionalString(req.model) ?? DEFAULT_MINIMAX_VIDEO_MODEL;
-			const body = {
-				model,
-				prompt: req.prompt
-			};
-			const firstFrameImage = resolveFirstFrameImage(req);
-			if (firstFrameImage) body.first_frame_image = firstFrameImage;
-			const resolution = resolveResolution({
-				model,
-				resolution: req.resolution
-			});
-			if (resolution) body.resolution = resolution;
-			const durationSeconds = resolveDurationSeconds({
-				model,
-				durationSeconds: req.durationSeconds
-			});
-			if (typeof durationSeconds === "number") body.duration = durationSeconds;
-			const { response, release } = await postJsonRequest({
-				url: `${baseUrl}/v1/video_generation`,
-				headers,
-				body,
-				timeoutMs: resolveProviderOperationTimeoutMs({
-					deadline,
-					defaultTimeoutMs: DEFAULT_TIMEOUT_MS
-				}),
-				fetchFn,
-				allowPrivateNetwork,
-				dispatcherPolicy
-			});
-			try {
-				await assertOkOrThrowHttpError(response, "MiniMax video generation failed");
-				const submitted = await response.json();
-				assertMinimaxBaseResp(submitted.base_resp, "MiniMax video generation failed");
-				const taskId = normalizeOptionalString(submitted.task_id);
-				if (!taskId) throw new Error("MiniMax video generation response missing task_id");
-				const completed = await pollMinimaxVideo({
-					taskId,
-					headers,
-					timeoutMs: resolveProviderOperationTimeoutMs({
-						deadline,
-						defaultTimeoutMs: DEFAULT_OPERATION_TIMEOUT_MS
-					}),
-					baseUrl,
-					fetchFn
-				});
-				const videoUrl = normalizeOptionalString(completed.video_url);
-				const fileId = normalizeOptionalString(completed.file_id);
-				return {
-					videos: [videoUrl ? await downloadVideoFromUrl({
-						url: videoUrl,
-						timeoutMs: createProviderOperationTimeoutResolver({
-							deadline,
-							defaultTimeoutMs: DEFAULT_TIMEOUT_MS
-						}),
-						fetchFn,
-						maxBytes: resolveGeneratedVideoMaxBytes(req)
-					}) : fileId ? await downloadVideoFromFileId({
-						fileId,
-						headers,
-						timeoutMs: createProviderOperationTimeoutResolver({
-							deadline,
-							defaultTimeoutMs: DEFAULT_TIMEOUT_MS
-						}),
-						baseUrl,
-						fetchFn,
-						maxBytes: resolveGeneratedVideoMaxBytes(req)
-					}) : (() => {
-						throw new Error("MiniMax video generation completed without a video URL or file_id");
-					})()],
-					model,
-					metadata: {
-						taskId,
-						status: completed.status,
-						fileId,
-						videoUrl
-					}
-				};
-			} finally {
-				await release();
-			}
-		}
-	};
-}
-function buildMinimaxVideoGenerationProvider() {
-	return buildMinimaxVideoProvider("minimax");
-}
-function buildMinimaxPortalVideoGenerationProvider() {
-	return buildMinimaxVideoProvider("minimax-portal");
-}
-//#endregion
-export { buildMinimaxVideoGenerationProvider as n, buildMinimaxPortalVideoGenerationProvider as t };