climage 0.5.3 → 0.6.1

package/dist/index.js

@@ -1220,9 +1220,138 @@ var openaiProvider = {
   }
 };
 
+// src/providers/vercel.ts
+import {
+  experimental_generateVideo as sdkGenerateVideo,
+  generateImage as sdkGenerateImage,
+  createGateway
+} from "ai";
+function getGatewayApiKey(env) {
+  return env.AI_GATEWAY_API_KEY;
+}
+var verboseMode4 = false;
+function log5(...args) {
+  if (verboseMode4) console.error("[vercel]", ...args);
+}
+function makeGateway(apiKey) {
+  return createGateway({ apiKey });
+}
+function dataUriToUint8Array(dataUri) {
+  const commaIdx = dataUri.indexOf(",");
+  const b64 = dataUri.slice(commaIdx + 1);
+  return Uint8Array.from(Buffer.from(b64, "base64"));
+}
+var DEFAULT_VIDEO_MODEL2 = "xai/grok-imagine-video";
+var DEFAULT_IMAGE_MODEL2 = "xai/grok-imagine-image";
+async function generateVercelVideo(req, apiKey) {
+  const gw = makeGateway(apiKey);
+  const model = req.model ?? DEFAULT_VIDEO_MODEL2;
+  log5("Starting video generation, model:", model);
+  const imageInput = req.startFrame ?? req.inputImages?.[0];
+  let prompt;
+  if (imageInput) {
+    const imageData = imageInput.startsWith("data:") ? dataUriToUint8Array(imageInput) : imageInput;
+    prompt = { image: imageData, text: req.prompt };
+    log5("Using image-to-video mode");
+  } else {
+    prompt = req.prompt;
+  }
+  log5("Calling experimental_generateVideo...");
+  const startTime = Date.now();
+  const result = await sdkGenerateVideo({
+    model: gw.video(model),
+    prompt,
+    ...req.aspectRatio ? { aspectRatio: req.aspectRatio } : {},
+    ...req.duration !== void 0 ? { duration: req.duration } : {},
+    n: req.n
+  });
+  log5(`Video generation completed in ${Date.now() - startTime}ms`);
+  const videos = result.videos ?? (result.video ? [result.video] : []);
+  log5(`Got ${videos.length} video(s)`);
+  if (!videos.length) {
+    throw new Error("Vercel AI Gateway returned no videos");
+  }
+  return videos.map((v, i) => ({
+    kind: "video",
+    provider: "vercel",
+    model,
+    index: i,
+    bytes: v.uint8Array,
+    mimeType: "video/mp4"
+  }));
+}
+async function generateVercelImage(req, apiKey) {
+  const gw = makeGateway(apiKey);
+  const model = req.model ?? DEFAULT_IMAGE_MODEL2;
+  log5("Starting image generation, model:", model);
+  const hasInputImages = req.inputImages && req.inputImages.length > 0;
+  let prompt;
+  if (hasInputImages) {
+    const images2 = req.inputImages.map(
+      (img) => img.startsWith("data:") ? dataUriToUint8Array(img) : Uint8Array.from(Buffer.from(img))
+    );
+    prompt = { images: images2, text: req.prompt };
+    log5("Using image editing mode with", images2.length, "input image(s)");
+  } else {
+    prompt = req.prompt;
+  }
+  log5("Calling generateImage...");
+  const startTime = Date.now();
+  const result = await sdkGenerateImage({
+    model: gw.image(model),
+    prompt,
+    ...req.aspectRatio ? { aspectRatio: req.aspectRatio } : {},
+    n: req.n
+  });
+  log5(`Image generation completed in ${Date.now() - startTime}ms`);
+  const images = result.images ?? (result.image ? [result.image] : []);
+  log5(`Got ${images.length} image(s)`);
+  if (!images.length) {
+    throw new Error("Vercel AI Gateway returned no images");
+  }
+  return images.map((img, i) => ({
+    kind: "image",
+    provider: "vercel",
+    model,
+    index: i,
+    bytes: img.uint8Array,
+    mimeType: "image/png"
+  }));
+}
+var vercelCapabilities = {
+  maxInputImages: 1,
+  supportsCustomAspectRatio: true,
+  supportsVideoInterpolation: false,
+  videoDurationRange: [1, 15],
+  supportsImageEditing: true
+};
+var vercelProvider = {
+  id: "vercel",
+  displayName: "Vercel AI Gateway",
+  supports: ["video", "image"],
+  capabilities: vercelCapabilities,
+  isAvailable(env) {
+    return Boolean(getGatewayApiKey(env));
+  },
+  async generate(req, env) {
+    const apiKey = getGatewayApiKey(env);
+    if (!apiKey) throw new Error("Missing AI Gateway API key. Set AI_GATEWAY_API_KEY.");
+    verboseMode4 = req.verbose;
+    log5("Provider initialized, kind:", req.kind);
+    if (req.kind === "video") return generateVercelVideo(req, apiKey);
+    return generateVercelImage(req, apiKey);
+  }
+};
+
 // src/core/router.ts
