vargai 0.4.0-alpha47 → 0.4.0-alpha49

package/examples/grok-imagine-ai-sdk.tsx

@@ -0,0 +1,201 @@
+/**
+ * Grok Imagine Video - AI SDK Provider Test
+ *
+ * Run with: bun run examples/grok-imagine-ai-sdk.tsx
+ *
+ * Tests the Grok Imagine Video model via the AI-SDK interface
+ */
+
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fal } from "../src/ai-sdk/providers/fal";
+
+async function testGrokTextToVideo() {
+  console.log("\n=== Grok Text-to-Video (AI-SDK) ===\n");
+
+  const model = fal.videoModel("grok-imagine");
+
+  const result = await model.doGenerate({
+    prompt:
+      "A futuristic city at night with neon lights reflecting on wet streets, flying cars passing by, cyberpunk aesthetic",
+    n: 1,
+    duration: 6,
+    aspectRatio: "16:9",
+    resolution: undefined,
+    fps: undefined,
+    seed: undefined,
+    files: undefined,
+    providerOptions: {
+      fal: {
+        resolution: "720p",
+      },
+    },
+  });
+
+  console.log("Warnings:", result.warnings);
+  console.log("Response:", {
+    timestamp: result.response.timestamp,
+    modelId: result.response.modelId,
+  });
+
+  // Save the video
+  const outputPath = join(import.meta.dir, "../output/grok-t2v-test.mp4");
+  await writeFile(outputPath, result.videos[0]!);
+  console.log(`Video saved to: ${outputPath}`);
+
+  return outputPath;
+}
+
+async function testGrokImageToVideo() {
+  console.log("\n=== Grok Image-to-Video (AI-SDK) ===\n");
+
+  const model = fal.videoModel("grok-imagine");
+
+  // Fetch a sample image
+  const imageUrl =
+    "https://v3b.fal.media/files/b/0a8b90e0/BFLE9VDlZqsryU-UA3BoD_image_004.png";
+  const imageResponse = await fetch(imageUrl);
+  const imageBuffer = new Uint8Array(await imageResponse.arrayBuffer());
+
+  const result = await model.doGenerate({
+    prompt:
+      "The knight slowly raises their sword, preparing for battle, dramatic lighting",
+    n: 1,
+    duration: 6,
+    aspectRatio: "16:9",
+    resolution: undefined,
+    fps: undefined,
+    seed: undefined,
+    files: [
+      {
+        type: "file",
+        data: imageBuffer,
+        mediaType: "image/png",
+      },
+    ],
+    providerOptions: {
+      fal: {
+        resolution: "720p",
+      },
+    },
+  });
+
+  console.log("Warnings:", result.warnings);
+  console.log("Response:", {
+    timestamp: result.response.timestamp,
+    modelId: result.response.modelId,
+  });
+
+  // Save the video
+  const outputPath = join(import.meta.dir, "../output/grok-i2v-test.mp4");
+  await writeFile(outputPath, result.videos[0]!);
+  console.log(`Video saved to: ${outputPath}`);
+
+  return outputPath;
+}
+
+async function testGrokEditVideo() {
+  console.log("\n=== Grok Edit Video (AI-SDK) ===\n");
+
+  const model = fal.videoModel("grok-imagine-edit");
+
+  // Use a sample video
+  const videoUrl =
+    "https://v3b.fal.media/files/b/0a8b9112/V5Z_NIPE3ppMDWivNo6_q_video_019.mp4";
+  const videoResponse = await fetch(videoUrl);
+  const videoBuffer = new Uint8Array(await videoResponse.arrayBuffer());
+
+  const result = await model.doGenerate({
+    prompt:
+      "Transform the scene into a watercolor painting style with soft pastel colors",
+    n: 1,
+    duration: undefined,
+    aspectRatio: undefined,
+    resolution: undefined,
+    fps: undefined,
+    seed: undefined,
+    files: [
+      {
+        type: "file",
+        data: videoBuffer,
+        mediaType: "video/mp4",
+      },
+    ],
+    providerOptions: {
+      fal: {
+        resolution: "720p",
+      },
+    },
+  });
+
+  console.log("Warnings:", result.warnings);
+  console.log("Response:", {
+    timestamp: result.response.timestamp,
+    modelId: result.response.modelId,
+  });
+
+  // Save the video
+  const outputPath = join(import.meta.dir, "../output/grok-edit-test.mp4");
+  await writeFile(outputPath, result.videos[0]!);
+  console.log(`Video saved to: ${outputPath}`);
+
+  return outputPath;
+}
+
+// Main execution
+async function main() {
+  const args = process.argv.slice(2);
+  const mode = args[0] || "t2v";
+
+  console.log("Grok Imagine Video - AI SDK Test");
+  console.log("=================================");
+  console.log(`Mode: ${mode}`);
+
+  // Ensure output directory exists
+  const { mkdir } = await import("node:fs/promises");
+  await mkdir(join(import.meta.dir, "../output"), { recursive: true });
+
+  try {
+    switch (mode) {
+      case "t2v":
+        await testGrokTextToVideo();
+        break;
+
+      case "i2v":
+        await testGrokImageToVideo();
+        break;
+
+      case "edit":
+        await testGrokEditVideo();
+        break;
+
+      case "all":
+        await testGrokTextToVideo();
+        await testGrokImageToVideo();
+        await testGrokEditVideo();
+        break;
+
+      default:
+        console.log(`
+Usage: bun run examples/grok-imagine-ai-sdk.tsx [mode]
+
+Modes:
+  t2v     Text-to-Video generation
+  i2v     Image-to-Video generation  
+  edit    Video editing
+  all     Run all tests
+
+Examples:
+  bun run examples/grok-imagine-ai-sdk.tsx t2v
+  bun run examples/grok-imagine-ai-sdk.tsx all
+`);
+    }
+
+    console.log("\nTest completed!");
+  } catch (error) {
+    console.error("\nTest failed:", error);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

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

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

@@ -45,28 +45,46 @@ function createMemoryCache(): CacheStorage {
 }
 
 // TODO: allow passing CacheStorage via providerOptions.fal.cacheStorage for proper serverless support
-function isFilesystemWritable(): boolean {
-  try {
-    const testPath = `.cache/.write-test-${Date.now()}`;
-    Bun.spawnSync(["mkdir", "-p", ".cache"]);
-    const result = Bun.spawnSync(["touch", testPath]);
-    if (result.exitCode === 0) {
-      Bun.spawnSync(["rm", testPath]);
-      return true;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-
-const USE_FILE_CACHE = isFilesystemWritable();
-
 function createFalCache(name: string): CacheStorage {
-  if (!USE_FILE_CACHE) {
-    return createMemoryCache();
-  }
-  return fileCache({ dir: `.cache/${name}` });
+  let cache: CacheStorage | null = null;
+  let useFallback = false;
+  const fallback = createMemoryCache();
+
+  const getCache = () => {
+    if (useFallback) return fallback;
+    if (!cache) cache = fileCache({ dir: `.cache/${name}` });
+    return cache;
+  };
+
+  return {
+    async get(key) {
+      if (useFallback) return fallback.get(key);
+      try {
+        return await getCache().get(key);
+      } catch {
+        useFallback = true;
+        return fallback.get(key);
+      }
+    },
+    async set(key, value, ttl) {
+      if (useFallback) return fallback.set(key, value, ttl);
+      try {
+        await getCache().set(key, value, ttl);
+      } catch {
+        useFallback = true;
+        await fallback.set(key, value, ttl);
+      }
+    },
+    async delete(key) {
+      if (useFallback) return fallback.delete(key);
+      try {
+        await getCache().delete(key);
+      } catch {
+        useFallback = true;
+        await fallback.delete(key);
+      }
+    },
+  };
 }
 
 const pendingStorage = createFalCache("fal-pending");

package/src/react/renderers/burn-captions.ts

@@ -69,7 +69,11 @@ export async function burnCaptions(
   const { video, assPath, outputPath = "output.mp4", verbose } = options;
   const captions: FFmpegOutput = { type: "file", path: assPath };
 
-  const isCloud = options.backend !== undefined;
+  // Resolve backend first so we can check if it's cloud or local
+  // TODO: This is a hack - we should abstract backend capabilities (e.g., supportsLocalPaths)
+  // instead of checking the name directly. For now, we assume "local" is the only local backend.
+  const backend = options.backend ?? localBackend;
+  const isCloud = backend.name !== "local";
 
   const videoInput = await resolveInputPathMaybeUpload(video, {
     shouldUpload: isCloud,
@@ -78,14 +82,16 @@ export async function burnCaptions(
     shouldUpload: isCloud,
   });
 
-  const backend = options.backend ?? localBackend;
-
-  // FFmpeg filter syntax requires escaping backslashes and colons
-  const escapedAssPath = assInput.replace(/\\/g, "\\\\").replace(/:/g, "\\:");
+  // For cloud backends (Rendi): pass raw URL so replaceWithPlaceholders() can match
+  // and replace with {{in_X}} placeholder. Rendi downloads inputs and provides local paths.
+  // For local backend: escape for FFmpeg filter syntax (backslashes and colons)
+  const subtitlesPath = isCloud
+    ? assInput
+    : assInput.replace(/\\/g, "\\\\").replace(/:/g, "\\:");
 
   const result = await backend.run({
     inputs: [videoInput, assInput],
-    videoFilter: `subtitles=${escapedAssPath}`,
+    videoFilter: `subtitles=${subtitlesPath}`,
     outputArgs: ["-crf", "18", "-preset", "fast", "-c:a", "copy"],
     outputPath,
     verbose,