vargai 0.3.0

package/src/ai-sdk/examples/workflow-animated-girl.ts

@@ -0,0 +1,104 @@
+import {
+  generateImage as _generateImage,
+  experimental_generateSpeech as generateSpeech,
+} from "ai";
+import {
+  generateVideo as _generateVideo,
+  elevenlabs,
+  fal,
+  fileCache,
+  withCache,
+} from "../index";
+
+const storage = fileCache({ dir: ".cache/ai" });
+const generateImage = withCache(_generateImage, { storage });
+const generateVideo = withCache(_generateVideo, { storage });
+
+async function main() {
+  const script = `Hi everyone! Welcome to my channel. Today I want to share something exciting with you. 
+I've been learning about AI video generation, and it's absolutely amazing what we can create now. 
+From simple images to fully animated talking characters, the possibilities are endless. 
+Don't forget to like and subscribe for more content like this!`;
+
+  console.log("step 1: generating girl image...");
+  const { images } = await generateImage({
+    model: fal.imageModel("flux-schnell"),
+    prompt:
+      "young woman portrait, friendly smile, casual style, looking at camera, natural lighting, social media influencer vibe",
+    aspectRatio: "9:16",
+    n: 1,
+    cacheKey: ["animated-girl", "portrait"],
+  });
+
+  const imageData = images[0]!.uint8Array;
+  await Bun.write("output/workflow-girl-image.png", imageData);
+  console.log("saved: output/workflow-girl-image.png");
+
+  console.log("\nstep 2: generating voiceover...");
+  const { audio } = await generateSpeech({
+    model: elevenlabs.speechModel("turbo"),
+    text: script,
+    voice: "rachel",
+  });
+
+  const audioData = audio.uint8Array;
+  await Bun.write("output/workflow-girl-voice.mp3", audioData);
+  console.log("saved: output/workflow-girl-voice.mp3");
+
+  console.log("\nstep 3: animating image to video...");
+  const { video } = await generateVideo({
+    model: fal.videoModel("wan-2.5"),
+    prompt: {
+      text: "woman talking naturally, subtle head movements, blinking, friendly expression, lip sync",
+      images: [imageData],
+    },
+    duration: 5,
+    cacheKey: ["animated-girl", "video"],
+  });
+
+  await Bun.write("output/workflow-girl-animated.mp4", video.uint8Array);
+  console.log("saved: output/workflow-girl-animated.mp4");
+
+  console.log("\nstep 4: lip syncing video with audio...");
+  const { video: syncedVideo } = await generateVideo({
+    model: fal.videoModel("sync-v2"),
+    prompt: {
+      video: video.uint8Array,
+      audio: audioData,
+    },
+    cacheKey: ["animated-girl", "synced"],
+  });
+
+  await Bun.write("output/workflow-girl-synced.mp4", syncedVideo.uint8Array);
+  console.log("saved: output/workflow-girl-synced.mp4");
+
+  console.log("\nstep 5: generating captions...");
+  const transcription = fal.transcriptionModel("whisper");
+  const result = await transcription.doGenerate({
+    audio: audioData,
+    mediaType: "audio/mpeg",
+  });
+
+  const srtContent = result.segments
+    .map((seg, i) => {
+      const start = formatTime(seg.startSecond);
+      const end = formatTime(seg.endSecond);
+      return `${i + 1}\n${start} --> ${end}\n${seg.text.trim()}\n`;
+    })
+    .join("\n");
+
+  await Bun.write("output/workflow-girl-captions.srt", srtContent);
+  console.log("saved: output/workflow-girl-captions.srt");
+
+  console.log("\ndone! all files in output/workflow-girl-*");
+}
+
+function formatTime(seconds: number): string {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = Math.floor(seconds % 60);
+  const ms = Math.floor((seconds % 1) * 1000);
+  return `${h.toString().padStart(2, "0")}:${m.toString().padStart(2, "0")}:${s.toString().padStart(2, "0")},${ms.toString().padStart(3, "0")}`;
+}
+
+main().catch(console.error);

package/src/ai-sdk/examples/workflow-before-after.ts