-var providers = [googleProvider, xaiProvider, falProvider, openaiProvider];
-function log5(verbose, ...args) {
+var providers = [
+  googleProvider,
+  xaiProvider,
+  falProvider,
+  openaiProvider,
+  vercelProvider
+];
+function log6(verbose, ...args) {
   if (verbose) console.error("[router]", ...args);
 }
 function listProviders() {
@@ -1255,18 +1384,18 @@ async function normalizeOptions(prompt, opts, verbose) {
   const nameBase = slugify(opts.name ?? prompt);
   let inputImages;
   if (opts.inputImages?.length) {
-    log5(verbose, `Resolving ${opts.inputImages.length} input image(s)...`);
+    log6(verbose, `Resolving ${opts.inputImages.length} input image(s)...`);
     inputImages = await resolveImageInputs(opts.inputImages);
-    log5(verbose, `Resolved input images`);
+    log6(verbose, `Resolved input images`);
   }
   let startFrame;
   let endFrame;
   if (opts.startFrame) {
-    log5(verbose, `Resolving start frame: ${opts.startFrame}`);
+    log6(verbose, `Resolving start frame: ${opts.startFrame}`);
     startFrame = await resolveImageInput(opts.startFrame);
   }
   if (opts.endFrame) {
-    log5(verbose, `Resolving end frame: ${opts.endFrame}`);
+    log6(verbose, `Resolving end frame: ${opts.endFrame}`);
     endFrame = await resolveImageInput(opts.endFrame);
   }
   return {
@@ -1342,27 +1471,27 @@ async function generateMedia(prompt, opts = {}) {
     startFrame: req.startFrame?.startsWith("data:") ? `data:...${req.startFrame.length} chars` : req.startFrame,
     endFrame: req.endFrame?.startsWith("data:") ? `data:...${req.endFrame.length} chars` : req.endFrame
   };
-  log5(verbose, "Request:", JSON.stringify(reqSummary));
+  log6(verbose, "Request:", JSON.stringify(reqSummary));
   const provider = pickProvider(req.provider, env);
-  log5(verbose, "Selected provider:", provider.id, "| supports:", provider.supports);
+  log6(verbose, "Selected provider:", provider.id, "| supports:", provider.supports);
   if (!provider.supports.includes(req.kind)) {
     throw new Error(`Provider ${provider.id} does not support ${req.kind} generation`);
   }
   validateRequestForProvider(req, provider);
-  log5(verbose, "Calling provider.generate()...");
+  log6(verbose, "Calling provider.generate()...");
   const startTime = Date.now();
   const partials = await provider.generate(req, env);
-  log5(verbose, `Provider returned ${partials.length} items in ${Date.now() - startTime}ms`);
+  log6(verbose, `Provider returned ${partials.length} items in ${Date.now() - startTime}ms`);
   const items = [];
   for (let i = 0; i < partials.length; i++) {
     const p = partials[i];
     if (!p) continue;
     const filePath = makeOutputPath(req, i, p.mimeType);
-    log5(verbose, `Writing ${p.bytes.byteLength} bytes to: ${filePath}`);
+    log6(verbose, `Writing ${p.bytes.byteLength} bytes to: ${filePath}`);
     await writeMediaFile(filePath, p.bytes);
     items.push({ ...p, filePath });
   }
-  log5(verbose, `Done! Generated ${items.length} ${req.kind}(s)`);
+  log6(verbose, `Done! Generated ${items.length} ${req.kind}(s)`);
   return items;
 }
 async function generateImage(prompt, opts = {}) {