vargai 0.4.0-alpha39 → 0.4.0-alpha40

package/package.json

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

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

@@ -0,0 +1,214 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, rmSync } from "node:fs";
+import { computeFileHashes, computePendingKey } from "./fal";
+
+const TEST_PENDING_DIR = ".cache/fal-pending-test";
+
+describe("fal queue recovery", () => {
+  beforeEach(() => {
+    if (existsSync(TEST_PENDING_DIR)) {
+      rmSync(TEST_PENDING_DIR, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_PENDING_DIR)) {
+      rmSync(TEST_PENDING_DIR, { recursive: true });
+    }
+  });
+
+  describe("computePendingKey", () => {
+    test("produces same key for same endpoint and input", () => {
+      const endpoint = "fal-ai/flux-schnell";
+      const input = { prompt: "a cat", num_images: 1 };
+
+      const key1 = computePendingKey(endpoint, input);
+      const key2 = computePendingKey(endpoint, input);
+
+      expect(key1).toBe(key2);
+      expect(key1).toMatch(/^pending_[a-f0-9]+$/);
+    });
+
+    test("produces different keys for different inputs", () => {
+      const endpoint = "fal-ai/flux-schnell";
+
+      const key1 = computePendingKey(endpoint, { prompt: "a cat" });
+      const key2 = computePendingKey(endpoint, { prompt: "a dog" });
+
+      expect(key1).not.toBe(key2);
+    });
+
+    test("uses stableKey when provided", () => {
+      const endpoint = "fal-ai/flux-schnell";
+      const input1 = { prompt: "test", image_urls: ["https://fal.media/abc"] };
+      const input2 = { prompt: "test", image_urls: ["https://fal.media/xyz"] };
+      const stableKey = "stable-key-from-file-hashes";
+
+      const key1 = computePendingKey(endpoint, input1, stableKey);
+      const key2 = computePendingKey(endpoint, input2, stableKey);
+
+      expect(key1).toBe(key2);
+    });
+
+    test("without stableKey, different image_urls produce different keys", () => {
+      const endpoint = "fal-ai/flux-schnell";
+      const input1 = { prompt: "test", image_urls: ["https://fal.media/abc"] };
+      const input2 = { prompt: "test", image_urls: ["https://fal.media/xyz"] };
+
+      const key1 = computePendingKey(endpoint, input1);
+      const key2 = computePendingKey(endpoint, input2);
+
+      expect(key1).not.toBe(key2);
+    });
+  });
+
+  describe("computeFileHashes", () => {
+    test("returns empty array for undefined files", async () => {
+      const hashes = await computeFileHashes(undefined);
+      expect(hashes).toEqual([]);
+    });
+
+    test("returns empty array for empty files", async () => {
+      const hashes = await computeFileHashes([]);
+      expect(hashes).toEqual([]);
+    });
+
+    test("returns URL as-is for url type files", async () => {
+      const files = [
+        { type: "url" as const, url: "https://example.com/image.png" },
+      ];
+      const hashes = await computeFileHashes(files);
+      expect(hashes).toEqual(["https://example.com/image.png"]);
+    });
+
+    test("produces stable hash for same file bytes", async () => {
+      const bytes = new Uint8Array([1, 2, 3, 4, 5]);
+      const files = [
+        { type: "file" as const, data: bytes, mediaType: "image/png" },
+      ];
+
+      const hashes1 = await computeFileHashes(files);
+      const hashes2 = await computeFileHashes(files);
+
+      expect(hashes1).toEqual(hashes2);
+      expect(hashes1[0]).toMatch(/^[a-f0-9]+$/);
+    });
+
+    test("produces different hashes for different bytes", async () => {
+      const files1 = [
+        {
+          type: "file" as const,
+          data: new Uint8Array([1, 2, 3]),
+          mediaType: "image/png",
+        },
+      ];
+      const files2 = [
+        {
+          type: "file" as const,
+          data: new Uint8Array([4, 5, 6]),
+          mediaType: "image/png",
+        },
+      ];
+
+      const hashes1 = await computeFileHashes(files1);
+      const hashes2 = await computeFileHashes(files2);
+
+      expect(hashes1[0]).not.toBe(hashes2[0]);
+    });
+
+    test("handles base64 encoded data", async () => {
+      const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+      const base64 = btoa(String.fromCharCode(...bytes));
+      const files = [
+        { type: "file" as const, data: base64, mediaType: "image/png" },
+      ];
+
+      const hashes = await computeFileHashes(files);
+      expect(hashes[0]).toMatch(/^[a-f0-9]+$/);
+    });
+
+    test("same bytes as Uint8Array and base64 produce same hash", async () => {
+      const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+      const base64 = btoa(String.fromCharCode(...bytes));
+
+      const filesBytes = [
+        { type: "file" as const, data: bytes, mediaType: "image/png" },
+      ];
+      const filesBase64 = [
+        { type: "file" as const, data: base64, mediaType: "image/png" },
+      ];
+
+      const hashesBytes = await computeFileHashes(filesBytes);
+      const hashesBase64 = await computeFileHashes(filesBase64);
+
+      expect(hashesBytes[0]).toBe(hashesBase64[0]);
+    });
+  });
+
+  describe("stable key integration", () => {
+    test("same file bytes produce same stable key across runs", async () => {
+      const endpoint = "fal-ai/nano-banana-pro/edit";
+      const bytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+      const files = [
+        { type: "file" as const, data: bytes, mediaType: "image/png" },
+      ];
+
+      const fileHashes = await computeFileHashes(files);
+      const input = { prompt: "test prompt", num_images: 1 };
+      const stableKey = JSON.stringify({ endpoint, input, fileHashes });
+
+      const inputWithUrl1 = {
+        ...input,
+        image_urls: ["https://fal.media/upload1"],
+      };
+      const inputWithUrl2 = {
+        ...input,
+        image_urls: ["https://fal.media/upload2"],
+      };
+
+      const key1 = computePendingKey(endpoint, inputWithUrl1, stableKey);
+      const key2 = computePendingKey(endpoint, inputWithUrl2, stableKey);
+
+      expect(key1).toBe(key2);
+    });
+
+    test("different file bytes produce different stable keys", async () => {
+      const endpoint = "fal-ai/nano-banana-pro/edit";
+      const input = { prompt: "test prompt", num_images: 1 };
+
+      const files1 = [
+        {
+          type: "file" as const,
+          data: new Uint8Array([1, 2, 3]),
+          mediaType: "image/png",
+        },
+      ];
+      const files2 = [
+        {
+          type: "file" as const,
+          data: new Uint8Array([4, 5, 6]),
+          mediaType: "image/png",
+        },
+      ];
+
+      const hashes1 = await computeFileHashes(files1);
+      const hashes2 = await computeFileHashes(files2);
+
+      const stableKey1 = JSON.stringify({
+        endpoint,
+        input,
+        fileHashes: hashes1,
+      });
+      const stableKey2 = JSON.stringify({
+        endpoint,
+        input,
+        fileHashes: hashes2,
+      });
+
+      const key1 = computePendingKey(endpoint, input, stableKey1);
+      const key2 = computePendingKey(endpoint, input, stableKey2);
+
+      expect(key1).not.toBe(key2);
+    });
+  });
+});

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

