vargai 0.4.0-alpha36 → 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-alpha36",
+  "version": "0.4.0-alpha37",
   "exports": {
     ".": "./src/index.ts",
     "./ai": "./src/ai-sdk/index.ts",

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

@@ -48,6 +48,16 @@ const VIDEO_MODELS: Record<string, { t2v: string; i2v: string }> = {
     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
@@ -72,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
@@ -82,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",
@@ -186,14 +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 ?? {}),
@@ -243,6 +276,22 @@ 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;
@@ -263,6 +312,13 @@ class FalVideoModel implements VideoModelV3 {
       } 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;
       }
@@ -400,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 {
@@ -425,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) {
@@ -446,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) {
@@ -475,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");
       }
     }

package/src/cli/commands/storyboard.tsx

@@ -407,6 +407,36 @@ function escapeAttr(str: string): string {
     .replace(/>/g, ">");
 }
 
+function isLocalFilePath(src: string): boolean {
+  if (src.startsWith("http://") || src.startsWith("https://")) return false;
+  if (src.startsWith("data:")) return false;
+  return true;
+}
+
+async function localFileToDataUrl(src: string): Promise<string | undefined> {
+  try {
+    const resolved = resolve(process.cwd(), src);
+    const file = Bun.file(resolved);
+    if (!(await file.exists())) return undefined;
+    const buffer = await file.arrayBuffer();
+    const ext = src.split(".").pop()?.toLowerCase();
+    const mimeType =
+      ext === "png"
+        ? "image/png"
+        : ext === "jpg" || ext === "jpeg"
+          ? "image/jpeg"
+          : ext === "gif"
+            ? "image/gif"
+            : ext === "webp"
+              ? "image/webp"
+              : "image/png";
+    const base64 = Buffer.from(buffer).toString("base64");
+    return `data:${mimeType};base64,${base64}`;
+  } catch {
+    return undefined;
+  }
+}
+
 function generateHtml(storyboard: Storyboard, sourceFile: string): string {
   const escapedSourceFile = escapeHtml(sourceFile);
 
@@ -434,22 +464,30 @@ function generateHtml(storyboard: Storyboard, sourceFile: string): string {
       )
       .join("");
 
-    const isInputWithUrl =
-      el.type === "input" &&
-      el.src &&
-      (el.src.startsWith("http://") || el.src.startsWith("https://"));
+    const hasSrcWithPreview =
+      el.src && (el.type === "input" || (el.type === "image" && !el.prompt));
+    const previewSrc =
+      el.imageDataUrl ||
+      (el.src && !isLocalFilePath(el.src) ? el.src : undefined);
 
-    if (isInputWithUrl) {
-      const shortUrl =
+    if (hasSrcWithPreview) {
+      const shortPath =
         el.src!.length > 50 ? `${el.src!.slice(0, 50)}...` : el.src!;
+      const isUrl =
+        el.src!.startsWith("http://") || el.src!.startsWith("https://");
       const escapedSrc = escapeAttr(el.src!);
+      const previewImgSrc = previewSrc ? escapeAttr(previewSrc) : undefined;
       return `
       <div class="tree-node" style="--depth: ${depth}">
         <span class="tree-prefix">${parentPrefix}${connector}</span>
         <span class="type-tag" style="background: ${color}">${el.type}</span>
         <span class="input-preview-wrapper">
-          <a href="${escapedSrc}" target="_blank" rel="noopener noreferrer" class="tree-prompt input-url">${escapeHtml(shortUrl)}</a>
-          <span class="input-preview-tooltip"><img src="${escapedSrc}" alt="preview" /></span>
+          ${
+            isUrl
+              ? `<a href="${escapedSrc}" target="_blank" rel="noopener noreferrer" class="tree-prompt input-url">${escapeHtml(shortPath)}</a>`
+              : `<span class="tree-prompt input-url">${escapeHtml(shortPath)}</span>`
+          }
+          ${previewImgSrc ? `<span class="input-preview-tooltip"><img src="${previewImgSrc}" alt="preview" /></span>` : ""}
         </span>
       </div>${childrenHtml}`;
     }
@@ -522,24 +560,34 @@ function generateHtml(storyboard: Storyboard, sourceFile: string): string {
         const grandChildren =
           (child.details.children as StoryboardElement[]) || [];
 
-        const isInputWithUrl =
-          child.type === "input" &&
+        const hasSrcWithPreview =
           child.src &&
-          (child.src.startsWith("http://") || child.src.startsWith("https://"));
+          (child.type === "input" || (child.type === "image" && !child.prompt));
+        const previewSrc =
+          child.imageDataUrl ||
+          (child.src && !isLocalFilePath(child.src) ? child.src : undefined);
 
-        if (isInputWithUrl) {
-          const shortUrl =
+        if (hasSrcWithPreview) {
+          const shortPath =
             child.src!.length > 60
               ? `${child.src!.slice(0, 60)}...`
               : child.src!;
+          const isUrl =
+            child.src!.startsWith("http://") ||
+            child.src!.startsWith("https://");
           const escapedSrc = escapeAttr(child.src!);
+          const previewImgSrc = previewSrc ? escapeAttr(previewSrc) : undefined;
           return `
           <div class="timeline-nested">
             <span class="nested-connector">${connector}</span>
             <span class="nested-type" style="background: ${color}">${child.type}</span>
             <span class="input-preview-wrapper">
-              <a href="${escapedSrc}" target="_blank" rel="noopener noreferrer" class="nested-prompt input-url">${escapeHtml(shortUrl)}</a>
-              <span class="input-preview-tooltip"><img src="${escapedSrc}" alt="preview" /></span>
+              ${
+                isUrl
+                  ? `<a href="${escapedSrc}" target="_blank" rel="noopener noreferrer" class="nested-prompt input-url">${escapeHtml(shortPath)}</a>`
+                  : `<span class="nested-prompt input-url">${escapeHtml(shortPath)}</span>`
+              }
+              ${previewImgSrc ? `<span class="input-preview-tooltip"><img src="${previewImgSrc}" alt="preview" /></span>` : ""}
             </span>
           </div>
           ${grandChildren.length > 0 ? renderNestedTree(grandChildren, depth + 1) : ""}`;
@@ -1451,7 +1499,17 @@ async function populateCachedImages(
   let foundCount = 0;
 
   async function lookupImage(el: StoryboardElement): Promise<void> {
-    if (el.type === "image" && el._element) {
+    // Handle local file sources (for both "image" and "input" types)
+    if (el.src && isLocalFilePath(el.src) && !el.imageDataUrl) {
+      const dataUrl = await localFileToDataUrl(el.src);
+      if (dataUrl) {
+        el.imageDataUrl = dataUrl;
+        foundCount++;
+      }
+    }
+
+    // Handle cached generated images
+    if (el.type === "image" && el._element && !el.imageDataUrl) {
       const cacheKeyParts = computeCacheKey(el._element);
       const cacheKey = `generateImage:${cacheKeyParts.map((d) => String(d ?? "")).join(":")}`;
       const cached = (await cache.get(cacheKey)) as

package/src/definitions/actions/grok-edit.ts

@@ -0,0 +1,133 @@
+/**
+ * Grok Imagine Video Edit action
+ * Edit videos using xAI's Grok Imagine Video model
+ */
+
+import { z } from "zod";
+import { filePathSchema } from "../../core/schema/shared";
+import type { ActionDefinition, ZodSchema } from "../../core/schema/types";
+import { falProvider } from "../../providers/fal";
+
+// Resolution enum matching the API spec
+const grokEditResolutionSchema = z
+  .enum(["auto", "480p", "720p"])
+  .default("auto")
+  .describe("Resolution of the output video");
+
+// Input schema with Zod
+const grokEditInputSchema = z.object({
+  prompt: z.string().describe("Text description of the desired edit"),
+  video: filePathSchema.describe(
+    "Input video to edit (will be resized to max 854x480 and truncated to 8 seconds)",
+  ),
+  resolution: grokEditResolutionSchema,
+});
+
+// Output schema with Zod
+const grokEditOutputSchema = z.object({
+  videoUrl: z.string(),
+  width: z.number().optional(),
+  height: z.number().optional(),
+  duration: z.number().optional(),
+  fps: z.number().optional(),
+});
+
+// Schema object for the definition
+const schema: ZodSchema<
+  typeof grokEditInputSchema,
+  typeof grokEditOutputSchema
+> = {
+  input: grokEditInputSchema,
+  output: grokEditOutputSchema,
+};
+
+export const definition: ActionDefinition<typeof schema> = {
+  type: "action",
+  name: "grok-edit",
+  description: "Edit video using xAI's Grok Imagine Video",
+  schema,
+  routes: [
+    {
+      target: "xai/grok-imagine-video/edit-video",
+      priority: 10,
+    },
+  ],
+  execute: async (inputs) => {
+    const { prompt, video, resolution } = inputs;
+
+    console.log("[action/grok-edit] editing video with Grok Imagine");
+
+    const result = await falProvider.grokEditVideo({
+      prompt,
+      videoUrl: video,
+      resolution,
+    });
+
+    const data = result.data as {
+      video?: {
+        url?: string;
+        width?: number;
+        height?: number;
+        duration?: number;
+        fps?: number;
+      };
+    };
+
+    const videoUrl = data?.video?.url;
+    if (!videoUrl) {
+      throw new Error("No video URL in result");
+    }
+
+    return {
+      videoUrl,
+      width: data.video?.width,
+      height: data.video?.height,
+      duration: data.video?.duration,
+      fps: data.video?.fps,
+    };
+  },
+};
+
+// Re-export types for convenience
+export type GrokEditInput = z.infer<typeof grokEditInputSchema>;
+export type GrokEditOutput = z.infer<typeof grokEditOutputSchema>;
+
+// Convenience function
+export async function grokEditVideo(
+  prompt: string,
+  videoUrl: string,
+  options: { resolution?: "auto" | "480p" | "720p" } = {},
+): Promise<GrokEditOutput> {
+  console.log("[grok-edit] editing video");
+
+  const result = await falProvider.grokEditVideo({
+    prompt,
+    videoUrl,
+    resolution: options.resolution,
+  });
+
+  const data = result.data as {
+    video?: {
+      url?: string;
+      width?: number;
+      height?: number;
+      duration?: number;
+      fps?: number;
+    };
+  };
+
+  const url = data?.video?.url;
+  if (!url) {
+    throw new Error("No video URL in result");
+  }
+
+  return {
+    videoUrl: url,
+    width: data.video?.width,
+    height: data.video?.height,
+    duration: data.video?.duration,
+    fps: data.video?.fps,
+  };
+}
+
+export default definition;

package/src/definitions/actions/index.ts

@@ -38,6 +38,12 @@ export {
   trim,
   trimDefinition,
 } from "./edit";
+export type { GrokEditInput, GrokEditOutput } from "./grok-edit";
+// Grok Imagine Video Edit
+export {
+  definition as grokEdit,
+  grokEditVideo,
+} from "./grok-edit";
 export type { ImageGenerationResult } from "./image";
 // Image generation
 export {
@@ -48,6 +54,12 @@ export {
 export type { GenerateMusicOptions, MusicResult } from "./music";
 // Music generation
 export { definition as music, generateMusic } from "./music";
+export type { QwenAnglesInput, QwenAnglesOutput } from "./qwen-angles";
+// Qwen Image Edit 2511 Multiple Angles
+export {
+  definition as qwenAngles,
+  qwenAngles as qwenAnglesImage,
+} from "./qwen-angles";
 export type { LipsyncOptions, LipsyncResult, Wav2LipOptions } from "./sync";
 // Lip sync
 export {
@@ -87,8 +99,10 @@ import {
   transitionDefinition,
   trimDefinition,
 } from "./edit";
+import { definition as grokEditDefinition } from "./grok-edit";
 import { definition as imageDefinition } from "./image";
 import { definition as musicDefinition } from "./music";
+import { definition as qwenAnglesDefinition } from "./qwen-angles";
 import { definition as syncDefinition } from "./sync";
 import { definition as transcribeDefinition } from "./transcribe";
 import { definition as uploadDefinition } from "./upload";
@@ -103,6 +117,8 @@ export const allActions = [
   musicDefinition,
   syncDefinition,
   captionsDefinition,
+  grokEditDefinition,
+  qwenAnglesDefinition,
   trimDefinition,
   cutDefinition,
   mergeDefinition,

package/src/definitions/actions/qwen-angles.ts

@@ -0,0 +1,218 @@
+/**
+ * Qwen Image Edit 2511 Multiple Angles action
+ * Generates same scene from different camera angles (azimuth/elevation)
+ */
+
+import { z } from "zod";
+import { filePathSchema } from "../../core/schema/shared";
+import type { ActionDefinition, ZodSchema } from "../../core/schema/types";
+import { falProvider } from "../../providers/fal";
+
+// Input schema with Zod
+const qwenAnglesInputSchema = z.object({
+  image: filePathSchema.describe("Input image to adjust camera angle for"),
+  horizontalAngle: z
+    .number()
+    .min(0)
+    .max(360)
+    .default(0)
+    .describe(
+      "Horizontal rotation angle in degrees. 0=front, 90=right side, 180=back, 270=left side, 360=front",
+    ),
+  verticalAngle: z
+    .number()
+    .min(-30)
+    .max(90)
+    .default(0)
+    .describe(
+      "Vertical camera angle in degrees. -30=looking up, 0=eye-level, 30=elevated, 60=high-angle, 90=bird's-eye",
+    ),
+  zoom: z
+    .number()
+    .min(0)
+    .max(10)
+    .default(5)
+    .describe(
+      "Camera zoom/distance. 0=wide shot (far), 5=medium shot (normal), 10=close-up (very close)",
+    ),
+  prompt: z
+    .string()
+    .optional()
+    .describe(
+      "Additional text to append to the automatically generated prompt",
+    ),
+  loraScale: z
+    .number()
+    .min(0)
+    .max(4)
+    .default(1)
+    .describe("Strength of the camera control effect"),
+  guidanceScale: z
+    .number()
+    .min(1)
+    .max(20)
+    .default(4.5)
+    .describe("CFG (Classifier Free Guidance) scale"),
+  numInferenceSteps: z
+    .number()
+    .min(1)
+    .max(50)
+    .default(28)
+    .describe("Number of inference steps"),
+  negativePrompt: z
+    .string()
+    .default("")
+    .describe("Negative prompt for the generation"),
+  seed: z.number().optional().describe("Random seed for reproducibility"),
+  outputFormat: z
+    .enum(["png", "jpeg", "webp"])
+    .default("png")
+    .describe("Output image format"),
+  numImages: z
+    .number()
+    .min(1)
+    .max(4)
+    .default(1)
+    .describe("Number of images to generate"),
+});
+
+// Output schema with Zod
+const qwenAnglesOutputSchema = z.object({
+  imageUrl: z.string(),
+  images: z.array(z.object({ url: z.string() })).optional(),
+  seed: z.number().optional(),
+  prompt: z.string().optional(),
+});
+
+// Schema object for the definition
+const schema: ZodSchema<
+  typeof qwenAnglesInputSchema,
+  typeof qwenAnglesOutputSchema
+> = {
+  input: qwenAnglesInputSchema,
+  output: qwenAnglesOutputSchema,
+};
+
+export const definition: ActionDefinition<typeof schema> = {
+  type: "action",
+  name: "qwen-angles",
+  description:
+    "Adjust camera angle of an image using Qwen Image Edit 2511 Multiple Angles",
+  schema,
+  routes: [
+    {
+      target: "fal-ai/qwen-image-edit-2511-multiple-angles",
+      priority: 10,
+    },
+  ],
+  execute: async (inputs) => {
+    const {
+      image,
+      horizontalAngle,
+      verticalAngle,
+      zoom,
+      prompt,
+      loraScale,
+      guidanceScale,
+      numInferenceSteps,
+      negativePrompt,
+      seed,
+      outputFormat,
+      numImages,
+    } = inputs;
+
+    console.log("[action/qwen-angles] adjusting camera angle");
+
+    const result = await falProvider.qwenMultipleAngles({
+      imageUrl: image,
+      horizontalAngle,
+      verticalAngle,
+      zoom,
+      additionalPrompt: prompt,
+      loraScale,
+      guidanceScale,
+      numInferenceSteps,
+      negativePrompt,
+      seed,
+      outputFormat,
+      numImages,
+    });
+
+    const data = result.data as {
+      images?: Array<{ url: string }>;
+      seed?: number;
+      prompt?: string;
+    };
+
+    const images = data?.images;
+    if (!images || images.length === 0) {
+      throw new Error("No images in result");
+    }
+
+    return {
+      imageUrl: images[0]!.url,
+      images,
+      seed: data?.seed,
+      prompt: data?.prompt,
+    };
+  },
+};
+
+// Re-export types for convenience
+export type QwenAnglesInput = z.infer<typeof qwenAnglesInputSchema>;
+export type QwenAnglesOutput = z.infer<typeof qwenAnglesOutputSchema>;
+
+// Convenience function
+export async function qwenAngles(
+  imageUrl: string,
+  options: {
+    horizontalAngle?: number;
+    verticalAngle?: number;
+    zoom?: number;
+    prompt?: string;
+    loraScale?: number;
+    guidanceScale?: number;
+    numInferenceSteps?: number;
+    negativePrompt?: string;
+    seed?: number;
+    outputFormat?: "png" | "jpeg" | "webp";
+    numImages?: number;
+  } = {},
+): Promise<QwenAnglesOutput> {
+  console.log("[qwen-angles] adjusting camera angle");
+
+  const result = await falProvider.qwenMultipleAngles({
+    imageUrl,
+    horizontalAngle: options.horizontalAngle,
+    verticalAngle: options.verticalAngle,
+    zoom: options.zoom,
+    additionalPrompt: options.prompt,
+    loraScale: options.loraScale,
+    guidanceScale: options.guidanceScale,
+    numInferenceSteps: options.numInferenceSteps,
+    negativePrompt: options.negativePrompt,
+    seed: options.seed,
+    outputFormat: options.outputFormat,
+    numImages: options.numImages,
+  });
+
+  const data = result.data as {
+    images?: Array<{ url: string }>;
+    seed?: number;
+    prompt?: string;
+  };
+
+  const images = data?.images;
+  if (!images || images.length === 0) {
+    throw new Error("No images in result");
+  }
+
+  return {
+    imageUrl: images[0]!.url,
+    images,
+    seed: data?.seed,
+    prompt: data?.prompt,
+  };
+}
+
+export default definition;

package/src/providers/fal.ts

@@ -374,6 +374,197 @@ export class FalProvider extends BaseProvider {
     console.log("[fal] completed!");
     return result;
   }
+
+  // ============================================================================
+  // Grok Imagine Video methods (xAI)
+  // ============================================================================
+
+  /**
+   * Generate video from text using Grok Imagine Video
+   * Supports 1-15 second videos at 480p or 720p resolution
+   */
+  async grokTextToVideo(args: {
+    prompt: string;
+    duration?: number;
+    aspectRatio?: "16:9" | "4:3" | "3:2" | "1:1" | "2:3" | "3:4" | "9:16";
+    resolution?: "480p" | "720p";
+  }) {
+    const modelId = "xai/grok-imagine-video/text-to-video";
+
+    console.log(`[fal] starting grok text-to-video: ${modelId}`);
+    console.log(`[fal] prompt: ${args.prompt}`);
+
+    const result = await fal.subscribe(modelId, {
+      input: {
+        prompt: args.prompt,
+        duration: args.duration ?? 6,
+        aspect_ratio: args.aspectRatio ?? "16:9",
+        resolution: args.resolution ?? "720p",
+      },
+      logs: true,
+      onQueueUpdate: (update) => {
+        if (update.status === "IN_PROGRESS") {
+          console.log(
+            `[fal] ${update.logs?.map((l) => l.message).join(" ") || "processing..."}`,
+          );
+        }
+      },
+    });
+
+    console.log("[fal] completed!");
+    return result;
+  }
+
+  /**
+   * Generate video from image using Grok Imagine Video
+   * Supports 1-15 second videos at 480p or 720p resolution
+   */
+  async grokImageToVideo(args: {
+    prompt: string;
+    imageUrl: string;
+    duration?: number;
+    aspectRatio?:
+      | "auto"
+      | "16:9"
+      | "4:3"
+      | "3:2"
+      | "1:1"
+      | "2:3"
+      | "3:4"
+      | "9:16";
+    resolution?: "480p" | "720p";
+  }) {
+    const modelId = "xai/grok-imagine-video/image-to-video";
+
+    console.log(`[fal] starting grok image-to-video: ${modelId}`);
+    console.log(`[fal] prompt: ${args.prompt}`);
+
+    const imageUrl = await ensureUrl(args.imageUrl, (buffer) =>
+      this.uploadFile(buffer),
+    );
+
+    const result = await fal.subscribe(modelId, {
+      input: {
+        prompt: args.prompt,
+        image_url: imageUrl,
+        duration: args.duration ?? 6,
+        aspect_ratio: args.aspectRatio ?? "auto",
+        resolution: args.resolution ?? "720p",
+      },
+      logs: true,
+      onQueueUpdate: (update) => {
+        if (update.status === "IN_PROGRESS") {
+          console.log(
+            `[fal] ${update.logs?.map((l) => l.message).join(" ") || "processing..."}`,
+          );
+        }
+      },
+    });
+
+    console.log("[fal] completed!");
+    return result;
+  }
+
+  /**
+   * Edit video using Grok Imagine Video
+   * Video will be resized to max 854x480 and truncated to 8 seconds
+   */
+  async grokEditVideo(args: {
+    prompt: string;
+    videoUrl: string;
+    resolution?: "auto" | "480p" | "720p";
+  }) {
+    const modelId = "xai/grok-imagine-video/edit-video";
+
+    console.log(`[fal] starting grok edit-video: ${modelId}`);
+    console.log(`[fal] prompt: ${args.prompt}`);
+
+    const videoUrl = await ensureUrl(args.videoUrl, (buffer) =>
+      this.uploadFile(buffer),
+    );
+
+    const result = await fal.subscribe(modelId, {
+      input: {
+        prompt: args.prompt,
+        video_url: videoUrl,
+        resolution: args.resolution ?? "auto",
+      },
+      logs: true,
+      onQueueUpdate: (update) => {
+        if (update.status === "IN_PROGRESS") {
+          console.log(
+            `[fal] ${update.logs?.map((l) => l.message).join(" ") || "processing..."}`,
+          );
+        }
+      },
+    });
+
+    console.log("[fal] completed!");
+    return result;
+  }
+
+  // ============================================================================
+  // Qwen Image Edit 2511 Multiple Angles
+  // ============================================================================
+
+  /**
+   * Adjust camera angle of an image using Qwen Image Edit 2511 Multiple Angles
+   * Generates same scene from different angles (azimuth/elevation)
+   */
+  async qwenMultipleAngles(args: {
+    imageUrl: string;
+    horizontalAngle?: number;
+    verticalAngle?: number;
+    zoom?: number;
+    additionalPrompt?: string;
+    loraScale?: number;
+    imageSize?: string | { width: number; height: number };
+    guidanceScale?: number;
+    numInferenceSteps?: number;
+    acceleration?: "none" | "regular";
+    negativePrompt?: string;
+    seed?: number;
+    outputFormat?: "png" | "jpeg" | "webp";
+    numImages?: number;
+  }) {
+    const modelId = "fal-ai/qwen-image-edit-2511-multiple-angles";
+
+    console.log(`[fal] starting qwen multiple angles: ${modelId}`);
+
+    const imageUrl = await ensureUrl(args.imageUrl, (buffer) =>
+      this.uploadFile(buffer),
+    );
+
+    const result = await fal.subscribe(modelId, {
+      input: {
+        image_urls: [imageUrl],
+        horizontal_angle: args.horizontalAngle ?? 0,
+        vertical_angle: args.verticalAngle ?? 0,
+        zoom: args.zoom ?? 5,
+        additional_prompt: args.additionalPrompt,
+        lora_scale: args.loraScale ?? 1,
+        image_size: args.imageSize,
+        guidance_scale: args.guidanceScale ?? 4.5,
+        num_inference_steps: args.numInferenceSteps ?? 28,
+        acceleration: args.acceleration ?? "regular",
+        negative_prompt: args.negativePrompt ?? "",
+        seed: args.seed,
+        output_format: args.outputFormat ?? "png",
+        num_images: args.numImages ?? 1,
+      },
+      logs: true,
+      onQueueUpdate: (update) => {
+        if (update.status === "IN_PROGRESS") {
+          console.log(
+            `[fal] ${update.logs?.map((l) => l.message).join(" ") || "processing..."}`,
+          );
+        }
+      },
+    });
+
+    console.log("[fal] completed!");
+    return result;
+  }
 }
 
 // Export singleton instance

package/src/react/examples/qwen-angles-test.tsx

@@ -0,0 +1,72 @@
+/**
+ * Qwen Image Edit 2511 Multiple Angles Test
+ *
+ * Demonstrates camera angle adjustment using Qwen model.
+ * Generates the same scene from different perspectives (azimuth/elevation).
+ *
+ * Run with: bun run src/cli/index.ts render src/react/examples/qwen-angles-test.tsx
+ */
+
+import { fal } from "../../ai-sdk/providers/fal";
+import { Clip, Image, Render } from "..";
+
+// Source image - replace with your own image URL or local path
+const sourceImage =
+  "https://v3b.fal.media/files/b/0a8973cb/qUbVwDCcMlvX4drBGYB1H.png";
+
+export default (
+  <Render width={1024} height={1024}>
+    {/* Original image - front view */}
+    <Clip duration={2}>
+      <Image src={sourceImage} resize="cover" />
+    </Clip>
+
+    {/* Right side view (90 degrees horizontal) */}
+    <Clip duration={2}>
+      <Image
+        prompt={{ text: "", images: [sourceImage] }}
+        model={fal.imageModel("qwen-angles")}
+        aspectRatio="1:1"
+        providerOptions={{
+          fal: {
+            horizontal_angle: 90,
+            vertical_angle: 0,
+            zoom: 5,
+          },
+        }}
+      />
+    </Clip>
+
+    {/* Bird's eye view (60 degrees vertical) */}
+    <Clip duration={2}>
+      <Image
+        prompt={{ text: "", images: [sourceImage] }}
+        model={fal.imageModel("qwen-angles")}
+        aspectRatio="1:1"
+        providerOptions={{
+          fal: {
+            horizontal_angle: 0,
+            vertical_angle: 60,
+            zoom: 5,
+          },
+        }}
+      />
+    </Clip>
+
+    {/* Close-up from 45 degree angle */}
+    <Clip duration={2}>
+      <Image
+        prompt={{ text: "", images: [sourceImage] }}
+        model={fal.imageModel("qwen-angles")}
+        aspectRatio="1:1"
+        providerOptions={{
+          fal: {
+            horizontal_angle: 45,
+            vertical_angle: 30,
+            zoom: 8,
+          },
+        }}
+      />
+    </Clip>
+  </Render>
+);

package/src/react/react.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 import { existsSync, unlinkSync } from "node:fs";
 import { fal } from "../ai-sdk/providers/fal";
 import {
@@ -157,6 +157,55 @@ describe("varg-react render", () => {
 
     expect(render(root)).rejects.toThrow("model");
   });
+
+  test("parallel failures preserve successful results and report all errors", async () => {
+    let callCount = 0;
+    const mockModel = {
+      specificationVersion: "v3" as const,
+      provider: "mock",
+      modelId: "mock-model",
+      maxImagesPerCall: 1,
+      doGenerate: mock(async () => {
+        callCount++;
+        if (callCount === 2) {
+          throw new Error("Request Timeout");
+        }
+        return {
+          images: [new Uint8Array([0x89, 0x50, 0x4e, 0x47])],
+          warnings: [],
+          response: {
+            timestamp: new Date(),
+            modelId: "mock",
+            headers: undefined,
+          },
+        };
+      }),
+    };
+
+    const root = Render({
+      width: 720,
+      height: 720,
+      children: [
+        Clip({
+          duration: 1,
+          children: [Image({ prompt: "first", model: mockModel })],
+        }),
+        Clip({
+          duration: 1,
+          children: [Image({ prompt: "second", model: mockModel })],
+        }),
+        Clip({
+          duration: 1,
+          children: [Image({ prompt: "third", model: mockModel })],
+        }),
+      ],
+    });
+
+    const error = await render(root, { quiet: true }).catch((e) => e);
+    expect(error.message).toContain("1 of 3 clips failed");
+    expect(error.message).toContain("Request Timeout");
+    expect(callCount).toBe(3);
+  });
 });
 
 describe("layout renderers", () => {

package/src/react/renderers/clip.ts

@@ -226,11 +226,28 @@ async function renderClipLayers(
     }
   }
 
-  const layers = await Promise.all(
-    pending.map((p) => (p.type === "sync" ? p.layer : p.promise)),
+  const layerResults = await Promise.allSettled(
+    pending.map((p) =>
+      p.type === "sync" ? Promise.resolve(p.layer) : p.promise,
+    ),
   );
 
-  return layers;
+  const failures = layerResults
+    .map((r, i) =>
+      r.status === "rejected" ? { index: i, reason: r.reason } : null,
+    )
+    .filter(Boolean) as { index: number; reason: Error }[];
+
+  if (failures.length > 0) {
+    const errors = failures
+      .map((f) => f.reason?.message || "Unknown error")
+      .join("; ");
+    throw new Error(
+      `${failures.length} of ${layerResults.length} layers failed: ${errors}`,
+    );
+  }
+
+  return layerResults.map((r) => (r as PromiseFulfilledResult<Layer>).value);
 }
 
 export async function renderClip(

package/src/react/renderers/render.ts

@@ -205,10 +205,37 @@ export async function renderRoot(
     }
   }
 
-  const renderedClips = await Promise.all(
+  const clipResults = await Promise.allSettled(
     clipElements.map((clipElement) => renderClip(clipElement, ctx)),
   );
 
+  const failures = clipResults
+    .map((r, i) =>
+      r.status === "rejected" ? { index: i, reason: r.reason } : null,
+    )
+    .filter(Boolean) as { index: number; reason: Error }[];
+
+  if (failures.length > 0) {
+    const successCount = clipResults.length - failures.length;
+    if (successCount > 0) {
+      console.log(
+        `\x1b[33mℹ ${successCount} clip(s) cached, ${failures.length} failed\x1b[0m`,
+      );
+    }
+    const errors = failures
+      .map((f) => f.reason?.message || "Unknown error")
+      .join("; ");
+    throw new Error(
+      `${failures.length} of ${clipResults.length} clips failed: ${errors}`,
+    );
+  }
+
+  const renderedClips = clipResults.map(
+    (r) =>
+      (r as PromiseFulfilledResult<Awaited<ReturnType<typeof renderClip>>>)
+        .value,
+  );
+
   const clips: Clip[] = [];
   let currentTime = 0;