@full-self-developing/fsd 1.0.0

package/extensions/deepgram/realtime-transcription-provider.ts

@@ -0,0 +1,283 @@
+import {
+  createRealtimeTranscriptionWebSocketSession,
+  type RealtimeTranscriptionProviderConfig,
+  type RealtimeTranscriptionProviderPlugin,
+  type RealtimeTranscriptionSession,
+  type RealtimeTranscriptionSessionCreateRequest,
+} from "openclaw/plugin-sdk/realtime-transcription";
+import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { DEFAULT_DEEPGRAM_AUDIO_BASE_URL, DEFAULT_DEEPGRAM_AUDIO_MODEL } from "./audio.js";
+
+type DeepgramRealtimeTranscriptionEncoding = "linear16" | "mulaw" | "alaw";
+
+type DeepgramRealtimeTranscriptionProviderConfig = {
+  apiKey?: string;
+  baseUrl?: string;
+  model?: string;
+  language?: string;
+  sampleRate?: number;
+  encoding?: DeepgramRealtimeTranscriptionEncoding;
+  interimResults?: boolean;
+  endpointingMs?: number;
+};
+
+type DeepgramRealtimeTranscriptionSessionConfig = RealtimeTranscriptionSessionCreateRequest & {
+  apiKey: string;
+  baseUrl: string;
+  model: string;
+  sampleRate: number;
+  encoding: DeepgramRealtimeTranscriptionEncoding;
+  interimResults: boolean;
+  endpointingMs: number;
+  language?: string;
+};
+
+type DeepgramRealtimeTranscriptionEvent = {
+  type?: string;
+  channel?: {
+    alternatives?: Array<{
+      transcript?: string;
+    }>;
+  };
+  is_final?: boolean;
+  speech_final?: boolean;
+  error?: unknown;
+  message?: string;
+};
+
+const DEEPGRAM_REALTIME_DEFAULT_SAMPLE_RATE = 8000;
+const DEEPGRAM_REALTIME_DEFAULT_ENCODING: DeepgramRealtimeTranscriptionEncoding = "mulaw";
+const DEEPGRAM_REALTIME_DEFAULT_ENDPOINTING_MS = 800;
+const DEEPGRAM_REALTIME_CONNECT_TIMEOUT_MS = 10_000;
+const DEEPGRAM_REALTIME_CLOSE_TIMEOUT_MS = 5_000;
+const DEEPGRAM_REALTIME_MAX_RECONNECT_ATTEMPTS = 5;
+const DEEPGRAM_REALTIME_RECONNECT_DELAY_MS = 1000;
+const DEEPGRAM_REALTIME_MAX_QUEUED_BYTES = 2 * 1024 * 1024;
+
+function readRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function readNestedDeepgramConfig(rawConfig: RealtimeTranscriptionProviderConfig) {
+  const raw = readRecord(rawConfig);
+  const providers = readRecord(raw?.providers);
+  return readRecord(providers?.deepgram ?? raw?.deepgram ?? raw) ?? {};
+}
+
+function readFiniteNumber(value: unknown): number | undefined {
+  const next =
+    typeof value === "number"
+      ? value
+      : typeof value === "string"
+        ? Number.parseFloat(value)
+        : undefined;
+  return Number.isFinite(next) ? next : undefined;
+}
+
+function readBoolean(value: unknown): boolean | undefined {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  return undefined;
+}
+
+function normalizeDeepgramEncoding(
+  value: unknown,
+): DeepgramRealtimeTranscriptionEncoding | undefined {
+  const normalized = normalizeOptionalString(value)?.toLowerCase();
+  if (!normalized) {
+    return undefined;
+  }
+  if (normalized === "pcm" || normalized === "pcm_s16le" || normalized === "linear16") {
+    return "linear16";
+  }
+  if (normalized === "ulaw" || normalized === "g711_ulaw" || normalized === "g711-mulaw") {
+    return "mulaw";
+  }
+  if (normalized === "g711_alaw" || normalized === "g711-alaw") {
+    return "alaw";
+  }
+  if (normalized === "mulaw" || normalized === "alaw") {
+    return normalized;
+  }
+  throw new Error(`Invalid Deepgram realtime transcription encoding: ${normalized}`);
+}
+
+function normalizeDeepgramRealtimeBaseUrl(value?: string): string {
+  return (
+    normalizeOptionalString(value ?? process.env.DEEPGRAM_BASE_URL) ??
+    DEFAULT_DEEPGRAM_AUDIO_BASE_URL
+  );
+}
+
+function toDeepgramRealtimeWsUrl(config: DeepgramRealtimeTranscriptionSessionConfig): string {
+  const url = new URL(normalizeDeepgramRealtimeBaseUrl(config.baseUrl));
+  url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
+  url.pathname = `${url.pathname.replace(/\/+$/, "")}/listen`;
+  url.searchParams.set("model", config.model);
+  url.searchParams.set("encoding", config.encoding);
+  url.searchParams.set("sample_rate", String(config.sampleRate));
+  url.searchParams.set("channels", "1");
+  url.searchParams.set("interim_results", String(config.interimResults));
+  url.searchParams.set("endpointing", String(config.endpointingMs));
+  if (config.language) {
+    url.searchParams.set("language", config.language);
+  }
+  return url.toString();
+}
+
+function normalizeProviderConfig(
+  config: RealtimeTranscriptionProviderConfig,
+): DeepgramRealtimeTranscriptionProviderConfig {
+  const raw = readNestedDeepgramConfig(config);
+  return {
+    apiKey: normalizeResolvedSecretInputString({
+      value: raw.apiKey,
+      path: "plugins.entries.voice-call.config.streaming.providers.deepgram.apiKey",
+    }),
+    baseUrl: normalizeOptionalString(raw.baseUrl),
+    model: normalizeOptionalString(raw.model ?? raw.sttModel),
+    language: normalizeOptionalString(raw.language),
+    sampleRate: readFiniteNumber(raw.sampleRate ?? raw.sample_rate),
+    encoding: normalizeDeepgramEncoding(raw.encoding),
+    interimResults: readBoolean(raw.interimResults ?? raw.interim_results),
+    endpointingMs: readFiniteNumber(raw.endpointingMs ?? raw.endpointing ?? raw.silenceDurationMs),
+  };
+}
+
+function readErrorDetail(value: unknown): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  const record = readRecord(value);
+  const message = normalizeOptionalString(record?.message);
+  const code = normalizeOptionalString(record?.code);
+  return message ?? code ?? "Deepgram realtime transcription error";
+}
+
+function readTranscriptText(event: DeepgramRealtimeTranscriptionEvent): string | undefined {
+  return normalizeOptionalString(event.channel?.alternatives?.[0]?.transcript);
+}
+
+function createDeepgramRealtimeTranscriptionSession(
+  config: DeepgramRealtimeTranscriptionSessionConfig,
+): RealtimeTranscriptionSession {
+  let lastTranscript: string | undefined;
+  let speechStarted = false;
+
+  const emitTranscript = (text: string) => {
+    if (text === lastTranscript) {
+      return;
+    }
+    lastTranscript = text;
+    config.onTranscript?.(text);
+  };
+
+  const handleEvent = (event: DeepgramRealtimeTranscriptionEvent) => {
+    switch (event.type) {
+      case "Results": {
+        const text = readTranscriptText(event);
+        if (!text) {
+          return;
+        }
+        if (!speechStarted) {
+          speechStarted = true;
+          config.onSpeechStart?.();
+        }
+        if (event.is_final || event.speech_final) {
+          emitTranscript(text);
+          if (event.speech_final) {
+            speechStarted = false;
+          }
+          return;
+        }
+        config.onPartial?.(text);
+        return;
+      }
+      case "SpeechStarted":
+        speechStarted = true;
+        config.onSpeechStart?.();
+        return;
+      case "Error":
+      case "error":
+        config.onError?.(new Error(readErrorDetail(event.error ?? event.message)));
+        return;
+      default:
+        return;
+    }
+  };
+
+  return createRealtimeTranscriptionWebSocketSession<DeepgramRealtimeTranscriptionEvent>({
+    providerId: "deepgram",
+    callbacks: config,
+    url: () => toDeepgramRealtimeWsUrl(config),
+    headers: { Authorization: `Token ${config.apiKey}` },
+    readyOnOpen: true,
+    connectTimeoutMs: DEEPGRAM_REALTIME_CONNECT_TIMEOUT_MS,
+    closeTimeoutMs: DEEPGRAM_REALTIME_CLOSE_TIMEOUT_MS,
+    maxReconnectAttempts: DEEPGRAM_REALTIME_MAX_RECONNECT_ATTEMPTS,
+    reconnectDelayMs: DEEPGRAM_REALTIME_RECONNECT_DELAY_MS,
+    maxQueuedBytes: DEEPGRAM_REALTIME_MAX_QUEUED_BYTES,
+    connectTimeoutMessage: "Deepgram realtime transcription connection timeout",
+    connectClosedBeforeReadyMessage:
+      "Deepgram realtime transcription connection closed before ready",
+    reconnectLimitMessage: "Deepgram realtime transcription reconnect limit reached",
+    sendAudio: (audio, transport) => {
+      transport.sendBinary(audio);
+    },
+    onClose: (transport) => {
+      transport.sendJson({ type: "Finalize" });
+    },
+    onMessage: handleEvent,
+  });
+}
+
+export function buildDeepgramRealtimeTranscriptionProvider(): RealtimeTranscriptionProviderPlugin {
+  return {
+    id: "deepgram",
+    label: "Deepgram Realtime Transcription",
+    aliases: ["deepgram-realtime", "nova-3-streaming"],
+    defaultModel: DEFAULT_DEEPGRAM_AUDIO_MODEL,
+    autoSelectOrder: 35,
+    resolveConfig: ({ rawConfig }) => normalizeProviderConfig(rawConfig),
+    isConfigured: ({ providerConfig }) =>
+      Boolean(normalizeProviderConfig(providerConfig).apiKey || process.env.DEEPGRAM_API_KEY),
+    createSession: (req) => {
+      const config = normalizeProviderConfig(req.providerConfig);
+      const apiKey = config.apiKey || process.env.DEEPGRAM_API_KEY;
+      if (!apiKey) {
+        throw new Error("Deepgram API key missing");
+      }
+      return createDeepgramRealtimeTranscriptionSession({
+        ...req,
+        apiKey,
+        baseUrl: normalizeDeepgramRealtimeBaseUrl(config.baseUrl),
+        model: config.model ?? DEFAULT_DEEPGRAM_AUDIO_MODEL,
+        sampleRate: config.sampleRate ?? DEEPGRAM_REALTIME_DEFAULT_SAMPLE_RATE,
+        encoding: config.encoding ?? DEEPGRAM_REALTIME_DEFAULT_ENCODING,
+        interimResults: config.interimResults ?? true,
+        endpointingMs: config.endpointingMs ?? DEEPGRAM_REALTIME_DEFAULT_ENDPOINTING_MS,
+        language: config.language,
+      });
+    },
+  };
+}
+
+export const testing = {
+  normalizeProviderConfig,
+  toDeepgramRealtimeWsUrl,
+};
+export { testing as __testing };