@@ -11,8 +11,22 @@ import {
   type TranscriptionModelV3CallOptions,
 } from "@ai-sdk/provider";
 import { fal } from "@fal-ai/client";
+import { fileCache } from "../file-cache";
 import type { VideoModelV3, VideoModelV3CallOptions } from "../video-model";
 
+interface PendingRequest {
+  request_id: string;
+  endpoint: string;
+  submitted_at: number;
+}
+
+const pendingStorage = fileCache({ dir: ".cache/fal-pending" });
+
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+const FAL_TIMEOUT_MS = process.env.FAL_TIMEOUT_MS
+  ? Number.parseInt(process.env.FAL_TIMEOUT_MS, 10)
+  : DEFAULT_TIMEOUT_MS;
+
 const VIDEO_MODELS: Record<string, { t2v: string; i2v: string }> = {
   // Kling v2.6 - latest with native audio generation
   "kling-v2.6": {
@@ -182,6 +196,143 @@ async function uploadBuffer(buffer: ArrayBuffer): Promise<string> {
   return fal.storage.upload(new Blob([buffer]));
 }
 
+export function computePendingKey(
+  endpoint: string,
+  input: Record<string, unknown>,
+  stableKey?: string,
+): string {
+  const keyData = stableKey ?? JSON.stringify({ endpoint, input });
+  const hash = Bun.hash(keyData).toString(16);
+  return `pending_${hash}`;
+}
+
+export async function computeFileHashes(
+  files: ImageModelV3File[] | undefined,
+): Promise<string[]> {
+  if (!files || files.length === 0) return [];
+  return Promise.all(
+    files.map(async (f) => {
+      if (f.type === "url") return f.url;
+      const bytes =
+        typeof f.data === "string"
+          ? Uint8Array.from(atob(f.data), (c) => c.charCodeAt(0))
+          : f.data;
+      return Bun.hash(bytes).toString(16);
+    }),
+  );
+}
+
+async function executeWithQueueRecovery<T>(
+  endpoint: string,
+  input: Record<string, unknown>,
+  options: {
+    logs?: boolean;
+    onQueueUpdate?: (status: { status: string }) => void;
+    stableKey?: string;
+  } = {},
+): Promise<T> {
+  const { logs = true, onQueueUpdate, stableKey } = options;
+  const pendingKey = computePendingKey(endpoint, input, stableKey);
+
+  const pending = (await pendingStorage.get(pendingKey)) as
+    | PendingRequest
+    | undefined;
+
+  if (pending) {
+    try {
+      const status = await fal.queue.status(pending.endpoint, {
+        requestId: pending.request_id,
+        logs,
+      });
+
+      if (status.status === "COMPLETED") {
+        console.log(
+          `\x1b[32m⚡ recovered completed job from queue (${pending.request_id.slice(0, 8)}...)\x1b[0m`,
+        );
+        const result = await fal.queue.result(pending.endpoint, {
+          requestId: pending.request_id,
+        });
+        await pendingStorage.delete(pendingKey);
+        return result as T;
+      }
+
+      if (status.status === "IN_QUEUE" || status.status === "IN_PROGRESS") {
+        console.log(
+          `\x1b[33m⏳ resuming pending job (${pending.request_id.slice(0, 8)}...) - status: ${status.status}\x1b[0m`,
+        );
+        await fal.queue.subscribeToStatus(pending.endpoint, {
+          requestId: pending.request_id,
+          logs,
+          timeout: FAL_TIMEOUT_MS,
+          onQueueUpdate,
+        });
+        const result = await fal.queue.result(pending.endpoint, {
+          requestId: pending.request_id,
+        });
+        await pendingStorage.delete(pendingKey);
+        return result as T;
+      }
+
+      await pendingStorage.delete(pendingKey);
+    } catch (error) {
+      const isNotFound =
+        error instanceof Error &&
+        (error.message.includes("not found") ||
+          error.message.includes("404") ||
+          error.message.includes("does not exist"));
+
+      if (isNotFound) {
+        console.log(
+          `\x1b[33m⚠ pending job expired or not found, submitting new request\x1b[0m`,
+        );
+        await pendingStorage.delete(pendingKey);
+      } else {
+        console.log(
+          `\x1b[33m⚠ pending job check failed (${error instanceof Error ? error.message : "unknown"}), keeping for retry\x1b[0m`,
+        );
+        throw error;
+      }
+    }
+  }
+
+  const { request_id } = await fal.queue.submit(endpoint, { input });
+
+  await pendingStorage.set(
+    pendingKey,
+    {
+      request_id,
+      endpoint,
+      submitted_at: Date.now(),
+    } satisfies PendingRequest,
+    24 * 60 * 60 * 1000,
+  );
+
+  console.log(
+    `\x1b[36m📋 queued job ${request_id.slice(0, 8)}... (recoverable on timeout)\x1b[0m`,
+  );
+
+  try {
+    await fal.queue.subscribeToStatus(endpoint, {
+      requestId: request_id,
+      logs,
+      timeout: FAL_TIMEOUT_MS,
+      onQueueUpdate,
+    });
+
+    const result = await fal.queue.result(endpoint, {
+      requestId: request_id,
+    });
+
+    await pendingStorage.delete(pendingKey);
+    return result as T;
+  } catch (error) {
+    console.log(
+      `\x1b[33m⚠ job ${request_id.slice(0, 8)}... saved for recovery on next run\x1b[0m`,
+    );
+    throw error;
+  }
+}
+
 class FalVideoModel implements VideoModelV3 {
   readonly specificationVersion = "v3" as const;
   readonly provider = "fal";
@@ -220,6 +371,8 @@ class FalVideoModel implements VideoModelV3 {
     const isLtx2 = this.modelId === "ltx-2-19b-distilled";
     const isGrokImagine = this.modelId === "grok-imagine";
 
+    const fileHashes = await computeFileHashes(files as ImageModelV3File[]);
+
     const endpoint = isLipsync
       ? this.resolveLipsyncEndpoint()
       : isMotionControl
@@ -402,10 +555,24 @@ class FalVideoModel implements VideoModelV3 {
       }
     }
 
-    const result = await fal.subscribe(endpoint, {
+    const stableKey =
+      fileHashes.length > 0
+        ? JSON.stringify({
+            endpoint,
+            prompt,
+            duration,
+            aspectRatio,
+            providerOptions,
+            modelId: this.modelId,
+            fileHashes,
+          })
+        : undefined;
+
+    const result = await executeWithQueueRecovery<{ data: unknown }>(
+      endpoint,
       input,
-      logs: true,
-    });
+      { logs: true, stableKey },
+    );
 
     const data = result.data as { video?: { url?: string } };
     const videoUrl = data?.video?.url;
@@ -563,11 +730,25 @@ class FalImageModel implements ImageModelV3 {
     }
 
     const hasFiles = files && files.length > 0;
-    if (hasFiles) {
+    const finalEndpoint = this.resolveEndpoint();
+
+    let stableKey: string | undefined;
+    if (hasFiles && files) {
+      const fileHashes = await computeFileHashes(files);
+      stableKey = JSON.stringify({
+        endpoint: finalEndpoint,
+        prompt,
+        n,
+        size,
+        aspectRatio,
+        seed,
+        providerOptions,
+        modelId: this.modelId,
+        fileHashes,
+      });
       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");
     }
@@ -581,12 +762,11 @@ class FalImageModel implements ImageModelV3 {
       }
     }
 
-    const finalEndpoint = this.resolveEndpoint();
-
-    const result = await fal.subscribe(finalEndpoint, {
+    const result = await executeWithQueueRecovery<{ data: unknown }>(
+      finalEndpoint,
       input,
-      logs: true,
-    });
+      { logs: true, stableKey },
+    );
 
     const data = result.data as { images?: Array<{ url?: string }> };
     const images = data?.images ?? [];