@openclaw/deepinfra-provider 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/provider-models.js

@@ -1,2 +1,287 @@
-import { a as discoverDeepInfraModels, c as hasDeepInfraApiKey, i as buildDeepInfraModelDefinition, n as DEEPINFRA_DEFAULT_MODEL_REF, o as discoverDeepInfraSurfaces, r as DEEPINFRA_MODEL_CATALOG, s as getDeepInfraSurfaceFallbackCatalog, t as DEEPINFRA_BASE_URL } from "./provider-models-CXaqRQOl.js";
+import { t as modelCatalog } from "./openclaw.plugin-DhzOI6DT.js";
+import { buildManifestModelProviderConfig } from "openclaw/plugin-sdk/provider-catalog-shared";
+import { asPositiveSafeInteger } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { withTrustedEnvProxyGuardedFetchMode } from "openclaw/plugin-sdk/fetch-runtime";
+import { isProviderApiKeyConfigured } from "openclaw/plugin-sdk/provider-auth";
+import { LiveModelCatalogHttpError, getCachedLiveProviderModelRows } from "openclaw/plugin-sdk/provider-catalog-live-runtime";
+import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
+import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
+import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
+//#region extensions/deepinfra/provider-models.ts
+const log = createSubsystemLogger("deepinfra-models");
+const DEEPINFRA_MANIFEST_PROVIDER = buildManifestModelProviderConfig({
+	providerId: "deepinfra",
+	catalog: modelCatalog.providers.deepinfra
+});
+const DEEPINFRA_BASE_URL = DEEPINFRA_MANIFEST_PROVIDER.baseUrl;
+const DEEPINFRA_MODELS_URL = `${DEEPINFRA_BASE_URL}/models?sort_by=openclaw&filter=with_meta`;
+const DEEPINFRA_DEFAULT_MODEL_REF = `deepinfra/deepseek-ai/DeepSeek-V4-Flash`;
+const DEEPINFRA_DEFAULT_CONTEXT_WINDOW = 128e3;
+const DEEPINFRA_DEFAULT_MAX_TOKENS = 8192;
+const DEEPINFRA_MODEL_CATALOG = DEEPINFRA_MANIFEST_PROVIDER.models;
+const DISCOVERY_TIMEOUT_MS = 5e3;
+const DISCOVERY_CACHE_TTL_MS = 300 * 1e3;
+const SURFACE_FOR_TAG = {
+	chat: "chat",
+	vlm: "vlm",
+	embed: "embed",
+	"image-gen": "image-gen",
+	"video-gen": "video-gen",
+	tts: "tts",
+	stt: "stt"
+};
+function entryToSurfaceModel(entry) {
+	const id = typeof entry?.id === "string" ? entry.id.trim() : "";
+	if (!id) return null;
+	const metadata = entry.metadata;
+	if (!metadata) return null;
+	const tags = Array.isArray(metadata.tags) ? metadata.tags.filter((t) => typeof t === "string") : [];
+	const pricing = metadata.pricing ?? {};
+	return {
+		id,
+		name: id,
+		description: metadata.description ?? void 0,
+		tags,
+		contextWindow: asPositiveSafeInteger(metadata.context_length),
+		maxTokens: asPositiveSafeInteger(metadata.max_tokens),
+		pricing,
+		defaultWidth: asPositiveSafeInteger(metadata.default_width),
+		defaultHeight: asPositiveSafeInteger(metadata.default_height),
+		defaultIterations: asPositiveSafeInteger(metadata.default_iterations)
+	};
+}
+function bucketBySurface(models) {
+	const catalog = {
+		chat: [],
+		vlm: [],
+		embed: [],
+		imageGen: [],
+		videoGen: [],
+		tts: [],
+		stt: [],
+		live: true
+	};
+	const buckets = {
+		chat: catalog.chat,
+		vlm: catalog.vlm,
+		embed: catalog.embed,
+		"image-gen": catalog.imageGen,
+		"video-gen": catalog.videoGen,
+		tts: catalog.tts,
+		stt: catalog.stt
+	};
+	for (const model of models) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const tag of model.tags) {
+			const surface = SURFACE_FOR_TAG[tag];
+			if (surface && !seen.has(surface)) {
+				seen.add(surface);
+				buckets[surface].push(model);
+			}
+		}
+	}
+	return catalog;
+}
+function hasDeepInfraSurfaceModelRows(rows) {
+	return rows.some((entry) => entryToSurfaceModel(entry) !== null);
+}
+function manifestChatEntryToSurfaceModel(entry) {
+	const cost = entry.cost ?? {};
+	const pricing = {};
+	if (typeof cost.input === "number") pricing.input_tokens = cost.input;
+	if (typeof cost.output === "number") pricing.output_tokens = cost.output;
+	if (typeof cost.cacheRead === "number" && cost.cacheRead > 0) pricing.cache_read_tokens = cost.cacheRead;
+	const tags = ["chat"];
+	if (entry.input?.includes("image")) tags.push("vlm");
+	if (entry.reasoning) tags.push("reasoning");
+	return {
+		id: entry.id,
+		name: entry.name ?? entry.id,
+		tags,
+		contextWindow: entry.contextWindow,
+		maxTokens: entry.maxTokens,
+		pricing
+	};
+}
+const STATIC_NON_CHAT_FALLBACK = [
+	{
+		id: "black-forest-labs/FLUX-1-schnell",
+		name: "black-forest-labs/FLUX-1-schnell",
+		tags: ["image-gen"],
+		pricing: { per_image_unit: .003 },
+		defaultWidth: 1024,
+		defaultHeight: 1024,
+		defaultIterations: 4
+	},
+	{
+		id: "black-forest-labs/FLUX-1-dev",
+		name: "black-forest-labs/FLUX-1-dev",
+		tags: ["image-gen"],
+		pricing: { per_image_unit: .025 },
+		defaultWidth: 1024,
+		defaultHeight: 1024,
+		defaultIterations: 28
+	},
+	{
+		id: "Qwen/Qwen-Image-Max",
+		name: "Qwen/Qwen-Image-Max",
+		tags: ["image-gen"],
+		pricing: { per_image_unit: .075 },
+		defaultWidth: 1024,
+		defaultHeight: 1024,
+		defaultIterations: 28
+	},
+	{
+		id: "stabilityai/sdxl-turbo",
+		name: "stabilityai/sdxl-turbo",
+		tags: ["image-gen"],
+		pricing: { per_image_unit: 2e-4 },
+		defaultWidth: 1024,
+		defaultHeight: 1024,
+		defaultIterations: 4
+	},
+	{
+		id: "hexgrad/Kokoro-82M",
+		name: "hexgrad/Kokoro-82M",
+		tags: ["tts"],
+		pricing: { input_characters: .65 }
+	},
+	{
+		id: "Qwen/Qwen3-TTS",
+		name: "Qwen/Qwen3-TTS",
+		tags: ["tts"],
+		pricing: { input_characters: .65 }
+	},
+	{
+		id: "ResembleAI/chatterbox-turbo",
+		name: "ResembleAI/chatterbox-turbo",
+		tags: ["tts"],
+		pricing: { input_characters: 1 }
+	},
+	{
+		id: "sesame/csm-1b",
+		name: "sesame/csm-1b",
+		tags: ["tts"],
+		pricing: { input_characters: 7 }
+	},
+	{
+		id: "openai/whisper-large-v3-turbo",
+		name: "openai/whisper-large-v3-turbo",
+		tags: ["stt"],
+		pricing: { input_seconds: 4e-5 }
+	},
+	{
+		id: "BAAI/bge-m3",
+		name: "BAAI/bge-m3",
+		tags: ["embed"],
+		pricing: { input_tokens: .01 },
+		maxTokens: 8192,
+		contextWindow: 8192
+	}
+];
+function manifestFallbackCatalog() {
+	const catalog = bucketBySurface([...(modelCatalog.providers.deepinfra.models ?? []).map(manifestChatEntryToSurfaceModel), ...STATIC_NON_CHAT_FALLBACK]);
+	catalog.live = false;
+	return catalog;
+}
+function getDeepInfraSurfaceFallbackCatalog() {
+	return manifestFallbackCatalog();
+}
+function resolveDeepInfraThinkingFormat(modelId) {
+	return (modelId ?? "").toLowerCase().split("/")[0] === "deepseek-ai" ? "deepseek" : void 0;
+}
+function buildDeepInfraModelDefinition(model) {
+	const thinkingFormat = model.compat?.thinkingFormat ?? resolveDeepInfraThinkingFormat(model.id);
+	return {
+		...model,
+		compat: {
+			...model.compat,
+			supportsUsageInStreaming: model.compat?.supportsUsageInStreaming ?? true,
+			...thinkingFormat ? { thinkingFormat } : {}
+		}
+	};
+}
+function chatSurfaceModelToModelDefinition(model) {
+	const input = model.tags.includes("vlm") ? ["text", "image"] : ["text"];
+	const reasoning = model.tags.includes("reasoning") || model.tags.includes("reasoning_effort");
+	return buildDeepInfraModelDefinition({
+		id: model.id,
+		name: model.name,
+		reasoning,
+		input,
+		contextWindow: model.contextWindow ?? DEEPINFRA_DEFAULT_CONTEXT_WINDOW,
+		maxTokens: model.maxTokens ?? DEEPINFRA_DEFAULT_MAX_TOKENS,
+		cost: {
+			input: model.pricing.input_tokens ?? 0,
+			output: model.pricing.output_tokens ?? 0,
+			cacheRead: model.pricing.cache_read_tokens ?? 0,
+			cacheWrite: 0
+		}
+	});
+}
+function hasDeepInfraApiKey(options) {
+	const fromEnv = (options?.env ?? process.env).DEEPINFRA_API_KEY;
+	if (typeof fromEnv === "string" && fromEnv.trim() !== "") return true;
+	const providers = options?.config?.models?.providers;
+	for (const [providerId, provider] of Object.entries(providers ?? {})) if (providerId.trim().toLowerCase() === "deepinfra" && hasConfiguredSecretInput(provider?.apiKey, options?.config?.secrets?.defaults)) return true;
+	return isProviderApiKeyConfigured({
+		provider: "deepinfra",
+		agentDir: options?.agentDir
+	});
+}
+async function discoverDeepInfraSurfaces(options) {
+	if (process.env.VITEST) return manifestFallbackCatalog();
+	const env = options?.env ?? process.env;
+	if (!(options?.hasApiKey ?? hasDeepInfraApiKey({
+		env,
+		agentDir: options?.agentDir
+	}))) return manifestFallbackCatalog();
+	try {
+		const data = await getCachedLiveProviderModelRows({
+			providerId: "deepinfra",
+			endpoint: DEEPINFRA_MODELS_URL,
+			timeoutMs: DISCOVERY_TIMEOUT_MS,
+			ttlMs: DISCOVERY_CACHE_TTL_MS,
+			buildRequestHeaders: () => ({ Accept: "application/json" }),
+			auditContext: "deepinfra-model-discovery",
+			shouldCacheRows: hasDeepInfraSurfaceModelRows,
+			fetchGuard: (params) => fetchWithSsrFGuard(withTrustedEnvProxyGuardedFetchMode(params))
+		});
+		if (data.length === 0) {
+			log.warn("No models found from DeepInfra agent-projection endpoint, using static catalog");
+			return manifestFallbackCatalog();
+		}
+		const seenIds = /* @__PURE__ */ new Set();
+		const surfaceModels = [];
+		for (const entry of data) {
+			const model = entryToSurfaceModel(entry);
+			if (!model || seenIds.has(model.id)) continue;
+			seenIds.add(model.id);
+			surfaceModels.push(model);
+		}
+		if (surfaceModels.length === 0) return manifestFallbackCatalog();
+		return bucketBySurface(surfaceModels);
+	} catch (error) {
+		if (error instanceof LiveModelCatalogHttpError) {
+			log.warn(`Failed to discover models: HTTP ${error.status}, using static catalog`);
+			return manifestFallbackCatalog();
+		}
+		log.warn(`Discovery failed: ${String(error)}, using static catalog`);
+		return manifestFallbackCatalog();
+	}
+}
+async function discoverDeepInfraModels(options) {
+	const catalog = await discoverDeepInfraSurfaces(options);
+	const chatModels = catalog.chat.length > 0 ? catalog.chat : [...catalog.chat, ...catalog.vlm];
+	if (chatModels.length === 0) return DEEPINFRA_MODEL_CATALOG.map(buildDeepInfraModelDefinition);
+	const liveModels = chatModels.map(chatSurfaceModelToModelDefinition);
+	const seen = new Set(liveModels.map((model) => model.id));
+	const manifestModels = DEEPINFRA_MODEL_CATALOG.map(buildDeepInfraModelDefinition).filter((model) => {
+		if (seen.has(model.id)) return false;
+		seen.add(model.id);
+		return true;
+	});
+	return [...liveModels, ...manifestModels];
+}
+//#endregion
 export { DEEPINFRA_BASE_URL, DEEPINFRA_DEFAULT_MODEL_REF, DEEPINFRA_MODEL_CATALOG, buildDeepInfraModelDefinition, discoverDeepInfraModels, discoverDeepInfraSurfaces, getDeepInfraSurfaceFallbackCatalog, hasDeepInfraApiKey };

