@full-self-developing/fsd 1.0.0

package/extensions/deepinfra/speech-provider.test.ts

@@ -0,0 +1,169 @@
+import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
+import { buildDeepInfraSpeechProvider } from "./speech-provider.js";
+
+const {
+  assertOkOrThrowHttpErrorMock,
+  postJsonRequestMock,
+  readProviderBinaryResponseMock,
+  resolveProviderHttpRequestConfigMock,
+} = vi.hoisted(() => ({
+    assertOkOrThrowHttpErrorMock: vi.fn(async () => {}),
+    postJsonRequestMock: vi.fn(),
+    readProviderBinaryResponseMock: vi.fn(async (response: Response) => {
+      return new Uint8Array(await response.arrayBuffer());
+    }),
+    resolveProviderHttpRequestConfigMock: vi.fn((params: Record<string, unknown>) => ({
+      baseUrl: params.baseUrl ?? params.defaultBaseUrl ?? "https://api.deepinfra.com/v1/openai",
+      allowPrivateNetwork: false,
+      headers: new Headers(params.defaultHeaders as HeadersInit | undefined),
+      dispatcherPolicy: undefined,
+    })),
+  }));
+
+vi.mock("openclaw/plugin-sdk/provider-http", () => ({
+  assertOkOrThrowHttpError: assertOkOrThrowHttpErrorMock,
+  postJsonRequest: postJsonRequestMock,
+  readProviderBinaryResponse: readProviderBinaryResponseMock,
+  resolveProviderHttpRequestConfig: resolveProviderHttpRequestConfigMock,
+}));
+
+afterAll(() => {
+  vi.doUnmock("openclaw/plugin-sdk/provider-http");
+  vi.resetModules();
+});
+
+function requireFirstPostJsonRequest(): unknown {
+  const [call] = postJsonRequestMock.mock.calls;
+  if (!call) {
+    throw new Error("expected DeepInfra speech request");
+  }
+  return call[0];
+}
+
+describe("deepinfra speech provider", () => {
+  afterEach(() => {
+    assertOkOrThrowHttpErrorMock.mockClear();
+    postJsonRequestMock.mockReset();
+    readProviderBinaryResponseMock.mockClear();
+    resolveProviderHttpRequestConfigMock.mockClear();
+    vi.unstubAllEnvs();
+  });
+
+  it("normalizes provider-owned speech config", () => {
+    const provider = buildDeepInfraSpeechProvider();
+    const resolved = provider.resolveConfig?.({
+      cfg: {} as never,
+      timeoutMs: 30_000,
+      rawConfig: {
+        providers: {
+          deepinfra: {
+            apiKey: "sk-test",
+            baseUrl: "https://api.deepinfra.com/v1/openai/",
+            modelId: "deepinfra/hexgrad/Kokoro-82M",
+            voiceId: "af_alloy",
+            speed: 1.1,
+            responseFormat: " MP3 ",
+          },
+        },
+      },
+    });
+
+    expect(resolved).toEqual({
+      apiKey: "sk-test",
+      baseUrl: "https://api.deepinfra.com/v1/openai",
+      model: "hexgrad/Kokoro-82M",
+      voice: "af_alloy",
+      speed: 1.1,
+      responseFormat: "mp3",
+      extraBody: undefined,
+    });
+  });
+
+  it("synthesizes OpenAI-compatible speech through DeepInfra", async () => {
+    const release = vi.fn(async () => {});
+    postJsonRequestMock.mockResolvedValue({
+      response: new Response(new Uint8Array([1, 2, 3]), { status: 200 }),
+      release,
+    });
+
+    const provider = buildDeepInfraSpeechProvider();
+    const result = await provider.synthesize({
+      text: "hello",
+      cfg: {
+        models: {
+          providers: {
+            deepinfra: {
+              apiKey: "sk-deepinfra",
+              baseUrl: "https://api.deepinfra.com/v1/openai/",
+            },
+          },
+        },
+      } as never,
+      providerConfig: {
+        model: "hexgrad/Kokoro-82M",
+        voice: "af_alloy",
+        speed: 1.2,
+      },
+      target: "voice-note",
+      timeoutMs: 12_345,
+    });
+
+    expect(resolveProviderHttpRequestConfigMock.mock.calls).toEqual([
+      [
+        {
+          baseUrl: "https://api.deepinfra.com/v1/openai",
+          defaultBaseUrl: "https://api.deepinfra.com/v1/openai",
+          allowPrivateNetwork: false,
+          defaultHeaders: {
+            Authorization: "Bearer sk-deepinfra",
+            "Content-Type": "application/json",
+          },
+          provider: "deepinfra",
+          capability: "audio",
+          transport: "http",
+        },
+      ],
+    ]);
+    expect(postJsonRequestMock).toHaveBeenCalledOnce();
+    const postRequest = requireFirstPostJsonRequest();
+    const postRequestHeaders = Reflect.get(postRequest ?? {}, "headers");
+    expect(postRequestHeaders).toBeInstanceOf(Headers);
+    expect(Object.fromEntries((postRequestHeaders as Headers).entries())).toEqual({
+      authorization: "Bearer sk-deepinfra",
+      "content-type": "application/json",
+    });
+    expect(postRequest).toEqual({
+      url: "https://api.deepinfra.com/v1/openai/audio/speech",
+      headers: postRequestHeaders,
+      timeoutMs: 12_345,
+      body: {
+        model: "hexgrad/Kokoro-82M",
+        input: "hello",
+        voice: "af_alloy",
+        response_format: "mp3",
+        speed: 1.2,
+      },
+      fetchFn: fetch,
+      allowPrivateNetwork: false,
+      dispatcherPolicy: undefined,
+    });
+    expect(result.audioBuffer).toEqual(Buffer.from([1, 2, 3]));
+    expect(result.outputFormat).toBe("mp3");
+    expect(result.fileExtension).toBe(".mp3");
+    expect(result.voiceCompatible).toBe(true);
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it("uses DEEPINFRA_API_KEY when provider config omits apiKey", () => {
+    vi.stubEnv("DEEPINFRA_API_KEY", "sk-env");
+    const provider = buildDeepInfraSpeechProvider();
+
+    expect(
+      provider.isConfigured({
+        cfg: {} as never,
+        providerConfig: {},
+        timeoutMs: 30_000,
+      }),
+    ).toBe(true);
+  });
+});

package/extensions/deepinfra/speech-provider.ts

@@ -0,0 +1,41 @@
+import {
+  asObject,
+  createOpenAiCompatibleSpeechProvider,
+  type SpeechProviderPlugin,
+} from "openclaw/plugin-sdk/speech";
+import {
+  DEEPINFRA_BASE_URL,
+  DEEPINFRA_TTS_MODELS,
+  DEFAULT_DEEPINFRA_TTS_MODEL,
+  DEFAULT_DEEPINFRA_TTS_VOICE,
+  normalizeDeepInfraModelRef,
+} from "./media-models.js";
+
+const DEEPINFRA_TTS_RESPONSE_FORMATS = ["mp3", "opus", "flac", "wav", "pcm"] as const;
+
+type DeepInfraTtsExtraConfig = {
+  extraBody?: Record<string, unknown>;
+};
+
+export function buildDeepInfraSpeechProvider(): SpeechProviderPlugin {
+  return createOpenAiCompatibleSpeechProvider<DeepInfraTtsExtraConfig>({
+    id: "deepinfra",
+    label: "DeepInfra",
+    autoSelectOrder: 45,
+    models: DEEPINFRA_TTS_MODELS,
+    voices: [DEFAULT_DEEPINFRA_TTS_VOICE],
+    defaultModel: DEFAULT_DEEPINFRA_TTS_MODEL,
+    defaultVoice: DEFAULT_DEEPINFRA_TTS_VOICE,
+    defaultBaseUrl: DEEPINFRA_BASE_URL,
+    envKey: "DEEPINFRA_API_KEY",
+    responseFormats: DEEPINFRA_TTS_RESPONSE_FORMATS,
+    defaultResponseFormat: "mp3",
+    voiceCompatibleResponseFormats: ["mp3", "opus"],
+    baseUrlPolicy: { kind: "trim-trailing-slash" },
+    normalizeModel: normalizeDeepInfraModelRef,
+    apiErrorLabel: "DeepInfra TTS API error",
+    missingApiKeyError: "DeepInfra API key missing",
+    readExtraConfig: (raw) => ({ extraBody: asObject(raw?.extraBody) }),
+    extraJsonBodyFields: [{ configKey: "extraBody", requestKey: "extra_body" }],
+  });
+}

package/extensions/deepinfra/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.package-boundary.base.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./*.ts", "./src/**/*.ts"],
+  "exclude": [
+    "./**/*.test.ts",
+    "./dist/**",
+    "./node_modules/**",
+    "./src/test-support/**",
+    "./src/**/*test-helpers.ts",
+    "./src/**/*test-harness.ts",
+    "./src/**/*test-support.ts"
+  ]
+}

package/extensions/deepinfra/video-generation-provider.test.ts

@@ -0,0 +1,194 @@
+import {
+  getProviderHttpMocks,
+  installProviderHttpMockCleanup,
+} from "openclaw/plugin-sdk/provider-http-test-mocks";
+import { expectExplicitVideoGenerationCapabilities } from "openclaw/plugin-sdk/provider-test-contracts";
+import { beforeAll, describe, expect, it, vi } from "vitest";
+
+const { postJsonRequestMock, resolveProviderHttpRequestConfigMock } = getProviderHttpMocks();
+
+let buildDeepInfraVideoGenerationProvider: typeof import("./video-generation-provider.js").buildDeepInfraVideoGenerationProvider;
+
+beforeAll(async () => {
+  ({ buildDeepInfraVideoGenerationProvider } = await import("./video-generation-provider.js"));
+});
+
+installProviderHttpMockCleanup();
+
+function requireFirstPostJsonRequest(): unknown {
+  const [call] = postJsonRequestMock.mock.calls;
+  if (!call) {
+    throw new Error("expected DeepInfra video request");
+  }
+  return call[0];
+}
+
+describe("deepinfra video generation provider", () => {
+  it("declares explicit mode capabilities", () => {
+    expectExplicitVideoGenerationCapabilities(buildDeepInfraVideoGenerationProvider());
+  });
+
+  it("creates native text-to-video requests and returns the hosted output URL", async () => {
+    const release = vi.fn(async () => {});
+    postJsonRequestMock.mockResolvedValue({
+      response: {
+        json: async () => ({
+          video_url: "/generated/video.mp4",
+          request_id: "req_123",
+          seed: 42,
+          inference_status: { status: "succeeded" },
+        }),
+      },
+      release,
+    });
+
+    const provider = buildDeepInfraVideoGenerationProvider();
+    const result = await provider.generateVideo({
+      provider: "deepinfra",
+      model: "deepinfra/Pixverse/Pixverse-T2V",
+      prompt: "A bicycle weaving through a rainy neon street",
+      cfg: {},
+      aspectRatio: "16:9",
+      durationSeconds: 8,
+      providerOptions: {
+        seed: 42,
+        negative_prompt: "blur",
+        style: "anime",
+      },
+    });
+
+    expect(resolveProviderHttpRequestConfigMock.mock.calls).toEqual([
+      [
+        {
+          baseUrl: "https://api.deepinfra.com/v1/inference",
+          defaultBaseUrl: "https://api.deepinfra.com/v1/inference",
+          allowPrivateNetwork: false,
+          defaultHeaders: {
+            Authorization: "Bearer provider-key",
+            "Content-Type": "application/json",
+          },
+          provider: "deepinfra",
+          capability: "video",
+          transport: "http",
+        },
+      ],
+    ]);
+    expect(postJsonRequestMock).toHaveBeenCalledOnce();
+    const postRequest = requireFirstPostJsonRequest();
+    const postRequestHeaders = Reflect.get(postRequest ?? {}, "headers");
+    expect(postRequestHeaders).toBeInstanceOf(Headers);
+    expect(Object.fromEntries((postRequestHeaders as Headers).entries())).toEqual({
+      authorization: "Bearer provider-key",
+      "content-type": "application/json",
+    });
+    expect(postRequest).toEqual({
+      url: "https://api.deepinfra.com/v1/inference/Pixverse/Pixverse-T2V",
+      headers: postRequestHeaders,
+      body: {
+        prompt: "A bicycle weaving through a rainy neon street",
+        aspect_ratio: "16:9",
+        duration: 8,
+        seed: 42,
+        negative_prompt: "blur",
+        style: "anime",
+      },
+      timeoutMs: undefined,
+      fetchFn: fetch,
+      allowPrivateNetwork: false,
+      dispatcherPolicy: undefined,
+    });
+    expect(result.videos).toEqual([
+      {
+        url: "https://api.deepinfra.com/generated/video.mp4",
+        mimeType: "video/mp4",
+        fileName: "video-1.mp4",
+      },
+    ]);
+    expect(result.metadata).toEqual({
+      requestId: "req_123",
+      seed: 42,
+      status: "succeeded",
+    });
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it("reports malformed native video JSON as a provider error", async () => {
+    const release = vi.fn(async () => {});
+    postJsonRequestMock.mockResolvedValue({
+      response: {
+        json: async () => {
+          throw new SyntaxError("Unexpected token");
+        },
+      },
+      release,
+    });
+
+    const provider = buildDeepInfraVideoGenerationProvider();
+    await expect(
+      provider.generateVideo({
+        provider: "deepinfra",
+        model: "deepinfra/Pixverse/Pixverse-T2V",
+        prompt: "A bicycle weaving through a rainy neon street",
+        cfg: {},
+      }),
+    ).rejects.toThrow("DeepInfra video generation failed: malformed JSON response");
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it("names base64 WebM data URL outputs from the MIME type", async () => {
+    postJsonRequestMock.mockResolvedValue({
+      response: {
+        json: async () => ({
+          video_url: `data:video/webm;base64,${Buffer.from("webm-data").toString("base64")}`,
+          request_id: "req_webm",
+          inference_status: { status: "succeeded" },
+        }),
+      },
+      release: vi.fn(async () => {}),
+    });
+
+    const provider = buildDeepInfraVideoGenerationProvider();
+    const result = await provider.generateVideo({
+      provider: "deepinfra",
+      model: "deepinfra/Pixverse/Pixverse-T2V",
+      prompt: "A WebM data URL",
+      cfg: {},
+    });
+
+    expect(result.videos).toHaveLength(1);
+    const [video] = result.videos;
+    if (!video) {
+      throw new Error("Expected generated DeepInfra video");
+    }
+    expect(video).toEqual({
+      buffer: Buffer.from("webm-data"),
+      mimeType: "video/webm",
+      fileName: "video-1.webm",
+    });
+  });
+
+  it("rejects malformed base64 data URL video outputs", async () => {
+    const release = vi.fn(async () => undefined);
+    postJsonRequestMock.mockResolvedValue({
+      response: {
+        json: async () => ({
+          video_url: "data:video/webm;base64,not-base64!",
+          request_id: "req_bad_base64",
+          inference_status: { status: "succeeded" },
+        }),
+      },
+      release,
+    });
+
+    const provider = buildDeepInfraVideoGenerationProvider();
+    await expect(
+      provider.generateVideo({
+        provider: "deepinfra",
+        model: "deepinfra/Pixverse/Pixverse-T2V",
+        prompt: "A malformed WebM data URL",
+        cfg: {},
+      }),
+    ).rejects.toThrow("DeepInfra video response returned malformed data URL base64");
+    expect(release).toHaveBeenCalledOnce();
+  });
+});

package/extensions/deepinfra/video-generation-provider.ts

@@ -0,0 +1,262 @@
+import { extensionForMime } from "openclaw/plugin-sdk/media-mime";
+import { canonicalizeBase64 } from "openclaw/plugin-sdk/media-runtime";
+import { isProviderApiKeyConfigured } from "openclaw/plugin-sdk/provider-auth";
+import { resolveApiKeyForProvider } from "openclaw/plugin-sdk/provider-auth-runtime";
+import {
+  assertOkOrThrowHttpError,
+  postJsonRequest,
+  resolveProviderHttpRequestConfig,
+} from "openclaw/plugin-sdk/provider-http";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import type {
+  GeneratedVideoAsset,
+  VideoGenerationProvider,
+  VideoGenerationRequest,
+} from "openclaw/plugin-sdk/video-generation";
+import {
+  DEEPINFRA_NATIVE_BASE_URL,
+  DEEPINFRA_VIDEO_ASPECT_RATIOS,
+  DEEPINFRA_VIDEO_DURATIONS,
+  DEEPINFRA_VIDEO_MODELS,
+  DEFAULT_DEEPINFRA_VIDEO_MODEL,
+  normalizeDeepInfraBaseUrl,
+  normalizeDeepInfraModelRef,
+} from "./media-models.js";
+
+type DeepInfraVideoStatus = {
+  status?: string;
+  runtime_ms?: number;
+};
+
+type DeepInfraVideoResponse = {
+  video_url?: string;
+  seed?: number;
+  request_id?: string;
+  inference_status?: DeepInfraVideoStatus;
+};
+
+function encodeDeepInfraModelPath(model: string): string {
+  return model.split("/").map(encodeURIComponent).join("/");
+}
+
+function resolveDeepInfraNativeBaseUrl(req: VideoGenerationRequest): string {
+  const providerConfig = req.cfg?.models?.providers?.deepinfra as
+    | (Record<string, unknown> & { baseUrl?: unknown })
+    | undefined;
+  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: string): string {
+  if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("data:")) {
+    return url;
+  }
+  return new URL(url, "https://api.deepinfra.com").href;
+}
+
+function parseVideoDataUrl(url: string): GeneratedVideoAsset | undefined {
+  const match = /^data:([^;,]+);base64,(.+)$/u.exec(url);
+  if (!match) {
+    return undefined;
+  }
+  const mimeType = match[1] ?? "video/mp4";
+  const ext = extensionForMime(mimeType)?.slice(1) ?? "mp4";
+  const canonicalBase64 = canonicalizeBase64(match[2] ?? "");
+  if (!canonicalBase64) {
+    throw new Error("DeepInfra video response returned malformed data URL base64");
+  }
+  return {
+    buffer: Buffer.from(canonicalBase64, "base64"),
+    mimeType,
+    fileName: `video-1.${ext}`,
+  };
+}
+
+function coerceProviderNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function coerceProviderString(value: unknown): string | undefined {
+  return normalizeOptionalString(value);
+}
+
+function resolveDurationSeconds(value: number | undefined): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return undefined;
+  }
+  return value <= 6.5 ? 5 : 8;
+}
+
+function buildDeepInfraVideoBody(
+  req: VideoGenerationRequest,
+  model: string,
+): Record<string, unknown> {
+  const options = req.providerOptions ?? {};
+  const body: Record<string, unknown> = {
+    prompt: req.prompt,
+  };
+  const aspectRatio = normalizeOptionalString(req.aspectRatio);
+  if (aspectRatio) {
+    body.aspect_ratio = aspectRatio;
+  }
+  const duration = resolveDurationSeconds(req.durationSeconds);
+  if (duration) {
+    body.duration = duration;
+  }
+  const seed = coerceProviderNumber(options.seed);
+  if (seed != null) {
+    body.seed = seed;
+  }
+  const negativePrompt =
+    coerceProviderString(options.negative_prompt) ?? coerceProviderString(options.negativePrompt);
+  if (negativePrompt) {
+    body.negative_prompt = negativePrompt;
+  }
+  const style = coerceProviderString(options.style);
+  if (style) {
+    body.style = style;
+  }
+  const guidanceScale =
+    coerceProviderNumber(options.guidance_scale) ?? coerceProviderNumber(options.guidanceScale);
+  if (guidanceScale != null && model.startsWith("Wan-AI/")) {
+    body.guidance_scale = guidanceScale;
+  }
+  return body;
+}
+
+function extractDeepInfraVideoAsset(payload: DeepInfraVideoResponse): GeneratedVideoAsset {
+  const videoUrl = normalizeOptionalString(payload.video_url);
+  if (!videoUrl) {
+    throw new Error("DeepInfra video response missing video_url");
+  }
+  const normalizedUrl = normalizeDeepInfraVideoUrl(videoUrl);
+  const dataAsset = parseVideoDataUrl(normalizedUrl);
+  if (dataAsset) {
+    return dataAsset;
+  }
+  return {
+    url: normalizedUrl,
+    mimeType: "video/mp4",
+    fileName: "video-1.mp4",
+  };
+}
+
+function failureMessage(payload: DeepInfraVideoResponse): string | undefined {
+  const status = normalizeOptionalString(payload.inference_status?.status)?.toLowerCase();
+  if (status === "failed" || status === "error") {
+    return "DeepInfra video generation failed";
+  }
+  return undefined;
+}
+
+export function buildDeepInfraVideoGenerationProvider(): VideoGenerationProvider {
+  return {
+    id: "deepinfra",
+    label: "DeepInfra",
+    defaultModel: DEFAULT_DEEPINFRA_VIDEO_MODEL,
+    models: [...DEEPINFRA_VIDEO_MODELS],
+    isConfigured: ({ agentDir }) =>
+      isProviderApiKeyConfigured({
+        provider: "deepinfra",
+        agentDir,
+      }),
+    capabilities: {
+      generate: {
+        maxVideos: 1,
+        maxDurationSeconds: 8,
+        supportedDurationSeconds: [...DEEPINFRA_VIDEO_DURATIONS],
+        supportsAspectRatio: true,
+        aspectRatios: [...DEEPINFRA_VIDEO_ASPECT_RATIOS],
+        providerOptions: {
+          seed: "number",
+          negative_prompt: "string",
+          negativePrompt: "string",
+          style: "string",
+          guidance_scale: "number",
+          guidanceScale: "number",
+        },
+      },
+      imageToVideo: {
+        enabled: false,
+      },
+      videoToVideo: {
+        enabled: false,
+      },
+    },
+    async generateVideo(req) {
+      if ((req.inputImages?.length ?? 0) > 0) {
+        throw new Error("DeepInfra video generation currently supports text-to-video only.");
+      }
+      if ((req.inputVideos?.length ?? 0) > 0) {
+        throw new Error("DeepInfra video generation does not support video reference inputs.");
+      }
+      const auth = await resolveApiKeyForProvider({
+        provider: "deepinfra",
+        cfg: req.cfg,
+        agentDir: req.agentDir,
+        store: req.authStore,
+      });
+      if (!auth.apiKey) {
+        throw new Error("DeepInfra API key missing");
+      }
+
+      const model = normalizeDeepInfraModelRef(req.model, DEFAULT_DEEPINFRA_VIDEO_MODEL);
+      const resolvedBaseUrl = resolveDeepInfraNativeBaseUrl(req);
+      const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } =
+        resolveProviderHttpRequestConfig({
+          baseUrl: resolvedBaseUrl,
+          defaultBaseUrl: DEEPINFRA_NATIVE_BASE_URL,
+          allowPrivateNetwork: false,
+          defaultHeaders: {
+            Authorization: `Bearer ${auth.apiKey}`,
+            "Content-Type": "application/json",
+          },
+          provider: "deepinfra",
+          capability: "video",
+          transport: "http",
+        });
+
+      const { response, release } = await postJsonRequest({
+        url: `${baseUrl}/${encodeDeepInfraModelPath(model)}`,
+        headers,
+        body: buildDeepInfraVideoBody(req, model),
+        timeoutMs: req.timeoutMs,
+        fetchFn: fetch,
+        allowPrivateNetwork,
+        dispatcherPolicy,
+      });
+      try {
+        await assertOkOrThrowHttpError(response, "DeepInfra video generation failed");
+        let payload: DeepInfraVideoResponse;
+        try {
+          payload = (await response.json()) as DeepInfraVideoResponse;
+        } catch (cause) {
+          throw new Error("DeepInfra video generation failed: malformed JSON response", { cause });
+        }
+        const failed = failureMessage(payload);
+        if (failed) {
+          throw new Error(failed);
+        }
+        const video = extractDeepInfraVideoAsset(payload);
+        return {
+          videos: [video],
+          model,
+          metadata: {
+            requestId: normalizeOptionalString(payload.request_id),
+            seed: payload.seed,
+            status: payload.inference_status?.status,
+          },
+        };
+      } finally {
+        await release();
+      }
+    },
+  };
+}

package/extensions/deepseek/api.ts

@@ -0,0 +1,7 @@
+export {
+  buildDeepSeekModelDefinition,
+  DEEPSEEK_BASE_URL,
+  DEEPSEEK_MODEL_CATALOG,
+} from "./models.js";
+export { buildDeepSeekProvider } from "./provider-catalog.js";
+export { createDeepSeekV4ThinkingWrapper } from "./stream.js";