@@ -0,0 +1,114 @@
+import { generateImage as _generateImage } from "ai";
+import {
+  generateVideo as _generateVideo,
+  editly,
+  fal,
+  fileCache,
+  withCache,
+} from "../index";
+
+const storage = fileCache({ dir: ".cache/ai" });
+const generateImage = withCache(_generateImage, { storage });
+const generateVideo = withCache(_generateVideo, { storage });
+
+async function main() {
+  const personBase =
+    "30 year old man, brown hair, casual clothes, gym background";
+
+  console.log("step 1: generating before image (overweight)...");
+  const { images: beforeImages } = await generateImage({
+    model: fal.imageModel("flux-schnell"),
+    prompt: `${personBase}, overweight, tired expression, slouching posture, before fitness transformation`,
+    aspectRatio: "3:4",
+    n: 1,
+    cacheKey: ["before-after", "before-image"],
+  });
+
+  const beforeImage = beforeImages[0]!.uint8Array;
+  await Bun.write("output/workflow-before-image.png", beforeImage);
+  console.log("saved: output/workflow-before-image.png");
+
+  console.log("\nstep 2: generating after image (fit)...");
+  const { images: afterImages } = await generateImage({
+    model: fal.imageModel("flux-schnell"),
+    prompt: `${personBase}, fit and muscular, confident smile, good posture, after fitness transformation, healthy glow`,
+    aspectRatio: "3:4",
+    n: 1,
+    cacheKey: ["before-after", "after-image"],
+  });
+
+  const afterImage = afterImages[0]!.uint8Array;
+  await Bun.write("output/workflow-after-image.png", afterImage);
+  console.log("saved: output/workflow-after-image.png");
+
+  console.log("\nstep 3: animating before video...");
+  const { video: beforeVideo } = await generateVideo({
+    model: fal.videoModel("wan-2.5"),
+    prompt: {
+      text: "man standing, slight breathing movement, looking at camera, subtle movements",
+      images: [beforeImage],
+    },
+    duration: 5,
+    cacheKey: ["before-after", "before-video"],
+  });
+
+  await Bun.write("output/workflow-before-video.mp4", beforeVideo.uint8Array);
+  console.log("saved: output/workflow-before-video.mp4");
+
+  console.log("\nstep 4: animating after video...");
+  const { video: afterVideo } = await generateVideo({
+    model: fal.videoModel("wan-2.5"),
+    prompt: {
+      text: "fit man standing confidently, slight breathing movement, looking at camera, flexing slightly",
+      images: [afterImage],
+    },
+    duration: 5,
+    cacheKey: ["before-after", "after-video"],
+  });
+
+  await Bun.write("output/workflow-after-video.mp4", afterVideo.uint8Array);
+  console.log("saved: output/workflow-after-video.mp4");
+
+  console.log("\nstep 5: creating split-screen comparison...");
+  await editly({
+    outPath: "output/workflow-before-after.mp4",
+    width: 1280,
+    height: 720,
+    fps: 30,
+    verbose: true,
+    clips: [
+      {
+        duration: 5,
+        layers: [
+          { type: "fill-color", color: "#000000" },
+          {
+            type: "video",
+            path: "output/workflow-before-video.mp4",
+            width: 0.48,
+            height: 0.9,
+            left: 0.01,
+            top: 0.05,
+          },
+          {
+            type: "video",
+            path: "output/workflow-after-video.mp4",
+            width: 0.48,
+            height: 0.9,
+            left: 0.51,
+            top: 0.05,
+          },
+          {
+            type: "title",
+            text: "BEFORE                    AFTER",
+            textColor: "#ffffff",
+            position: "bottom",
+          },
+        ],
+      },
+    ],
+  });
+
+  console.log("\ndone! output/workflow-before-after.mp4");
+}
+
+main().catch(console.error);

package/src/ai-sdk/examples/workflow-character-grid.ts

