@shop-os/modelkit 0.2.19 → 0.2.21

package/dist/index.cjs

@@ -283,7 +283,9 @@ function geminiImage(id, label, aliases, sizes, display, exposure, references) {
   const constraints = {
     aspectRatios: [...GEMINI_RATIOS],
     sizes,
-    supports: ["safetySettings", "temperature"]
+    supports: ["safetySettings", "temperature"],
+    // google-image sends MediaRef.label as a text part beside each reference.
+    prompt: { referenceSyntax: "caption" }
   };
   if (references !== void 0) constraints.references = references;
   const model = {
@@ -570,6 +572,7 @@ var IMAGE_MODELS = [
     constraints: {
       aspectRatios: ["1:1", "2:3", "3:2", "16:9", "9:16", "4:3", "3:4", "4:5", "5:4", "21:9"],
       sizes: ["1K"],
+      references: { images: 8 },
       // flux-2-pro's job type always returns image/png; only the seed is forwarded.
       supports: ["seed"]
     },
@@ -1365,12 +1368,14 @@ var TEXT_MODELS = [
 var VIDEO_USAGE = { unit: "seconds" };
 var SEEDANCE_RATIOS = ["21:9", "16:9", "4:3", "1:1", "3:4", "9:16", "adaptive"];
 var KLING_RATIOS = ["16:9", "9:16", "1:1", "adaptive"];
+var KLING_OMNI_RATIOS = ["16:9", "9:16", "1:1"];
 var OMNI_RATIOS = ["16:9", "9:16"];
 var GROK_RATIOS = ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3"];
 var H3_RATIOS = ["21:9", "16:9", "4:3", "1:1", "3:4", "9:16"];
 var H3_REFERENCE_RATIOS = ["adaptive", ...H3_RATIOS];
 var NEGATIVE_PROMPT = "blur, distort, and low quality";
 var FRAMES_EXCLUDE_REFERENCES = { framesExcludeReferences: true };
+var KLING_PROMPT = { referenceSyntax: "numbered", maxChars: 2500 };
 var BYTEDANCE_LOGO = "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/3bba5d81-4e57-4e71-911b-cdfa05acca2c_compressed.png";
 var GOOGLE_LOGO2 = "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/192485d2-a76a-4657-9c06-930b2c70badd_compressed.png";
 var VIDEO_MODELS = [
@@ -1391,9 +1396,14 @@ var VIDEO_MODELS = [
     constraints: {
       aspectRatios: [...OMNI_RATIOS],
       resolutions: ["720p", "1080p", "4k"],
+      // Veo also takes 4 and 6, but must be 8 at 1080p/4k or with reference images;
+      // [8] until the kit has a rule that forces it there (CHANGELOG 0.2.21).
       durations: [8],
       references: { images: 3 },
-      supports: ["lastFrame", "seed"]
+      supports: ["lastFrame", "seed"],
+      // 1,024 text tokens; 3,000 characters assumes ~2.9 characters per token.
+      prompt: { referenceSyntax: "numbered", maxChars: 3e3 },
+      audio: "always"
     },
     defaults: { durationSeconds: 8, resolution: "720p", aspectRatio: "16:9" },
     usage: { ...VIDEO_USAGE, slug: "veo" },
@@ -1403,7 +1413,8 @@ var VIDEO_MODELS = [
       description: "Google's highest-quality video generation model. Supports up to 4K resolution and 8-second clips with reference image conditioning.",
       logo: GOOGLE_LOGO2
     },
-    capabilities: { ...FRAMES_EXCLUDE_REFERENCES }
+    // Veo's lastFrame "must be used in combination with the image parameter".
+    capabilities: { ...FRAMES_EXCLUDE_REFERENCES, lastFrameRequiresFirstFrame: true }
   },
   {
     id: "veo-3.1-fast",
@@ -1423,7 +1434,8 @@ var VIDEO_MODELS = [
       resolutions: ["720p", "1080p", "4k"],
       durations: [4, 6, 8],
       references: { images: 3 },
-      supports: ["lastFrame", "seed"]
+      supports: ["lastFrame", "seed"],
+      audio: "always"
     },
     defaults: { durationSeconds: 8, resolution: "720p", aspectRatio: "16:9" },
     usage: { ...VIDEO_USAGE },
@@ -1451,7 +1463,8 @@ var VIDEO_MODELS = [
       aspectRatios: [...OMNI_RATIOS],
       resolutions: ["720p", "1080p"],
       durations: [4, 6, 8],
-      supports: ["lastFrame", "seed"]
+      supports: ["lastFrame", "seed"],
+      audio: "always"
     },
     defaults: { durationSeconds: 8, resolution: "720p", aspectRatio: "16:9" },
     usage: { ...VIDEO_USAGE },
@@ -1485,7 +1498,10 @@ var VIDEO_MODELS = [
       durations: [3, 4, 5, 6, 7, 8, 9, 10],
       references: { images: 6, videos: 1, videoSeconds: { max: 10 } },
       sourceVideoSeconds: { max: 10 },
-      supports: []
+      supports: [],
+      // generateOmniVideo sends MediaRef.label as a text part beside each image.
+      prompt: { referenceSyntax: "caption" },
+      audio: "always"
     },
     defaults: {},
     usage: { ...VIDEO_USAGE, slug: "gemini_omni" },
@@ -1518,8 +1534,12 @@ var VIDEO_MODELS = [
       // extension can upload a <= 10 s source with task "extend"; later ones
       // chain by `previousInteractionId` (the API rejects the id together
       // with a video task, so those calls carry the prompt alone).
-      supports: ["videoExtension"],
-      extension: { segmentSeconds: 10, maxTotalSeconds: 40 }
+      // First-to-last-frame interpolation: `<LAST_FRAME>` goes with `<FIRST_FRAME>`.
+      supports: ["videoExtension", "lastFrame"],
+      extension: { segmentSeconds: 10, maxTotalSeconds: 40 },
+      // generateOmniVideo sends MediaRef.label as a text part beside each image.
+      prompt: { referenceSyntax: "caption" },
+      audio: "always"
     },
     defaults: {},
     usage: { ...VIDEO_USAGE },
@@ -1529,7 +1549,7 @@ var VIDEO_MODELS = [
       logo: GOOGLE_LOGO2,
       description: "Google Gemini Omni Flash 1.1 conversational video generation, editing and extension; text, image, and up to 10-second video input, 3-10 second output at up to 4K and 24 FPS, extendable to 40 seconds."
     },
-    capabilities: { acceptsSourceVideo: true }
+    capabilities: { acceptsSourceVideo: true, lastFrameRequiresFirstFrame: true }
   },
   {
     // vibe-triggers and Space Builder drop the ratio when a frame is wired; Cowork always sends it.
@@ -1555,7 +1575,9 @@ var VIDEO_MODELS = [
       },
       sourceVideoSeconds: { min: 2, max: 15, inReferenceTotal: true },
       ratioIgnoredWith: ["firstFrame", "sourceVideo"],
-      supports: ["generateAudio", "seed", "lastFrame", "watermark"]
+      // No seed: 2.x echoes it but does not honour it (two seeded runs differed, 2026-10-01).
+      supports: ["generateAudio", "lastFrame", "watermark"],
+      audio: "optional"
     },
     defaults: {
       durationSeconds: 5,
@@ -1594,7 +1616,9 @@ var VIDEO_MODELS = [
       },
       sourceVideoSeconds: { min: 2, max: 15, inReferenceTotal: true },
       ratioIgnoredWith: ["firstFrame", "sourceVideo"],
-      supports: ["generateAudio", "seed", "lastFrame", "watermark"]
+      // No seed: 2.x echoes it but does not honour it (two seeded runs differed, 2026-10-01).
+      supports: ["generateAudio", "lastFrame", "watermark"],
+      audio: "optional"
     },
     defaults: {
       durationSeconds: 5,
@@ -1612,7 +1636,6 @@ var VIDEO_MODELS = [
     capabilities: { acceptsSourceVideo: true, ...FRAMES_EXCLUDE_REFERENCES }
   },
   {
-    // generateAudio defaults to false here (trigger-workflows); Space Builder defaults it to true.
     // omni_reference_task_type edit/extend: adaptive ratio, edit sends duration -1.
     id: "seedance-2.5",
     aliases: ["seedance-2-5", "dreamina-seedance-2-5-260628"],
@@ -1634,13 +1657,15 @@ var VIDEO_MODELS = [
       },
       sourceVideoSeconds: { min: 2, max: 30, editMin: 4, inReferenceTotal: true },
       ratioIgnoredWith: ["firstFrame", "sourceVideo"],
-      supports: ["generateAudio", "seed", "lastFrame", "watermark", "taskType"]
+      // No seed: 2.x echoes it but does not honour it (two seeded runs differed, 2026-10-01).
+      supports: ["generateAudio", "lastFrame", "watermark", "taskType"],
+      audio: "optional"
     },
     defaults: {
       durationSeconds: 5,
       resolution: "720p",
       aspectRatio: "16:9",
-      generateAudio: false
+      generateAudio: true
     },
     usage: { ...VIDEO_USAGE },
     pricingKind: "video_per_second",
@@ -1652,7 +1677,6 @@ var VIDEO_MODELS = [
     capabilities: { acceptsSourceVideo: true, ...FRAMES_EXCLUDE_REFERENCES }
   },
   {
-    // Cowork allows 7 reference images and durations 4/6/8/10; Space Builder allows 5 and 1-15s.
     id: "grok-imagine",
     aliases: ["grok-imagine-video", "grokImagine"],
     label: "Grok Imagine",
@@ -1666,8 +1690,11 @@ var VIDEO_MODELS = [
       resolutions: ["480p", "720p"],
       durations: { min: 1, max: 15 },
       durationPresets: [4, 6, 8, 10],
-      references: { images: 5 },
-      supports: []
+      // xAI: "A maximum of 7 reference images can be provided per request."
+      references: { images: 7 },
+      supports: [],
+      // xAI can switch sound off (generate_audio); xai-video.ts never sends it.
+      audio: "always"
     },
     // No resolution default: xAI picks its own unless the caller asks.
     defaults: { durationSeconds: 8, aspectRatio: "16:9" },
@@ -1689,15 +1716,16 @@ var VIDEO_MODELS = [
     providerModelId: "kling-video/v2.5-turbo/pro/image-to-video",
     lifecycle: "active",
     exposure: ["cowork", "space_builder"],
+    // The endpoint has no aspect_ratio or last_image_url: the start image sets the framing.
     constraints: {
-      aspectRatios: [...KLING_RATIOS],
       durations: [5, 10],
       requires: ["firstFrame"],
-      supports: ["cfgScale", "negativePrompt", "lastFrame"]
+      supports: ["cfgScale", "negativePrompt"],
+      prompt: KLING_PROMPT,
+      audio: "never"
     },
     defaults: {
       durationSeconds: 5,
-      aspectRatio: "16:9",
       cfgScale: 0.5,
       negativePrompt: NEGATIVE_PROMPT
     },
@@ -1706,7 +1734,7 @@ var VIDEO_MODELS = [
     display: {
       provider: "kuaishou",
       logo: "https://cdn.jsdelivr.net/npm/@lobehub/icons-static-png@1.97.0/light/kling-color.png",
-      description: "Kuaishou Kling 2.5 Turbo Pro image-to-video; animates a single input image from a text prompt with an optional end image, 5- or 10-second clips."
+      description: "Kuaishou Kling 2.5 Turbo Pro image-to-video; animates a single input image from a text prompt, 5- or 10-second clips."
     },
     capabilities: { ...FRAMES_EXCLUDE_REFERENCES }
   },
@@ -1720,17 +1748,18 @@ var VIDEO_MODELS = [
     providerModelId: "kling-video/v3.0/pro/image-to-video",
     lifecycle: "active",
     exposure: ["cowork", "space_builder"],
+    // The endpoint has no aspect_ratio or negative_prompt; sound is "on"/"off" (default on).
     constraints: {
-      aspectRatios: [...KLING_RATIOS],
       durations: { min: 3, max: 15 },
       requires: ["firstFrame"],
-      supports: ["cfgScale", "negativePrompt", "lastFrame"]
+      supports: ["cfgScale", "lastFrame", "generateAudio"],
+      prompt: KLING_PROMPT,
+      audio: "optional"
     },
     defaults: {
       durationSeconds: 5,
-      aspectRatio: "16:9",
       cfgScale: 0.5,
-      negativePrompt: NEGATIVE_PROMPT
+      generateAudio: true
     },
     usage: { ...VIDEO_USAGE },
     pricingKind: "video_per_second",
@@ -1742,7 +1771,7 @@ var VIDEO_MODELS = [
     capabilities: { ...FRAMES_EXCLUDE_REFERENCES }
   },
   {
-    // mode standard/pro selects 720p/1080p; the endpoint takes no separate resolution.
+    // mode standard/pro/4k selects 720p/1080p/4K; the endpoint takes no separate resolution.
     // Replicate: "Max 7 [images] without video, 4 with video"; 4K does not support
     // reference_video. No `videos` limit yet: the adapter sends no reference video,
     // so `imagesWithVideo` stays dormant until one is wired through.
@@ -1755,21 +1784,25 @@ var VIDEO_MODELS = [
     lifecycle: "active",
     exposure: ["cowork", "space_builder"],
     constraints: {
-      aspectRatios: [...KLING_RATIOS],
-      resolutions: ["720p", "1080p"],
+      aspectRatios: [...KLING_OMNI_RATIOS],
+      resolutions: ["720p", "1080p", "4k"],
       durations: { min: 3, max: 15 },
       references: { images: 7, imagesWithVideo: 4 },
-      supports: ["generateAudio", "lastFrame"]
+      supports: ["generateAudio", "lastFrame"],
+      prompt: KLING_PROMPT,
+      audio: "optional"
     },
-    defaults: { durationSeconds: 5, aspectRatio: "16:9", generateAudio: false, mode: "pro" },
+    defaults: { durationSeconds: 5, aspectRatio: "16:9", generateAudio: true, mode: "pro" },
     usage: { unit: "compute_seconds" },
     pricingKind: "video_per_second",
     display: {
       provider: "kuaishou",
       logo: "https://cdn.jsdelivr.net/npm/@lobehub/icons-static-png@1.97.0/light/kling-color.png",
-      description: "Kuaishou Kling Video 3.0 Omni unified generation and editing from text, start/end images, up to 7 reference images, and reference video; up to 15 seconds at up to 1080p."
-    },
-    capabilities: {}
+      description: "Kuaishou Kling Video 3.0 Omni unified generation and editing from text, start/end images, up to 7 reference images, and reference video; up to 15 seconds at up to 4K."
+    }
+    // end_image "Requires start_image", but no lastFrameRequiresFirstFrame: SpaceLab resolves
+    // replicate rows in error mode, so the flag would refuse its end-frame-only nodes, which
+    // the adapter sends as start_image.
   },
   {
     id: "minimax-h3",
@@ -1784,7 +1817,10 @@ var VIDEO_MODELS = [
       aspectRatios: [...H3_RATIOS],
       resolutions: ["480p", "768p", "2k", "4k"],
       durations: { min: 5, max: 15 },
-      supports: ["seed", "promptExpansion", "lastFrame", "safetyChecker"]
+      // fal's image-to-video endpoint has no aspect_ratio; the frame sets it.
+      ratioIgnoredWith: ["firstFrame"],
+      supports: ["seed", "promptExpansion", "lastFrame", "safetyChecker"],
+      audio: "always"
     },
     defaults: {
       durationSeconds: 5,
@@ -1812,9 +1848,12 @@ var VIDEO_MODELS = [
     exposure: ["cowork", "space_builder"],
     constraints: {
       aspectRatios: [...H3_RATIOS],
-      resolutions: ["480p", "768p"],
+      resolutions: ["480p", "768p", "1080p"],
       durations: { min: 5, max: 15 },
-      supports: ["seed", "promptExpansion", "lastFrame", "safetyChecker"]
+      // fal's image-to-video endpoint has no aspect_ratio; the frame sets it.
+      ratioIgnoredWith: ["firstFrame"],
+      supports: ["seed", "promptExpansion", "lastFrame", "safetyChecker"],
+      audio: "always"
     },
     defaults: {
       durationSeconds: 5,
@@ -1827,7 +1866,7 @@ var VIDEO_MODELS = [
     display: {
       provider: "minimax",
       logo: "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/f4c2e906-28b7-4a4a-b491-df8fef7808ed.png",
-      description: "High-speed MiniMax H3 Max variant for text-to-video and image-to-video (first/last frame) only, up to 768p."
+      description: "High-speed MiniMax H3 Max variant for text-to-video and image-to-video (first/last frame) only, up to 1080p."
     },
     capabilities: { ...FRAMES_EXCLUDE_REFERENCES }
   },
@@ -1844,6 +1883,8 @@ var VIDEO_MODELS = [
       aspectRatios: [...H3_REFERENCE_RATIOS],
       resolutions: ["480p", "768p", "2k", "4k"],
       durations: { min: 5, max: 15 },
+      // A start frame routes to image-to-video, which has no aspect_ratio.
+      ratioIgnoredWith: ["firstFrame"],
       references: {
         images: 9,
         videos: 3,
@@ -1852,7 +1893,8 @@ var VIDEO_MODELS = [
         audioOnly: false,
         videoSeconds: { min: 2, max: 15, total: 15 }
       },
-      supports: ["seed", "promptExpansion", "safetyChecker"]
+      supports: ["seed", "promptExpansion", "safetyChecker"],
+      audio: "always"
     },
     defaults: {
       durationSeconds: 5,
@@ -1867,7 +1909,9 @@ var VIDEO_MODELS = [
       logo: "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/f4c2e906-28b7-4a4a-b491-df8fef7808ed.png",
       description: "MiniMax H3 reference-to-video mode guided by up to 9 reference images, 3 reference videos, and 3 audio clips; reference and image-to-video inputs cannot be mixed."
     },
-    capabilities: {}
+    // fal's reference-to-video endpoint never reads a frame; the resolver must drop the
+    // references instead of the adapter silently dropping the frame.
+    capabilities: { ...FRAMES_EXCLUDE_REFERENCES }
   },
   {
     id: "minimax-h3-max-reference",
@@ -1880,8 +1924,10 @@ var VIDEO_MODELS = [
     exposure: ["cowork", "space_builder"],
     constraints: {
       aspectRatios: [...H3_REFERENCE_RATIOS],
-      resolutions: ["480p", "768p"],
+      resolutions: ["480p", "768p", "1080p"],
       durations: { min: 5, max: 15 },
+      // A start frame routes to image-to-video, which has no aspect_ratio.
+      ratioIgnoredWith: ["firstFrame"],
       references: {
         images: 9,
         videos: 3,
@@ -1890,7 +1936,8 @@ var VIDEO_MODELS = [
         audioOnly: false,
         videoSeconds: { min: 2, max: 15, total: 15 }
       },
-      supports: ["seed", "promptExpansion", "safetyChecker"]
+      supports: ["seed", "promptExpansion", "safetyChecker"],
+      audio: "always"
     },
     defaults: {
       durationSeconds: 5,
@@ -1905,7 +1952,9 @@ var VIDEO_MODELS = [
       logo: "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/f4c2e906-28b7-4a4a-b491-df8fef7808ed.png",
       description: "MiniMax H3 Max reference-to-video on fal; conditions on reference images, videos, and audio. MiniMax's own docs do not list a reference mode for H3 Max."
     },
-    capabilities: {}
+    // fal's reference-to-video endpoint never reads a frame; the resolver must drop the
+    // references instead of the adapter silently dropping the frame.
+    capabilities: { ...FRAMES_EXCLUDE_REFERENCES }
   },
   {
     // Duration 3-10s per trigger-workflows mapDuration; the endpoint takes no resolution.
@@ -1922,7 +1971,8 @@ var VIDEO_MODELS = [
       durations: { min: 3, max: 10 },
       requires: ["sourceVideo"],
       sourceVideoSeconds: { min: 3, max: 10.05 },
-      supports: []
+      supports: [],
+      audio: "never"
     },
     defaults: { durationSeconds: 5, aspectRatio: "16:9" },
     usage: { ...VIDEO_USAGE },
@@ -1946,7 +1996,8 @@ var VIDEO_MODELS = [
     constraints: {
       resolutions: ["768p"],
       durations: [6, 10],
-      supports: ["lastFrame"]
+      supports: ["lastFrame"],
+      audio: "never"
     },
     defaults: { durationSeconds: 6, resolution: "768p" },
     usage: { unit: "compute_seconds" },
@@ -1969,7 +2020,8 @@ var VIDEO_MODELS = [
     exposure: [],
     constraints: {
       requires: ["firstFrame"],
-      supports: ["seed", "lastFrame"]
+      supports: ["seed", "lastFrame"],
+      audio: "never"
     },
     defaults: {},
     usage: { ...VIDEO_USAGE },
@@ -1991,7 +2043,7 @@ var MODELS = [
 ];
 
 // src/catalog/schema.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/catalog/collisions.ts
 function collisionIssues(rows) {
@@ -2038,8 +2090,57 @@ function collisionIssues(rows) {
   return issues;
 }
 
-// src/catalog/input-spec.ts
+// src/catalog/conventions.ts
 var import_zod = require("zod");
+var AudioOutputSchema = import_zod.z.enum(["always", "optional", "never"]);
+var ReferenceSyntaxSchema = import_zod.z.enum(["numbered", "caption", "descriptive"]);
+var MaxCharsSchema = import_zod.z.number().int().positive();
+var PromptConventionsSchema = import_zod.z.strictObject({
+  referenceSyntax: ReferenceSyntaxSchema,
+  maxChars: MaxCharsSchema.optional()
+});
+var AUDIO_OUTPUTS = AudioOutputSchema.options;
+var REFERENCE_SYNTAXES = ReferenceSyntaxSchema.options;
+var ConstraintsReadView = import_zod.z.looseObject({
+  audio: AudioOutputSchema.optional().catch(void 0),
+  prompt: import_zod.z.looseObject({
+    referenceSyntax: ReferenceSyntaxSchema.catch("numbered"),
+    maxChars: MaxCharsSchema.optional().catch(void 0)
+  }).optional().catch(void 0)
+});
+var DEFAULT_CONVENTIONS = { referenceSyntax: "numbered" };
+function promptConventions(row) {
+  const view = ConstraintsReadView.safeParse(row.constraints);
+  const prompt = view.success ? view.data.prompt : void 0;
+  if (prompt === void 0) return { ...DEFAULT_CONVENTIONS };
+  const result = { referenceSyntax: prompt.referenceSyntax };
+  if (prompt.maxChars !== void 0) result.maxChars = prompt.maxChars;
+  return result;
+}
+var RawConventionsView = import_zod.z.looseObject({
+  audio: import_zod.z.unknown().optional(),
+  prompt: import_zod.z.unknown().optional()
+});
+function normaliseConventions(row) {
+  const view = RawConventionsView.safeParse(row.constraints);
+  if (!view.success) return { row, invalidKeys: [] };
+  const { audio, prompt } = view.data;
+  const badAudio = audio !== void 0 && !AudioOutputSchema.safeParse(audio).success;
+  const badPrompt = prompt !== void 0 && !PromptConventionsSchema.safeParse(prompt).success;
+  if (!badAudio && !badPrompt) return { row, invalidKeys: [] };
+  const invalidKeys = [];
+  if (badAudio) invalidKeys.push("constraints.audio");
+  if (badPrompt) invalidKeys.push("constraints.prompt");
+  const entries = Object.entries(row.constraints).flatMap(([key, value]) => {
+    if (key === "audio" && badAudio) return [];
+    if (key === "prompt" && badPrompt) return [[key, promptConventions(row)]];
+    return [[key, value]];
+  });
+  return { row: { ...row, constraints: Object.fromEntries(entries) }, invalidKeys };
+}
+
+// src/catalog/input-spec.ts
+var import_zod2 = require("zod");
 var VIDEO_INPUT_SPEC_KEYS = [
   "prompt",
   "durationSeconds",
@@ -2078,8 +2179,8 @@ var ALL_KEY_SET = /* @__PURE__ */ new Set([
   ...VIDEO_INPUT_SPEC_KEYS,
   ...AUDIO_INPUT_SPEC_KEYS
 ]);
-var ProviderScalarSchema = import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()]);
-var FieldsSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.string().min(1)).superRefine((fields, ctx) => {
+var ProviderScalarSchema = import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean()]);
+var FieldsSchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string().min(1)).superRefine((fields, ctx) => {
   const keys = Object.keys(fields);
   if (keys.length === 0) {
     ctx.addIssue({
@@ -2097,7 +2198,7 @@ var FieldsSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.strin
     }
   }
 });
-var ValuesSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.record(import_zod.z.string(), ProviderScalarSchema)).superRefine((values, ctx) => {
+var ValuesSchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.record(import_zod2.z.string(), ProviderScalarSchema)).superRefine((values, ctx) => {
   for (const key of Object.keys(values)) {
     if (!ALL_KEY_SET.has(key)) {
       ctx.addIssue({
@@ -2107,8 +2208,8 @@ var ValuesSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.recor
     }
   }
 });
-var StaticSchema = import_zod.z.record(import_zod.z.string(), ProviderScalarSchema);
-var InputSpecSchema = import_zod.z.strictObject({
+var StaticSchema = import_zod2.z.record(import_zod2.z.string(), ProviderScalarSchema);
+var InputSpecSchema = import_zod2.z.strictObject({
   fields: FieldsSchema,
   values: ValuesSchema.optional(),
   static: StaticSchema.optional()
@@ -2215,16 +2316,16 @@ var ADAPTER_IDS = [
   "higgsfield",
   "xai-video"
 ];
-var ModelTypeSchema = import_zod2.z.enum(["text", "image", "video", "audio", "upscale", "bg-remove"]);
-var LifecycleSchema = import_zod2.z.enum(["active", "deprecated", "retired"]);
-var SurfaceSchema = import_zod2.z.enum(["cowork", "space_builder"]);
+var ModelTypeSchema = import_zod3.z.enum(["text", "image", "video", "audio", "upscale", "bg-remove"]);
+var LifecycleSchema = import_zod3.z.enum(["active", "deprecated", "retired"]);
+var SurfaceSchema = import_zod3.z.enum(["cowork", "space_builder"]);
 var SURFACES2 = SurfaceSchema.options;
-var ExposureSchema = import_zod2.z.preprocess(
+var ExposureSchema = import_zod3.z.preprocess(
   normalizeExposure,
-  import_zod2.z.array(SurfaceSchema)
+  import_zod3.z.array(SurfaceSchema)
 );
-var AdapterSchema = import_zod2.z.enum(ADAPTER_IDS);
-var AspectRatioSchema = import_zod2.z.enum([
+var AdapterSchema = import_zod3.z.enum(ADAPTER_IDS);
+var AspectRatioSchema = import_zod3.z.enum([
   "1:1",
   "16:9",
   "9:16",
@@ -2239,12 +2340,12 @@ var AspectRatioSchema = import_zod2.z.enum([
   "97:30",
   "adaptive"
 ]);
-var ImageSizeSchema = import_zod2.z.enum(["512", "1K", "2K", "4K"]);
-var VideoResolutionSchema = import_zod2.z.enum(["360p", "480p", "720p", "768p", "1080p", "2k", "4k"]);
-var ImageQualitySchema = import_zod2.z.enum(["auto", "low", "medium", "high", "xhigh", "max"]);
-var OutputFormatSchema = import_zod2.z.enum(["png", "jpeg", "webp"]);
-var RequiredInputSchema = import_zod2.z.enum(["firstFrame", "sourceVideo", "references"]);
-var SupportedOptionSchema = import_zod2.z.enum([
+var ImageSizeSchema = import_zod3.z.enum(["512", "1K", "2K", "4K"]);
+var VideoResolutionSchema = import_zod3.z.enum(["360p", "480p", "720p", "768p", "1080p", "2k", "4k"]);
+var ImageQualitySchema = import_zod3.z.enum(["auto", "low", "medium", "high", "xhigh", "max"]);
+var OutputFormatSchema = import_zod3.z.enum(["png", "jpeg", "webp"]);
+var RequiredInputSchema = import_zod3.z.enum(["firstFrame", "sourceVideo", "references"]);
+var SupportedOptionSchema = import_zod3.z.enum([
   "seed",
   "quality",
   "negativePrompt",
@@ -2264,142 +2365,147 @@ var SupportedOptionSchema = import_zod2.z.enum([
   "videoExtension",
   "instrumental"
 ]);
-var UsageUnitSchema = import_zod2.z.enum([
+var UsageUnitSchema = import_zod3.z.enum([
   "tokens",
   "images",
   "seconds",
   "reported_cost_usd",
   "compute_seconds"
 ]);
-var PricingKindSchema = import_zod2.z.enum(["token", "image_size", "video_per_second", "flat"]);
-var ProviderOptionValueSchema = import_zod2.z.lazy(
-  () => import_zod2.z.union([
-    import_zod2.z.string(),
-    import_zod2.z.number(),
-    import_zod2.z.boolean(),
-    import_zod2.z.array(ProviderOptionValueSchema),
-    import_zod2.z.record(import_zod2.z.string(), ProviderOptionValueSchema)
+var PricingKindSchema = import_zod3.z.enum(["token", "image_size", "video_per_second", "flat"]);
+var ProviderOptionValueSchema = import_zod3.z.lazy(
+  () => import_zod3.z.union([
+    import_zod3.z.string(),
+    import_zod3.z.number(),
+    import_zod3.z.boolean(),
+    import_zod3.z.array(ProviderOptionValueSchema),
+    import_zod3.z.record(import_zod3.z.string(), ProviderOptionValueSchema)
   ])
 );
-var ProviderOptionsSchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.record(import_zod2.z.string(), ProviderOptionValueSchema));
-var VideoSecondsLimitsSchema = import_zod2.z.looseObject({
-  min: import_zod2.z.number().optional(),
-  max: import_zod2.z.number().optional(),
-  total: import_zod2.z.number().optional(),
-  editMin: import_zod2.z.number().optional()
+var ProviderOptionsSchema = import_zod3.z.record(import_zod3.z.string(), import_zod3.z.record(import_zod3.z.string(), ProviderOptionValueSchema));
+var VideoSecondsLimitsSchema = import_zod3.z.looseObject({
+  min: import_zod3.z.number().optional(),
+  max: import_zod3.z.number().optional(),
+  total: import_zod3.z.number().optional(),
+  editMin: import_zod3.z.number().optional()
 });
-var ReferenceLimitsSchema = import_zod2.z.looseObject({
-  images: import_zod2.z.number().optional(),
-  imagesWithVideo: import_zod2.z.number().optional(),
-  videos: import_zod2.z.number().optional(),
-  audios: import_zod2.z.number().optional(),
-  total: import_zod2.z.number().optional(),
-  audioOnly: import_zod2.z.boolean().optional(),
+var ReferenceLimitsSchema = import_zod3.z.looseObject({
+  images: import_zod3.z.number().optional(),
+  imagesWithVideo: import_zod3.z.number().optional(),
+  videos: import_zod3.z.number().optional(),
+  audios: import_zod3.z.number().optional(),
+  total: import_zod3.z.number().optional(),
+  audioOnly: import_zod3.z.boolean().optional(),
   videoSeconds: VideoSecondsLimitsSchema.optional()
 });
-var ModelConstraintsSchema = import_zod2.z.looseObject({
-  aspectRatios: import_zod2.z.array(AspectRatioSchema).optional(),
-  sizes: import_zod2.z.array(ImageSizeSchema).optional(),
-  resolutions: import_zod2.z.array(VideoResolutionSchema).optional(),
-  durations: import_zod2.z.union([import_zod2.z.looseObject({ min: import_zod2.z.number(), max: import_zod2.z.number() }), import_zod2.z.array(import_zod2.z.number())]).optional(),
-  durationPresets: import_zod2.z.array(import_zod2.z.number()).optional(),
-  qualityOptions: import_zod2.z.array(import_zod2.z.string()).optional(),
-  exactSizes: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional(),
+var ModelConstraintsSchema = import_zod3.z.looseObject({
+  aspectRatios: import_zod3.z.array(AspectRatioSchema).optional(),
+  sizes: import_zod3.z.array(ImageSizeSchema).optional(),
+  resolutions: import_zod3.z.array(VideoResolutionSchema).optional(),
+  durations: import_zod3.z.union([import_zod3.z.looseObject({ min: import_zod3.z.number(), max: import_zod3.z.number() }), import_zod3.z.array(import_zod3.z.number())]).optional(),
+  durationPresets: import_zod3.z.array(import_zod3.z.number()).optional(),
+  qualityOptions: import_zod3.z.array(import_zod3.z.string()).optional(),
+  exactSizes: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional(),
   references: ReferenceLimitsSchema.optional(),
-  requires: import_zod2.z.array(RequiredInputSchema).optional(),
-  supports: import_zod2.z.array(SupportedOptionSchema).optional(),
-  ratioIgnoredWith: import_zod2.z.array(import_zod2.z.enum(["firstFrame", "sourceVideo"])).optional(),
-  sourceVideoSeconds: VideoSecondsLimitsSchema.omit({ total: true }).extend({ inReferenceTotal: import_zod2.z.boolean().optional() }).optional(),
-  extension: import_zod2.z.looseObject({ segmentSeconds: import_zod2.z.number(), maxTotalSeconds: import_zod2.z.number() }).optional()
+  requires: import_zod3.z.array(RequiredInputSchema).optional(),
+  supports: import_zod3.z.array(SupportedOptionSchema).optional(),
+  ratioIgnoredWith: import_zod3.z.array(import_zod3.z.enum(["firstFrame", "sourceVideo"])).optional(),
+  sourceVideoSeconds: VideoSecondsLimitsSchema.omit({ total: true }).extend({ inReferenceTotal: import_zod3.z.boolean().optional() }).optional(),
+  extension: import_zod3.z.looseObject({ segmentSeconds: import_zod3.z.number(), maxTotalSeconds: import_zod3.z.number() }).optional(),
+  // Loose on purpose: the read path keeps a row whose value is invalid (the accessors in
+  // conventions.ts read it as "not set"); CatalogModelSchema below rejects it on write.
+  audio: import_zod3.z.unknown().optional(),
+  prompt: import_zod3.z.unknown().optional()
 });
-var MediaRefSchema = import_zod2.z.union([
-  import_zod2.z.looseObject({
-    url: import_zod2.z.string(),
-    label: import_zod2.z.string().optional(),
-    durationSeconds: import_zod2.z.number().optional()
+var MediaRefSchema = import_zod3.z.union([
+  import_zod3.z.looseObject({
+    url: import_zod3.z.string(),
+    label: import_zod3.z.string().optional(),
+    durationSeconds: import_zod3.z.number().optional()
   }),
-  import_zod2.z.looseObject({
-    bytes: import_zod2.z.instanceof(Uint8Array),
-    mime: import_zod2.z.string(),
-    label: import_zod2.z.string().optional(),
-    durationSeconds: import_zod2.z.number().optional()
+  import_zod3.z.looseObject({
+    bytes: import_zod3.z.instanceof(Uint8Array),
+    mime: import_zod3.z.string(),
+    label: import_zod3.z.string().optional(),
+    durationSeconds: import_zod3.z.number().optional()
   })
 ]);
-var ImageSafetySettingSchema = import_zod2.z.looseObject({ category: import_zod2.z.string(), threshold: import_zod2.z.string() });
-var UpscaleOptionsSchema = import_zod2.z.looseObject({
-  enhanceModel: import_zod2.z.string().optional(),
-  subjectDetection: import_zod2.z.string().optional(),
-  faceEnhancement: import_zod2.z.boolean().optional(),
-  faceEnhancementCreativity: import_zod2.z.number().optional(),
-  faceEnhancementStrength: import_zod2.z.number().optional()
+var ImageSafetySettingSchema = import_zod3.z.looseObject({ category: import_zod3.z.string(), threshold: import_zod3.z.string() });
+var UpscaleOptionsSchema = import_zod3.z.looseObject({
+  enhanceModel: import_zod3.z.string().optional(),
+  subjectDetection: import_zod3.z.string().optional(),
+  faceEnhancement: import_zod3.z.boolean().optional(),
+  faceEnhancementCreativity: import_zod3.z.number().optional(),
+  faceEnhancementStrength: import_zod3.z.number().optional()
 });
-var DefaultsSchema = import_zod2.z.looseObject({
-  references: import_zod2.z.array(MediaRefSchema).optional(),
+var DefaultsSchema = import_zod3.z.looseObject({
+  references: import_zod3.z.array(MediaRefSchema).optional(),
   aspectRatio: AspectRatioSchema.optional(),
   size: ImageSizeSchema.optional(),
-  exactSize: import_zod2.z.string().optional(),
+  exactSize: import_zod3.z.string().optional(),
   quality: ImageQualitySchema.optional(),
-  seed: import_zod2.z.number().optional(),
-  count: import_zod2.z.number().optional(),
+  seed: import_zod3.z.number().optional(),
+  count: import_zod3.z.number().optional(),
   outputFormat: OutputFormatSchema.optional(),
-  scaleFactor: import_zod2.z.number().optional(),
-  safetySettings: import_zod2.z.array(ImageSafetySettingSchema).optional(),
-  temperature: import_zod2.z.number().optional(),
+  scaleFactor: import_zod3.z.number().optional(),
+  safetySettings: import_zod3.z.array(ImageSafetySettingSchema).optional(),
+  temperature: import_zod3.z.number().optional(),
   upscale: UpscaleOptionsSchema.optional(),
   firstFrame: MediaRefSchema.optional(),
   lastFrame: MediaRefSchema.optional(),
   sourceVideo: MediaRefSchema.optional(),
-  referenceImages: import_zod2.z.array(MediaRefSchema).optional(),
-  referenceVideos: import_zod2.z.array(MediaRefSchema).optional(),
-  referenceAudios: import_zod2.z.array(MediaRefSchema).optional(),
+  referenceImages: import_zod3.z.array(MediaRefSchema).optional(),
+  referenceVideos: import_zod3.z.array(MediaRefSchema).optional(),
+  referenceAudios: import_zod3.z.array(MediaRefSchema).optional(),
   resolution: VideoResolutionSchema.optional(),
-  durationSeconds: import_zod2.z.number().optional(),
-  generateAudio: import_zod2.z.boolean().optional(),
-  negativePrompt: import_zod2.z.string().optional(),
-  cfgScale: import_zod2.z.number().optional(),
-  promptExpansion: import_zod2.z.enum(["fast", "balanced", "quality"]).optional(),
-  watermark: import_zod2.z.boolean().optional(),
-  safetyChecker: import_zod2.z.boolean().optional(),
-  taskType: import_zod2.z.enum(["reference", "edit", "extend"]).optional(),
-  mode: import_zod2.z.enum(["standard", "pro"]).optional(),
-  instrumental: import_zod2.z.boolean().optional()
+  durationSeconds: import_zod3.z.number().optional(),
+  generateAudio: import_zod3.z.boolean().optional(),
+  negativePrompt: import_zod3.z.string().optional(),
+  cfgScale: import_zod3.z.number().optional(),
+  promptExpansion: import_zod3.z.enum(["fast", "balanced", "quality"]).optional(),
+  watermark: import_zod3.z.boolean().optional(),
+  safetyChecker: import_zod3.z.boolean().optional(),
+  taskType: import_zod3.z.enum(["reference", "edit", "extend"]).optional(),
+  mode: import_zod3.z.enum(["standard", "pro"]).optional(),
+  instrumental: import_zod3.z.boolean().optional()
 });
-var CatalogDisplaySchema = import_zod2.z.looseObject({
-  provider: import_zod2.z.string(),
-  description: import_zod2.z.string(),
-  logo: import_zod2.z.string().optional(),
-  costTier: import_zod2.z.union([import_zod2.z.literal(1), import_zod2.z.literal(2), import_zod2.z.literal(3)]).optional(),
-  recommended: import_zod2.z.boolean().optional(),
-  sortOrder: import_zod2.z.number().optional(),
-  chat: import_zod2.z.looseObject({
+var CatalogDisplaySchema = import_zod3.z.looseObject({
+  provider: import_zod3.z.string(),
+  description: import_zod3.z.string(),
+  logo: import_zod3.z.string().optional(),
+  costTier: import_zod3.z.union([import_zod3.z.literal(1), import_zod3.z.literal(2), import_zod3.z.literal(3)]).optional(),
+  recommended: import_zod3.z.boolean().optional(),
+  sortOrder: import_zod3.z.number().optional(),
+  chat: import_zod3.z.looseObject({
     providerOptions: ProviderOptionsSchema.optional(),
-    temperature: import_zod2.z.number().optional()
+    temperature: import_zod3.z.number().optional()
   }).optional()
 });
-var CatalogCapabilitiesSchema = import_zod2.z.looseObject({
-  acceptsSourceVideo: import_zod2.z.boolean().optional(),
-  framesExcludeReferences: import_zod2.z.boolean().optional(),
-  reasoning: import_zod2.z.boolean().optional(),
-  vision: import_zod2.z.boolean().optional(),
-  contextWindow: import_zod2.z.number().optional()
+var CatalogCapabilitiesSchema = import_zod3.z.looseObject({
+  acceptsSourceVideo: import_zod3.z.boolean().optional(),
+  framesExcludeReferences: import_zod3.z.boolean().optional(),
+  lastFrameRequiresFirstFrame: import_zod3.z.boolean().optional(),
+  reasoning: import_zod3.z.boolean().optional(),
+  vision: import_zod3.z.boolean().optional(),
+  contextWindow: import_zod3.z.number().optional()
 });
-var CatalogModelSchemaBase = import_zod2.z.looseObject({
-  id: import_zod2.z.string().min(1),
-  aliases: import_zod2.z.array(import_zod2.z.string()).default([]),
-  label: import_zod2.z.string().min(1),
+var CatalogModelSchemaBase = import_zod3.z.looseObject({
+  id: import_zod3.z.string().min(1),
+  aliases: import_zod3.z.array(import_zod3.z.string()).default([]),
+  label: import_zod3.z.string().min(1),
   type: ModelTypeSchema,
   adapter: AdapterSchema,
-  providerModelId: import_zod2.z.string().min(1),
+  providerModelId: import_zod3.z.string().min(1),
   lifecycle: LifecycleSchema,
-  replacedBy: import_zod2.z.string().optional(),
+  replacedBy: import_zod3.z.string().optional(),
   exposure: ExposureSchema,
   constraints: ModelConstraintsSchema,
   defaults: DefaultsSchema,
   providerOptions: ProviderOptionsSchema.optional(),
-  usage: import_zod2.z.looseObject({
+  usage: import_zod3.z.looseObject({
     unit: UsageUnitSchema,
-    slug: import_zod2.z.string().optional(),
-    providerLabel: import_zod2.z.string().optional()
+    slug: import_zod3.z.string().optional(),
+    providerLabel: import_zod3.z.string().optional()
   }),
   pricingKind: PricingKindSchema,
   display: CatalogDisplaySchema.optional(),
@@ -2450,9 +2556,30 @@ var CatalogModelSchema = CatalogModelSchemaBase.superRefine(
         }
       }
     }
+    const audio = row.constraints.audio;
+    if (audio !== void 0 && !AudioOutputSchema.safeParse(audio).success) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["constraints", "audio"],
+        message: 'audio must be "always", "optional" or "never"'
+      });
+    }
+    const prompt = row.constraints.prompt;
+    if (prompt !== void 0) {
+      const parsed = PromptConventionsSchema.safeParse(prompt);
+      if (!parsed.success) {
+        for (const issue of parsed.error.issues) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["constraints", "prompt", ...issue.path.map(String)],
+            message: issue.message
+          });
+        }
+      }
+    }
   }
 );
-var CatalogSchema = import_zod2.z.array(CatalogModelSchemaBase).superRefine((rows, ctx) => {
+var CatalogSchema = import_zod3.z.array(CatalogModelSchemaBase.transform((row) => normaliseConventions(row).row)).superRefine((rows, ctx) => {
   for (const issue of collisionIssues(rows)) {
     ctx.addIssue({
       code: "custom",
@@ -2473,7 +2600,7 @@ var import_xai = require("@ai-sdk/xai");
 var import_deepseek = require("@ai-sdk/deepseek");
 var import_moonshotai = require("@ai-sdk/moonshotai");
 var import_ai = require("ai");
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 var TEXT_PROVIDERS = [
   "openai",
   "anthropic",
@@ -2484,7 +2611,7 @@ var TEXT_PROVIDERS = [
   "moonshot",
   "minimax"
 ];
-var textProviderSchema = import_zod3.z.enum(TEXT_PROVIDERS);
+var textProviderSchema = import_zod4.z.enum(TEXT_PROVIDERS);
 function isTextProvider(value) {
   return textProviderSchema.safeParse(value).success;
 }
@@ -2777,24 +2904,24 @@ var aiSdkTextAdapter = {
 };
 
 // src/adapters/ark.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/retry.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // src/json.ts
-var import_zod4 = require("zod");
-var JsonValueSchema = import_zod4.z.lazy(
-  () => import_zod4.z.union([
-    import_zod4.z.string(),
-    import_zod4.z.number(),
-    import_zod4.z.boolean(),
-    import_zod4.z.null(),
-    import_zod4.z.array(JsonValueSchema),
-    import_zod4.z.record(import_zod4.z.string(), JsonValueSchema)
+var import_zod5 = require("zod");
+var JsonValueSchema = import_zod5.z.lazy(
+  () => import_zod5.z.union([
+    import_zod5.z.string(),
+    import_zod5.z.number(),
+    import_zod5.z.boolean(),
+    import_zod5.z.null(),
+    import_zod5.z.array(JsonValueSchema),
+    import_zod5.z.record(import_zod5.z.string(), JsonValueSchema)
   ])
 );
-var JsonObjectSchema = import_zod4.z.record(import_zod4.z.string(), JsonValueSchema);
+var JsonObjectSchema = import_zod5.z.record(import_zod5.z.string(), JsonValueSchema);
 async function readErrorBody(res) {
   const text2 = await res.text().catch(() => "");
   try {
@@ -2803,11 +2930,11 @@ async function readErrorBody(res) {
     return text2;
   }
 }
-var thrownErrorSchema = import_zod4.z.object({
-  message: import_zod4.z.string().optional(),
-  status: import_zod4.z.number().optional(),
-  statusCode: import_zod4.z.number().optional(),
-  responseBody: import_zod4.z.string().optional()
+var thrownErrorSchema = import_zod5.z.object({
+  message: import_zod5.z.string().optional(),
+  status: import_zod5.z.number().optional(),
+  statusCode: import_zod5.z.number().optional(),
+  responseBody: import_zod5.z.string().optional()
 });
 function describeThrown(cause) {
   const parsed = thrownErrorSchema.safeParse(cause);
@@ -2818,7 +2945,7 @@ function describeThrown(cause) {
 }
 
 // src/retry.ts
-var textBody = import_zod5.z.string();
+var textBody = import_zod6.z.string();
 function classifyHttpError(status, body, provider, model) {
   const asText = textBody.safeParse(body);
   const text2 = asText.success ? asText.data : JSON.stringify(body);
@@ -3077,7 +3204,7 @@ function arkKey(ctx) {
   return key;
 }
 function throwArkError(status, body, model) {
-  const parsed = import_zod6.z.string().safeParse(body);
+  const parsed = import_zod7.z.string().safeParse(body);
   const text2 = parsed.success ? parsed.data : JSON.stringify(body ?? "");
   if (/sensitive.?content|human.?face/i.test(text2)) {
     const init = {
@@ -3115,13 +3242,13 @@ function sniffedImageMime(bytes) {
     return "image/webp";
   return "image/jpeg";
 }
-var SeedreamImageSchema = import_zod6.z.object({
-  url: import_zod6.z.string().optional(),
-  b64_json: import_zod6.z.string().optional()
+var SeedreamImageSchema = import_zod7.z.object({
+  url: import_zod7.z.string().optional(),
+  b64_json: import_zod7.z.string().optional()
 });
-var SeedreamResponseSchema = import_zod6.z.object({
-  data: import_zod6.z.array(SeedreamImageSchema).optional(),
-  error: import_zod6.z.object({ message: import_zod6.z.string().optional(), code: import_zod6.z.string().optional() }).optional()
+var SeedreamResponseSchema = import_zod7.z.object({
+  data: import_zod7.z.array(SeedreamImageSchema).optional(),
+  error: import_zod7.z.object({ message: import_zod7.z.string().optional(), code: import_zod7.z.string().optional() }).optional()
 });
 function fetchInitFor(ctx, init) {
   if (ctx.signal !== void 0) init.signal = ctx.signal;
@@ -3203,21 +3330,21 @@ async function generateSeedreamImage(req, ctx) {
   if (req.quality !== void 0) usage2.imageQuality = req.quality;
   return { images: [{ bytes, mime: sniffedImageMime(bytes) }], usage: usage2, raw: data };
 }
-var SeedanceUsageSchema = import_zod6.z.object({
-  total_tokens: import_zod6.z.number().optional(),
-  completion_tokens: import_zod6.z.number().optional()
+var SeedanceUsageSchema = import_zod7.z.object({
+  total_tokens: import_zod7.z.number().optional(),
+  completion_tokens: import_zod7.z.number().optional()
 });
-var SeedanceResponseSchema = import_zod6.z.object({
-  id: import_zod6.z.string().optional(),
-  status: import_zod6.z.string().optional(),
-  content: import_zod6.z.object({ video_url: import_zod6.z.string().optional() }).optional(),
+var SeedanceResponseSchema = import_zod7.z.object({
+  id: import_zod7.z.string().optional(),
+  status: import_zod7.z.string().optional(),
+  content: import_zod7.z.object({ video_url: import_zod7.z.string().optional() }).optional(),
   usage: SeedanceUsageSchema.optional(),
-  duration: import_zod6.z.number().optional(),
-  framespersecond: import_zod6.z.number().optional(),
-  resolution: import_zod6.z.string().optional(),
-  error: import_zod6.z.union([import_zod6.z.string(), import_zod6.z.object({ message: import_zod6.z.string().optional() })]).optional()
+  duration: import_zod7.z.number().optional(),
+  framespersecond: import_zod7.z.number().optional(),
+  resolution: import_zod7.z.string().optional(),
+  error: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.object({ message: import_zod7.z.string().optional() })]).optional()
 });
-var SeedanceErrorMessageSchema = import_zod6.z.object({ message: import_zod6.z.string().optional() });
+var SeedanceErrorMessageSchema = import_zod7.z.object({ message: import_zod7.z.string().optional() });
 function seedanceUsage(ctx, req, duration) {
   const usage2 = {
     model: ctx.model.id,
@@ -3231,7 +3358,7 @@ function seedanceUsage(ctx, req, duration) {
   return usage2;
 }
 function seedanceErrorMessage(error, status) {
-  const asString = import_zod6.z.string().safeParse(error);
+  const asString = import_zod7.z.string().safeParse(error);
   if (asString.success) return asString.data;
   const asObject = SeedanceErrorMessageSchema.safeParse(error);
   if (asObject.success && asObject.data.message !== void 0) return asObject.data.message;
@@ -3404,18 +3531,18 @@ async function generateSeedanceVideo(req, ctx) {
 }
 
 // src/adapters/fal.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var import_client = require("@fal-ai/client");
 
 // src/adapters/fal-http.ts
-var import_zod7 = require("zod");
-var queueUrl = import_zod7.z.url().refine((value) => new URL(value).origin === "https://queue.fal.run");
-var submissionSchema = import_zod7.z.object({
-  request_id: import_zod7.z.string(),
+var import_zod8 = require("zod");
+var queueUrl = import_zod8.z.url().refine((value) => new URL(value).origin === "https://queue.fal.run");
+var submissionSchema = import_zod8.z.object({
+  request_id: import_zod8.z.string(),
   status_url: queueUrl,
   response_url: queueUrl
 });
-var statusSchema = import_zod7.z.object({ status: import_zod7.z.string() });
+var statusSchema = import_zod8.z.object({ status: import_zod8.z.string() });
 function createFalHttpClient(opts) {
   const jobs = /* @__PURE__ */ new Map();
   async function request(url, input, signal) {
@@ -3499,7 +3626,7 @@ var KLING_O1_ENDPOINT = "fal-ai/kling-video/o1/video-to-video/reference";
 var FAL_QUEUE_HOST = "https://queue.fal.run";
 var PASSTHROUGH_POLL_MS = 2e3;
 var PASSTHROUGH_MAX_WAIT_MS = 18e4;
-var falSubscribePayloadSchema = import_zod8.z.object({ data: JsonValueSchema });
+var falSubscribePayloadSchema = import_zod9.z.object({ data: JsonValueSchema });
 function defaultCreateFalClient(opts) {
   if (opts.maxRetries !== void 0)
     return createFalHttpClient({
@@ -3555,7 +3682,7 @@ function createFalAdapter(deps = defaultDeps) {
   };
 }
 var falAdapter = createFalAdapter();
-var falDetailSchema = import_zod8.z.object({ detail: JsonValueSchema });
+var falDetailSchema = import_zod9.z.object({ detail: JsonValueSchema });
 function liftDetail(body) {
   const parsed = falDetailSchema.safeParse(body);
   const detail = parsed.success ? parsed.data.detail : void 0;
@@ -3564,11 +3691,11 @@ function liftDetail(body) {
 function falError(status, body, model) {
   return classifyHttpError(status, liftDetail(body), "fal", model);
 }
-var falSdkThrownSchema = import_zod8.z.object({
-  status: import_zod8.z.number().optional(),
-  statusCode: import_zod8.z.number().optional(),
+var falSdkThrownSchema = import_zod9.z.object({
+  status: import_zod9.z.number().optional(),
+  statusCode: import_zod9.z.number().optional(),
   body: JsonValueSchema.optional(),
-  message: import_zod8.z.string().optional()
+  message: import_zod9.z.string().optional()
 });
 function falSdkError(cause, model) {
   const parsed = falSdkThrownSchema.safeParse(cause);
@@ -3616,12 +3743,12 @@ async function gatewayFetch(cfg, fetchImpl, targetUrl, init) {
   if (init.body !== void 0) request.body = init.body;
   return fetchImpl(cfg.baseUrl, request);
 }
-var falQueueSubmitSchema = import_zod8.z.object({
-  request_id: import_zod8.z.string(),
-  status_url: import_zod8.z.string(),
-  response_url: import_zod8.z.string()
+var falQueueSubmitSchema = import_zod9.z.object({
+  request_id: import_zod9.z.string(),
+  status_url: import_zod9.z.string(),
+  response_url: import_zod9.z.string()
 });
-var falQueueStatusSchema = import_zod8.z.object({ status: import_zod8.z.string() });
+var falQueueStatusSchema = import_zod9.z.object({ status: import_zod9.z.string() });
 async function passthroughRequest(ctx, endpoint, input) {
   const cfg = gatewayConfig(ctx);
   const submitRes = await gatewayFetch(cfg, ctx.fetch, `${FAL_QUEUE_HOST}/${endpoint}`, {
@@ -3754,11 +3881,11 @@ async function decodeImage(ctx, url, contentType) {
   const mime = res.headers.get("content-type") ?? contentType ?? "image/png";
   return { bytes: new Uint8Array(await res.arrayBuffer()), mime };
 }
-var museImageResultSchema = import_zod8.z.object({
-  images: import_zod8.z.array(
-    import_zod8.z.object({
-      url: import_zod8.z.string().optional(),
-      content_type: import_zod8.z.string().nullable().optional()
+var museImageResultSchema = import_zod9.z.object({
+  images: import_zod9.z.array(
+    import_zod9.z.object({
+      url: import_zod9.z.string().optional(),
+      content_type: import_zod9.z.string().nullable().optional()
     })
   ).optional()
 });
@@ -3862,8 +3989,8 @@ function klingO1Input(req) {
   if (refs.length > 0) input.image_urls = refs;
   return input;
 }
-var falVideoResultSchema = import_zod8.z.object({
-  video: import_zod8.z.object({ url: import_zod8.z.string().optional() }).optional()
+var falVideoResultSchema = import_zod9.z.object({
+  video: import_zod9.z.object({ url: import_zod9.z.string().optional() }).optional()
 });
 function extractVideoUrl(result, endpoint, model) {
   const parsed = falVideoResultSchema.safeParse(result);
@@ -4064,11 +4191,11 @@ async function passthroughVideoJob(ctx, req, endpoint, input) {
 }
 
 // src/adapters/google-genai.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var import_genai = require("@google/genai");
 
 // src/adapters/google-files.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var GOOGLE_FILES_BASE = "https://generativelanguage.googleapis.com";
 var GOOGLE_FILES_POLL_INTERVAL_MS = 2e3;
 var GOOGLE_FILES_POLL_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -4078,17 +4205,17 @@ var GENERIC_MEDIA_TYPES = /* @__PURE__ */ new Set([
   "binary/octet-stream",
   "application/binary"
 ]);
-var uploadedFileSchema = import_zod9.z.object({
-  file: import_zod9.z.object({
-    uri: import_zod9.z.string().optional(),
-    name: import_zod9.z.string().optional(),
-    state: import_zod9.z.string().optional(),
-    mimeType: import_zod9.z.string().optional()
+var uploadedFileSchema = import_zod10.z.object({
+  file: import_zod10.z.object({
+    uri: import_zod10.z.string().optional(),
+    name: import_zod10.z.string().optional(),
+    state: import_zod10.z.string().optional(),
+    mimeType: import_zod10.z.string().optional()
   }).optional()
 });
-var fileStateSchema = import_zod9.z.object({
-  state: import_zod9.z.string().optional(),
-  error: import_zod9.z.object({ message: import_zod9.z.string().optional() }).optional()
+var fileStateSchema = import_zod10.z.object({
+  state: import_zod10.z.string().optional(),
+  error: import_zod10.z.object({ message: import_zod10.z.string().optional() }).optional()
 });
 function resolveMime(declared, fallback) {
   const clean = declared?.split(";")[0]?.trim().toLowerCase();
@@ -4305,7 +4432,7 @@ var OMNI_POLL_INTERVAL_MS = 1e4;
 var RESULT_TIMEOUT_MS2 = 15 * 60 * 1e3;
 var OMNI_INLINE_LIMIT_BYTES = 4 * 1024 * 1024;
 var MEDIA_PART_INLINE_LIMIT_BYTES = 20 * 1024 * 1024;
-var errorTextSchema = import_zod10.z.string();
+var errorTextSchema = import_zod11.z.string();
 function isGoogleGenaiVideoKnown(providerModelId) {
   return providerModelId.startsWith("veo-") || providerModelId.startsWith("gemini-omni");
 }
@@ -4580,7 +4707,12 @@ async function generateOmniVideo(req, ctx, createGenAIClient) {
   const extend = req.taskType === "extend";
   const previousId = extend ? req.previousInteractionId : void 0;
   const chained = previousId !== void 0;
-  for (const field of ["referenceImages", "referenceVideos", "firstFrame"]) {
+  for (const field of [
+    "referenceImages",
+    "referenceVideos",
+    "firstFrame",
+    "lastFrame"
+  ]) {
     const value = req[field];
     if (!chained || value === void 0 || Array.isArray(value) && value.length === 0)
       continue;
@@ -4594,6 +4726,14 @@ async function generateOmniVideo(req, ctx, createGenAIClient) {
   const images = chained ? [] : req.referenceImages ?? [];
   const videos = chained ? [] : req.referenceVideos ?? [];
   const firstFrame = chained ? void 0 : req.firstFrame;
+  const lastFrame = firstFrame ? req.lastFrame : void 0;
+  if (!chained && req.lastFrame !== void 0 && lastFrame === void 0) {
+    ctx.warnings.push({
+      code: "option_ignored",
+      field: "lastFrame",
+      message: `${modelId} takes an end frame only with a start frame; lastFrame ignored`
+    });
+  }
   if (extend && !chained && req.sourceVideo === void 0) {
     throw new ModelKitError({
       code: "missing_input",
@@ -4678,27 +4818,7 @@ async function generateOmniVideo(req, ctx, createGenAIClient) {
         mime_type: media.mime
       });
     }
-    if (firstFrame) {
-      if (firstFrame.label !== void 0)
-        parts.push({ type: "text", text: firstFrame.label });
-      const media = await resolveMedia(
-        firstFrame,
-        ctx.fetch,
-        ctx.signal,
-        "image/png",
-        modelId
-      );
-      if (media.bytes.length > OMNI_INLINE_LIMIT_BYTES) {
-        parts.push({
-          type: "image",
-          uri: await uploadOne("image", media.bytes, media.mime),
-          mime_type: media.mime
-        });
-      } else {
-        parts.push({ type: "image", data: toBase64(media.bytes), mime_type: media.mime });
-      }
-    }
-    for (const ref of images) {
+    const pushImage = async (ref) => {
       if (ref.label !== void 0) parts.push({ type: "text", text: ref.label });
       const media = await resolveMedia(ref, ctx.fetch, ctx.signal, "image/png", modelId);
       if (media.bytes.length > OMNI_INLINE_LIMIT_BYTES) {
@@ -4710,8 +4830,12 @@ async function generateOmniVideo(req, ctx, createGenAIClient) {
       } else {
         parts.push({ type: "image", data: toBase64(media.bytes), mime_type: media.mime });
       }
-    }
-    parts.push({ type: "text", text: req.prompt });
+    };
+    if (firstFrame) await pushImage(firstFrame);
+    if (lastFrame) await pushImage(lastFrame);
+    for (const ref of images) await pushImage(ref);
+    const prompt = lastFrame ? `<FIRST_FRAME> <LAST_FRAME> ${req.prompt}` : req.prompt;
+    parts.push({ type: "text", text: prompt });
     try {
       interaction = await withRetry(async () => {
         try {
@@ -4914,15 +5038,15 @@ async function prepareGoogleMediaPart(ref, mediaType, ctx) {
 // src/adapters/google-image.ts
 var import_google2 = require("@ai-sdk/google");
 var import_ai2 = require("ai");
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var GEMINI_IMAGE_TIMEOUT_MS = 6e5;
 var defaultGoogleImageDeps = {
   createGoogleClient: (opts) => (0, import_google2.createGoogleGenerativeAI)(opts),
   runTextGeneration: (opts) => (0, import_ai2.generateText)(opts)
 };
-var causeChainNodeSchema = import_zod11.z.object({
-  message: import_zod11.z.string().optional(),
-  cause: import_zod11.z.unknown().optional()
+var causeChainNodeSchema = import_zod12.z.object({
+  message: import_zod12.z.string().optional(),
+  cause: import_zod12.z.unknown().optional()
 });
 function extractBlockReason(cause) {
   let current = cause;
@@ -5042,7 +5166,7 @@ function createGoogleImageAdapter(deps = defaultGoogleImageDeps) {
 var googleImageAdapter = createGoogleImageAdapter();
 
 // src/adapters/higgsfield.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 
 // src/adapters/higgsfield-motions.ts
 var MOTION_MAP = {
@@ -5241,14 +5365,34 @@ function videoUsage3(ctx, req, duration) {
   if (req.durationSeconds !== void 0) event.durationSeconds = req.durationSeconds;
   return event;
 }
-var klingCreateSchema = import_zod12.z.object({ status_url: import_zod12.z.string() });
-var klingStatusSchema = import_zod12.z.object({
-  status: import_zod12.z.string().optional(),
-  video: import_zod12.z.object({ url: import_zod12.z.string().optional() }).optional(),
+var KLING_ENDPOINT_FIELDS = /* @__PURE__ */ new Map([
+  [
+    "kling-video/v2.5-turbo/pro/image-to-video",
+    { aspectRatio: false, negativePrompt: true, lastFrame: false, sound: false }
+  ],
+  [
+    "kling-video/v3.0/pro/image-to-video",
+    { aspectRatio: false, negativePrompt: false, lastFrame: true, sound: true }
+  ]
+]);
+var UNLISTED_KLING_FIELDS = {
+  aspectRatio: true,
+  negativePrompt: true,
+  lastFrame: true,
+  sound: false
+};
+function klingEndpointFields(providerModelId) {
+  const path = (providerModelId.startsWith("/") ? providerModelId.slice(1) : providerModelId).toLowerCase();
+  return KLING_ENDPOINT_FIELDS.get(path) ?? UNLISTED_KLING_FIELDS;
+}
+var klingCreateSchema = import_zod13.z.object({ status_url: import_zod13.z.string() });
+var klingStatusSchema = import_zod13.z.object({
+  status: import_zod13.z.string().optional(),
+  video: import_zod13.z.object({ url: import_zod13.z.string().optional() }).optional(),
   error: JsonValueSchema.optional()
 });
-var errorMessageSchema = import_zod12.z.object({ message: import_zod12.z.string().optional() });
-var textValueSchema = import_zod12.z.string();
+var errorMessageSchema = import_zod13.z.object({ message: import_zod13.z.string().optional() });
+var textValueSchema = import_zod13.z.string();
 function klingErrorDetail(error) {
   if (error === void 0) return "unknown_error";
   const asText = textValueSchema.safeParse(error);
@@ -5275,6 +5419,13 @@ async function createRequest(ctx, url, init) {
   }
   return res;
 }
+function ignoreKlingField(ctx, field) {
+  ctx.warnings.push({
+    code: "option_ignored",
+    field,
+    message: `${ctx.model.id}: the Higgsfield endpoint has no ${field} input; ignored`
+  });
+}
 async function generateKlingVideo(req, ctx) {
   const firstFrame = req.firstFrame ? refToUrl(req.firstFrame) : void 0;
   if (!firstFrame) {
@@ -5286,16 +5437,29 @@ async function generateKlingVideo(req, ctx) {
       retryable: false
     });
   }
+  const fields = klingEndpointFields(ctx.model.providerModelId);
   const body = {
     prompt: req.prompt.trim(),
     image_url: firstFrame,
-    cfg_scale: req.cfgScale ?? 0.5,
-    negative_prompt: req.negativePrompt ?? DEFAULT_NEGATIVE_PROMPT
+    cfg_scale: req.cfgScale ?? 0.5
   };
+  if (fields.negativePrompt) {
+    body.negative_prompt = req.negativePrompt ?? DEFAULT_NEGATIVE_PROMPT;
+  } else if (req.negativePrompt !== void 0) {
+    ignoreKlingField(ctx, "negativePrompt");
+  }
   if (req.durationSeconds !== void 0) body.duration = req.durationSeconds;
-  if (req.aspectRatio !== void 0 && req.aspectRatio !== "adaptive")
-    body.aspect_ratio = req.aspectRatio;
-  if (req.lastFrame) body.last_image_url = refToUrl(req.lastFrame);
+  if (req.aspectRatio !== void 0 && req.aspectRatio !== "adaptive") {
+    if (fields.aspectRatio) body.aspect_ratio = req.aspectRatio;
+    else ignoreKlingField(ctx, "aspectRatio");
+  }
+  if (req.lastFrame) {
+    if (fields.lastFrame) body.last_image_url = refToUrl(req.lastFrame);
+    else ignoreKlingField(ctx, "lastFrame");
+  }
+  if (fields.sound && req.generateAudio !== void 0) {
+    body.sound = req.generateAudio ? "on" : "off";
+  }
   const endpoint = klingEndpoint(ctx.model.providerModelId, ctx.model.id);
   const retryOptions = mediaRetryOptions(ctx.call, ctx.signal);
   const createRes = await withRetry(
@@ -5384,8 +5548,8 @@ async function generateKlingVideo(req, ctx) {
     }
   };
 }
-var dopMotionOptionsSchema = import_zod12.z.object({
-  modelkit: import_zod12.z.object({ motion: import_zod12.z.string().optional() }).optional()
+var dopMotionOptionsSchema = import_zod13.z.object({
+  modelkit: import_zod13.z.object({ motion: import_zod13.z.string().optional() }).optional()
 });
 function dopMotionId(ctx) {
   const parsed = dopMotionOptionsSchema.safeParse(ctx.model.providerOptions);
@@ -5401,7 +5565,7 @@ function dopMotionId(ctx) {
     });
   return id;
 }
-var jsonRecordSchema = import_zod12.z.record(import_zod12.z.string(), JsonValueSchema);
+var jsonRecordSchema = import_zod13.z.record(import_zod13.z.string(), JsonValueSchema);
 var DOP_URL_KEYS = ["url", "video_url", "output_url", "result_url", "download_url"];
 var DOP_NESTED_KEYS = ["video", "result", "results"];
 function dopUrl(body) {
@@ -5429,8 +5593,8 @@ function dopUrl(body) {
   }
   return void 0;
 }
-var dopCreateSchema = import_zod12.z.object({ id: import_zod12.z.string() });
-var dopStatusSchema = import_zod12.z.object({ status: import_zod12.z.string().optional() });
+var dopCreateSchema = import_zod13.z.object({ id: import_zod13.z.string() });
+var dopStatusSchema = import_zod13.z.object({ status: import_zod13.z.string().optional() });
 async function generateDopVideo(req, ctx) {
   const firstFrame = req.firstFrame ? refToUrl(req.firstFrame) : void 0;
   if (!firstFrame) {
@@ -5558,7 +5722,7 @@ var higgsfieldAdapter = {
 
 // src/adapters/openai-image.ts
 var import_openai2 = __toESM(require("openai"), 1);
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var MAX_EDIT_REFERENCES = 16;
 function aspectRatioToSize(ratio, tier) {
   const TIER_LONG_EDGE = {
@@ -5641,9 +5805,9 @@ function toProviderError2(cause, ctx) {
     ctx.model.id
   );
 }
-var openaiUsageSchema = import_zod13.z.object({
-  input_tokens: import_zod13.z.number().optional(),
-  output_tokens: import_zod13.z.number().optional()
+var openaiUsageSchema = import_zod14.z.object({
+  input_tokens: import_zod14.z.number().optional(),
+  output_tokens: import_zod14.z.number().optional()
 });
 var openaiImageAdapter = {
   id: "openai-image",
@@ -6054,13 +6218,13 @@ var prodiaAdapter = {
 var import_replicate = __toESM(require("replicate"), 1);
 
 // src/adapters/replicate-http.ts
-var import_zod14 = require("zod");
-var predictionSchema = import_zod14.z.object({
-  id: import_zod14.z.string(),
-  status: import_zod14.z.string(),
+var import_zod15 = require("zod");
+var predictionSchema = import_zod15.z.object({
+  id: import_zod15.z.string(),
+  status: import_zod15.z.string(),
   output: JsonValueSchema.optional(),
   error: JsonValueSchema.optional(),
-  metrics: import_zod14.z.object({ predict_time: import_zod14.z.number().optional() }).optional()
+  metrics: import_zod15.z.object({ predict_time: import_zod15.z.number().optional() }).optional()
 });
 function createReplicateHttpClient(opts) {
   async function request(path, body, signal) {
@@ -6111,7 +6275,7 @@ function createReplicateHttpClient(opts) {
 }
 
 // src/adapters/replicate.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 
 // src/adapters/input-spec-mapper.ts
 function canonicalValue(req, key) {
@@ -6186,8 +6350,8 @@ function route(providerModelId) {
   if (!providerModelId.includes("/")) return { version: providerModelId };
   return { model: providerModelId };
 }
-var replicateResponseStatusSchema = import_zod15.z.object({
-  response: import_zod15.z.object({ status: import_zod15.z.number() }).partial()
+var replicateResponseStatusSchema = import_zod16.z.object({
+  response: import_zod16.z.object({ status: import_zod16.z.number() }).partial()
 });
 function replicateError(cause, ctx) {
   if (isModelKitError(cause)) return cause;
@@ -6214,7 +6378,7 @@ function isUrlFn(value) {
 function extractOutputUrl(output) {
   const root = Array.isArray(output) ? output[0] : output;
   if (root === void 0) throw noOutput();
-  const asString = import_zod15.z.string().safeParse(root);
+  const asString = import_zod16.z.string().safeParse(root);
   if (asString.success && asString.data) return asString.data;
   if (root instanceof URL) return root.href;
   if (isObjectOutput(root)) {
@@ -6223,15 +6387,15 @@ function extractOutputUrl(output) {
       if (urlValue !== void 0 && isUrlFn(urlValue)) {
         const called = urlValue();
         if (called instanceof URL) return called.href;
-        const calledString = import_zod15.z.string().safeParse(called);
+        const calledString = import_zod16.z.string().safeParse(called);
         if (calledString.success && calledString.data) return calledString.data;
       } else {
-        const direct = import_zod15.z.string().safeParse(urlValue);
+        const direct = import_zod16.z.string().safeParse(urlValue);
         if (direct.success && direct.data) return direct.data;
       }
     }
     if ("default" in root) {
-      const fallback = import_zod15.z.string().safeParse(root.default);
+      const fallback = import_zod16.z.string().safeParse(root.default);
       if (fallback.success && fallback.data) return fallback.data;
     }
   }
@@ -6292,7 +6456,7 @@ async function runPrediction(ctx, input, deps) {
     }
     return void 0;
   }, pollOpts);
-  const predictTime = import_zod15.z.number().safeParse(done.metrics?.predict_time);
+  const predictTime = import_zod16.z.number().safeParse(done.metrics?.predict_time);
   if (done.output === void 0) throw noOutput();
   return {
     url: extractOutputUrl(done.output),
@@ -6597,24 +6761,22 @@ function klingInput(req) {
   return input;
 }
 function klingOmniMode(req) {
+  if (req.resolution === "4k") return "4k";
   if (req.resolution === "1080p") return "pro";
   if (req.resolution === "720p") return "standard";
   return req.mode ?? "standard";
 }
 function klingOmniInput(req) {
-  const images = (req.firstFrame ? [req.firstFrame] : []).map(refToUrl);
-  if (req.lastFrame) images.push(refToUrl(req.lastFrame));
   const input = {
     prompt: req.prompt,
     duration: req.durationSeconds ?? 10,
     mode: klingOmniMode(req),
     generate_audio: req.generateAudio ?? false
   };
-  const startImage = images[0];
-  if (startImage !== void 0) {
-    input.start_image = startImage;
-    const endImage = images[1];
-    if (endImage !== void 0) input.end_image = endImage;
+  const start = req.firstFrame ?? req.lastFrame;
+  if (start) {
+    input.start_image = refToUrl(start);
+    if (req.firstFrame && req.lastFrame) input.end_image = refToUrl(req.lastFrame);
   } else if (req.aspectRatio !== "adaptive") {
     input.aspect_ratio = req.aspectRatio ?? "16:9";
   }
@@ -6677,7 +6839,7 @@ async function generateReplicateVideo(req, ctx, deps) {
       throw replicateError(cause, ctx);
     }
     if (current.status === "succeeded") {
-      const predictTime = import_zod15.z.number().safeParse(current.metrics?.predict_time);
+      const predictTime = import_zod16.z.number().safeParse(current.metrics?.predict_time);
       if (current.output === void 0) throw noOutput();
       return {
         url: extractOutputUrl(current.output),
@@ -6818,7 +6980,7 @@ async function generateReplicateAudio(req, ctx, deps) {
 // src/adapters/xai-video.ts
 var import_ai3 = require("ai");
 var import_xai2 = require("@ai-sdk/xai");
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 var POLL_INTERVAL_MS2 = 1e4;
 var POLL_TIMEOUT_MS2 = 15 * 6e4;
 var defaultXaiDeps = {
@@ -6831,8 +6993,8 @@ function createXaiVideoAdapter(deps = defaultXaiDeps) {
   };
 }
 var xaiVideoAdapter = createXaiVideoAdapter();
-var xaiResponseStatusSchema = import_zod16.z.object({
-  response: import_zod16.z.object({ status: import_zod16.z.number() }).partial()
+var xaiResponseStatusSchema = import_zod17.z.object({
+  response: import_zod17.z.object({ status: import_zod17.z.number() }).partial()
 });
 function xaiError(cause, ctx) {
   const info = describeThrown(cause);
@@ -6840,12 +7002,12 @@ function xaiError(cause, ctx) {
   const status = info.status ?? (nested.success ? nested.data.response?.status : void 0);
   return classifyThrown("xai-video", cause, ctx.model.id, { status, body: info.body });
 }
-var xaiMetaSchema = import_zod16.z.object({
+var xaiMetaSchema = import_zod17.z.object({
   videoUrl: JsonValueSchema.optional(),
   costInUsdTicks: JsonValueSchema.optional(),
   duration: JsonValueSchema.optional()
 });
-var xaiProviderMetadataSchema = import_zod16.z.object({ xai: xaiMetaSchema });
+var xaiProviderMetadataSchema = import_zod17.z.object({ xai: xaiMetaSchema });
 function metaOf(result) {
   const parsed = xaiProviderMetadataSchema.partial().safeParse(result.providerMetadata);
   if (!parsed.success) return {};
@@ -6862,7 +7024,7 @@ async function generateXaiVideo(req, ctx, deps) {
       retryable: false
     });
   }
-  const refUrls = (req.referenceImages ?? []).map(refToUrl).slice(0, 5);
+  const refUrls = (req.referenceImages ?? []).map(refToUrl).slice(0, 7);
   const xaiOptions = {
     pollIntervalMs: POLL_INTERVAL_MS2,
     pollTimeoutMs: POLL_TIMEOUT_MS2
@@ -6953,7 +7115,7 @@ async function mapResult(ctx, req, result) {
     };
   }
   const meta = metaOf(result);
-  const videoUrl = import_zod16.z.string().safeParse(meta.videoUrl);
+  const videoUrl = import_zod17.z.string().safeParse(meta.videoUrl);
   if (videoUrl.success && videoUrl.data) {
     const res = await ctx.fetch(videoUrl.data);
     if (!res.ok) {
@@ -6976,7 +7138,7 @@ async function mapResult(ctx, req, result) {
   });
 }
 function usage(ctx, req, meta) {
-  const costTicks = import_zod16.z.number().safeParse(meta.costInUsdTicks);
+  const costTicks = import_zod17.z.number().safeParse(meta.costInUsdTicks);
   const cost = costTicks.success ? costTicks.data / 1e10 : void 0;
   const event = {
     model: ctx.model.id,
@@ -7109,22 +7271,22 @@ var liveState = store[KEY] ??= {
 var liveCatalog = liveState.catalog;
 
 // src/catalog/load.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 function rowCount() {
   return liveCatalog.list({ lifecycle: ["active", "deprecated", "retired"] }).length;
 }
 function authHeaders(auth) {
   return "bearer" in auth ? { Authorization: `Bearer ${auth.bearer}` } : { "x-api-key": auth.apiKey };
 }
-var EnvelopeSchema = import_zod17.z.object({
-  rows: import_zod17.z.array(JsonValueSchema),
-  revision: import_zod17.z.string().optional()
+var EnvelopeSchema = import_zod18.z.object({
+  rows: import_zod18.z.array(JsonValueSchema),
+  revision: import_zod18.z.string().optional()
 });
 function dropReason(path, message) {
   return path.length === 0 ? message : `${path.map((part) => String(part)).join(".")} ${message}`;
 }
 function rowId(raw) {
-  const parsed = import_zod17.z.object({ id: import_zod17.z.string().min(1) }).loose().safeParse(raw);
+  const parsed = import_zod18.z.object({ id: import_zod18.z.string().min(1) }).loose().safeParse(raw);
   if (!parsed.success) return "?";
   return parsed.data.id;
 }
@@ -7152,7 +7314,13 @@ function quarantine(rawRows, logger) {
         );
       }
     }
-    valid.push(row);
+    const normalised = normaliseConventions(row);
+    if (normalised.invalidKeys.length > 0) {
+      logger.warn(
+        `[modelkit] catalog row ${row.id} has an invalid ${normalised.invalidKeys.join(", ")}; read as not set`
+      );
+    }
+    valid.push(normalised.row);
   }
   let kept = valid;
   for (; ; ) {
@@ -7570,6 +7738,24 @@ function resolveVideoOptions(model, request, onUnsupported = "error") {
     });
     delete merged.sourceVideo;
   }
+  if (merged.lastFrame !== void 0 && merged.firstFrame === void 0 && model.capabilities?.lastFrameRequiresFirstFrame) {
+    if (onUnsupported === "error") {
+      throw new ModelKitError({
+        code: "missing_input",
+        message: `${model.id} takes an end frame only together with a start frame`,
+        model: model.id,
+        retryable: false
+      });
+    }
+    warnings.push({
+      code: "option_ignored",
+      field: "lastFrame",
+      to: "firstFrame",
+      message: `end frame used as start frame: ${model.id} needs a start frame with an end frame`
+    });
+    merged.firstFrame = merged.lastFrame;
+    delete merged.lastFrame;
+  }
   const hasFrames = merged.firstFrame !== void 0 || merged.lastFrame !== void 0;
   const hasRefs = compact(merged.referenceImages).length + compact(merged.referenceVideos).length + compact(merged.referenceAudios).length > 0;
   if (hasFrames && hasRefs && model.capabilities?.framesExcludeReferences) {
@@ -7945,7 +8131,7 @@ function createTextSteps(initial, resolve, callerProviderOptions) {
 
 // src/client.ts
 var import_ai5 = require("ai");
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/generated-image.ts
 function toGeneratedImage(image) {
@@ -8020,10 +8206,10 @@ function textAbortOptions(sdk, context) {
   if (abortSignal) return { abortSignal };
   return {};
 }
-var catalogId = import_zod18.z.string();
-var exactSize = import_zod18.z.templateLiteral([import_zod18.z.number(), "x", import_zod18.z.number()]);
-var sdkRatio = import_zod18.z.templateLiteral([import_zod18.z.number(), ":", import_zod18.z.number()]);
-var sizeTier = import_zod18.z.enum(["512", "1K", "2K", "4K"]);
+var catalogId = import_zod19.z.string();
+var exactSize = import_zod19.z.templateLiteral([import_zod19.z.number(), "x", import_zod19.z.number()]);
+var sdkRatio = import_zod19.z.templateLiteral([import_zod19.z.number(), ":", import_zod19.z.number()]);
+var sizeTier = import_zod19.z.enum(["512", "1K", "2K", "4K"]);
 function isCatalogId(model) {
   return catalogId.safeParse(model).success;
 }