vargai 0.4.0-alpha46 → 0.4.0-alpha48

package/package.json

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

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

@@ -12,6 +12,7 @@ import {
 } from "@ai-sdk/provider";
 import { fal } from "@fal-ai/client";
 import pMap from "p-map";
+import type { CacheStorage } from "../cache";
 import { fileCache } from "../file-cache";
 import type { VideoModelV3, VideoModelV3CallOptions } from "../video-model";
 
@@ -21,7 +22,72 @@ interface PendingRequest {
   submitted_at: number;
 }
 
-const pendingStorage = fileCache({ dir: ".cache/fal-pending" });
+const memoryStorage = new Map<string, { value: unknown; expires: number }>();
+
+function createMemoryCache(): CacheStorage {
+  return {
+    async get(key: string) {
+      const entry = memoryStorage.get(key);
+      if (!entry) return undefined;
+      if (entry.expires && Date.now() > entry.expires) {
+        memoryStorage.delete(key);
+        return undefined;
+      }
+      return entry.value;
+    },
+    async set(key: string, value: unknown, ttl?: number) {
+      memoryStorage.set(key, { value, expires: ttl ? Date.now() + ttl : 0 });
+    },
+    async delete(key: string) {
+      memoryStorage.delete(key);
+    },
+  };
+}
+
+// TODO: allow passing CacheStorage via providerOptions.fal.cacheStorage for proper serverless support
+function createFalCache(name: string): CacheStorage {
+  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");
 
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
 const FAL_TIMEOUT_MS = (() => {
@@ -183,7 +249,7 @@ function detectImageType(bytes: Uint8Array): string | undefined {
   return undefined;
 }
 
-const uploadCache = fileCache({ dir: ".cache/fal-uploads" });
+const uploadCache = createFalCache("fal-uploads");
 
 async function fileToUrl(file: ImageModelV3File): Promise<string> {
   if (file.type === "url") return file.url;