@@ -0,0 +1,112 @@
+import { generateImage as _generateImage } from "ai";
+import { editly, fal, fileCache, withCache } from "../index";
+
+const storage = fileCache({ dir: ".cache/ai" });
+const generateImage = withCache(_generateImage, { storage });
+
+const CHARACTER_PROMPTS = [
+  {
+    name: "Warrior",
+    prompt: "fierce warrior with sword, armor, battle-ready stance",
+  },
+  {
+    name: "Mage",
+    prompt: "mystical mage with glowing staff, flowing robes, magical aura",
+  },
+  {
+    name: "Rogue",
+    prompt: "stealthy rogue with daggers, hooded cloak, shadows",
+  },
+  {
+    name: "Healer",
+    prompt: "gentle healer with staff, white robes, soft light",
+  },
+  {
+    name: "Archer",
+    prompt: "skilled archer with bow, leather armor, focused eyes",
+  },
+  {
+    name: "Knight",
+    prompt: "noble knight with shield, heavy armor, proud stance",
+  },
+  {
+    name: "Necromancer",
+    prompt: "dark necromancer with skull staff, black robes, green magic",
+  },
+  {
+    name: "Paladin",
+    prompt: "holy paladin with hammer, golden armor, divine light",
+  },
+  {
+    name: "Bard",
+    prompt: "charismatic bard with lute, colorful clothes, smile",
+  },
+  {
+    name: "Druid",
+    prompt: "nature druid with wooden staff, leaf clothing, animals",
+  },
+  {
+    name: "Monk",
+    prompt: "disciplined monk with wrapped fists, simple robes, calm",
+  },
+  {
+    name: "Assassin",
+    prompt: "deadly assassin with hidden blades, dark mask, shadows",
+  },
+];
+
+async function main() {
+  console.log("generating 12 character portraits...\n");
+
+  const baseStyle =
+    "fantasy character portrait, stylized art, vibrant colors, detailed, facing camera";
+
+  const images = await Promise.all(
+    CHARACTER_PROMPTS.map(async ({ name, prompt }, i) => {
+      console.log(`generating ${name}...`);
+      const { images } = await generateImage({
+        model: fal.imageModel("flux-schnell"),
+        prompt: `${prompt}, ${baseStyle}`,
+        aspectRatio: "1:1",
+        n: 1,
+        cacheKey: ["character-grid", name],
+      });
+      const data = images[0]!.uint8Array;
+      await Bun.write(`output/character-${i}-${name.toLowerCase()}.png`, data);
+      return {
+        name,
+        data,
+        path: `output/character-${i}-${name.toLowerCase()}.png`,
+      };
+    }),
+  );
+
+  console.log("\ncreating character grid video...");
+
+  const clips = images.map(({ name, path }) => ({
+    duration: 2,
+    layers: [
+      { type: "image" as const, path },
+      {
+        type: "title" as const,
+        text: name,
+        textColor: "#ffffff",
+        position: "bottom" as const,
+      },
+    ],
+    transition: { name: "fade", duration: 0.3 },
+  }));
+
+  await editly({
+    outPath: "output/workflow-character-grid.mp4",
+    width: 720,
+    height: 720,
+    fps: 30,
+    verbose: true,
+    clips,
+  });
+
+  console.log("\ndone! output/workflow-character-grid.mp4");
+}
+
+main().catch(console.error);

package/src/ai-sdk/examples/workflow-slideshow.ts