package/extensions/deepgram/test-api.ts

@@ -0,0 +1,2 @@
+export { deepgramMediaUnderstandingProvider } from "./media-understanding-provider.js";
+export { buildDeepgramRealtimeTranscriptionProvider } from "./realtime-transcription-provider.js";

package/extensions/deepgram/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/api.ts

@@ -0,0 +1,8 @@
+export { buildDeepInfraProvider, buildStaticDeepInfraProvider } from "./provider-catalog.js";
+export { applyDeepInfraConfig } from "./onboard.js";
+export { DEEPINFRA_DEFAULT_MODEL_REF } from "./provider-models.js";
+export { buildDeepInfraImageGenerationProvider } from "./image-generation-provider.js";
+export { deepinfraMediaUnderstandingProvider } from "./media-understanding-provider.js";
+export { deepinfraMemoryEmbeddingProviderAdapter } from "./memory-embedding-adapter.js";
+export { buildDeepInfraSpeechProvider } from "./speech-provider.js";
+export { buildDeepInfraVideoGenerationProvider } from "./video-generation-provider.js";

package/extensions/deepinfra/embedding-provider.ts

@@ -0,0 +1,33 @@
+import {
+  createRemoteEmbeddingProvider,
+  resolveRemoteEmbeddingClient,
+  type MemoryEmbeddingProviderCreateOptions,
+  type MemoryEmbeddingProviderCreateResult,
+} from "openclaw/plugin-sdk/memory-core-host-engine-embeddings";
+import {
+  DEEPINFRA_BASE_URL,
+  DEFAULT_DEEPINFRA_EMBEDDING_MODEL,
+  normalizeDeepInfraModelRef,
+} from "./media-models.js";
+
+export { DEFAULT_DEEPINFRA_EMBEDDING_MODEL };
+
+export async function createDeepInfraEmbeddingProvider(
+  options: MemoryEmbeddingProviderCreateOptions,
+): Promise<MemoryEmbeddingProviderCreateResult & { client: { model: string } }> {
+  const client = await resolveRemoteEmbeddingClient({
+    provider: "deepinfra",
+    options: {
+      ...options,
+      model: normalizeDeepInfraModelRef(options.model, DEFAULT_DEEPINFRA_EMBEDDING_MODEL),
+    },
+    defaultBaseUrl: DEEPINFRA_BASE_URL,
+    normalizeModel: (model) => normalizeDeepInfraModelRef(model, DEFAULT_DEEPINFRA_EMBEDDING_MODEL),
+  });
+  const provider = createRemoteEmbeddingProvider({
+    id: "deepinfra",
+    client,
+    errorPrefix: "DeepInfra embeddings API error",
+  });
+  return { provider, client };
+}

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