package/dist/speech-provider.js

@@ -1,4 +1,4 @@
-import { t as DEEPINFRA_BASE_URL } from "./provider-models-CXaqRQOl.js";
+import { DEEPINFRA_BASE_URL } from "./provider-models.js";
 import { DEEPINFRA_TTS_FALLBACK_MODELS, DEFAULT_DEEPINFRA_TTS_VOICE, normalizeDeepInfraModelRef } from "./media-models.js";
 import { asObject, createOpenAiCompatibleSpeechProvider } from "openclaw/plugin-sdk/speech";
 //#region extensions/deepinfra/speech-provider.ts

package/dist/surface-model-catalogs.js

@@ -1,4 +1,4 @@
-import { o as discoverDeepInfraSurfaces } from "./provider-models-CXaqRQOl.js";
+import { discoverDeepInfraSurfaces } from "./provider-models.js";
 import { DEEPINFRA_VIDEO_ASPECT_RATIOS, DEEPINFRA_VIDEO_DURATIONS } from "./media-models.js";
 //#region extensions/deepinfra/surface-model-catalogs.ts
 const PROVIDER_ID = "deepinfra";
@@ -27,9 +27,7 @@ function buildDeepInfraVideoModelCapabilities() {
 			seed: "number",
 			negative_prompt: "string",
 			negativePrompt: "string",
-			style: "string",
-			guidance_scale: "number",
-			guidanceScale: "number"
+			style: "string"
 		},
 		generate: {
 			maxVideos: 1,

package/dist/video-generation-provider.js

@@ -1,26 +1,19 @@
-import { DEEPINFRA_NATIVE_BASE_URL, DEEPINFRA_VIDEO_ASPECT_RATIOS, DEEPINFRA_VIDEO_DURATIONS, DEEPINFRA_VIDEO_FALLBACK_MODELS, normalizeDeepInfraBaseUrl, normalizeDeepInfraModelRef } from "./media-models.js";
+import { DEEPINFRA_BASE_URL } from "./provider-models.js";
+import { DEEPINFRA_VIDEO_ASPECT_RATIOS, DEEPINFRA_VIDEO_DURATIONS, DEEPINFRA_VIDEO_FALLBACK_MODELS, normalizeDeepInfraBaseUrl, normalizeDeepInfraModelRef } from "./media-models.js";
 import { resolveDeepInfraVideoModelCapabilities } from "./surface-model-catalogs.js";
-import { asFiniteNumber, asSafeIntegerInRange, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asSafeIntegerInRange, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { isProviderApiKeyConfigured } from "openclaw/plugin-sdk/provider-auth";
 import { extensionForMime } from "openclaw/plugin-sdk/media-mime";
 import { canonicalizeBase64 } from "openclaw/plugin-sdk/media-runtime";
 import { resolveApiKeyForProvider } from "openclaw/plugin-sdk/provider-auth-runtime";
-import { assertOkOrThrowHttpError, postJsonRequest, readProviderJsonResponse, resolveProviderHttpRequestConfig } from "openclaw/plugin-sdk/provider-http";
+import { assertOkOrThrowHttpError, createProviderOperationDeadline, pollProviderOperationJson, postJsonRequest, readProviderJsonResponse, resolveProviderHttpRequestConfig, resolveProviderOperationTimeoutMs } from "openclaw/plugin-sdk/provider-http";
 //#region extensions/deepinfra/video-generation-provider.ts
-function encodeDeepInfraModelPath(model) {
-	return model.split("/").map(encodeURIComponent).join("/");
-}
-function resolveDeepInfraNativeBaseUrl(req) {
-	const providerConfig = req.cfg?.models?.providers?.deepinfra;
-	const nativeBaseUrl = normalizeOptionalString(providerConfig?.nativeBaseUrl);
-	if (nativeBaseUrl) return normalizeDeepInfraBaseUrl(nativeBaseUrl, DEEPINFRA_NATIVE_BASE_URL);
-	const configuredBaseUrl = normalizeOptionalString(providerConfig?.baseUrl);
-	if (configuredBaseUrl?.includes("/v1/inference")) return normalizeDeepInfraBaseUrl(configuredBaseUrl, DEEPINFRA_NATIVE_BASE_URL);
-	return DEEPINFRA_NATIVE_BASE_URL;
-}
-function normalizeDeepInfraVideoUrl(url) {
+const DEFAULT_HTTP_TIMEOUT_MS = 6e4;
+const POLL_INTERVAL_MS = 5e3;
+const MAX_POLL_ATTEMPTS = 120;
+function normalizeDeepInfraVideoUrl(url, baseUrl) {
 	if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("data:")) return url;
-	return new URL(url, "https://api.deepinfra.com").href;
+	return new URL(url, baseUrl).href;
 }
 function parseVideoDataUrl(url) {
 	const match = /^data:([^;,]+);base64,(.+)$/u.exec(url);
@@ -47,33 +40,32 @@ function resolveSeed(value) {
 }
 function buildDeepInfraVideoBody(req, model) {
 	const options = req.providerOptions ?? {};
-	const body = { prompt: req.prompt };
+	const body = {
+		model,
+		prompt: req.prompt
+	};
 	const aspectRatio = normalizeOptionalString(req.aspectRatio);
 	if (aspectRatio) body.aspect_ratio = aspectRatio;
 	const duration = resolveDurationSeconds(req.durationSeconds);
-	if (duration) body.duration = duration;
+	if (duration) body.seconds = duration;
 	const seed = resolveSeed(options.seed);
 	if (seed != null) body.seed = seed;
 	const negativePrompt = normalizeOptionalString(options.negative_prompt) ?? normalizeOptionalString(options.negativePrompt);
 	if (negativePrompt) body.negative_prompt = negativePrompt;
 	const style = normalizeOptionalString(options.style);
 	if (style) body.style = style;
-	const guidanceScale = asFiniteNumber(options.guidance_scale) ?? asFiniteNumber(options.guidanceScale);
-	if (guidanceScale != null && model.startsWith("Wan-AI/")) body.guidance_scale = guidanceScale;
 	return body;
 }
-function firstDeepInfraVideoUrl(payload) {
-	const direct = normalizeOptionalString(payload.video_url) ?? normalizeOptionalString(payload.video);
-	if (direct) return direct;
-	for (const entry of payload.videos ?? []) {
-		const videoUrl = typeof entry === "string" ? normalizeOptionalString(entry) : normalizeOptionalString(entry.url) ?? normalizeOptionalString(entry.video_url);
+function firstDeepInfraVideoUrl(job) {
+	for (const entry of job.data ?? []) {
+		const videoUrl = entry ? normalizeOptionalString(entry.url) : void 0;
 		if (videoUrl) return videoUrl;
 	}
 }
-function extractDeepInfraVideoAsset(payload) {
-	const videoUrl = firstDeepInfraVideoUrl(payload);
+function extractDeepInfraVideoAsset(job, baseUrl) {
+	const videoUrl = firstDeepInfraVideoUrl(job);
 	if (!videoUrl) throw new Error("DeepInfra video response missing video URL");
-	const normalizedUrl = normalizeDeepInfraVideoUrl(videoUrl);
+	const normalizedUrl = normalizeDeepInfraVideoUrl(videoUrl, baseUrl);
 	const dataAsset = parseVideoDataUrl(normalizedUrl);
 	if (dataAsset) return dataAsset;
 	return {
@@ -82,9 +74,11 @@ function extractDeepInfraVideoAsset(payload) {
 		fileName: "video-1.mp4"
 	};
 }
-function failureMessage(payload) {
-	const status = (normalizeOptionalString(payload.inference_status?.status) ?? normalizeOptionalString(payload.status))?.toLowerCase();
-	if (status === "failed" || status === "error") return "DeepInfra video generation failed";
+function resolveDeepInfraVideoBaseUrl(req) {
+	const providerConfig = req.cfg?.models?.providers?.deepinfra;
+	const baseUrl = normalizeDeepInfraBaseUrl(providerConfig?.baseUrl, DEEPINFRA_BASE_URL);
+	if (baseUrl.includes("/v1/inference")) throw new Error("DeepInfra video generation requires an OpenAI-compatible endpoint, but models.providers.deepinfra.baseUrl targets the retired native /v1/inference surface. Run \"openclaw doctor --fix\" (api.deepinfra.com migrates automatically; custom hosts must set baseUrl to an OpenAI-compatible videos endpoint).");
+	return baseUrl;
 }
 function buildDeepInfraVideoGenerationProvider(options) {
 	const ids = options?.videoGenModels && options.videoGenModels.length > 0 ? options.videoGenModels.map((model) => model.id) : [...DEEPINFRA_VIDEO_FALLBACK_MODELS];
@@ -110,9 +104,7 @@ function buildDeepInfraVideoGenerationProvider(options) {
 					seed: "number",
 					negative_prompt: "string",
 					negativePrompt: "string",
-					style: "string",
-					guidance_scale: "number",
-					guidanceScale: "number"
+					style: "string"
 				}
 			},
 			imageToVideo: { enabled: false },
@@ -129,9 +121,13 @@ function buildDeepInfraVideoGenerationProvider(options) {
 			});
 			if (!auth.apiKey) throw new Error("DeepInfra API key missing");
 			const model = normalizeDeepInfraModelRef(req.model, defaultModel);
+			const deadline = createProviderOperationDeadline({
+				timeoutMs: req.timeoutMs,
+				label: "DeepInfra video generation"
+			});
 			const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveProviderHttpRequestConfig({
-				baseUrl: resolveDeepInfraNativeBaseUrl(req),
-				defaultBaseUrl: DEEPINFRA_NATIVE_BASE_URL,
+				baseUrl: resolveDeepInfraVideoBaseUrl(req),
+				defaultBaseUrl: DEEPINFRA_BASE_URL,
 				allowPrivateNetwork: false,
 				defaultHeaders: {
 					Authorization: `Bearer ${auth.apiKey}`,
@@ -142,31 +138,51 @@ function buildDeepInfraVideoGenerationProvider(options) {
 				transport: "http"
 			});
 			const { response, release } = await postJsonRequest({
-				url: `${baseUrl}/${encodeDeepInfraModelPath(model)}`,
+				url: `${baseUrl}/videos`,
 				headers,
 				body: buildDeepInfraVideoBody(req, model),
-				timeoutMs: req.timeoutMs,
+				timeoutMs: resolveProviderOperationTimeoutMs({
+					deadline,
+					defaultTimeoutMs: DEFAULT_HTTP_TIMEOUT_MS
+				}),
 				fetchFn: fetch,
 				allowPrivateNetwork,
 				dispatcherPolicy
 			});
+			let submitted;
 			try {
 				await assertOkOrThrowHttpError(response, "DeepInfra video generation failed");
-				const payload = await readProviderJsonResponse(response, "DeepInfra video generation failed");
-				const failed = failureMessage(payload);
-				if (failed) throw new Error(failed);
-				return {
-					videos: [extractDeepInfraVideoAsset(payload)],
-					model,
-					metadata: {
-						requestId: normalizeOptionalString(payload.request_id),
-						seed: resolveSeed(payload.seed),
-						status: payload.inference_status?.status ?? payload.status
-					}
-				};
+				submitted = await readProviderJsonResponse(response, "DeepInfra video generation failed");
 			} finally {
 				await release();
 			}
+			const jobId = normalizeOptionalString(submitted.id);
+			if (!jobId) throw new Error("DeepInfra video generation response missing job id");
+			if (submitted.status === "failed") throw new Error(normalizeOptionalString(submitted.error) ?? "DeepInfra video generation failed");
+			const completed = submitted.status === "succeeded" ? submitted : await pollProviderOperationJson({
+				url: `${baseUrl}/videos/${encodeURIComponent(jobId)}`,
+				headers,
+				deadline,
+				defaultTimeoutMs: DEFAULT_HTTP_TIMEOUT_MS,
+				fetchFn: fetch,
+				maxAttempts: MAX_POLL_ATTEMPTS,
+				pollIntervalMs: POLL_INTERVAL_MS,
+				requestFailedMessage: "DeepInfra video status request failed",
+				timeoutMessage: `DeepInfra video generation job ${jobId} did not finish in time`,
+				allowPrivateNetwork,
+				dispatcherPolicy,
+				auditContext: "deepinfra-video-status",
+				isComplete: (payload) => payload.status === "succeeded",
+				getFailureMessage: (payload) => payload.status === "failed" ? normalizeOptionalString(payload.error) ?? "DeepInfra video generation failed" : void 0
+			});
+			return {
+				videos: [extractDeepInfraVideoAsset(completed, baseUrl)],
+				model: normalizeOptionalString(completed.model) ?? model,
+				metadata: {
+					jobId,
+					status: completed.status
+				}
+			};
 		}
 	};
 }