vargai 0.4.0-alpha67 → 0.4.0-alpha69

package/package.json

@@ -61,6 +61,7 @@
     "fluent-ffmpeg": "^2.1.3",
     "groq-sdk": "^0.36.0",
     "ink": "^6.5.1",
+    "p-limit": "^6.2.0",
     "p-map": "^7.0.4",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
@@ -70,7 +71,7 @@
     "zod": "^4.2.1"
   },
   "sideEffects": false,
-  "version": "0.4.0-alpha67",
+  "version": "0.4.0-alpha69",
   "exports": {
     ".": "./src/index.ts",
     "./ai": "./src/ai-sdk/index.ts",

package/src/ai-sdk/index.ts

@@ -101,8 +101,12 @@ export {
 } from "./providers/together";
 export {
   falStorage,
+  limitedRetryUpload,
   type R2StorageOptions,
+  type RetryOptions,
   r2Storage,
+  r2UploadLimiter,
+  retryR2Upload,
   type StorageProvider,
 } from "./storage";
 export type {

package/src/ai-sdk/storage/index.ts

@@ -1,3 +1,9 @@
 export { falStorage } from "./fal";
 export { type R2StorageOptions, r2Storage } from "./r2";
+export {
+  limitedRetryUpload,
+  type RetryOptions,
+  r2UploadLimiter,
+  retryR2Upload,
+} from "./retry";
 export type { StorageProvider } from "./types";

package/src/ai-sdk/storage/r2.ts

@@ -1,4 +1,5 @@
 import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { limitedRetryUpload } from "./retry";
 import type { StorageProvider } from "./types";
 
 export interface R2StorageOptions {
@@ -41,13 +42,15 @@ export function r2Storage(options?: R2StorageOptions): StorageProvider {
 
   return {
     async upload(data: Uint8Array, key: string, mediaType: string) {
-      await client.send(
-        new PutObjectCommand({
-          Bucket: bucket,
-          Key: key,
-          Body: data,
-          ContentType: mediaType,
-        }),
+      await limitedRetryUpload(() =>
+        client.send(
+          new PutObjectCommand({
+            Bucket: bucket,
+            Key: key,
+            Body: data,
+            ContentType: mediaType,
+          }),
+        ),
       );
       return getPublicUrl(key);
     },

package/src/ai-sdk/storage/retry.test.ts

@@ -0,0 +1,372 @@
+import { describe, expect, mock, test } from "bun:test";
+import { limitedRetryUpload, r2UploadLimiter, retryR2Upload } from "./retry";
+
+// Use minimal delays for tests
+const fastOpts = { maxRetries: 3, baseDelay: 1 };
+
+// ─── Error factories ─────────────────────────────────────────────────────────
+
+/** Simulates an AWS SDK v3 ServiceException with $metadata */
+function awsError(
+  name: string,
+  message: string,
+  httpStatusCode?: number,
+): Error & { $metadata?: { httpStatusCode: number } } {
+  const err = new Error(message) as Error & {
+    $metadata?: { httpStatusCode: number };
+  };
+  err.name = name;
+  if (httpStatusCode !== undefined) {
+    err.$metadata = { httpStatusCode };
+  }
+  return err;
+}
+
+/** Error with a `code` property (Node.js-style) */
+function codeError(
+  code: string,
+  message = "connection failed",
+): Error & { code: string } {
+  const err = new Error(message) as Error & { code: string };
+  err.code = code;
+  return err;
+}
+
+// ─── isRetryable (tested indirectly through retryR2Upload) ───────────────────
+
+describe("retryR2Upload", () => {
+  describe("retries on retryable errors", () => {
+    test("retries on error.message containing 'concurrent request rate'", async () => {
+      let calls = 0;
+      const result = await retryR2Upload(async () => {
+        calls++;
+        if (calls === 1)
+          throw new Error(
+            "Reduce your concurrent request rate for the same object.",
+          );
+        return "ok";
+      }, fastOpts);
+
+      expect(result).toBe("ok");
+      expect(calls).toBe(2);
+    });
+
+    test("retries on error.name = SlowDown (AWS SDK v3 pattern)", async () => {
+      let calls = 0;
+      const result = await retryR2Upload(async () => {
+        calls++;
+        if (calls === 1)
+          throw awsError("SlowDown", "Please reduce request rate.");
+        return "ok";
+      }, fastOpts);
+
+      expect(result).toBe("ok");
+      expect(calls).toBe(2);
+    });
+
+    test("retries on error.name = ServiceUnavailable", async () => {
+      let calls = 0;
+      const result = await retryR2Upload(async () => {
+        calls++;
+        if (calls === 1)
+          throw awsError(
+            "ServiceUnavailable",
+            "Service is temporarily unavailable",
+          );
+        return "ok";
+      }, fastOpts);
+
+      expect(result).toBe("ok");
+      expect(calls).toBe(2);
+    });
+
+    test("retries on $metadata.httpStatusCode = 429", async () => {
+      let calls = 0;
+      const result = await retryR2Upload(async () => {
+        calls++;
+        if (calls === 1) throw awsError("UnknownError", "rate limited", 429);
+        return "ok";
+      }, fastOpts);
+
+      expect(result).toBe("ok");
+      expect(calls).toBe(2);
+    });
+
+    test("retries on $metadata.httpStatusCode = 500", async () => {
+      let calls = 0;
+      const result = await retryR2Upload(async () => {
+        calls++;
+        if (calls === 1) throw awsError("InternalServerError", "oops", 500);
+        return "ok";
+      }, fastOpts);
+
+      expect(result).toBe("ok");
+      expect(calls).toBe(2);
+    });
+
+    test("retries on $metadata.httpStatusCode = 503", async () => {
+      let calls = 0;
+      const result = await retryR2Upload(async () => {
+        calls++;
+        if (calls === 1) throw awsError("Unavailable", "try again", 503);
+        return "ok";
+      }, fastOpts);
+
+      expect(result).toBe("ok");
+      expect(calls).toBe(2);
+    });
+
+    test("retries on error.code = ECONNRESET", async () => {
+      let calls = 0;
+      const result = await retryR2Upload(async () => {
+        calls++;
+        if (calls === 1) throw codeError("ECONNRESET");
+        return "ok";
+      }, fastOpts);
+
+      expect(result).toBe("ok");
+      expect(calls).toBe(2);
+    });
+
+    test("retries on error.code = ETIMEDOUT", async () => {
+      let calls = 0;
+      const result = await retryR2Upload(async () => {
+        calls++;
+        if (calls === 1) throw codeError("ETIMEDOUT");
+        return "ok";
+      }, fastOpts);
+
+      expect(result).toBe("ok");
+      expect(calls).toBe(2);
+    });
+
+    test("retries on 'socket hang up' in message", async () => {
+      let calls = 0;
+      const result = await retryR2Upload(async () => {
+        calls++;
+        if (calls === 1) throw new Error("socket hang up");
+        return "ok";
+      }, fastOpts);
+
+      expect(result).toBe("ok");
+      expect(calls).toBe(2);
+    });
+  });
+
+  describe("does NOT retry on non-retryable errors", () => {
+    test("throws immediately on AccessDenied", async () => {
+      let calls = 0;
+      await expect(
+        retryR2Upload(async () => {
+          calls++;
+          throw awsError("AccessDenied", "Access Denied", 403);
+        }, fastOpts),
+      ).rejects.toThrow("Access Denied");
+
+      expect(calls).toBe(1);
+    });
+
+    test("throws immediately on NoSuchBucket", async () => {
+      let calls = 0;
+      await expect(
+        retryR2Upload(async () => {
+          calls++;
+          throw awsError(
+            "NoSuchBucket",
+            "The specified bucket does not exist",
+            404,
+          );
+        }, fastOpts),
+      ).rejects.toThrow("The specified bucket does not exist");
+
+      expect(calls).toBe(1);
+    });
+
+    test("throws immediately on generic Error", async () => {
+      let calls = 0;
+      await expect(
+        retryR2Upload(async () => {
+          calls++;
+          throw new Error("something completely unrelated");
+        }, fastOpts),
+      ).rejects.toThrow("something completely unrelated");
+
+      expect(calls).toBe(1);
+    });
+
+    test("does not retry primitive/null errors", async () => {
+      let calls = 0;
+      await expect(
+        retryR2Upload(async () => {
+          calls++;
+          throw null;
+        }, fastOpts),
+      ).rejects.toBeNull();
+
+      expect(calls).toBe(1);
+    });
+  });
+
+  describe("retry limits and exhaustion", () => {
+    test("retries up to maxRetries times then throws", async () => {
+      let calls = 0;
+      await expect(
+        retryR2Upload(
+          async () => {
+            calls++;
+            throw new Error("SlowDown");
+          },
+          { maxRetries: 2, baseDelay: 1 },
+        ),
+      ).rejects.toThrow("SlowDown");
+
+      // 1 initial + 2 retries = 3 total calls
+      expect(calls).toBe(3);
+    });
+
+    test("maxRetries: 0 means no retries (single attempt)", async () => {
+      let calls = 0;
+      await expect(
+        retryR2Upload(
+          async () => {
+            calls++;
+            throw new Error("SlowDown");
+          },
+          { maxRetries: 0, baseDelay: 1 },
+        ),
+      ).rejects.toThrow("SlowDown");
+
+      expect(calls).toBe(1);
+    });
+
+    test("succeeds on the last retry attempt", async () => {
+      let calls = 0;
+      const result = await retryR2Upload(
+        async () => {
+          calls++;
+          if (calls <= 3) throw new Error("SlowDown");
+          return "finally";
+        },
+        { maxRetries: 3, baseDelay: 1 },
+      );
+
+      expect(result).toBe("finally");
+      expect(calls).toBe(4); // 1 initial + 3 retries
+    });
+  });
+
+  describe("returns value on success", () => {
+    test("returns value on first attempt", async () => {
+      const result = await retryR2Upload(async () => "immediate", fastOpts);
+      expect(result).toBe("immediate");
+    });
+
+    test("returns complex objects", async () => {
+      const obj = { url: "https://s3.varg.ai/test.mp4", key: "test.mp4" };
+      const result = await retryR2Upload(async () => obj, fastOpts);
+      expect(result).toEqual(obj);
+    });
+  });
+
+  describe("input validation", () => {
+    test("rejects negative maxRetries", async () => {
+      await expect(
+        retryR2Upload(async () => "ok", { maxRetries: -1, baseDelay: 1 }),
+      ).rejects.toThrow("maxRetries");
+    });
+
+    test("rejects NaN maxRetries", async () => {
+      await expect(
+        retryR2Upload(async () => "ok", { maxRetries: NaN, baseDelay: 1 }),
+      ).rejects.toThrow("maxRetries");
+    });
+
+    test("rejects float maxRetries", async () => {
+      await expect(
+        retryR2Upload(async () => "ok", { maxRetries: 2.5, baseDelay: 1 }),
+      ).rejects.toThrow("maxRetries");
+    });
+
+    test("rejects negative baseDelay", async () => {
+      await expect(
+        retryR2Upload(async () => "ok", { maxRetries: 1, baseDelay: -100 }),
+      ).rejects.toThrow("baseDelay");
+    });
+
+    test("rejects Infinity baseDelay", async () => {
+      await expect(
+        retryR2Upload(async () => "ok", {
+          maxRetries: 1,
+          baseDelay: Number.POSITIVE_INFINITY,
+        }),
+      ).rejects.toThrow("baseDelay");
+    });
+
+    test("accepts zero baseDelay", async () => {
+      const result = await retryR2Upload(async () => "ok", {
+        maxRetries: 0,
+        baseDelay: 0,
+      });
+      expect(result).toBe("ok");
+    });
+  });
+});
+
+// ─── limitedRetryUpload ──────────────────────────────────────────────────────
+
+describe("limitedRetryUpload", () => {
+  test("runs upload through concurrency limiter and retry", async () => {
+    const result = await limitedRetryUpload(async () => "uploaded");
+    expect(result).toBe("uploaded");
+  });
+
+  test("retries within the limiter on retryable errors", async () => {
+    let calls = 0;
+    const result = await limitedRetryUpload(
+      async () => {
+        calls++;
+        if (calls === 1) throw new Error("SlowDown");
+        return "ok";
+      },
+      { maxRetries: 2, baseDelay: 1 },
+    );
+
+    expect(result).toBe("ok");
+    expect(calls).toBe(2);
+  });
+
+  test("respects concurrency limit", async () => {
+    let concurrent = 0;
+    let maxConcurrent = 0;
+
+    const tasks = Array.from({ length: 20 }, () =>
+      limitedRetryUpload(
+        async () => {
+          concurrent++;
+          maxConcurrent = Math.max(maxConcurrent, concurrent);
+          await new Promise((r) => setTimeout(r, 10));
+          concurrent--;
+          return "done";
+        },
+        { maxRetries: 0, baseDelay: 0 },
+      ),
+    );
+
+    await Promise.all(tasks);
+
+    // r2UploadLimiter is set to 10
+    expect(maxConcurrent).toBeLessThanOrEqual(10);
+    expect(maxConcurrent).toBeGreaterThan(1); // should actually parallelize
+  });
+});
+
+// ─── r2UploadLimiter ─────────────────────────────────────────────────────────
+
+describe("r2UploadLimiter", () => {
+  test("is a p-limit instance with concurrency 10", () => {
+    // p-limit exposes activeCount and pendingCount
+    expect(typeof r2UploadLimiter).toBe("function");
+    expect(r2UploadLimiter.activeCount).toBe(0);
+    expect(r2UploadLimiter.pendingCount).toBe(0);
+  });
+});

package/src/ai-sdk/storage/retry.ts

@@ -0,0 +1,111 @@
+import pLimit from "p-limit";
+
+/**
+ * Global concurrency limiter for R2/S3 uploads.
+ * Caps concurrent uploads to avoid Cloudflare R2 rate limits
+ * ("Reduce your concurrent request rate for the same object").
+ */
+export const r2UploadLimiter = pLimit(10);
+
+/** Errors that indicate R2/S3 rate limiting or transient failures worth retrying */
+const RETRYABLE_PATTERNS = [
+  "concurrent request rate",
+  "SlowDown",
+  "ServiceUnavailable",
+  "TooManyRequests",
+  "RequestTimeout",
+  "InternalError",
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "socket hang up",
+];
+
+/** HTTP status codes that indicate a retryable error */
+const RETRYABLE_STATUS_CODES = new Set([429, 500, 503]);
+
+function isRetryable(error: unknown): boolean {
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+
+  const err = error as {
+    message?: string;
+    name?: string;
+    code?: string;
+    $metadata?: { httpStatusCode?: number };
+  };
+
+  // Check AWS SDK v3 $metadata.httpStatusCode
+  const statusCode = err.$metadata?.httpStatusCode;
+  if (statusCode !== undefined && RETRYABLE_STATUS_CODES.has(statusCode)) {
+    return true;
+  }
+
+  // Check error.name, error.code, and error.message against known patterns
+  const haystack = [err.message, err.name, err.code].filter(Boolean).join(" ");
+  return RETRYABLE_PATTERNS.some((pattern) => haystack.includes(pattern));
+}
+
+export interface RetryOptions {
+  /** Maximum number of retries after the initial attempt (default: 5) */
+  maxRetries?: number;
+  /** Initial backoff delay in ms (default: 500) */
+  baseDelay?: number;
+}
+
+/**
+ * Retry an R2/S3 upload with exponential backoff + jitter.
+ * Only retries on known transient/rate-limit errors.
+ *
+ * Backoff schedule (default): 500ms, 1s, 2s, 4s, 8s (+ random jitter up to 30%)
+ */
+export async function retryR2Upload<T>(
+  fn: () => Promise<T>,
+  opts?: RetryOptions,
+): Promise<T> {
+  const maxRetries = opts?.maxRetries ?? 5;
+  const baseDelay = opts?.baseDelay ?? 500;
+
+  if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+    throw new Error("retry option `maxRetries` must be a non-negative integer");
+  }
+  if (!Number.isFinite(baseDelay) || baseDelay < 0) {
+    throw new Error("retry option `baseDelay` must be a non-negative number");
+  }
+
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+
+      if (attempt >= maxRetries || !isRetryable(error)) {
+        throw error;
+      }
+
+      const delay = baseDelay * 2 ** attempt;
+      const jitter = delay * 0.3 * Math.random();
+      const totalDelay = Math.round(delay + jitter);
+
+      console.warn(
+        `[r2-upload] attempt ${attempt + 1}/${maxRetries + 1} failed, retrying in ${totalDelay}ms: ${error instanceof Error ? error.message : String(error)}`,
+      );
+
+      await new Promise((resolve) => setTimeout(resolve, totalDelay));
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Convenience: run an R2 upload through both the concurrency limiter and retry logic.
+ */
+export function limitedRetryUpload<T>(
+  fn: () => Promise<T>,
+  opts?: RetryOptions,
+): Promise<T> {
+  return r2UploadLimiter(() => retryR2Upload(fn, opts));
+}

package/src/providers/storage.ts

@@ -8,6 +8,7 @@ import {
   S3Client,
 } from "@aws-sdk/client-s3";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { limitedRetryUpload } from "../ai-sdk/storage/retry";
 import type { JobStatusUpdate, ProviderConfig } from "../core/schema/types";
 import { BaseProvider } from "./base";
 
@@ -73,12 +74,14 @@ export class StorageProvider extends BaseProvider {
     const file = Bun.file(filePath);
     const buffer = await file.arrayBuffer();
 
-    await this.client.send(
-      new PutObjectCommand({
-        Bucket: this.bucket,
-        Key: objectKey,
-        Body: new Uint8Array(buffer),
-      }),
+    await limitedRetryUpload(() =>
+      this.client.send(
+        new PutObjectCommand({
+          Bucket: this.bucket,
+          Key: objectKey,
+          Body: new Uint8Array(buffer),
+        }),
+      ),
     );
 
     return this.getPublicUrl(objectKey);
@@ -93,12 +96,14 @@ export class StorageProvider extends BaseProvider {
     const response = await fetch(url);
     const buffer = await response.arrayBuffer();
 
-    await this.client.send(
-      new PutObjectCommand({
-        Bucket: this.bucket,
-        Key: objectKey,
-        Body: new Uint8Array(buffer),
-      }),
+    await limitedRetryUpload(() =>
+      this.client.send(
+        new PutObjectCommand({
+          Bucket: this.bucket,
+          Key: objectKey,
+          Body: new Uint8Array(buffer),
+        }),
+      ),
     );
 
     return this.getPublicUrl(objectKey);
@@ -114,13 +119,15 @@ export class StorageProvider extends BaseProvider {
   ): Promise<string> {
     console.log(`[storage] uploading buffer to ${objectKey}`);
 
-    await this.client.send(
-      new PutObjectCommand({
-        Bucket: this.bucket,
-        Key: objectKey,
-        Body: buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer),
-        ContentType: contentType,
-      }),
+    await limitedRetryUpload(() =>
+      this.client.send(
+        new PutObjectCommand({
+          Bucket: this.bucket,
+          Key: objectKey,
+          Body: buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer),
+          ContentType: contentType,
+        }),
+      ),
     );
 
     return this.getPublicUrl(objectKey);

package/src/react/renderers/image.ts

@@ -22,7 +22,20 @@ async function resolveImageInput(
     return new Uint8Array(await response.arrayBuffer());
   }
   const file = await renderImage(input, ctx);
-  return file.arrayBuffer();
+  const data = await file.arrayBuffer();
+  // Debug: ensure we always return a proper Uint8Array
+  if (!(data instanceof Uint8Array)) {
+    console.error(
+      `[resolveImageInput] file.arrayBuffer() returned ${typeof data} (constructor: ${data?.constructor?.name}), converting...`,
+    );
+    if (data instanceof ArrayBuffer) {
+      return new Uint8Array(data);
+    }
+    throw new Error(
+      `resolveImageInput: unexpected data type ${typeof data} from file.arrayBuffer()`,
+    );
+  }
+  return data;
 }
 
 async function resolvePrompt(
@@ -35,6 +48,15 @@ async function resolvePrompt(
   const resolvedImages = await Promise.all(
     prompt.images.map((img) => resolveImageInput(img, ctx)),
   );
+  // Debug: verify all images are Uint8Array before passing to generateImage
+  for (let i = 0; i < resolvedImages.length; i++) {
+    const img = resolvedImages[i];
+    if (!(img instanceof Uint8Array)) {
+      console.error(
+        `[resolvePrompt] images[${i}] is ${typeof img} (constructor: ${(img as any)?.constructor?.name}), not Uint8Array`,
+      );
+    }
+  }
   return { text: prompt.text, images: resolvedImages };
 }
 

package/src/react/renderers/render.ts

@@ -290,9 +290,7 @@ export async function renderRoot(
   }
 
   const concurrency =
-    options.concurrency === undefined
-      ? Number.POSITIVE_INFINITY
-      : options.concurrency;
+    options.concurrency === undefined ? 3 : options.concurrency;
 
   if (
     concurrency !== Number.POSITIVE_INFINITY &&

package/src/react/types.ts

@@ -285,7 +285,7 @@ export interface RenderOptions {
   defaults?: DefaultModels;
   backend?: FFmpegBackend;
   storage?: StorageProvider;
-  /** Max concurrent clip renders. Defaults to unlimited. */
+  /** Max concurrent clip renders. Defaults to 3. */
   concurrency?: number;
 }