@@ -0,0 +1,224 @@
+import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
+import { buildDeepInfraImageGenerationProvider } from "./image-generation-provider.js";
+
+const {
+  assertOkOrThrowHttpErrorMock,
+  postJsonRequestMock,
+  postMultipartRequestMock,
+  resolveApiKeyForProviderMock,
+  resolveProviderHttpRequestConfigMock,
+  createProviderOperationDeadlineMock,
+  resolveProviderOperationTimeoutMsMock,
+} = vi.hoisted(() => ({
+  assertOkOrThrowHttpErrorMock: vi.fn(async () => {}),
+  postJsonRequestMock: vi.fn(),
+  postMultipartRequestMock: vi.fn(),
+  resolveApiKeyForProviderMock: vi.fn(async () => ({ apiKey: "deepinfra-key" })),
+  createProviderOperationDeadlineMock: vi.fn((params: Record<string, unknown>) => params),
+  resolveProviderOperationTimeoutMsMock: vi.fn(
+    (params: Record<string, unknown>) => params.defaultTimeoutMs,
+  ),
+  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-auth-runtime", () => ({
+  resolveApiKeyForProvider: resolveApiKeyForProviderMock,
+}));
+
+vi.mock("openclaw/plugin-sdk/provider-http", () => ({
+  assertOkOrThrowHttpError: assertOkOrThrowHttpErrorMock,
+  createProviderOperationDeadline: createProviderOperationDeadlineMock,
+  postJsonRequest: postJsonRequestMock,
+  postMultipartRequest: postMultipartRequestMock,
+  resolveProviderHttpRequestConfig: resolveProviderHttpRequestConfigMock,
+  resolveProviderOperationTimeoutMs: resolveProviderOperationTimeoutMsMock,
+  sanitizeConfiguredModelProviderRequest: vi.fn((request) => request),
+}));
+
+afterAll(() => {
+  vi.doUnmock("openclaw/plugin-sdk/provider-auth-runtime");
+  vi.doUnmock("openclaw/plugin-sdk/provider-http");
+  vi.resetModules();
+});
+
+function requireFirstMockArg(mock: ReturnType<typeof vi.fn>, label: string): unknown {
+  const [call] = mock.mock.calls;
+  if (!call) {
+    throw new Error(`expected ${label}`);
+  }
+  return call[0];
+}
+
+function requireFirstMockObjectArg(mock: ReturnType<typeof vi.fn>, label: string): object {
+  const value = requireFirstMockArg(mock, label);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`expected ${label}`);
+  }
+  return value;
+}
+
+describe("deepinfra image generation provider", () => {
+  afterEach(() => {
+    assertOkOrThrowHttpErrorMock.mockClear();
+    postJsonRequestMock.mockReset();
+    postMultipartRequestMock.mockReset();
+    resolveApiKeyForProviderMock.mockClear();
+    resolveProviderHttpRequestConfigMock.mockClear();
+  });
+
+  it("declares generation and single-reference edit support", () => {
+    const provider = buildDeepInfraImageGenerationProvider();
+
+    expect(provider.id).toBe("deepinfra");
+    expect(provider.defaultModel).toBe("black-forest-labs/FLUX-1-schnell");
+    expect(provider.capabilities.generate.maxCount).toBe(4);
+    expect(provider.capabilities.edit.enabled).toBe(true);
+    expect(provider.capabilities.edit.maxInputImages).toBe(1);
+  });
+
+  it("sends OpenAI-compatible image generation requests and sniffs JPEG output", async () => {
+    const release = vi.fn(async () => {});
+    const jpegBytes = Buffer.from([0xff, 0xd8, 0xff, 0x00]);
+    postJsonRequestMock.mockResolvedValue({
+      response: {
+        json: async () => ({
+          data: [{ b64_json: jpegBytes.toString("base64"), revised_prompt: "red square" }],
+        }),
+      },
+      release,
+    });
+
+    const provider = buildDeepInfraImageGenerationProvider();
+    const result = await provider.generateImage({
+      provider: "deepinfra",
+      model: "deepinfra/black-forest-labs/FLUX-1-schnell",
+      prompt: "red square",
+      count: 2,
+      size: "512x512",
+      timeoutMs: 12_345,
+      cfg: {
+        models: {
+          providers: {
+            deepinfra: {
+              baseUrl: "https://api.deepinfra.com/v1/openai/",
+            },
+          },
+        },
+      } as never,
+    });
+
+    expect(resolveProviderHttpRequestConfigMock.mock.calls).toEqual([
+      [
+        {
+          baseUrl: "https://api.deepinfra.com/v1/openai",
+          defaultBaseUrl: "https://api.deepinfra.com/v1/openai",
+          allowPrivateNetwork: false,
+          request: undefined,
+          defaultHeaders: {
+            Authorization: "Bearer deepinfra-key",
+          },
+          provider: "deepinfra",
+          capability: "image",
+          transport: "http",
+        },
+      ],
+    ]);
+    expect(postJsonRequestMock).toHaveBeenCalledOnce();
+    const jsonRequest = requireFirstMockArg(postJsonRequestMock, "DeepInfra JSON image request");
+    const jsonRequestHeaders = Reflect.get(jsonRequest ?? {}, "headers");
+    expect(jsonRequestHeaders).toBeInstanceOf(Headers);
+    expect(Object.fromEntries((jsonRequestHeaders as Headers).entries())).toEqual({
+      authorization: "Bearer deepinfra-key",
+      "content-type": "application/json",
+    });
+    expect(jsonRequest).toEqual({
+      url: "https://api.deepinfra.com/v1/openai/images/generations",
+      headers: jsonRequestHeaders,
+      timeoutMs: 12_345,
+      body: {
+        model: "black-forest-labs/FLUX-1-schnell",
+        prompt: "red square",
+        n: 2,
+        size: "512x512",
+        response_format: "b64_json",
+      },
+      fetchFn: fetch,
+      allowPrivateNetwork: false,
+      dispatcherPolicy: undefined,
+    });
+    expect(result.images).toHaveLength(1);
+    const [firstImage] = result.images;
+    if (!firstImage) {
+      throw new Error("Expected generated DeepInfra image");
+    }
+    expect(firstImage).toEqual({
+      buffer: jpegBytes,
+      mimeType: "image/jpeg",
+      fileName: "image-1.jpg",
+      revisedPrompt: "red square",
+    });
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it("sends image edits as multipart OpenAI-compatible requests", async () => {
+    postMultipartRequestMock.mockResolvedValue({
+      response: {
+        json: async () => ({
+          data: [
+            {
+              b64_json: Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]).toString(
+                "base64",
+              ),
+            },
+          ],
+        }),
+      },
+      release: vi.fn(async () => {}),
+    });
+
+    const provider = buildDeepInfraImageGenerationProvider();
+    const result = await provider.generateImage({
+      provider: "deepinfra",
+      model: "black-forest-labs/FLUX-1-schnell",
+      prompt: "make it neon",
+      inputImages: [{ buffer: Buffer.from("source"), mimeType: "image/png" }],
+      cfg: {} as never,
+    });
+
+    expect(postMultipartRequestMock).toHaveBeenCalledOnce();
+    const multipartRequest = requireFirstMockObjectArg(
+      postMultipartRequestMock,
+      "DeepInfra multipart image request",
+    );
+    const multipartHeaders = Reflect.get(multipartRequest, "headers");
+    expect(multipartHeaders).toBeInstanceOf(Headers);
+    expect(Object.fromEntries((multipartHeaders as Headers).entries())).toEqual({
+      authorization: "Bearer deepinfra-key",
+    });
+    const form = Reflect.get(multipartRequest, "body") as FormData;
+    expect(multipartRequest).toEqual({
+      url: "https://api.deepinfra.com/v1/openai/images/edits",
+      headers: multipartHeaders,
+      body: form,
+      timeoutMs: undefined,
+      fetchFn: fetch,
+      allowPrivateNetwork: false,
+      dispatcherPolicy: undefined,
+    });
+    expect(form.get("model")).toBe("black-forest-labs/FLUX-1-schnell");
+    expect(form.get("prompt")).toBe("make it neon");
+    expect(form.get("response_format")).toBe("b64_json");
+    expect(form.get("image")).toBeInstanceOf(File);
+    expect(result.images).toHaveLength(1);
+    const [image] = result.images;
+    if (!image) {
+      throw new Error("Expected edited DeepInfra image");
+    }
+    expect(image.mimeType).toBe("image/png");
+  });
+});

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

