vargai 0.4.0-alpha35 → 0.4.0-alpha37

package/examples/grok-imagine-test.tsx

@@ -0,0 +1,155 @@
+/**
+ * Grok Imagine Video Test Example
+ *
+ * Run with: bun run examples/grok-imagine-test.tsx
+ *
+ * Tests all three Grok Imagine Video endpoints:
+ * 1. Text-to-Video
+ * 2. Image-to-Video
+ * 3. Edit Video
+ */
+
+import { fal } from "@fal-ai/client";
+import { falProvider } from "../src/providers/fal";
+
+// Configure fal client
+const apiKey = process.env.FAL_API_KEY ?? process.env.FAL_KEY;
+if (!apiKey) {
+  console.error("Error: FAL_API_KEY or FAL_KEY environment variable required");
+  process.exit(1);
+}
+fal.config({ credentials: apiKey });
+
+async function testTextToVideo() {
+  console.log("\n=== Testing Grok Text-to-Video ===\n");
+
+  const result = await falProvider.grokTextToVideo({
+    prompt:
+      "A majestic eagle soaring through clouds at sunset, cinematic lighting, slow motion",
+    duration: 6,
+    aspectRatio: "16:9",
+    resolution: "720p",
+  });
+
+  const data = result.data as { video?: { url?: string; duration?: number } };
+  console.log("Text-to-Video Result:");
+  console.log("  Video URL:", data?.video?.url);
+  console.log("  Duration:", data?.video?.duration);
+
+  return data?.video?.url;
+}
+
+async function testImageToVideo(imageUrl: string) {
+  console.log("\n=== Testing Grok Image-to-Video ===\n");
+
+  const result = await falProvider.grokImageToVideo({
+    prompt:
+      "The subject slowly turns their head and smiles, gentle wind blowing their hair",
+    imageUrl,
+    duration: 6,
+    aspectRatio: "auto",
+    resolution: "720p",
+  });
+
+  const data = result.data as { video?: { url?: string; duration?: number } };
+  console.log("Image-to-Video Result:");
+  console.log("  Video URL:", data?.video?.url);
+  console.log("  Duration:", data?.video?.duration);
+
+  return data?.video?.url;
+}
+
+async function testEditVideo(videoUrl: string) {
+  console.log("\n=== Testing Grok Edit Video ===\n");
+
+  const result = await falProvider.grokEditVideo({
+    prompt: "Add a vintage film grain effect and warm color grading",
+    videoUrl,
+    resolution: "auto",
+  });
+
+  const data = result.data as { video?: { url?: string; duration?: number } };
+  console.log("Edit Video Result:");
+  console.log("  Video URL:", data?.video?.url);
+  console.log("  Duration:", data?.video?.duration);
+
+  return data?.video?.url;
+}
+
+// Main execution
+async function main() {
+  const args = process.argv.slice(2);
+  const mode = args[0] || "t2v";
+
+  console.log("Grok Imagine Video Test");
+  console.log("=======================");
+  console.log(`Mode: ${mode}`);
+
+  try {
+    switch (mode) {
+      case "t2v":
+      case "text-to-video": {
+        await testTextToVideo();
+        break;
+      }
+
+      case "i2v":
+      case "image-to-video": {
+        const imageUrl =
+          args[1] ||
+          "https://v3b.fal.media/files/b/0a8b90e0/BFLE9VDlZqsryU-UA3BoD_image_004.png";
+        await testImageToVideo(imageUrl);
+        break;
+      }
+
+      case "edit":
+      case "edit-video": {
+        const videoUrl =
+          args[1] ||
+          "https://v3b.fal.media/files/b/0a8b9112/V5Z_NIPE3ppMDWivNo6_q_video_019.mp4";
+        await testEditVideo(videoUrl);
+        break;
+      }
+
+      case "all": {
+        // Run all tests in sequence
+        const t2vUrl = await testTextToVideo();
+
+        // Use a sample image for i2v test
+        const sampleImage =
+          "https://v3b.fal.media/files/b/0a8b90e0/BFLE9VDlZqsryU-UA3BoD_image_004.png";
+        await testImageToVideo(sampleImage);
+
+        // Use the t2v result for edit test if available
+        if (t2vUrl) {
+          await testEditVideo(t2vUrl);
+        }
+        break;
+      }
+
+      default:
+        console.log(`
+Usage: bun run examples/grok-imagine-test.tsx [mode] [url]
+
+Modes:
+  t2v, text-to-video    Generate video from text prompt
+  i2v, image-to-video   Generate video from image (provide image URL)
+  edit, edit-video      Edit existing video (provide video URL)
+  all                   Run all tests
+
+Examples:
+  bun run examples/grok-imagine-test.tsx t2v
+  bun run examples/grok-imagine-test.tsx i2v https://example.com/image.png
+  bun run examples/grok-imagine-test.tsx edit https://example.com/video.mp4
+  bun run examples/grok-imagine-test.tsx all
+`);
+    }
+
+    console.log("\nTest completed successfully!");
+  } catch (error) {
+    console.error("\nTest failed:", error);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -68,7 +68,7 @@
     "sharp": "^0.34.5",
     "zod": "^4.2.1"
   },
-  "version": "0.4.0-alpha35",
+  "version": "0.4.0-alpha37",
   "exports": {
     ".": "./src/index.ts",
     "./ai": "./src/ai-sdk/index.ts",

package/src/ai-sdk/providers/editly/backends/local.ts

@@ -44,7 +44,7 @@ export class LocalBackend implements FFmpegBackend {
       if (typeof input === "string") {
         args.push("-i", input);
       } else if ("raw" in input) {
-        args.push(...input.raw.split(" "));
+        args.push(...input.raw);
       } else {
         if (input.options) args.push(...input.options);
         args.push("-i", input.path);

package/src/ai-sdk/providers/editly/backends/types.ts

@@ -22,8 +22,8 @@ export type FFmpegInput =
       options?: string[];
     }
   | {
-      /** Raw ffmpeg args that don't use -i (e.g. "-f lavfi -i color=black") */
-      raw: string;
+      /** Raw ffmpeg args that don't use -i (e.g. ["-f", "lavfi", "-i", "color=black"]) */
+      raw: string[];
     };
 
 /**

package/src/ai-sdk/providers/editly/rendi/index.ts

@@ -134,7 +134,10 @@ export class RendiBackend implements FFmpegBackend {
 
     const replaceWithPlaceholders = (str: string): string => {
       let result = str;
-      for (const [url, ph] of pathToPlaceholder) {
+      const sortedEntries = [...pathToPlaceholder.entries()].sort(
+        (a, b) => b[0].length - a[0].length,
+      );
+      for (const [url, ph] of sortedEntries) {
         if (result.includes(url)) {
           result = result.replaceAll(url, ph);
         }

package/src/ai-sdk/providers/fal.ts

@@ -43,6 +43,21 @@ const VIDEO_MODELS: Record<string, { t2v: string; i2v: string }> = {
     t2v: "fal-ai/minimax-video/text-to-video",
     i2v: "fal-ai/minimax-video/image-to-video",
   },
+  // LTX-2 19B Distilled - video with native audio generation
+  "ltx-2-19b-distilled": {
+    t2v: "fal-ai/ltx-2-19b/distilled/text-to-video",
+    i2v: "fal-ai/ltx-2-19b/distilled/image-to-video",
+  },
+  // Grok Imagine Video - xAI's video generation with audio
+  "grok-imagine": {
+    t2v: "xai/grok-imagine-video/text-to-video",
+    i2v: "xai/grok-imagine-video/image-to-video",
+  },
+};
+
+// Video edit models - video-to-video editing
+const VIDEO_EDIT_MODELS: Record<string, string> = {
+  "grok-imagine-edit": "xai/grok-imagine-video/edit-video",
 };
 
 // Motion control models - video-to-video with motion transfer
@@ -67,6 +82,8 @@ const IMAGE_MODELS: Record<string, string> = {
   "nano-banana-pro": "fal-ai/nano-banana-pro",
   "nano-banana-pro/edit": "fal-ai/nano-banana-pro/edit",
   "seedream-v4.5/edit": "fal-ai/bytedance/seedream/v4.5/edit",
+  // Qwen Image Edit 2511 Multiple Angles - camera angle adjustment
+  "qwen-angles": "fal-ai/qwen-image-edit-2511-multiple-angles",
 };
 
 // Models that use image_size instead of aspect_ratio
@@ -77,6 +94,23 @@ const IMAGE_SIZE_MODELS = new Set([
   "seedream-v4.5/edit",
 ]);
 
+// Qwen Angles model - image-to-image with camera angle adjustment
+const QWEN_ANGLES_MODEL = "qwen-angles";
+
+// Map aspect ratio to image_size for Qwen Angles (base dimension 1024)
+const ASPECT_RATIO_TO_QWEN_SIZE: Record<
+  string,
+  { width: number; height: number }
+> = {
+  "1:1": { width: 1024, height: 1024 },
+  "4:3": { width: 1024, height: 768 },
+  "3:4": { width: 768, height: 1024 },
+  "16:9": { width: 1024, height: 576 },
+  "9:16": { width: 576, height: 1024 },
+  "3:2": { width: 1024, height: 683 },
+  "2:3": { width: 683, height: 1024 },
+};
+
 // Map aspect ratio strings to image_size enum values
 const ASPECT_RATIO_TO_IMAGE_SIZE: Record<string, string> = {
   "1:1": "square",
@@ -181,13 +215,18 @@ class FalVideoModel implements VideoModelV3 {
 
     const isLipsync = LIPSYNC_MODELS[this.modelId] !== undefined;
     const isMotionControl = MOTION_CONTROL_MODELS[this.modelId] !== undefined;
+    const isVideoEdit = VIDEO_EDIT_MODELS[this.modelId] !== undefined;
     const isKlingV26 = this.modelId === "kling-v2.6";
+    const isLtx2 = this.modelId === "ltx-2-19b-distilled";
+    const isGrokImagine = this.modelId === "grok-imagine";
 
     const endpoint = isLipsync
       ? this.resolveLipsyncEndpoint()
       : isMotionControl
         ? this.resolveMotionControlEndpoint()
-        : this.resolveEndpoint(hasImageInput ?? false);
+        : isVideoEdit
+          ? this.resolveVideoEditEndpoint()
+          : this.resolveEndpoint(hasImageInput ?? false);
 
     const input: Record<string, unknown> = {
       ...(providerOptions?.fal ?? {}),
@@ -237,13 +276,49 @@ class FalVideoModel implements VideoModelV3 {
       if (input.keep_original_sound === undefined) {
         input.keep_original_sound = true;
       }
+    } else if (isVideoEdit) {
+      // Video edit: video input + prompt for editing instruction
+      input.prompt = prompt;
+
+      const videoFile = files?.find((f) =>
+        getMediaType(f)?.startsWith("video/"),
+      );
+
+      if (videoFile) {
+        input.video_url = await fileToUrl(videoFile);
+      }
+
+      // Grok Imagine Edit supports resolution: "auto", "480p", "720p"
+      if (!input.resolution) {
+        input.resolution = "auto";
+      }
     } else {
       // Standard video generation
       input.prompt = prompt;
 
-      // Duration must be string "5" or "10" for Kling v2.6
-      if (isKlingV26) {
+      // LTX-2 uses num_frames instead of duration, and has different defaults
+      if (isLtx2) {
+        // LTX-2: convert duration to num_frames (25fps default)
+        // Always set num_frames from duration unless explicitly provided via providerOptions
+        if (input.num_frames === undefined) {
+          const fps = (input.fps as number) ?? 25;
+          const durationSec = duration ?? 5; // default 5 seconds
+          input.num_frames = Math.round(durationSec * fps);
+        }
+        // LTX-2 uses video_size instead of aspect_ratio
+        if (input.video_size === undefined) {
+          input.video_size = "auto";
+        }
+      } else if (isKlingV26) {
+        // Duration must be string "5" or "10" for Kling v2.6
         input.duration = String(duration ?? 5);
+      } else if (isGrokImagine) {
+        // Grok Imagine: duration 1-15 seconds (default 6)
+        input.duration = duration ?? 6;
+        // Grok Imagine supports resolution: "480p", "720p" (default "720p")
+        if (!input.resolution) {
+          input.resolution = "720p";
+        }
       } else {
         input.duration = duration ?? 5;
       }
@@ -255,23 +330,36 @@ class FalVideoModel implements VideoModelV3 {
         if (imageFiles.length > 0) {
           // First image is start image
           input.image_url = await fileToUrl(imageFiles[0]!);
-          // Second image (if provided) is end image for Kling v2.6
-          if (isKlingV26 && imageFiles.length > 1) {
+          // Second image (if provided) is end image for Kling v2.6 and LTX-2
+          if ((isKlingV26 || isLtx2) && imageFiles.length > 1) {
             input.end_image_url = await fileToUrl(imageFiles[1]!);
           }
         }
-      } else {
+      } else if (!isLtx2) {
+        // LTX-2 uses video_size, not aspect_ratio
         input.aspect_ratio = aspectRatio ?? "16:9";
       }
 
-      // Kling v2.6 supports native audio generation
-      if (isKlingV26) {
+      // Kling v2.6 and LTX-2 support native audio generation
+      if (isKlingV26 || isLtx2) {
         // Default to generating audio unless explicitly disabled
         if (input.generate_audio === undefined) {
           input.generate_audio = true;
         }
       }
 
+      // LTX-2 specific defaults
+      if (isLtx2) {
+        // Enable multiscale for better coherence (default: true)
+        if (input.use_multiscale === undefined) {
+          input.use_multiscale = true;
+        }
+        // Enable prompt expansion for better results (default: true)
+        if (input.enable_prompt_expansion === undefined) {
+          input.enable_prompt_expansion = true;
+        }
+      }
+
       const audioFile = files?.find((f) =>
         getMediaType(f)?.startsWith("audio/"),
       );
@@ -280,12 +368,17 @@ class FalVideoModel implements VideoModelV3 {
       }
     }
 
+    // LTX-2 supports seed, other models don't
     if (options.seed !== undefined) {
-      warnings.push({
-        type: "unsupported",
-        feature: "seed",
-        details: "Seed is not supported by this model",
-      });
+      if (isLtx2) {
+        input.seed = options.seed;
+      } else {
+        warnings.push({
+          type: "unsupported",
+          feature: "seed",
+          details: "Seed is not supported by this model",
+        });
+      }
     }
 
     if (options.resolution !== undefined) {
@@ -296,12 +389,17 @@ class FalVideoModel implements VideoModelV3 {
       });
     }
 
+    // LTX-2 supports fps configuration
     if (options.fps !== undefined) {
-      warnings.push({
-        type: "unsupported",
-        feature: "fps",
-        details: "FPS is not configurable for this model",
-      });
+      if (isLtx2) {
+        input.fps = options.fps;
+      } else {
+        warnings.push({
+          type: "unsupported",
+          feature: "fps",
+          details: "FPS is not configurable for this model",
+        });
+      }
     }
 
     const result = await fal.subscribe(endpoint, {
@@ -358,6 +456,14 @@ class FalVideoModel implements VideoModelV3 {
 
     return MOTION_CONTROL_MODELS[this.modelId] ?? this.modelId;
   }
+
+  private resolveVideoEditEndpoint(): string {
+    if (this.modelId.startsWith("raw:")) {
+      return this.modelId.slice(4);
+    }
+
+    return VIDEO_EDIT_MODELS[this.modelId] ?? this.modelId;
+  }
 }
 
 class FalImageModel implements ImageModelV3 {
@@ -383,14 +489,28 @@ class FalImageModel implements ImageModelV3 {
     } = options;
     const warnings: SharedV3Warning[] = [];
 
+    const isQwenAngles = this.modelId === QWEN_ANGLES_MODEL;
+
     const input: Record<string, unknown> = {
-      prompt,
       num_images: n ?? 1,
-      // Use high acceleration for faster queue processing on supported models (flux-schnell)
-      acceleration: "high",
       ...(providerOptions?.fal ?? {}),
     };
 
+    // Qwen Angles uses additional_prompt instead of prompt
+    if (isQwenAngles) {
+      if (prompt) {
+        input.additional_prompt = prompt;
+      }
+      // Qwen Angles supports "regular" or "none" acceleration, not "high"
+      if (!input.acceleration) {
+        input.acceleration = "regular";
+      }
+    } else {
+      input.prompt = prompt;
+      // Use high acceleration for faster queue processing on supported models (flux-schnell)
+      input.acceleration = "high";
+    }
+
     const usesImageSize = IMAGE_SIZE_MODELS.has(this.modelId);
 
     if (size) {
@@ -404,7 +524,21 @@ class FalImageModel implements ImageModelV3 {
     }
 
     if (aspectRatio) {
-      if (usesImageSize) {
+      if (isQwenAngles) {
+        // Convert aspect ratio to image_size dimensions for Qwen Angles
+        if (!input.image_size) {
+          const qwenSize = ASPECT_RATIO_TO_QWEN_SIZE[aspectRatio];
+          if (qwenSize) {
+            input.image_size = qwenSize;
+          } else {
+            warnings.push({
+              type: "unsupported",
+              feature: "aspectRatio",
+              details: `Aspect ratio "${aspectRatio}" not supported for qwen-angles, use one of: ${Object.keys(ASPECT_RATIO_TO_QWEN_SIZE).join(", ")}`,
+            });
+          }
+        }
+      } else if (usesImageSize) {
         // Convert aspect ratio to image_size enum for models that require it
         // Only set if size wasn't already provided
         if (!input.image_size) {
@@ -433,11 +567,16 @@ class FalImageModel implements ImageModelV3 {
       input.image_urls = await Promise.all(files.map((f) => fileToUrl(f)));
     }
 
+    // Qwen Angles requires image_urls
+    if (isQwenAngles && !input.image_urls) {
+      throw new Error("qwen-angles requires at least one image file");
+    }
+
     const hasImageUrls =
       hasFiles ||
       !!(providerOptions?.fal as Record<string, unknown>)?.image_urls;
     if (hasImageUrls) {
-      if (!files) {
+      if (!files && !isQwenAngles) {
         throw new Error("No files provided");
       }
     }