climage 0.1.0 → 0.3.0

package/dist/cli.js

@@ -26,6 +26,16 @@ function loadEnv(cwd = process2.cwd()) {
 // src/core/output.ts
 import fs2 from "fs/promises";
 import path2 from "path";
+var IMAGE_MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".avif": "image/avif",
+  ".heif": "image/heif",
+  ".heic": "image/heic"
+};
 function extensionForFormat(format) {
   switch (format) {
     case "jpg":
@@ -34,6 +44,12 @@ function extensionForFormat(format) {
       return "png";
     case "webp":
       return "webp";
+    case "mp4":
+      return "mp4";
+    case "webm":
+      return "webm";
+    case "gif":
+      return "gif";
   }
 }
 function resolveOutDir(outDir) {
@@ -47,10 +63,56 @@ function makeOutputPath(req, index) {
   const filename = `${base}${suffix}.${ext}`;
   return path2.join(req.outDir, filename);
 }
-async function writeImageFile(filePath, bytes) {
+async function writeMediaFile(filePath, bytes) {
   await fs2.mkdir(path2.dirname(filePath), { recursive: true });
   await fs2.writeFile(filePath, bytes);
 }
+function toJsonResult(items) {
+  const images = items.filter((i) => i.kind === "image").map((img) => ({
+    provider: img.provider,
+    model: img.model,
+    index: img.index,
+    filePath: img.filePath,
+    url: img.url,
+    bytes: img.bytes.byteLength,
+    mimeType: img.mimeType
+  }));
+  const videos = items.filter((i) => i.kind === "video").map((vid) => ({
+    provider: vid.provider,
+    model: vid.model,
+    index: vid.index,
+    filePath: vid.filePath,
+    url: vid.url,
+    bytes: vid.bytes.byteLength,
+    mimeType: vid.mimeType
+  }));
+  return {
+    ...images.length ? { images } : {},
+    ...videos.length ? { videos } : {}
+  };
+}
+async function resolveImageInput(pathOrUrl) {
+  if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+    return pathOrUrl;
+  }
+  if (pathOrUrl.startsWith("data:")) {
+    return pathOrUrl;
+  }
+  const resolvedPath = path2.isAbsolute(pathOrUrl) ? pathOrUrl : path2.resolve(process.cwd(), pathOrUrl);
+  const ext = path2.extname(resolvedPath).toLowerCase();
+  const mimeType = IMAGE_MIME_TYPES[ext];
+  if (!mimeType) {
+    throw new Error(
+      `Unsupported image format: ${ext}. Supported: ${Object.keys(IMAGE_MIME_TYPES).join(", ")}`
+    );
+  }
+  const fileBuffer = await fs2.readFile(resolvedPath);
+  const base64 = fileBuffer.toString("base64");
+  return `data:${mimeType};base64,${base64}`;
+}
+async function resolveImageInputs(pathsOrUrls) {
+  return Promise.all(pathsOrUrls.map(resolveImageInput));
+}
 
 // src/core/strings.ts
 function slugify(input, maxLen = 60) {
@@ -68,62 +130,253 @@ var XAI_API_BASE = "https://api.x.ai/v1";
 function getXaiApiKey(env) {
   return env.XAI_API_KEY || env.XAI_TOKEN || env.GROK_API_KEY;
 }
+var verboseMode = false;
+function log(...args) {
+  if (verboseMode) console.error("[xai]", ...args);
+}
 async function downloadBytes(url) {
+  log("Downloading from:", url.slice(0, 100) + "...");
+  const start = Date.now();
   const res = await fetch(url);
-  if (!res.ok) throw new Error(`xAI image download failed (${res.status})`);
+  if (!res.ok) throw new Error(`xAI download failed (${res.status})`);
   const ab = await res.arrayBuffer();
   const ct = res.headers.get("content-type") || void 0;
+  log(`Downloaded ${ab.byteLength} bytes in ${Date.now() - start}ms, type: ${ct}`);
   return { bytes: new Uint8Array(ab), mimeType: ct };
 }
+async function sleep(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+async function generateXaiImages(req, apiKey) {
+  const model = req.model ?? "grok-imagine-image";
+  log("Starting image generation, model:", model, "n:", req.n);
+  const body = {
+    model,
+    prompt: req.prompt,
+    n: req.n,
+    // xAI docs: endpoint supports aspect_ratio
+    ...req.aspectRatio ? { aspect_ratio: req.aspectRatio } : {},
+    // Use URL format to download + save.
+    response_format: "url"
+  };
+  log("Request body:", JSON.stringify(body));
+  log("Calling xAI images/generations...");
+  const startTime = Date.now();
+  const res = await fetch(`${XAI_API_BASE}/images/generations`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${apiKey}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  log(`API responded in ${Date.now() - startTime}ms, status: ${res.status}`);
+  if (!res.ok) {
+    const txt = await res.text().catch(() => "");
+    log("Error response:", txt.slice(0, 1e3));
+    throw new Error(`xAI generations failed (${res.status}): ${txt.slice(0, 500)}`);
+  }
+  const json = await res.json();
+  log("Response data count:", json.data?.length);
+  if (!json.data?.length) throw new Error("xAI returned no images");
+  return processXaiImageResponse(json, model);
+}
+async function editXaiImages(req, apiKey) {
+  const model = req.model ?? "grok-imagine-image";
+  const inputImage = req.inputImages?.[0];
+  if (!inputImage) throw new Error("No input image provided for editing");
+  log("Starting image editing, model:", model, "n:", req.n);
+  const body = {
+    model,
+    prompt: req.prompt,
+    n: req.n,
+    image: { url: inputImage },
+    // Object with url field containing data URI or URL
+    response_format: "url",
+    ...req.aspectRatio ? { aspect_ratio: req.aspectRatio } : {}
+  };
+  log("Request body:", JSON.stringify({ ...body, image: { url: "...(data uri)..." } }));
+  log("Calling xAI images/edits...");
+  const startTime = Date.now();
+  const res = await fetch(`${XAI_API_BASE}/images/edits`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${apiKey}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  log(`API responded in ${Date.now() - startTime}ms, status: ${res.status}`);
+  if (!res.ok) {
+    const txt = await res.text().catch(() => "");
+    log("Error response:", txt.slice(0, 1e3));
+    throw new Error(`xAI edits failed (${res.status}): ${txt.slice(0, 500)}`);
+  }
+  const json = await res.json();
+  log("Response data count:", json.data?.length);
+  if (!json.data?.length) throw new Error("xAI returned no images");
+  return processXaiImageResponse(json, model);
+}
+async function processXaiImageResponse(json, model) {
+  const results = [];
+  for (let i = 0; i < json.data.length; i++) {
+    const img = json.data[i];
+    if (!img) continue;
+    log(`Processing image ${i}...`);
+    if (img.url) {
+      const { bytes, mimeType } = await downloadBytes(img.url);
+      results.push({
+        kind: "image",
+        provider: "xai",
+        model,
+        index: i,
+        url: img.url,
+        bytes,
+        ...mimeType !== void 0 ? { mimeType } : {}
+      });
+      continue;
+    }
+    if (img.b64_json) {
+      log(`Image ${i} is base64 encoded`);
+      const bytes = Uint8Array.from(Buffer.from(img.b64_json, "base64"));
+      results.push({ kind: "image", provider: "xai", model, index: i, bytes });
+      continue;
+    }
+    throw new Error("xAI returned image without url or b64_json");
+  }
+  log(`Successfully generated ${results.length} image(s)`);
+  return results;
+}
+async function generateXaiVideo(req, apiKey) {
+  const model = req.model ?? "grok-imagine-video";
+  const imageUrl = req.startFrame ?? req.inputImages?.[0];
+  log(
+    "Starting video generation, model:",
+    model,
+    "hasImageUrl:",
+    !!imageUrl,
+    "duration:",
+    req.duration
+  );
+  const createBody = {
+    prompt: req.prompt,
+    model,
+    ...req.aspectRatio ? { aspect_ratio: req.aspectRatio } : {},
+    // Add image_url for image-to-video (data URI or URL string)
+    ...imageUrl ? { image_url: imageUrl } : {},
+    // Add duration (xAI supports 1-15 seconds)
+    ...req.duration !== void 0 ? { duration: req.duration } : {}
+  };
+  log(
+    "Request body:",
+    JSON.stringify({
+      ...createBody,
+      image_url: createBody.image_url ? `...(${String(createBody.image_url).length} chars)` : void 0
+    })
+  );
+  log("Calling xAI videos/generations...");
+  const startTime = Date.now();
+  const createRes = await fetch(`${XAI_API_BASE}/videos/generations`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${apiKey}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(createBody)
+  });
+  log(`API responded in ${Date.now() - startTime}ms, status: ${createRes.status}`);
+  if (!createRes.ok) {
+    const txt = await createRes.text().catch(() => "");
+    log("Error response:", txt.slice(0, 1e3));
+    throw new Error(`xAI video generations failed (${createRes.status}): ${txt.slice(0, 500)}`);
+  }
+  const createJson = await createRes.json();
+  const requestId = createJson.request_id;
+  log("Got request_id:", requestId);
+  if (!requestId) throw new Error("xAI video generation returned no request_id");
+  const maxAttempts = 120;
+  const intervalMs = 3e3;
+  let result;
+  log(`Starting poll loop (max ${maxAttempts} attempts, ${intervalMs}ms interval)...`);
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const res = await fetch(`${XAI_API_BASE}/videos/${encodeURIComponent(requestId)}`, {
+      method: "GET",
+      headers: {
+        authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!res.ok) {
+      const txt = await res.text().catch(() => "");
+      log(`Poll attempt ${attempt + 1} failed:`, txt.slice(0, 500));
+      throw new Error(`xAI video poll failed (${res.status}): ${txt.slice(0, 500)}`);
+    }
+    const json = await res.json();
+    result = json;
+    log(
+      `Poll attempt ${attempt + 1}/${maxAttempts}: status=${json.status}, raw:`,
+      JSON.stringify(json).slice(0, 300)
+    );
+    if (json.video?.url) {
+      log("Video generation complete!");
+      break;
+    }
+    if (json.status === "failed" || json.status === "error") {
+      log("Video generation failed:", JSON.stringify(json));
+      throw new Error(`xAI video generation failed: ${JSON.stringify(json)}`);
+    }
+    await sleep(intervalMs);
+  }
+  if (!result?.video?.url) {
+    log("Timed out. Last result:", JSON.stringify(result));
+    throw new Error(`xAI video generation timed out (request_id=${requestId})`);
+  }
+  const url = result.video.url;
+  log("Video URL:", url);
+  if (result.video?.respect_moderation === false) {
+    throw new Error("xAI video generation was blocked by moderation");
+  }
+  const { bytes, mimeType } = await downloadBytes(url);
+  log(`Successfully generated video, ${bytes.byteLength} bytes`);
+  return [
+    {
+      kind: "video",
+      provider: "xai",
+      model: result.model ?? model,
+      index: 0,
+      url,
+      bytes,
+      ...mimeType !== void 0 ? { mimeType } : {}
+    }
+  ];
+}
+var xaiCapabilities = {
+  maxInputImages: 1,
+  supportsVideoInterpolation: false,
+  // xAI does not support end frame
+  videoDurationRange: [1, 15],
+  // 1-15 seconds
+  supportsImageEditing: true
+};
 var xaiProvider = {
   id: "xai",
-  displayName: "xAI (grok-imagine-image)",
+  displayName: "xAI",
+  supports: ["image", "video"],
+  capabilities: xaiCapabilities,
   isAvailable(env) {
     return Boolean(getXaiApiKey(env));
   },
   async generate(req, env) {
     const apiKey = getXaiApiKey(env);
     if (!apiKey) throw new Error("Missing xAI API key. Set XAI_API_KEY (or XAI_TOKEN).");
-    const model = req.model ?? "grok-imagine-image";
-    const body = {
-      model,
-      prompt: req.prompt,
-      n: req.n,
-      // xAI docs: endpoint supports aspect_ratio
-      ...req.aspectRatio ? { aspect_ratio: req.aspectRatio } : {},
-      // Use URL format to download + save.
-      response_format: "url"
-    };
-    const res = await fetch(`${XAI_API_BASE}/images/generations`, {
-      method: "POST",
-      headers: {
-        authorization: `Bearer ${apiKey}`,
-        "content-type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-    if (!res.ok) {
-      const txt = await res.text().catch(() => "");
-      throw new Error(`xAI generations failed (${res.status}): ${txt.slice(0, 500)}`);
-    }
-    const json = await res.json();
-    if (!json.data?.length) throw new Error("xAI returned no images");
-    const results = [];
-    for (let i = 0; i < json.data.length; i++) {
-      const img = json.data[i];
-      if (img.url) {
-        const { bytes, mimeType } = await downloadBytes(img.url);
-        results.push({ provider: "xai", model, index: i, url: img.url, bytes, mimeType });
-        continue;
-      }
-      if (img.b64_json) {
-        const bytes = Uint8Array.from(Buffer.from(img.b64_json, "base64"));
-        results.push({ provider: "xai", model, index: i, bytes });
-        continue;
-      }
-      throw new Error("xAI returned image without url or b64_json");
+    verboseMode = req.verbose;
+    log("Provider initialized, kind:", req.kind);
+    if (req.kind === "video") return generateXaiVideo(req, apiKey);
+    const hasInputImages = req.inputImages && req.inputImages.length > 0;
+    if (hasInputImages) {
+      log("Input images detected, using edit endpoint");
+      return editXaiImages(req, apiKey);
     }
-    return results;
+    return generateXaiImages(req, apiKey);
   }
 };
 
@@ -132,50 +385,198 @@ import { fal } from "@fal-ai/client";
 function getFalKey(env) {
   return env.FAL_API_KEY || env.FAL_KEY;
 }
-async function downloadBytes2(url) {
+function log2(verbose, ...args) {
+  if (verbose) console.error("[fal]", ...args);
+}
+async function downloadBytes2(url, verbose) {
+  log2(verbose, "Downloading from:", url.slice(0, 100) + "...");
+  const start = Date.now();
   const res = await fetch(url);
-  if (!res.ok) throw new Error(`fal image download failed (${res.status})`);
+  if (!res.ok) throw new Error(`fal download failed (${res.status})`);
   const ab = await res.arrayBuffer();
   const ct = res.headers.get("content-type") || void 0;
+  log2(verbose, `Downloaded ${ab.byteLength} bytes in ${Date.now() - start}ms, type: ${ct}`);
   return { bytes: new Uint8Array(ab), mimeType: ct };
 }
+function pickMany(result, kind) {
+  if (kind === "image") {
+    if (Array.isArray(result.images) && result.images.length) return result.images;
+    if (result.image?.url) return [result.image];
+    return [];
+  }
+  if (Array.isArray(result.videos) && result.videos.length) return result.videos;
+  if (result.video?.url) return [result.video];
+  return [];
+}
+var DEFAULT_IMAGE_MODEL = "fal-ai/flux/dev";
+var DEFAULT_IMAGE_TO_IMAGE_MODEL = "fal-ai/flux/dev/image-to-image";
+var DEFAULT_VIDEO_MODEL = "fal-ai/ltxv-2/text-to-video/fast";
+var DEFAULT_IMAGE_TO_VIDEO_MODEL = "fal-ai/vidu/q2/image-to-video";
+var DEFAULT_START_END_VIDEO_MODEL = "fal-ai/vidu/start-end-to-video";
+var DEFAULT_REFERENCE_VIDEO_MODEL = "fal-ai/vidu/q2/reference-to-video";
+function selectVideoModel(req) {
+  if (req.model) return req.model;
+  if (req.startFrame && req.endFrame) {
+    return DEFAULT_START_END_VIDEO_MODEL;
+  }
+  if (req.inputImages?.length && !req.startFrame) {
+    return DEFAULT_REFERENCE_VIDEO_MODEL;
+  }
+  if (req.startFrame || req.inputImages?.length) {
+    return DEFAULT_IMAGE_TO_VIDEO_MODEL;
+  }
+  return DEFAULT_VIDEO_MODEL;
+}
+function selectImageModel(req) {
+  if (req.model) return req.model;
+  if (req.inputImages?.length) return DEFAULT_IMAGE_TO_IMAGE_MODEL;
+  return DEFAULT_IMAGE_MODEL;
+}
+function mapAspectRatio(aspectRatio) {
+  if (!aspectRatio) return void 0;
+  const ar = aspectRatio.trim();
+  if (ar === "1:1") return "square";
+  if (ar === "4:3") return "landscape_4_3";
+  if (ar === "16:9") return "landscape_16_9";
+  if (ar === "3:4") return "portrait_4_3";
+  if (ar === "9:16") return "portrait_16_9";
+  return ar;
+}
+function buildVideoInput(req) {
+  const input = {
+    prompt: req.prompt
+  };
+  if (req.startFrame && req.endFrame) {
+    input.start_image_url = req.startFrame;
+    input.end_image_url = req.endFrame;
+    return input;
+  }
+  if (req.inputImages?.length && !req.startFrame) {
+    input.reference_image_urls = req.inputImages.slice(0, 7);
+    const ar = mapAspectRatio(req.aspectRatio);
+    if (ar) input.aspect_ratio = ar;
+    if (req.duration) input.duration = String(req.duration);
+    return input;
+  }
+  const imageUrl = req.startFrame ?? req.inputImages?.[0];
+  if (imageUrl) {
+    input.image_url = imageUrl;
+    if (req.duration) input.duration = String(req.duration);
+    return input;
+  }
+  const imageSize = mapAspectRatio(req.aspectRatio);
+  if (imageSize) input.image_size = imageSize;
+  if (req.n) input.num_videos = req.n;
+  return input;
+}
+function buildImageInput(req) {
+  const input = {
+    prompt: req.prompt
+  };
+  const imageSize = mapAspectRatio(req.aspectRatio);
+  if (imageSize) input.image_size = imageSize;
+  if (req.n) input.num_images = req.n;
+  if (req.inputImages?.[0]) {
+    input.image_url = req.inputImages[0];
+    input.strength = 0.75;
+  }
+  return input;
+}
+var falCapabilities = {
+  maxInputImages: 7,
+  // Vidu supports up to 7 reference images
+  supportsVideoInterpolation: true,
+  // Vidu start-end-to-video
+  videoDurationRange: [2, 8],
+  // Vidu supports 2-8 seconds
+  supportsImageEditing: true
+};
 var falProvider = {
   id: "fal",
   displayName: "fal.ai",
+  supports: ["image", "video"],
+  capabilities: falCapabilities,
   isAvailable(env) {
     return Boolean(getFalKey(env));
   },
   async generate(req, env) {
     const key = getFalKey(env);
     if (!key) throw new Error("Missing fal API key. Set FAL_KEY (or FAL_API_KEY).");
+    const verbose = req.verbose;
+    log2(verbose, "Starting generation, kind:", req.kind, "n:", req.n);
+    log2(
+      verbose,
+      "Input images:",
+      req.inputImages?.length ?? 0,
+      "startFrame:",
+      !!req.startFrame,
+      "endFrame:",
+      !!req.endFrame
+    );
     fal.config({ credentials: key });
-    const model = req.model ?? "fal-ai/flux/dev";
-    let image_size = void 0;
-    if (req.aspectRatio) {
-      const ar = req.aspectRatio.trim();
-      if (ar === "1:1") image_size = "square";
-      else if (ar === "4:3") image_size = "landscape_4_3";
-      else if (ar === "16:9") image_size = "landscape_16_9";
-      else if (ar === "3:4") image_size = "portrait_4_3";
-      else if (ar === "9:16") image_size = "portrait_16_9";
-    }
-    const input = {
-      prompt: req.prompt,
-      ...image_size ? { image_size } : {},
-      // Some fal models support "num_images"; flux/dev returns images array length.
-      ...req.n ? { num_images: req.n } : {}
+    const model = req.kind === "video" ? selectVideoModel(req) : selectImageModel(req);
+    log2(verbose, "Selected model:", model);
+    const input = req.kind === "video" ? buildVideoInput(req) : buildImageInput(req);
+    const inputSummary = { ...input };
+    for (const key2 of ["image_url", "start_image_url", "end_image_url"]) {
+      if (typeof inputSummary[key2] === "string" && inputSummary[key2].startsWith("data:")) {
+        inputSummary[key2] = `data:...${inputSummary[key2].length} chars`;
+      }
+    }
+    if (Array.isArray(inputSummary.reference_image_urls)) {
+      inputSummary.reference_image_urls = inputSummary.reference_image_urls.map(
+        (url) => url.startsWith("data:") ? `data:...${url.length} chars` : url
+      );
+    }
+    log2(verbose, "Request input:", JSON.stringify(inputSummary));
+    log2(verbose, "Calling fal.subscribe...");
+    const startTime = Date.now();
+    const subscribeOptions = {
+      input,
+      logs: verbose
     };
-    const result = await fal.subscribe(model, { input });
-    const images = result?.data?.images;
-    if (!images?.length) throw new Error("fal returned no images");
+    if (verbose) {
+      subscribeOptions.onQueueUpdate = (update) => {
+        log2(true, "Queue update:", update.status, JSON.stringify(update).slice(0, 200));
+      };
+    }
+    const result = await fal.subscribe(model, subscribeOptions);
+    log2(verbose, `fal.subscribe completed in ${Date.now() - startTime}ms`);
+    log2(verbose, "Raw result keys:", Object.keys(result?.data ?? {}));
+    log2(verbose, "Result preview:", JSON.stringify(result?.data ?? {}).slice(0, 500));
+    const items = pickMany(result?.data ?? {}, req.kind);
+    log2(verbose, `Found ${items.length} ${req.kind}(s) in response`);
+    if (!items?.length) {
+      const noun = req.kind === "video" ? "videos" : "images";
+      throw new Error(
+        `fal returned no ${noun}. Raw response: ${JSON.stringify(result?.data).slice(0, 300)}`
+      );
+    }
     const out = [];
-    for (let i = 0; i < Math.min(images.length, req.n); i++) {
-      const img = images[i];
-      if (!img?.url) continue;
-      const { bytes, mimeType } = await downloadBytes2(img.url);
-      out.push({ provider: "fal", model, index: i, url: img.url, bytes, mimeType: img.content_type ?? mimeType });
+    for (let i = 0; i < Math.min(items.length, req.n); i++) {
+      const m = items[i];
+      if (!m?.url) {
+        log2(verbose, `Item ${i} has no URL, skipping`);
+        continue;
+      }
+      log2(verbose, `Downloading item ${i}...`);
+      const { bytes, mimeType } = await downloadBytes2(m.url, verbose);
+      const finalMimeType = m.content_type ?? mimeType;
+      out.push({
+        kind: req.kind,
+        provider: "fal",
+        model,
+        index: i,
+        url: m.url,
+        bytes,
+        ...finalMimeType !== void 0 ? { mimeType: finalMimeType } : {}
+      });
     }
-    if (!out.length) throw new Error("fal returned images but none were downloadable");
+    if (!out.length) {
+      const noun = req.kind === "video" ? "videos" : "images";
+      throw new Error(`fal returned ${noun} but none were downloadable`);
+    }
+    log2(verbose, `Successfully generated ${out.length} ${req.kind}(s)`);
     return out;
   }
 };
@@ -185,7 +586,7 @@ import { GoogleGenAI } from "@google/genai";
 function getGeminiApiKey(env) {
   return env.GEMINI_API_KEY || env.GOOGLE_API_KEY || env.GOOGLE_GENAI_API_KEY;
 }
-function mimeForFormat(format) {
+function mimeForImageFormat(format) {
   switch (format) {
     case "jpg":
       return "image/jpeg";
@@ -196,43 +597,522 @@ function mimeForFormat(format) {
       return "image/png";
   }
 }
+var verboseMode2 = false;
+function log3(...args) {
+  if (verboseMode2) console.error("[google]", ...args);
+}
+var MODEL_ALIASES = {
+  "nano-banana": "gemini-2.5-flash-image",
+  "nano-banana-pro": "gemini-3-pro-image-preview",
+  // Veo (video)
+  veo2: "veo-2.0-generate-001",
+  "veo-2": "veo-2.0-generate-001",
+  veo3: "veo-3.0-generate-001",
+  "veo-3": "veo-3.0-generate-001",
+  "veo-3.1": "veo-3.1-generate-preview",
+  veo31: "veo-3.1-generate-preview"
+};
+var VEO_31_MODELS = ["veo-3.1-generate-preview", "veo-3.1-fast-generate-preview"];
+function isVeo31Model(model) {
+  return VEO_31_MODELS.some((m) => model.includes(m) || model.includes("veo-3.1"));
+}
+function parseDataUri(dataUri) {
+  const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
+  if (!match) return null;
+  return { mimeType: match[1] ?? "image/png", data: match[2] ?? "" };
+}
+function imageToGoogleFormat(imageInput) {
+  if (imageInput.startsWith("data:")) {
+    const parsed = parseDataUri(imageInput);
+    if (parsed) {
+      return { inlineData: { data: parsed.data, mimeType: parsed.mimeType } };
+    }
+  }
+  return { fileUri: imageInput };
+}
+var GEMINI_IMAGE_MODELS = ["gemini-2.5-flash-image", "gemini-3-pro-image-preview"];
+function resolveModel(model) {
+  if (!model) return "gemini-2.5-flash-image";
+  return MODEL_ALIASES[model] ?? model;
+}
+function isGeminiImageModel(model) {
+  return GEMINI_IMAGE_MODELS.some((m) => model.startsWith(m));
+}
+async function downloadBytes3(url) {
+  log3("Downloading from:", url.slice(0, 100) + "...");
+  const start = Date.now();
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Google video download failed (${res.status})`);
+  const ab = await res.arrayBuffer();
+  const ct = res.headers.get("content-type") || void 0;
+  log3(`Downloaded ${ab.byteLength} bytes in ${Date.now() - start}ms, type: ${ct}`);
+  return { bytes: new Uint8Array(ab), mimeType: ct };
+}
+async function sleep2(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+var googleCapabilities = {
+  maxInputImages: 3,
+  // Veo 3.1 supports up to 3 reference images
+  supportsVideoInterpolation: true,
+  // Veo 3.1 supports first + last frame
+  videoDurationRange: [4, 8],
+  // Veo 3.1 supports 4, 6, 8 seconds
+  supportsImageEditing: true
+};
 var googleProvider = {
   id: "google",
-  displayName: "Google (Gemini / Imagen)",
+  displayName: "Google (Gemini / Imagen / Veo)",
+  supports: ["image", "video"],
+  capabilities: googleCapabilities,
   isAvailable(env) {
     return Boolean(getGeminiApiKey(env));
   },
   async generate(req, env) {
     const apiKey = getGeminiApiKey(env);
     if (!apiKey) throw new Error("Missing Google API key. Set GEMINI_API_KEY (or GOOGLE_API_KEY).");
+    verboseMode2 = req.verbose;
+    log3("Provider initialized, kind:", req.kind);
+    log3(
+      "Input images:",
+      req.inputImages?.length ?? 0,
+      "startFrame:",
+      !!req.startFrame,
+      "endFrame:",
+      !!req.endFrame
+    );
     const ai = new GoogleGenAI({ apiKey });
-    const model = req.model ?? "imagen-4.0-generate-001";
-    const res = await ai.models.generateImages({
+    if (req.kind === "video") {
+      const hasAdvancedFeatures = req.startFrame || req.endFrame || req.inputImages?.length;
+      const defaultModel = hasAdvancedFeatures ? "veo-3.1-generate-preview" : "veo-2.0-generate-001";
+      const model2 = MODEL_ALIASES[req.model ?? ""] ?? req.model ?? defaultModel;
+      log3("Using video model:", model2);
+      if (hasAdvancedFeatures && !isVeo31Model(model2)) {
+        log3(
+          "WARNING: Advanced video features (startFrame, endFrame, referenceImages) require Veo 3.1"
+        );
+      }
+      return generateWithVeo(ai, model2, req);
+    }
+    const model = resolveModel(req.model);
+    log3("Resolved model:", model);
+    if (isGeminiImageModel(model)) {
+      log3("Using Gemini native image generation");
+      return generateWithGemini(ai, model, req);
+    }
+    log3("Using Imagen API");
+    return generateWithImagen(ai, model, req);
+  }
+};
+async function generateWithVeo(ai, model, req) {
+  log3("Starting Veo video generation, model:", model, "n:", req.n);
+  const startTime = Date.now();
+  const config = {
+    numberOfVideos: req.n,
+    ...req.aspectRatio ? { aspectRatio: req.aspectRatio } : {},
+    // Add duration if specified (Veo 3.1 supports 4, 6, 8)
+    ...req.duration !== void 0 ? { durationSeconds: String(req.duration) } : {}
+  };
+  if (req.inputImages?.length && isVeo31Model(model)) {
+    const referenceImages = req.inputImages.slice(0, 3).map((img) => {
+      const imageData = imageToGoogleFormat(img);
+      return {
+        image: imageData,
+        referenceType: "asset"
+      };
+    });
+    config.referenceImages = referenceImages;
+    log3("Added", referenceImages.length, "reference images");
+  }
+  const generateParams = {
+    model,
+    prompt: req.prompt,
+    config
+  };
+  const firstFrameImage = req.startFrame ?? (req.inputImages?.length === 1 ? req.inputImages[0] : void 0);
+  if (firstFrameImage && isVeo31Model(model)) {
+    const imageData = imageToGoogleFormat(firstFrameImage);
+    generateParams.image = imageData;
+    log3("Added first frame image");
+  }
+  if (req.endFrame && isVeo31Model(model)) {
+    const lastFrameData = imageToGoogleFormat(req.endFrame);
+    config.lastFrame = lastFrameData;
+    log3("Added last frame for interpolation");
+  }
+  log3("Calling ai.models.generateVideos...");
+  let op = await ai.models.generateVideos(generateParams);
+  log3("Initial operation state:", op.done ? "done" : "pending", "name:", op.name);
+  const maxAttempts = 60;
+  const intervalMs = 1e4;
+  for (let attempt = 0; attempt < maxAttempts && !op.done; attempt++) {
+    log3(`Poll attempt ${attempt + 1}/${maxAttempts}...`);
+    await sleep2(intervalMs);
+    op = await ai.operations.getVideosOperation({ operation: op });
+    log3(`Poll result: done=${op.done}`);
+  }
+  log3(`Operation completed in ${Date.now() - startTime}ms`);
+  if (!op.done) {
+    log3("Timed out. Operation state:", JSON.stringify(op).slice(0, 500));
+    throw new Error("Google Veo video generation timed out");
+  }
+  const videos = op.response?.generatedVideos;
+  log3("Generated videos count:", videos?.length);
+  if (!videos?.length) {
+    log3("Full response:", JSON.stringify(op.response).slice(0, 1e3));
+    throw new Error("Google Veo returned no videos");
+  }
+  const out = [];
+  for (let i = 0; i < Math.min(videos.length, req.n); i++) {
+    const v = videos[i];
+    log3(`Processing video ${i}:`, JSON.stringify(v).slice(0, 300));
+    const uri = v?.video?.uri;
+    if (!uri) {
+      log3(`Video ${i} has no URI, skipping`);
+      continue;
+    }
+    if (uri.startsWith("gs://")) {
+      throw new Error(
+        `Google Veo returned a gs:// URI (${uri}). Configure outputGcsUri / Vertex flow to fetch from GCS.`
+      );
+    }
+    const { bytes, mimeType } = await downloadBytes3(uri);
+    out.push({
+      kind: "video",
+      provider: "google",
       model,
-      prompt: req.prompt,
-      config: {
-        numberOfImages: req.n,
-        outputMimeType: mimeForFormat(req.format)
-        // Note: aspect ratio / size varies by model. Add later.
+      index: i,
+      url: uri,
+      bytes,
+      ...mimeType !== void 0 ? { mimeType } : {}
+    });
+  }
+  if (!out.length) throw new Error("Google Veo returned videos but none were downloadable");
+  log3(`Successfully generated ${out.length} video(s)`);
+  return out;
+}
+async function generateWithGemini(ai, model, req) {
+  const hasInputImage = req.inputImages?.length;
+  log3(
+    "Starting Gemini image generation, model:",
+    model,
+    "n:",
+    req.n,
+    "hasInputImage:",
+    !!hasInputImage
+  );
+  const startTime = Date.now();
+  const out = [];
+  const buildContents = () => {
+    if (hasInputImage && req.inputImages?.[0]) {
+      const imageData = imageToGoogleFormat(req.inputImages[0]);
+      return [{ ...imageData }, { text: req.prompt }];
+    }
+    return req.prompt;
+  };
+  for (let i = 0; i < req.n; i++) {
+    log3(`Generating image ${i + 1}/${req.n}...`);
+    const callStart = Date.now();
+    try {
+      const res = await ai.models.generateContent({
+        model,
+        contents: buildContents(),
+        config: {
+          responseModalities: ["IMAGE"]
+        }
+      });
+      log3(`API call ${i + 1} took ${Date.now() - callStart}ms`);
+      const parts = res.candidates?.[0]?.content?.parts;
+      log3(`Response has ${parts?.length ?? 0} parts`);
+      if (!parts) {
+        log3(
+          `No parts in response for image ${i}. Full response:`,
+          JSON.stringify(res).slice(0, 500)
+        );
+        continue;
+      }
+      for (const part of parts) {
+        if (part.inlineData?.data) {
+          const rawBytes = part.inlineData.data;
+          const bytes = typeof rawBytes === "string" ? Uint8Array.from(Buffer.from(rawBytes, "base64")) : rawBytes;
+          log3(`Image ${i}: got ${bytes.byteLength} bytes, mimeType: ${part.inlineData.mimeType}`);
+          out.push({
+            kind: "image",
+            provider: "google",
+            model,
+            index: i,
+            bytes,
+            mimeType: part.inlineData.mimeType ?? mimeForImageFormat(req.format)
+          });
+          break;
+        }
       }
+    } catch (err) {
+      log3(`Error generating image ${i}:`, err);
+      throw err;
+    }
+  }
+  log3(`Total generation time: ${Date.now() - startTime}ms`);
+  if (!out.length) throw new Error("Gemini returned no images");
+  log3(`Successfully generated ${out.length} image(s)`);
+  return out;
+}
+async function generateWithImagen(ai, model, req) {
+  log3("Starting Imagen generation, model:", model, "n:", req.n);
+  const startTime = Date.now();
+  log3("Calling ai.models.generateImages...");
+  const res = await ai.models.generateImages({
+    model,
+    prompt: req.prompt,
+    config: {
+      numberOfImages: req.n,
+      outputMimeType: mimeForImageFormat(req.format),
+      // Imagen 4 supports aspectRatio
+      ...req.aspectRatio ? { aspectRatio: req.aspectRatio } : {}
+    }
+  });
+  log3(`API call took ${Date.now() - startTime}ms`);
+  const imgs = res.generatedImages;
+  log3("Generated images count:", imgs?.length);
+  if (!imgs?.length) {
+    log3("Full response:", JSON.stringify(res).slice(0, 1e3));
+    throw new Error("Google generateImages returned no images");
+  }
+  const out = [];
+  for (let i = 0; i < Math.min(imgs.length, req.n); i++) {
+    const img = imgs[i];
+    const rawBytes = img?.image?.imageBytes;
+    if (!rawBytes) {
+      log3(`Image ${i} has no bytes, skipping`);
+      continue;
+    }
+    const bytes = typeof rawBytes === "string" ? Uint8Array.from(Buffer.from(rawBytes, "base64")) : rawBytes;
+    log3(`Image ${i}: got ${bytes.byteLength} bytes`);
+    out.push({
+      kind: "image",
+      provider: "google",
+      model,
+      index: i,
+      bytes,
+      mimeType: mimeForImageFormat(req.format)
     });
-    const imgs = res.generatedImages;
-    if (!imgs?.length) throw new Error("Google generateImages returned no images");
-    const out = [];
-    for (let i = 0; i < Math.min(imgs.length, req.n); i++) {
-      const img = imgs[i];
-      const rawBytes = img?.image?.imageBytes;
-      if (!rawBytes) continue;
-      const bytes = typeof rawBytes === "string" ? Uint8Array.from(Buffer.from(rawBytes, "base64")) : rawBytes;
-      out.push({ provider: "google", model, index: i, bytes, mimeType: mimeForFormat(req.format) });
-    }
-    if (!out.length) throw new Error("Google returned images but no bytes were present");
-    return out;
+  }
+  if (!out.length) throw new Error("Google returned images but no bytes were present");
+  log3(`Successfully generated ${out.length} image(s)`);
+  return out;
+}
+
+// src/providers/openai.ts
+var OPENAI_API_BASE = "https://api.openai.com/v1";
+function getOpenAIApiKey(env) {
+  return env.OPENAI_API_KEY || env.OPENAI_KEY;
+}
+var verboseMode3 = false;
+function log4(...args) {
+  if (verboseMode3) console.error("[openai]", ...args);
+}
+function dataUriToBlob(dataUri) {
+  const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
+  if (!match) throw new Error("Invalid data URI");
+  const mimeType = match[1] ?? "image/png";
+  const base64 = match[2] ?? "";
+  const binary = Buffer.from(base64, "base64");
+  return new Blob([binary], { type: mimeType });
+}
+async function urlToBlob(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Failed to fetch image: ${res.status}`);
+  return res.blob();
+}
+async function imageInputToBlob(input) {
+  if (input.startsWith("data:")) {
+    return dataUriToBlob(input);
+  }
+  return urlToBlob(input);
+}
+async function downloadBytes4(url) {
+  log4("Downloading from:", url.slice(0, 100) + "...");
+  const start = Date.now();
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`OpenAI image download failed (${res.status})`);
+  const ab = await res.arrayBuffer();
+  const ct = res.headers.get("content-type");
+  log4(`Downloaded ${ab.byteLength} bytes in ${Date.now() - start}ms, type: ${ct}`);
+  return ct ? { bytes: new Uint8Array(ab), mimeType: ct } : { bytes: new Uint8Array(ab) };
+}
+function mapAspectRatioToSize(aspectRatio, model) {
+  if (!aspectRatio) return void 0;
+  const ar = aspectRatio.trim();
+  if (model?.startsWith("gpt-image")) {
+    if (ar === "1:1") return "1024x1024";
+    if (ar === "3:2" || ar === "4:3" || ar === "16:9") return "1536x1024";
+    if (ar === "2:3" || ar === "3:4" || ar === "9:16") return "1024x1536";
+  } else if (model === "dall-e-3") {
+    if (ar === "1:1") return "1024x1024";
+    if (ar === "16:9" || ar === "4:3") return "1792x1024";
+    if (ar === "9:16" || ar === "3:4") return "1024x1792";
+  }
+  return void 0;
+}
+var openaiCapabilities = {
+  maxInputImages: 2,
+  // image + optional mask
+  supportsVideoInterpolation: false,
+  // OpenAI doesn't support video
+  // videoDurationRange omitted - no video support
+  supportsImageEditing: true
+};
+async function generateWithEdit(req, apiKey, model) {
+  log4("Using edit endpoint for image editing");
+  const startTime = Date.now();
+  const formData = new FormData();
+  formData.append("model", model);
+  formData.append("prompt", req.prompt);
+  formData.append("n", String(req.n));
+  const size = mapAspectRatioToSize(req.aspectRatio, model);
+  if (size) formData.append("size", size);
+  const imageInput = req.inputImages?.[0];
+  if (!imageInput) throw new Error("No input image provided for editing");
+  const imageBlob = await imageInputToBlob(imageInput);
+  formData.append("image", imageBlob, "image.png");
+  log4("Added input image to form data");
+  const maskInput = req.inputImages?.[1];
+  if (maskInput) {
+    const maskBlob = await imageInputToBlob(maskInput);
+    formData.append("mask", maskBlob, "mask.png");
+    log4("Added mask image to form data");
+  }
+  log4("Calling OpenAI images/edits...");
+  const res = await fetch(`${OPENAI_API_BASE}/images/edits`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${apiKey}`
+      // Don't set content-type - FormData sets it with boundary
+    },
+    body: formData
+  });
+  log4(`API responded in ${Date.now() - startTime}ms, status: ${res.status}`);
+  if (!res.ok) {
+    const txt = await res.text().catch(() => "");
+    log4("Error response:", txt.slice(0, 1e3));
+    throw new Error(`OpenAI edit failed (${res.status}): ${txt.slice(0, 500)}`);
+  }
+  const json = await res.json();
+  log4("Response data count:", json.data?.length);
+  if (!json.data?.length) throw new Error("OpenAI edit returned no images");
+  const results = [];
+  for (let i = 0; i < json.data.length; i++) {
+    const img = json.data[i];
+    if (!img) continue;
+    log4(`Processing image ${i}...`);
+    if (img.url) {
+      const dl = await downloadBytes4(img.url);
+      results.push({
+        kind: "image",
+        provider: "openai",
+        model,
+        index: i,
+        url: img.url,
+        bytes: dl.bytes,
+        ...dl.mimeType ? { mimeType: dl.mimeType } : {}
+      });
+      continue;
+    }
+    if (img.b64_json) {
+      log4(`Image ${i} is base64 encoded, ${img.b64_json.length} chars`);
+      const bytes = Uint8Array.from(Buffer.from(img.b64_json, "base64"));
+      results.push({ kind: "image", provider: "openai", model, index: i, bytes });
+      continue;
+    }
+    throw new Error("OpenAI returned image without url or b64_json");
+  }
+  log4(`Successfully edited ${results.length} image(s)`);
+  return results;
+}
+var openaiProvider = {
+  id: "openai",
+  displayName: "OpenAI (GPT Image / DALL-E)",
+  supports: ["image"],
+  capabilities: openaiCapabilities,
+  isAvailable(env) {
+    return Boolean(getOpenAIApiKey(env));
+  },
+  async generate(req, env) {
+    const apiKey = getOpenAIApiKey(env);
+    if (!apiKey) throw new Error("Missing OpenAI API key. Set OPENAI_API_KEY.");
+    verboseMode3 = req.verbose;
+    log4("Provider initialized, kind:", req.kind);
+    const model = req.model ?? "gpt-image-1";
+    log4("Using model:", model, "hasInputImages:", !!req.inputImages?.length);
+    if (req.inputImages?.length) {
+      return generateWithEdit(req, apiKey, model);
+    }
+    const size = mapAspectRatioToSize(req.aspectRatio, model);
+    const body = {
+      model,
+      prompt: req.prompt,
+      n: req.n,
+      ...size ? { size } : {},
+      // gpt-image-1 doesn't support response_format, defaults to b64_json
+      // dall-e-2/3 support response_format
+      ...!model.startsWith("gpt-image") ? { response_format: "url" } : {}
+    };
+    log4("Request body:", JSON.stringify(body));
+    log4("Calling OpenAI images/generations...");
+    const startTime = Date.now();
+    const res = await fetch(`${OPENAI_API_BASE}/images/generations`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    log4(`API responded in ${Date.now() - startTime}ms, status: ${res.status}`);
+    if (!res.ok) {
+      const txt = await res.text().catch(() => "");
+      log4("Error response:", txt.slice(0, 1e3));
+      throw new Error(`OpenAI generations failed (${res.status}): ${txt.slice(0, 500)}`);
+    }
+    const json = await res.json();
+    log4("Response data count:", json.data?.length);
+    if (!json.data?.length) throw new Error("OpenAI returned no images");
+    const results = [];
+    for (let i = 0; i < json.data.length; i++) {
+      const img = json.data[i];
+      if (!img) continue;
+      log4(`Processing image ${i}...`);
+      if (img.url) {
+        const dl = await downloadBytes4(img.url);
+        results.push({
+          kind: "image",
+          provider: "openai",
+          model,
+          index: i,
+          url: img.url,
+          bytes: dl.bytes,
+          ...dl.mimeType ? { mimeType: dl.mimeType } : {}
+        });
+        continue;
+      }
+      if (img.b64_json) {
+        log4(`Image ${i} is base64 encoded, ${img.b64_json.length} chars`);
+        const bytes = Uint8Array.from(Buffer.from(img.b64_json, "base64"));
+        results.push({ kind: "image", provider: "openai", model, index: i, bytes });
+        continue;
+      }
+      throw new Error("OpenAI returned image without url or b64_json");
+    }
+    log4(`Successfully generated ${results.length} image(s)`);
+    return results;
   }
 };
 
 // src/core/router.ts
-var providers = [googleProvider, xaiProvider, falProvider];
+var providers = [googleProvider, xaiProvider, falProvider, openaiProvider];
+function log5(verbose, ...args) {
+  if (verbose) console.error("[router]", ...args);
+}
 function listProviders() {
   return [...providers];
 }
@@ -244,44 +1124,119 @@ function pickProvider(id, env) {
     return p2;
   }
   const p = providers.find((pp) => pp.isAvailable(env));
-  if (!p) throw new Error("No providers available. Set XAI_API_KEY (or other provider keys) in .env or environment.");
+  if (!p)
+    throw new Error(
+      "No providers available. Set XAI_API_KEY (or other provider keys) in .env or environment."
+    );
   return p;
 }
-function normalizeOptions(prompt, opts) {
+function defaultFormatForKind(kind) {
+  return kind === "video" ? "mp4" : "png";
+}
+async function normalizeOptions(prompt, opts, verbose) {
   const nRaw = opts.n ?? 1;
   const n = Math.max(1, Math.min(10, Math.floor(nRaw)));
-  const format = opts.format ?? "png";
+  const kind = opts.kind ?? "image";
+  const format = opts.format ?? defaultFormatForKind(kind);
   const outDir = resolveOutDir(opts.outDir ?? ".");
   const timestamp = timestampLocalCompact();
   const nameBase = slugify(opts.name ?? prompt);
+  let inputImages;
+  if (opts.inputImages?.length) {
+    log5(verbose, `Resolving ${opts.inputImages.length} input image(s)...`);
+    inputImages = await resolveImageInputs(opts.inputImages);
+    log5(verbose, `Resolved input images`);
+  }
+  let startFrame;
+  let endFrame;
+  if (opts.startFrame) {
+    log5(verbose, `Resolving start frame: ${opts.startFrame}`);
+    startFrame = await resolveImageInput(opts.startFrame);
+  }
+  if (opts.endFrame) {
+    log5(verbose, `Resolving end frame: ${opts.endFrame}`);
+    endFrame = await resolveImageInput(opts.endFrame);
+  }
   return {
     prompt,
     provider: opts.provider ?? "auto",
     model: opts.model ?? void 0,
     n,
     aspectRatio: opts.aspectRatio ?? void 0,
+    kind,
     format,
     outDir,
     out: opts.out ? path3.resolve(process.cwd(), opts.out) : void 0,
     nameBase,
     timestamp,
-    verbose: Boolean(opts.verbose)
+    verbose: Boolean(opts.verbose),
+    // New fields
+    inputImages,
+    startFrame,
+    endFrame,
+    duration: opts.duration
   };
 }
-async function generateImage(prompt, opts = {}) {
+function validateRequestForProvider(req, provider) {
+  const caps = provider.capabilities;
+  const inputCount = req.inputImages?.length ?? 0;
+  if (inputCount > caps.maxInputImages) {
+    throw new Error(
+      `Provider ${provider.id} supports max ${caps.maxInputImages} input image(s), but ${inputCount} provided`
+    );
+  }
+  if (req.endFrame && !caps.supportsVideoInterpolation) {
+    throw new Error(
+      `Provider ${provider.id} does not support video interpolation (end frame). Only startFrame is supported for image-to-video.`
+    );
+  }
+  if (req.duration !== void 0 && req.kind === "video" && caps.videoDurationRange) {
+    const [min, max] = caps.videoDurationRange;
+    if (req.duration < min || req.duration > max) {
+      throw new Error(
+        `Provider ${provider.id} supports video duration ${min}-${max}s, but ${req.duration}s requested`
+      );
+    }
+  }
+  if (req.kind === "image" && inputCount > 0 && !caps.supportsImageEditing) {
+    throw new Error(`Provider ${provider.id} does not support image editing with input images`);
+  }
+}
+async function generateMedia(prompt, opts = {}) {
   const { env } = loadEnv(process.cwd());
-  const req = normalizeOptions(prompt, opts);
+  const verbose = Boolean(opts.verbose);
+  const req = await normalizeOptions(prompt, opts, verbose);
+  const reqSummary = {
+    ...req,
+    prompt: req.prompt.slice(0, 50) + "...",
+    inputImages: req.inputImages?.map(
+      (img) => img.startsWith("data:") ? `data:...${img.length} chars` : img
+    ),
+    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));
   const provider = pickProvider(req.provider, env);
+  log5(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()...");
+  const startTime = Date.now();
   const partials = await provider.generate(req, env);
-  const images = [];
+  log5(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);
-    await writeImageFile(filePath, p.bytes);
-    images.push({ ...p, filePath });
+    log5(verbose, `Writing ${p.bytes.byteLength} bytes to: ${filePath}`);
+    await writeMediaFile(filePath, p.bytes);
+    items.push({ ...p, filePath });
   }
-  return images;
+  log5(verbose, `Done! Generated ${items.length} ${req.kind}(s)`);
+  return items;
 }
 
 // src/cli.ts
@@ -295,24 +1250,38 @@ Usage:
 Options:
   --provider <auto|${providers2}>   Provider (default: auto)
   --model <id>                    Model id (provider-specific)
-  --n <1..10>                     Number of images (default: 1)
-  --format <png|jpg|webp>         Output format (default: png)
+  --n <1..10>                     Number of outputs (default: 1)
+  --type <image|video>            Output type (default: image)
+  --video                         Shortcut for: --type video
+  --format <png|jpg|webp|mp4|webm|gif>
+                                 Output format (default: png for image, mp4 for video)
   --out <path>                    Output file path (only when n=1)
   --outDir <dir>                  Output directory (default: .)
   --name <text>                   Base name (slugified); default: prompt
-  --aspect-ratio <w:h>            Aspect ratio (xAI supports e.g. 4:3)
+  --aspect-ratio <w:h>            Aspect ratio (provider-specific)
   --json                          Print machine-readable JSON
   --verbose                       Verbose logging
   -h, --help                      Show help
 
+Input Images:
+  --input <path>                  Input image for editing or reference (repeatable)
+  --start-frame <path>            First frame image (for video generation)
+  --end-frame <path>              Last frame image (for video interpolation)
+  --duration <seconds>            Video duration in seconds (provider-specific)
+
 Env:
   GEMINI_API_KEY (or GOOGLE_API_KEY)
   XAI_API_KEY (or XAI_TOKEN, GROK_API_KEY)
   FAL_KEY (or FAL_API_KEY)
+  OPENAI_API_KEY
 
 Examples:
   npx climage "make image of kitten"
   npx climage "A cat in a tree" --provider xai --n 4
+  npx climage "a cinematic shot of a corgi running" --provider fal --type video
+  npx climage "make the cat orange" --provider xai --input photo.jpg
+  npx climage "the cat walks away" --video --provider google --start-frame cat.png
+  npx climage "morphing transition" --video --provider fal --start-frame a.png --end-frame b.png
 `);
   process3.exit(code);
 }
@@ -320,68 +1289,116 @@ function parseArgs(argv) {
   const args = [...argv];
   const opts = {};
   let json = false;
-  const take = (name) => {
-    const v = args.shift();
-    if (!v) throw new Error(`Missing value for ${name}`);
-    return v;
-  };
-  while (args.length) {
-    const a = args[0];
-    if (!a) break;
+  const promptParts = [];
+  const inputImages = [];
+  const optionsWithValue = /* @__PURE__ */ new Set([
+    "--provider",
+    "--model",
+    "--n",
+    "--type",
+    "--format",
+    "--out",
+    "--outDir",
+    "--name",
+    "--aspect-ratio",
+    "--input",
+    "--start-frame",
+    "--end-frame",
+    "--duration"
+  ]);
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (!a) {
+      i++;
+      continue;
+    }
     if (a === "-h" || a === "--help") usage(0);
     if (a === "--json") {
       json = true;
-      args.shift();
+      i++;
+      continue;
+    }
+    if (a === "--video") {
+      opts.kind = "video";
+      i++;
+      continue;
+    }
+    if (a === "--verbose") {
+      opts.verbose = true;
+      i++;
+      continue;
+    }
+    if (optionsWithValue.has(a)) {
+      const v = args[i + 1];
+      if (!v || v.startsWith("-")) throw new Error(`Missing value for ${a}`);
+      switch (a) {
+        case "--provider":
+          opts.provider = v;
+          break;
+        case "--model":
+          opts.model = v;
+          break;
+        case "--n":
+          opts.n = Number(v);
+          break;
+        case "--type":
+          opts.kind = v;
+          break;
+        case "--format":
+          opts.format = v;
+          break;
+        case "--out":
+          opts.out = v;
+          break;
+        case "--outDir":
+          opts.outDir = v;
+          break;
+        case "--name":
+          opts.name = v;
+          break;
+        case "--aspect-ratio":
+          opts.aspectRatio = v;
+          break;
+        case "--input":
+          inputImages.push(v);
+          break;
+        case "--start-frame":
+          opts.startFrame = v;
+          break;
+        case "--end-frame":
+          opts.endFrame = v;
+          break;
+        case "--duration":
+          opts.duration = Number(v);
+          break;
+      }
+      i += 2;
       continue;
     }
-    if (!a.startsWith("-")) break;
-    args.shift();
-    switch (a) {
-      case "--provider":
-        opts.provider = take(a);
-        break;
-      case "--model":
-        opts.model = take(a);
-        break;
-      case "--n":
-        opts.n = Number(take(a));
-        break;
-      case "--format":
-        opts.format = take(a);
-        break;
-      case "--out":
-        opts.out = take(a);
-        break;
-      case "--outDir":
-        opts.outDir = take(a);
-        break;
-      case "--name":
-        opts.name = take(a);
-        break;
-      case "--aspect-ratio":
-        opts.aspectRatio = take(a);
-        break;
-      case "--verbose":
-        opts.verbose = true;
-        break;
-      default:
-        throw new Error(`Unknown option: ${a}`);
-    }
-  }
-  const prompt = args.join(" ").trim();
+    if (a.startsWith("-")) {
+      throw new Error(`Unknown option: ${a}`);
+    }
+    promptParts.push(a);
+    i++;
+  }
+  if (inputImages.length) {
+    opts.inputImages = inputImages;
+  }
+  const prompt = promptParts.join(" ").trim();
   if (!prompt) throw new Error("Missing prompt");
   return { prompt, opts, json };
 }
 async function main() {
   try {
     const { prompt, opts, json } = parseArgs(process3.argv.slice(2));
-    const images = await generateImage(prompt, opts);
+    const items = await generateMedia(prompt, opts);
     if (json) {
-      process3.stdout.write(JSON.stringify({ images }, null, 2) + "\n");
+      process3.stdout.write(JSON.stringify(toJsonResult(items), null, 2) + "\n");
       return;
     }
-    for (const img of images) {
-      process3.stdout.write(img.filePath + "\n");
+    for (const item of items) {
+      process3.stdout.write(item.filePath + "\n");
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);