@@ -0,0 +1,161 @@
+import {
+  generateImage as _generateImage,
+  experimental_generateSpeech as generateSpeech,
+} from "ai";
+import {
+  generateVideo as _generateVideo,
+  editly,
+  elevenlabs,
+  fal,
+  fileCache,
+  withCache,
+} from "../index";
+
+const storage = fileCache({ dir: ".cache/ai" });
+const generateImage = withCache(_generateImage, { storage });
+const generateVideo = withCache(_generateVideo, { storage });
+
+const SCENES = [
+  "standing in a modern coffee shop, holding a latte",
+  "walking in a beautiful park with autumn leaves",
+  "sitting at a desk in a bright home office",
+  "cooking in a stylish modern kitchen",
+  "relaxing on a cozy couch with a book",
+  "standing on a rooftop with city skyline behind",
+];
+
+async function main() {
+  const characterBase =
+    "young professional woman, brown hair, warm smile, casual chic style";
+  const narration = `Let me take you through a day in my life. 
+Morning starts with my favorite coffee. 
+Then a refreshing walk in the park. 
+Time to get some work done. 
+Cooking something delicious for lunch. 
+Afternoon reading session. 
+And ending with this amazing view.`;
+
+  console.log("step 1: generating 6 scene images...");
+  const sceneImages = await Promise.all(
+    SCENES.map(async (scene, i) => {
+      console.log(`  generating scene ${i + 1}: ${scene.slice(0, 40)}...`);
+      const { images } = await generateImage({
+        model: fal.imageModel("flux-schnell"),
+        prompt: `${characterBase}, ${scene}, lifestyle photography`,
+        aspectRatio: "16:9",
+        n: 1,
+        cacheKey: ["slideshow", "scene", i],
+      });
+      const data = images[0]!.uint8Array;
+      await Bun.write(`output/workflow-scene-${i}.png`, data);
+      return `output/workflow-scene-${i}.png`;
+    }),
+  );
+  console.log("saved: output/workflow-scene-*.png");
+
+  console.log("\nstep 2: generating talking head image...");
+  const { images: talkingImages } = await generateImage({
+    model: fal.imageModel("flux-schnell"),
+    prompt: `${characterBase}, headshot, facing camera, talking, vlog style, clean background`,
+    aspectRatio: "1:1",
+    n: 1,
+    cacheKey: ["slideshow", "talking-head"],
+  });
+
+  const talkingImage = talkingImages[0]!.uint8Array;
+  await Bun.write("output/workflow-talking-head.png", talkingImage);
+
+  console.log("\nstep 3: generating voiceover...");
+  const { audio } = await generateSpeech({
+    model: elevenlabs.speechModel("turbo"),
+    text: narration,
+    voice: "bella",
+  });
+
+  const audioData = audio.uint8Array;
+  await Bun.write("output/workflow-slideshow-voice.mp3", audioData);
+
+  console.log("\nstep 4: animating talking head...");
+  const { video: talkingVideo } = await generateVideo({
+    model: fal.videoModel("wan-2.5"),
+    prompt: {
+      text: "woman talking naturally, subtle head movements, friendly expression",
+      images: [talkingImage],
+    },
+    duration: 5,
+    cacheKey: ["slideshow", "talking-video"],
+  });
+
+  await Bun.write("output/workflow-talking-head.mp4", talkingVideo.uint8Array);
+
+  console.log("\nstep 5: lip syncing talking head...");
+  const { video: syncedTalkingVideo } = await generateVideo({
+    model: fal.videoModel("sync-v2"),
+    prompt: {
+      video: talkingVideo.uint8Array,
+      audio: audioData,
+    },
+    cacheKey: ["slideshow", "synced-video"],
+  });
+
+  await Bun.write(
+    "output/workflow-talking-synced.mp4",
+    syncedTalkingVideo.uint8Array,
+  );
+
+  console.log("\nstep 6: generating captions...");
+  const transcription = fal.transcriptionModel("whisper");
+  const result = await transcription.doGenerate({
+    audio: audioData,
+    mediaType: "audio/mpeg",
+  });
+
+  const srtContent = result.segments
+    .map((seg, i) => {
+      const start = formatTime(seg.startSecond);
+      const end = formatTime(seg.endSecond);
+      return `${i + 1}\n${start} --> ${end}\n${seg.text.trim()}\n`;
+    })
+    .join("\n");
+
+  await Bun.write("output/workflow-slideshow.srt", srtContent);
+
+  console.log("\nstep 7: creating slideshow with pip...");
+  const clips = sceneImages.map((imagePath, i) => ({
+    duration: 2,
+    layers: [
+      { type: "image" as const, path: imagePath },
+      {
+        type: "video" as const,
+        path: "output/workflow-talking-synced.mp4",
+        width: 0.25,
+        height: 0.25,
+        left: 0.73,
+        top: 0.73,
+      },
+    ],
+    transition: { name: "fade", duration: 0.3 } as const,
+  }));
+
+  await editly({
+    outPath: "output/workflow-slideshow.mp4",
+    width: 1280,
+    height: 720,
+    fps: 30,
+    verbose: true,
+    audioFilePath: "output/workflow-slideshow-voice.mp3",
+    clips,
+  });
+
+  console.log("\ndone! output/workflow-slideshow.mp4");
+}
+
+function formatTime(seconds: number): string {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = Math.floor(seconds % 60);
+  const ms = Math.floor((seconds % 1) * 1000);
+  return `${h.toString().padStart(2, "0")}:${m.toString().padStart(2, "0")}:${s.toString().padStart(2, "0")},${ms.toString().padStart(3, "0")}`;
+}
+
+main().catch(console.error);