@@ -0,0 +1,89 @@
+import {
+  createOpenAiCompatibleImageGenerationProvider,
+  imageSourceUploadFileName,
+  type ImageGenerationProvider,
+} from "openclaw/plugin-sdk/image-generation";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import {
+  DEEPINFRA_BASE_URL,
+  DEEPINFRA_IMAGE_MODELS,
+  DEFAULT_DEEPINFRA_IMAGE_MODEL,
+  DEFAULT_DEEPINFRA_IMAGE_SIZE,
+  normalizeDeepInfraBaseUrl,
+  normalizeDeepInfraModelRef,
+} from "./media-models.js";
+
+const DEEPINFRA_IMAGE_SIZES = ["512x512", "1024x1024", "1024x1792", "1792x1024"] as const;
+const MAX_DEEPINFRA_INPUT_IMAGES = 1;
+
+export function buildDeepInfraImageGenerationProvider(): ImageGenerationProvider {
+  return createOpenAiCompatibleImageGenerationProvider({
+    id: "deepinfra",
+    label: "DeepInfra",
+    defaultModel: DEFAULT_DEEPINFRA_IMAGE_MODEL,
+    models: [...DEEPINFRA_IMAGE_MODELS],
+    capabilities: {
+      generate: {
+        maxCount: 4,
+        supportsSize: true,
+        supportsAspectRatio: false,
+        supportsResolution: false,
+      },
+      edit: {
+        enabled: true,
+        maxCount: 1,
+        maxInputImages: MAX_DEEPINFRA_INPUT_IMAGES,
+        supportsSize: true,
+        supportsAspectRatio: false,
+        supportsResolution: false,
+      },
+      geometry: {
+        sizes: [...DEEPINFRA_IMAGE_SIZES],
+      },
+    },
+    defaultBaseUrl: DEEPINFRA_BASE_URL,
+    normalizeModel: normalizeDeepInfraModelRef,
+    resolveBaseUrl: ({ providerConfig }) =>
+      normalizeDeepInfraBaseUrl(providerConfig?.baseUrl, DEEPINFRA_BASE_URL),
+    resolveAllowPrivateNetwork: () => false,
+    useConfiguredRequest: true,
+    resolveCount: ({ req, mode }) => (mode === "edit" ? 1 : (req.count ?? 1)),
+    buildGenerateRequest: ({ req, model, count }) => ({
+      kind: "json",
+      body: {
+        model,
+        prompt: req.prompt,
+        n: count,
+        size: normalizeOptionalString(req.size) ?? DEFAULT_DEEPINFRA_IMAGE_SIZE,
+        response_format: "b64_json",
+      },
+    }),
+    buildEditRequest: ({ req, inputImages, model, count }) => {
+      const image = inputImages[0];
+      if (!image) {
+        throw new Error("DeepInfra image edit missing reference image.");
+      }
+      const form = new FormData();
+      form.set("model", model);
+      form.set("prompt", req.prompt);
+      form.set("n", String(count));
+      form.set("size", normalizeOptionalString(req.size) ?? DEFAULT_DEEPINFRA_IMAGE_SIZE);
+      form.set("response_format", "b64_json");
+      const mimeType = normalizeOptionalString(image.mimeType) ?? "image/png";
+      form.append(
+        "image",
+        new Blob([new Uint8Array(image.buffer)], { type: mimeType }),
+        imageSourceUploadFileName({ image, index: 0 }),
+      );
+      return { kind: "multipart", form };
+    },
+    response: { defaultMimeType: "image/jpeg", sniffMimeType: true },
+    tooManyInputImagesError: "DeepInfra image editing supports one reference image.",
+    missingApiKeyError: "DeepInfra API key missing",
+    emptyResponseError: "DeepInfra image response did not include generated image data",
+    failureLabels: {
+      generate: "DeepInfra image generation failed",
+      edit: "DeepInfra image edit failed",
+    },
+  });
+}