climage 0.4.2 → 0.5.1

package/dist/index.js

@@ -408,8 +408,15 @@ var DEFAULT_IMAGE_MODEL = "fal-ai/flux/dev";
 var DEFAULT_IMAGE_TO_IMAGE_MODEL = "fal-ai/flux/dev/image-to-image";
 var DEFAULT_VIDEO_MODEL = "fal-ai/ltxv-2/text-to-video/fast";
 var DEFAULT_IMAGE_TO_VIDEO_MODEL = "fal-ai/vidu/q2/image-to-video";
+var KLING_V3_PRO_IMAGE_TO_VIDEO_MODEL = "fal-ai/kling-video/v3/pro/image-to-video";
 var DEFAULT_START_END_VIDEO_MODEL = "fal-ai/vidu/start-end-to-video";
 var DEFAULT_REFERENCE_VIDEO_MODEL = "fal-ai/vidu/q2/reference-to-video";
+function isKlingV3Model(model) {
+  return model === KLING_V3_PRO_IMAGE_TO_VIDEO_MODEL || model.startsWith("fal-ai/kling-video/v3/");
+}
+function isViduModel(model) {
+  return model.includes("/vidu/");
+}
 function selectVideoModel(req) {
   if (req.model) return req.model;
   if (req.startFrame && req.endFrame) {
@@ -428,9 +435,12 @@ function selectImageModel(req) {
   if (req.inputImages?.length) return DEFAULT_IMAGE_TO_IMAGE_MODEL;
   return DEFAULT_IMAGE_MODEL;
 }
-function mapAspectRatio(aspectRatio) {
+function mapAspectRatio(aspectRatio, model) {
   if (!aspectRatio) return void 0;
   const ar = aspectRatio.trim();
+  if (model && isKlingV3Model(model)) {
+    return ar;
+  }
   if (ar === "1:1") return "square";
   if (ar === "4:3") return "landscape_4_3";
   if (ar === "16:9") return "landscape_16_9";
@@ -438,29 +448,50 @@ function mapAspectRatio(aspectRatio) {
   if (ar === "9:16") return "portrait_16_9";
   return ar;
 }
-function buildVideoInput(req) {
+function buildVideoInput(req, model) {
   const input = {
     prompt: req.prompt
   };
   if (req.startFrame && req.endFrame) {
     input.start_image_url = req.startFrame;
     input.end_image_url = req.endFrame;
+    const ar = mapAspectRatio(req.aspectRatio, model);
+    if (ar) input.aspect_ratio = ar;
+    if (req.duration) input.duration = String(req.duration);
     return input;
   }
   if (req.inputImages?.length && !req.startFrame) {
+    if (isKlingV3Model(model)) {
+      input.start_image_url = req.inputImages[0];
+      const ar2 = mapAspectRatio(req.aspectRatio, model);
+      if (ar2) input.aspect_ratio = ar2;
+      if (req.duration) input.duration = String(req.duration);
+      return input;
+    }
     input.reference_image_urls = req.inputImages.slice(0, 7);
-    const ar = mapAspectRatio(req.aspectRatio);
+    const ar = mapAspectRatio(req.aspectRatio, model);
     if (ar) input.aspect_ratio = ar;
     if (req.duration) input.duration = String(req.duration);
     return input;
   }
   const imageUrl = req.startFrame ?? req.inputImages?.[0];
   if (imageUrl) {
-    input.image_url = imageUrl;
+    if (isKlingV3Model(model)) {
+      input.start_image_url = imageUrl;
+      const ar = mapAspectRatio(req.aspectRatio, model);
+      if (ar) input.aspect_ratio = ar;
+    } else {
+      input.image_url = imageUrl;
+    }
     if (req.duration) input.duration = String(req.duration);
     return input;
   }
-  const imageSize = mapAspectRatio(req.aspectRatio);
+  if (isKlingV3Model(model)) {
+    throw new Error(
+      `Model ${model} requires --start-frame (or --input) because it is image-to-video only`
+    );
+  }
+  const imageSize = mapAspectRatio(req.aspectRatio, model);
   if (imageSize) input.image_size = imageSize;
   if (req.n) input.num_videos = req.n;
   return input;
@@ -485,8 +516,8 @@ var falCapabilities = {
   supportsCustomAspectRatio: true,
   supportsVideoInterpolation: true,
   // Vidu start-end-to-video
-  videoDurationRange: [2, 8],
-  // Vidu supports 2-8 seconds
+  videoDurationRange: [2, 15],
+  // Most models are 2-8; Kling v3 supports up to 15
   supportsImageEditing: true
 };
 var falProvider = {
@@ -514,7 +545,19 @@ var falProvider = {
     fal.config({ credentials: key });
     const model = req.kind === "video" ? selectVideoModel(req) : selectImageModel(req);
     log2(verbose, "Selected model:", model);
-    const input = req.kind === "video" ? buildVideoInput(req) : buildImageInput(req);
+    if (req.kind === "video" && req.duration !== void 0) {
+      if (isKlingV3Model(model) && (req.duration < 3 || req.duration > 15)) {
+        throw new Error(
+          `Model ${model} supports video duration 3-15s, but ${req.duration}s requested`
+        );
+      }
+      if (isViduModel(model) && (req.duration < 2 || req.duration > 8)) {
+        throw new Error(
+          `Model ${model} supports video duration 2-8s, but ${req.duration}s requested`
+        );
+      }
+    }
+    const input = req.kind === "video" ? buildVideoInput(req, model) : buildImageInput(req);
     const inputSummary = { ...input };
     for (const key2 of ["image_url", "start_image_url", "end_image_url"]) {
       if (typeof inputSummary[key2] === "string" && inputSummary[key2].startsWith("data:")) {
@@ -581,6 +624,9 @@ var falProvider = {
 
 // src/providers/google.ts
 import { GoogleGenAI } from "@google/genai";
+import { mkdtemp, readFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
 function getGeminiApiKey(env) {
   return env.GEMINI_API_KEY || env.GOOGLE_API_KEY || env.GOOGLE_GENAI_API_KEY;
 }
@@ -628,6 +674,21 @@ function imageToGoogleFormat(imageInput) {
   }
   return { fileUri: imageInput };
 }
+function imageToVeoFormat(imageInput) {
+  if (imageInput.startsWith("data:")) {
+    const parsed = parseDataUri(imageInput);
+    if (!parsed?.data) {
+      throw new Error("Failed to parse data URI for Veo image input");
+    }
+    return { imageBytes: parsed.data, mimeType: parsed.mimeType };
+  }
+  if (imageInput.startsWith("gs://")) {
+    return { gcsUri: imageInput };
+  }
+  throw new Error(
+    `Veo image inputs must be data: URIs or gs:// URIs (got ${imageInput.slice(0, 24)}...)`
+  );
+}
 var GEMINI_IMAGE_MODELS = ["gemini-2.5-flash-image", "gemini-3-pro-image-preview"];
 function resolveModel(model) {
   if (!model) return "gemini-2.5-flash-image";
@@ -646,6 +707,31 @@ async function downloadBytes3(url) {
   log3(`Downloaded ${ab.byteLength} bytes in ${Date.now() - start}ms, type: ${ct}`);
   return { bytes: new Uint8Array(ab), mimeType: ct };
 }
+async function downloadGeneratedVideo(ai, generatedVideo) {
+  const video = generatedVideo?.video;
+  if (video?.videoBytes) {
+    return {
+      bytes: new Uint8Array(Buffer.from(video.videoBytes, "base64")),
+      mimeType: video.mimeType
+    };
+  }
+  if (video?.uri && !video.uri.startsWith("gs://")) {
+    try {
+      return await downloadBytes3(video.uri);
+    } catch (err) {
+      log3("Direct video download failed, falling back to ai.files.download:", String(err));
+    }
+  }
+  const tempDir = await mkdtemp(join(tmpdir(), "climage-veo-"));
+  const downloadPath = join(tempDir, "video.mp4");
+  try {
+    await ai.files.download({ file: generatedVideo, downloadPath });
+    const buf = await readFile(downloadPath);
+    return { bytes: new Uint8Array(buf), mimeType: video?.mimeType ?? "video/mp4" };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
 async function sleep2(ms) {
   await new Promise((r) => setTimeout(r, ms));
 }
@@ -711,15 +797,15 @@ async function generateWithVeo(ai, model, req) {
   const config = {
     numberOfVideos: req.n,
     ...req.aspectRatio ? { aspectRatio: req.aspectRatio } : {},
-    // Add duration if specified (Veo 3.1 supports 4, 6, 8)
-    ...req.duration !== void 0 ? { durationSeconds: String(req.duration) } : {}
+    // Add duration if specified (Veo supports 4-8 seconds depending on model)
+    ...req.duration !== void 0 ? { durationSeconds: req.duration } : {}
   };
   if (req.inputImages?.length && isVeo31Model(model)) {
     const referenceImages = req.inputImages.slice(0, 3).map((img) => {
-      const imageData = imageToGoogleFormat(img);
+      const imageData = imageToVeoFormat(img);
       return {
         image: imageData,
-        referenceType: "asset"
+        referenceType: "ASSET"
       };
     });
     config.referenceImages = referenceImages;
@@ -732,12 +818,12 @@ async function generateWithVeo(ai, model, req) {
   };
   const firstFrameImage = req.startFrame ?? (req.inputImages?.length === 1 ? req.inputImages[0] : void 0);
   if (firstFrameImage && isVeo31Model(model)) {
-    const imageData = imageToGoogleFormat(firstFrameImage);
+    const imageData = imageToVeoFormat(firstFrameImage);
     generateParams.image = imageData;
     log3("Added first frame image");
   }
   if (req.endFrame && isVeo31Model(model)) {
-    const lastFrameData = imageToGoogleFormat(req.endFrame);
+    const lastFrameData = imageToVeoFormat(req.endFrame);
     config.lastFrame = lastFrameData;
     log3("Added last frame for interpolation");
   }
@@ -767,26 +853,22 @@ async function generateWithVeo(ai, model, req) {
   for (let i = 0; i < Math.min(videos.length, req.n); i++) {
     const v = videos[i];
     log3(`Processing video ${i}:`, JSON.stringify(v).slice(0, 300));
-    const uri = v?.video?.uri;
-    if (!uri) {
-      log3(`Video ${i} has no URI, skipping`);
+    if (!v?.video) {
+      log3(`Video ${i} has no video payload, skipping`);
       continue;
     }
-    if (uri.startsWith("gs://")) {
-      throw new Error(
-        `Google Veo returned a gs:// URI (${uri}). Configure outputGcsUri / Vertex flow to fetch from GCS.`
-      );
-    }
-    const { bytes, mimeType } = await downloadBytes3(uri);
-    out.push({
+    const uri = v?.video?.uri;
+    const { bytes, mimeType } = await downloadGeneratedVideo(ai, v);
+    const item = {
       kind: "video",
       provider: "google",
       model,
       index: i,
-      url: uri,
       bytes,
       ...mimeType !== void 0 ? { mimeType } : {}
-    });
+    };
+    if (uri) item.url = uri;
+    out.push(item);
   }
   if (!out.length) throw new Error("Google Veo returned videos but none were downloadable");
   log3(`Successfully generated ${out.length} video(s)`);