fix(sse): make Leonardo image and video generation work (model UUIDs, text-to-video endpoint)

changelog.d/fixes/18670-leonardo-image-video.md

@@ -0,0 +1 @@
+- **fix(sse):** Leonardo image and video generation work again; image requests sent the catalog id (`phoenix`, `sdxl`) where Leonardo expects a platform-model UUID and got HTTP 500 "internal error", and video posted an image body to the image endpoint (400 "Unexpected variable num_frames"); video now uses `/generations-text-to-video` with Motion 2.0 / Motion 2.0 Fast and returns the mp4 instead of the thumbnail ([#18670](https://github.com/cheaper-inference/OmniRoute/pull/18670))

open-sse/config/videoRegistry.ts

@@ -197,12 +197,15 @@ export const VIDEO_PROVIDERS: Record<string, VideoProvider> = {
   },
   leonardo: {
     id: "leonardo",
-    baseUrl: "https://cloud.leonardo.ai/api/rest/v1/generations",
+    baseUrl: "https://cloud.leonardo.ai/api/rest/v1/generations-text-to-video",
     statusUrl: "https://cloud.leonardo.ai/api/rest/v1/generations",
     authType: "apikey",
     authHeader: "bearer",
     format: "leonardo-video",
-    models: [{ id: "phoenix", name: "Phoenix Video" }],
+    models: [
+      { id: "motion-2.0", name: "Motion 2.0" },
+      { id: "motion-2.0-fast", name: "Motion 2.0 Fast" },
+    ],
   },
   pollinations: {
     id: "pollinations",

open-sse/handlers/imageGeneration/providers/leonardo.ts

@@ -6,13 +6,27 @@ import { saveCallLog } from "@/lib/usageDb";
 import { sleep } from "../../../utils/sleep.ts";
 import { sanitizeErrorMessage } from "../../../utils/error.ts";
 
+// Leonardo's v1 API takes a platform-model UUID as `modelId` and answers a catalog id such
+// as "phoenix" with HTTP 500 "internal error". UUIDs from GET /api/rest/v1/platformModels.
+const LEONARDO_MODEL_IDS: Record<string, string> = {
+  phoenix: "de7d3faf-762f-48e0-b3b7-9d0ac3a3fcf3", // Phoenix 1.0
+  sdxl: "16e7060a-803e-4df3-97ee-edcfa5dc9cc8", // SDXL 1.0
+};
+
+/** The catalog id's platform-model UUID; anything else (e.g. a raw UUID) passes through. */
+export function resolveLeonardoModelId(model: string | undefined): string {
+  const id = model || "phoenix";
+  return LEONARDO_MODEL_IDS[id] ?? id;
+}
+
 export async function handleLeonardoImageGeneration({
   model,
   provider,
   providerConfig,
   body,
   credentials,
   log,
+  pollIntervalMs = 5000,
 }) {
   const startTime = Date.now();
   const token = credentials?.apiKey || "";
@@ -25,7 +39,7 @@ export async function handleLeonardoImageGeneration({
       method: "POST",
       headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
       body: JSON.stringify({
-        modelId: model || "phoenix",
+        modelId: resolveLeonardoModelId(model),
         prompt,
         width: body.width || 1024,
         height: body.height || 1024,
@@ -61,7 +75,7 @@ export async function handleLeonardoImageGeneration({
     }
     const deadline = Date.now() + 300000;
     while (Date.now() < deadline) {
-      await sleep(5000);
+      await sleep(pollIntervalMs);
       const statusRes = await fetch(`${providerConfig.baseUrl}/${genId}`, {
         headers: { Authorization: `Bearer ${token}` },
       });
@@ -137,4 +151,3 @@ export async function handleLeonardoImageGeneration({
     };
   }
 }
-

open-sse/handlers/videoGeneration/leonardoHandler.ts

@@ -1,5 +1,5 @@
 /**
- * Leonardo AI (Phoenix) video generation: submit → poll → fetch output.
+ * Leonardo AI (Motion 2.0) text-to-video: submit → poll → fetch the mp4.
  *
  * Extracted out of the frozen `videoGeneration.ts` god-file (unchanged behavior) to make
  * room for the new DeepInfra video adapter without pushing the file-size ratchet over its
@@ -9,6 +9,49 @@
 import { saveCallLog } from "@/lib/usageDb";
 import { abortedVideoResult, POLL_ABORTED, pollJsonAfter } from "./abort.ts";
 
+// Catalog id -> Leonardo `model` enum for POST /generations-text-to-video. `phoenix` was the
+// old catalog id (an image model); it keeps working as Motion 2.0. Anything else passes
+// through as the enum itself.
+const LEONARDO_VIDEO_MODELS: Record<string, string> = {
+  "motion-2.0": "MOTION2",
+  "motion-2.0-fast": "MOTION2FAST",
+  phoenix: "MOTION2",
+};
+
+/** Catalog id -> Leonardo `model` enum; an unknown id is sent as the enum itself. */
+export function resolveLeonardoVideoModel(model: string): string {
+  return LEONARDO_VIDEO_MODELS[model] ?? model;
+}
+
+// Leonardo's video sizes as [long side, short side].
+const LEONARDO_VIDEO_SIZES = {
+  RESOLUTION_480: [832, 480],
+  RESOLUTION_720: [1280, 720],
+} as const;
+
+function parseVideoSize(size: unknown): [number, number] {
+  const match = typeof size === "string" ? size.trim().match(/^(\d+)x(\d+)$/i) : null;
+  return match ? [Number(match[1]), Number(match[2])] : [0, 0];
+}
+
+/** A `WxH` size with a short side <= 480 picks RESOLUTION_480, else RESOLUTION_720. */
+export function resolveLeonardoVideoSize(size: unknown) {
+  const [width, height] = parseVideoSize(size);
+  const resolution =
+    width > 0 && Math.min(width, height) <= 480 ? "RESOLUTION_480" : "RESOLUTION_720";
+  const [long, short] = LEONARDO_VIDEO_SIZES[resolution];
+  return height > width
+    ? { resolution, width: short, height: long }
+    : { resolution, width: long, height: short };
+}
+
+/** The finished video: `motionMP4URL`, since `url` on a video generation is a jpg thumbnail. */
+function leonardoVideoUrl(generation: {
+  generated_images?: Array<{ motionMP4URL?: string }>;
+}): string | undefined {
+  return generation.generated_images?.[0]?.motionMP4URL;
+}
+
 export async function handleLeonardoVideoGeneration({
   model,
   provider,
@@ -17,18 +60,18 @@ export async function handleLeonardoVideoGeneration({
   credentials,
   log,
   signal = null,
+  pollIntervalMs = 5000,
 }) {
   const startTime = Date.now();
   const token = credentials?.apiKey || "";
   const res = await fetch(providerConfig.baseUrl, {
     method: "POST",
     headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
     body: JSON.stringify({
-      modelId: "phoenix",
+      model: resolveLeonardoVideoModel(model),
       prompt: body.prompt,
-      width: 1024,
-      height: 576,
-      num_frames: 24,
+      ...resolveLeonardoVideoSize(body.size),
+      isPublic: false,
     }),
   });
   if (!res.ok) {
@@ -44,8 +87,8 @@ export async function handleLeonardoVideoGeneration({
     }).catch(() => {});
     return { success: false, status: res.status, error: errorText };
   }
-  const { sdGenerationJob } = await res.json();
-  const genId = sdGenerationJob?.generationId;
+  const { motionVideoGenerationJob } = await res.json();
+  const genId = motionVideoGenerationJob?.generationId;
   if (!genId) {
     saveCallLog({
       method: "POST",
@@ -61,18 +104,17 @@ export async function handleLeonardoVideoGeneration({
   const deadline = Date.now() + 300000;
   while (Date.now() < deadline) {
     const status = await pollJsonAfter(
-      5000,
-
-      `${providerConfig.baseUrl}/${genId}`,
+      pollIntervalMs,
+      `${providerConfig.statusUrl}/${genId}`,
       { Authorization: `Bearer ${token}` },
       signal
     );
     if (status === POLL_ABORTED) return abortedVideoResult();
     const gen = status.generations_by_pk || status;
     if (gen.status === "COMPLETE") {
-      const imgUrl = gen.generated_images?.[0]?.url;
-      if (imgUrl) {
-        const videoRes = await fetch(imgUrl);
+      const videoUrl = leonardoVideoUrl(gen);
+      if (videoUrl) {
+        const videoRes = await fetch(videoUrl);
         const buf = await videoRes.arrayBuffer();
         saveCallLog({
           method: "POST",

tests/unit/leonardo-image-model-id.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Leonardo's v1 REST API takes a platform-model UUID as `modelId`. The handler sent the
+ * catalog id (`phoenix`, `sdxl`) as-is, and Leonardo answers that with HTTP 500
+ * `{"error":"internal error","code":"unexpected"}`, so every `leonardo/*` image request
+ * failed. The UUIDs below are from `GET /api/rest/v1/platformModels`.
+ */
+
+import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+process.env.DATA_DIR = mkdtempSync(join(tmpdir(), "omniroute-leonardo-model-id-"));
+
+const { handleLeonardoImageGeneration } =
+  await import("../../open-sse/handlers/imageGeneration/providers/leonardo.ts");
+
+const BASE_URL = "https://cloud.leonardo.ai/api/rest/v1/generations";
+const PHOENIX_1_0 = "de7d3faf-762f-48e0-b3b7-9d0ac3a3fcf3";
+const SDXL_1_0 = "16e7060a-803e-4df3-97ee-edcfa5dc9cc8";
+
+const originalFetch = globalThis.fetch;
+test.after(() => {
+  globalThis.fetch = originalFetch;
+});
+
+function json(payload: unknown) {
+  return new Response(JSON.stringify(payload), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+/** Fake Leonardo: records the submitted modelId and completes the generation on first poll. */
+async function submittedModelId(model: string): Promise<unknown> {
+  let modelId: unknown;
+  globalThis.fetch = (async (url: unknown, options?: RequestInit) => {
+    const href = String(url);
+    if (href === BASE_URL && options?.method === "POST") {
+      modelId = JSON.parse(String(options.body)).modelId;
+      return json({ sdGenerationJob: { generationId: "gen-1" } });
+    }
+    if (href === `${BASE_URL}/gen-1`) {
+      return json({
+        generations_by_pk: {
+          status: "COMPLETE",
+          generated_images: [{ url: "https://cdn.leonardo.ai/img.png" }],
+        },
+      });
+    }
+    if (href === "https://cdn.leonardo.ai/img.png") return new Response(new Uint8Array([1, 2, 3]));
+    throw new Error(`unexpected fetch ${href}`);
+  }) as typeof fetch;
+
+  const result = await handleLeonardoImageGeneration({
+    model,
+    provider: "leonardo",
+    providerConfig: { baseUrl: BASE_URL },
+    body: { prompt: "a red apple" },
+    credentials: { apiKey: "test-key" },
+    log: null,
+    pollIntervalMs: 0,
+  });
+  assert.equal(result.success, true);
+  return modelId;
+}
+
+test("the phoenix catalog id is sent as the Phoenix 1.0 model UUID", async () => {
+  assert.equal(await submittedModelId("phoenix"), PHOENIX_1_0);
+});
+
+test("the sdxl catalog id is sent as the SDXL 1.0 model UUID", async () => {
+  assert.equal(await submittedModelId("sdxl"), SDXL_1_0);
+});
+
+test("a model UUID passes through unchanged, so any Leonardo model can be used", async () => {
+  const custom = "b24e16ff-06e3-43eb-8d33-4416c2d75876";
+  assert.equal(await submittedModelId(custom), custom);
+});
+
+test("no model falls back to Phoenix 1.0", async () => {
+  assert.equal(await submittedModelId(""), PHOENIX_1_0);
+});

tests/unit/leonardo-video-generation.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Leonardo video: the handler posted an image-generation body (`modelId: "phoenix"`,
+ * `num_frames`) to the image endpoint, which Leonardo rejects with
+ * `400 Unexpected variable num_frames`. Video goes to `POST /generations-text-to-video`
+ * with a `model` enum and a `resolution`, the job comes back as `motionVideoGenerationJob`,
+ * and the mp4 is `generated_images[0].motionMP4URL` (`url` is a jpg thumbnail).
+ */
+
+import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+process.env.DATA_DIR = mkdtempSync(join(tmpdir(), "omniroute-leonardo-video-"));
+
+const { handleLeonardoVideoGeneration } =
+  await import("../../open-sse/handlers/videoGeneration/leonardoHandler.ts");
+const { getVideoProvider } = await import("../../open-sse/config/videoRegistry.ts");
+
+const providerConfig = getVideoProvider("leonardo");
+const SUBMIT_URL = "https://cloud.leonardo.ai/api/rest/v1/generations-text-to-video";
+const STATUS_URL = "https://cloud.leonardo.ai/api/rest/v1/generations";
+const MP4 = new Uint8Array([0, 0, 0, 24, 102, 116, 121, 112]);
+
+const originalFetch = globalThis.fetch;
+test.after(() => {
+  globalThis.fetch = originalFetch;
+});
+
+function json(payload: unknown) {
+  return new Response(JSON.stringify(payload), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+/** Fake Leonardo: records the submit request and completes the job on the first poll. */
+async function generate(model: string, body: Record<string, unknown> = {}) {
+  let submitted: { url: string; body: Record<string, unknown> } | null = null;
+  globalThis.fetch = (async (url: unknown, options?: RequestInit) => {
+    const href = String(url);
+    if (options?.method === "POST") {
+      submitted = { url: href, body: JSON.parse(String(options.body)) };
+      return json({ motionVideoGenerationJob: { generationId: "vid-1" } });
+    }
+    if (href === `${STATUS_URL}/vid-1`) {
+      return json({
+        generations_by_pk: {
+          status: "COMPLETE",
+          generated_images: [
+            {
+              url: "https://cdn.leonardo.ai/thumb.jpg",
+              motionMP4URL: "https://cdn.leonardo.ai/video.mp4",
+            },
+          ],
+        },
+      });
+    }
+    if (href === "https://cdn.leonardo.ai/video.mp4") return new Response(MP4);
+    if (href === "https://cdn.leonardo.ai/thumb.jpg") return new Response("jpeg");
+    throw new Error(`unexpected fetch ${href}`);
+  }) as typeof fetch;
+
+  const result = await handleLeonardoVideoGeneration({
+    model,
+    provider: "leonardo",
+    providerConfig,
+    body: { prompt: "a paper boat drifting on a pond", ...body },
+    credentials: { apiKey: "test-key" },
+    log: null,
+    pollIntervalMs: 0,
+  });
+  return { result, submitted };
+}
+
+test("a video request goes to the text-to-video endpoint with a model enum and resolution", async () => {
+  const { submitted } = await generate("motion-2.0-fast");
+  assert.equal(submitted?.url, SUBMIT_URL);
+  assert.equal(submitted?.body.model, "MOTION2FAST");
+  assert.equal(submitted?.body.resolution, "RESOLUTION_720");
+  assert.equal(submitted?.body.width, 1280);
+  assert.equal(submitted?.body.height, 720);
+  assert.equal(submitted?.body.prompt, "a paper boat drifting on a pond");
+  assert.equal(submitted?.body.num_frames, undefined);
+  assert.equal(submitted?.body.modelId, undefined);
+});
+
+test("the result is the mp4 from motionMP4URL, not the jpg thumbnail", async () => {
+  const { result } = await generate("motion-2.0");
+  assert.equal(result.success, true);
+  const item = (result as { data: { data: Array<{ b64_json: string; format: string }> } }).data
+    .data[0];
+  assert.equal(item.format, "mp4");
+  assert.deepEqual(new Uint8Array(Buffer.from(item.b64_json, "base64")), MP4);
+});
+
+test("motion-2.0 and the old phoenix id both send Motion 2.0", async () => {
+  assert.equal((await generate("motion-2.0")).submitted?.body.model, "MOTION2");
+  assert.equal((await generate("phoenix")).submitted?.body.model, "MOTION2");
+});
+
+test("a 480p size picks RESOLUTION_480 and keeps a portrait orientation", async () => {
+  const landscape = (await generate("motion-2.0-fast", { size: "832x480" })).submitted?.body;
+  assert.deepEqual(
+    [landscape?.resolution, landscape?.width, landscape?.height],
+    ["RESOLUTION_480", 832, 480]
+  );
+  const portrait = (await generate("motion-2.0-fast", { size: "480x832" })).submitted?.body;
+  assert.deepEqual(
+    [portrait?.resolution, portrait?.width, portrait?.height],
+    ["RESOLUTION_480", 480, 832]
+  );
+  const portrait720 = (await generate("motion-2.0", { size: "720x1280" })).submitted?.body;
+  assert.deepEqual(
+    [portrait720?.resolution, portrait720?.width, portrait720?.height],
+    ["RESOLUTION_720", 720, 1280]
+  );
+});
+
+test("the catalog lists the Motion 2.0 models", () => {
+  assert.deepEqual(
+    providerConfig.models.map((m: { id: string }) => m.id),
+    ["motion-2.0", "motion-2.0-fast"]
+  );
+});