package/src/ai-sdk/file-cache.ts

@@ -0,0 +1,112 @@
+import type { CacheStorage } from "./cache";
+
+interface CacheEntry {
+  value: unknown;
+  expires: number;
+}
+
+function serialize(value: unknown): string {
+  return JSON.stringify(value, (_key, val) => {
+    if (val instanceof Uint8Array) {
+      return {
+        __type: "Uint8Array",
+        data: Buffer.from(val).toString("base64"),
+      };
+    }
+    return val;
+  });
+}
+
+function deserialize(json: string): unknown {
+  return JSON.parse(json, (_key, val) => {
+    if (val && typeof val === "object" && val.__type === "Uint8Array") {
+      return new Uint8Array(Buffer.from(val.data, "base64"));
+    }
+    return val;
+  });
+}
+
+/**
+ * File-based cache storage using Bun's file API.
+ * Persists cache entries to disk as JSON files.
+ *
+ * @example
+ * ```ts
+ * import { generateImage } from "ai";
+ * import { withCache, fileCache } from "./index";
+ *
+ * const storage = fileCache({ dir: ".cache/ai" });
+ * const generateImage_ = withCache(generateImage, { ttl: "24h", storage });
+ *
+ * const { images } = await generateImage_({
+ *   model: fal.imageModel("flux-schnell"),
+ *   prompt: "lion roaring",
+ *   cacheKey: ["lion", take],
+ * });
+ * ```
+ */
+export function fileCache(options: { dir: string }): CacheStorage {
+  const { dir } = options;
+
+  const ensureDir = async () => {
+    const file = Bun.file(dir);
+    if (!(await file.exists())) {
+      await Bun.write(`${dir}/.gitkeep`, "");
+    }
+  };
+
+  const keyToPath = (key: string): string => {
+    const safe = key.replace(/[^a-zA-Z0-9_-]/g, "_");
+    if (safe.length > 200) {
+      const hash = Bun.hash(key).toString(16);
+      return `${dir}/${safe.slice(0, 100)}_${hash}.json`;
+    }
+    return `${dir}/${safe}.json`;
+  };
+
+  return {
+    async get(key: string): Promise<unknown | undefined> {
+      try {
+        const path = keyToPath(key);
+        const file = Bun.file(path);
+
+        if (!(await file.exists())) {
+          return undefined;
+        }
+
+        const content = await file.text();
+        const entry = deserialize(content) as CacheEntry;
+
+        if (entry.expires && Date.now() > entry.expires) {
+          // expired, clean up
+          await Bun.write(path, "").catch(() => {});
+          return undefined;
+        }
+
+        return entry.value;
+      } catch {
+        return undefined;
+      }
+    },
+
+    async set(key: string, value: unknown, ttl?: number): Promise<void> {
+      await ensureDir();
+      const path = keyToPath(key);
+      const entry: CacheEntry = {
+        value,
+        expires: ttl ? Date.now() + ttl : 0,
+      };
+      await Bun.write(path, serialize(entry));
+    },
+
+    async delete(key: string): Promise<void> {
+      const path = keyToPath(key);
+      const file = Bun.file(path);
+      if (await file.exists()) {
+        // Bun doesn't have a direct delete, use unlink
+        const { unlink } = await import("node:fs/promises");
+        await unlink(path).catch(() => {});
+      }
+    },
+  };
+}