@mrgoonie/multix 0.0.2 → 0.0.5

package/dist/cli.js

@@ -155,10 +155,6 @@ var init_http_client = __esm({
 import { createRequire } from "module";
 import { Command } from "commander";
 
-// src/providers/gemini/commands/analyze.ts
-init_errors();
-import fs5 from "fs";
-
 // src/core/logger.ts
 var ANSI = {
   reset: "\x1B[0m",
@@ -204,10 +200,6 @@ ${line}
 }
 var defaultLogger = createLogger({ verbose: false });
 
-// src/providers/gemini/client.ts
-import fs3 from "fs";
-import path4 from "path";
-
 // src/core/env-loader.ts
 import fs from "fs";
 import os from "os";
@@ -236,234 +228,1130 @@ function redact(key) {
   return `${key.slice(0, 6)}...${key.slice(-4)}`;
 }
 
-// src/providers/gemini/client.ts
+// src/providers/byteplus/client.ts
 init_errors();
 init_http_client();
 
-// src/providers/gemini/task-resolver.ts
+// src/providers/byteplus/models.ts
+var DEFAULT_BYTEPLUS_BASE_URL = "https://ark.ap-southeast.bytepluses.com/api/v3";
+var DEFAULT_BYTEPLUS_IMAGE_MODEL = "seedream-4-0-250828";
+var DEFAULT_BYTEPLUS_VIDEO_MODEL = "seedance-2.0";
+var BYTEPLUS_DEFAULTS = {
+  imageModel: process.env.BYTEPLUS_IMAGE_MODEL ?? DEFAULT_BYTEPLUS_IMAGE_MODEL,
+  videoModel: process.env.BYTEPLUS_VIDEO_MODEL ?? DEFAULT_BYTEPLUS_VIDEO_MODEL,
+  videoResolution: "1080p",
+  videoDuration: 8,
+  videoAspectRatio: "16:9",
+  imageSize: "2K"
+};
+function bytePlusVideoParamsMode() {
+  const m = process.env.BYTEPLUS_VIDEO_PARAMS_MODE;
+  return m === "structured" ? "structured" : "flags";
+}
+
+// src/providers/byteplus/client.ts
+function requireBytePlusKey() {
+  const key = resolveKey("BYTEPLUS_API_KEY") ?? resolveKey("ARK_API_KEY");
+  if (!key) {
+    throw new ConfigError(
+      "BytePlus API key not set. Set BYTEPLUS_API_KEY or ARK_API_KEY. Get one at https://console.byteplus.com/auth/api-keys"
+    );
+  }
+  return key;
+}
+function bytePlusBaseUrl() {
+  return resolveKey("BYTEPLUS_BASE_URL") ?? DEFAULT_BYTEPLUS_BASE_URL;
+}
+var BytePlusClient = class {
+  constructor(apiKey, baseUrl = bytePlusBaseUrl()) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  apiKey;
+  baseUrl;
+  async request(path35, opts = {}) {
+    const base = this.baseUrl.replace(/\/$/, "");
+    const url = new URL(base + path35);
+    if (opts.query) {
+      for (const [k, v] of Object.entries(opts.query)) {
+        if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+      }
+    }
+    opts.logger?.debug(`${opts.method ?? "GET"} ${url.toString()}`);
+    return httpJson({
+      url: url.toString(),
+      method: opts.method ?? "GET",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${this.apiKey}`
+      },
+      body: opts.body,
+      timeoutMs: opts.timeoutMs ?? 12e4
+    });
+  }
+  get(path35, query, logger) {
+    return this.request(path35, { method: "GET", query, logger });
+  }
+  post(path35, body, logger) {
+    return this.request(path35, { method: "POST", body, logger });
+  }
+  delete(path35, logger) {
+    return this.request(path35, { method: "DELETE", logger });
+  }
+};
+function createBytePlusClient() {
+  return new BytePlusClient(requireBytePlusKey(), bytePlusBaseUrl());
+}
+
+// src/providers/byteplus/generators/image.ts
+init_http_client();
+import fs5 from "fs";
+import path5 from "path";
+
+// src/core/image-input.ts
+import fs3 from "fs/promises";
 import path3 from "path";
-var MIME_MAP = {
-  // Audio
-  ".mp3": "audio/mp3",
-  ".wav": "audio/wav",
-  ".aac": "audio/aac",
-  ".flac": "audio/flac",
-  ".ogg": "audio/ogg",
-  ".aiff": "audio/aiff",
-  ".m4a": "audio/mp4",
-  // Image
+var IMAGE_MIME_BY_EXT = {
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
   ".png": "image/png",
   ".webp": "image/webp",
-  ".heic": "image/heic",
-  ".heif": "image/heif",
-  ".gif": "image/gif",
-  ".bmp": "image/bmp",
-  // Video
+  ".gif": "image/gif"
+};
+var VIDEO_MIME_BY_EXT = {
   ".mp4": "video/mp4",
-  ".mpeg": "video/mpeg",
-  ".mov": "video/quicktime",
-  ".avi": "video/x-msvideo",
-  ".flv": "video/x-flv",
-  ".mpg": "video/mpeg",
   ".webm": "video/webm",
-  ".wmv": "video/x-ms-wmv",
-  ".3gpp": "video/3gpp",
-  // Document
-  ".pdf": "application/pdf",
-  ".txt": "text/plain",
-  ".html": "text/html",
-  ".htm": "text/html",
-  ".md": "text/markdown",
-  ".csv": "text/csv",
-  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+  ".mov": "video/quicktime",
+  ".m4v": "video/x-m4v"
 };
-function getMimeType(filePath) {
-  const ext = path3.extname(filePath).toLowerCase();
-  return MIME_MAP[ext] ?? "application/octet-stream";
-}
-function requiresProcessingWait(mimeType) {
-  return mimeType.startsWith("audio/") || mimeType.startsWith("video/");
+var AUDIO_MIME_BY_EXT = {
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".m4a": "audio/mp4",
+  ".flac": "audio/flac",
+  ".ogg": "audio/ogg"
+};
+var DEFAULT_SOFT_LIMIT_BYTES = 10 * 1024 * 1024;
+var DEFAULT_HARD_LIMIT_BYTES = 25 * 1024 * 1024;
+function isHttpUrl(input) {
+  return /^https?:\/\//i.test(input);
 }
-
-// src/providers/gemini/client.ts
-var BASE = "https://generativelanguage.googleapis.com";
-var FILES_BASE = `${BASE}/upload/v1beta/files`;
-var GENERATE_BASE = `${BASE}/v1beta/models`;
-function requireApiKey() {
-  const key = resolveKey("GEMINI_API_KEY");
-  if (!key)
-    throw new ConfigError(
-      "GEMINI_API_KEY is not set. Get one at https://aistudio.google.com/apikey"
+async function readAsDataUrl(filePath, mimeTable, kindLabel, opts = {}) {
+  const ext = path3.extname(filePath).toLowerCase();
+  const mime = mimeTable[ext];
+  if (!mime) {
+    throw new Error(
+      `Unsupported ${kindLabel} extension '${ext}'. Allowed: ${Object.keys(mimeTable).join(", ")}`
     );
-  return key;
-}
-function authHeaders(apiKey) {
-  return { "x-goog-api-key": apiKey };
-}
-async function uploadFile(filePath, opts = {}) {
-  const apiKey = requireApiKey();
-  const { timeoutMs = 3e5, logger } = opts;
-  const mimeType = getMimeType(filePath);
-  const fileBytes = fs3.readFileSync(filePath);
-  const displayName = path4.basename(filePath);
-  const boundary = `multix_${Date.now()}`;
-  const metaJson = JSON.stringify({ file: { displayName, mimeType } });
-  const body = Buffer.concat([
-    Buffer.from(
-      `--${boundary}\r
-Content-Type: application/json; charset=UTF-8\r
-\r
-${metaJson}\r
---${boundary}\r
-Content-Type: ${mimeType}\r
-\r
-`
-    ),
-    fileBytes,
-    Buffer.from(`\r
---${boundary}--`)
-  ]);
-  logger?.debug(`Uploading ${displayName} (${(fileBytes.length / 1024 / 1024).toFixed(2)} MB)`);
-  const resp = await globalThis.fetch(FILES_BASE, {
-    method: "POST",
-    headers: {
-      "x-goog-api-key": apiKey,
-      "Content-Type": `multipart/related; boundary=${boundary}`,
-      "Content-Length": String(body.length),
-      "X-Goog-Upload-Protocol": "multipart"
-    },
-    body,
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-  if (!resp.ok) {
-    const txt = await resp.text();
-    throw new ProviderError(
-      `File upload failed (HTTP ${resp.status}): ${txt.slice(0, 500)}`,
-      "gemini"
+  }
+  const hard = opts.hardLimitBytes ?? DEFAULT_HARD_LIMIT_BYTES;
+  const soft = opts.softLimitBytes ?? DEFAULT_SOFT_LIMIT_BYTES;
+  const buf = await fs3.readFile(filePath);
+  if (buf.byteLength > hard) {
+    throw new Error(
+      `${kindLabel} file ${filePath} is ${(buf.byteLength / 1024 / 1024).toFixed(1)}MB \u2014 exceeds ${(hard / 1024 / 1024).toFixed(0)}MB limit. Upload to a URL instead.`
     );
   }
-  const data = await resp.json();
-  let fileRef = data.file;
-  if (requiresProcessingWait(mimeType)) {
-    const deadline = Date.now() + timeoutMs;
-    while (fileRef.state === "PROCESSING" && Date.now() < deadline) {
-      await sleep(2e3);
-      fileRef = await httpJson({
-        url: `${BASE}/v1beta/${fileRef.name}`,
-        headers: authHeaders(apiKey)
-      }).then((r) => r.file);
-      logger?.debug(`Processing... state=${fileRef.state}`);
-    }
-    if (fileRef.state === "FAILED")
-      throw new ProviderError(`File processing failed: ${filePath}`, "gemini");
-    if (fileRef.state === "PROCESSING")
-      throw new ProviderError(`Processing timeout: ${filePath}`, "gemini");
+  if (buf.byteLength > soft) {
+    opts.logger?.warn(
+      `${kindLabel} payload ${(buf.byteLength / 1024 / 1024).toFixed(1)}MB is large; consider URL input.`
+    );
   }
-  logger?.debug(`Uploaded: ${fileRef.name} (${fileRef.uri})`);
-  return fileRef;
+  const dataUrl = `data:${mime};base64,${buf.toString("base64")}`;
+  return { dataUrl, mime, bytes: buf.byteLength };
 }
-async function generateContent(req) {
-  const apiKey = requireApiKey();
-  return httpJson({
-    url: `${GENERATE_BASE}/${req.model}:generateContent`,
-    method: "POST",
-    headers: authHeaders(apiKey),
-    body: {
-      contents: req.contents,
-      ...req.generationConfig ? { generationConfig: req.generationConfig } : {}
-    }
-  });
+async function resolveImageInput(input, opts = {}) {
+  const o = normalizeOpts(opts);
+  if (isHttpUrl(input)) return { kind: "url", url: input };
+  const { dataUrl, mime, bytes } = await readAsDataUrl(input, IMAGE_MIME_BY_EXT, "image", o);
+  return { kind: "data", dataUrl, mime, bytes };
 }
-function extractText(resp) {
-  const parts = resp.candidates?.[0]?.content?.parts ?? [];
-  return parts.filter((p) => p.text !== void 0).map((p) => p.text ?? "").join("");
+async function resolveVideoInput(input, opts = {}) {
+  const o = normalizeOpts(opts);
+  if (isHttpUrl(input)) return { kind: "url", url: input };
+  const { dataUrl, mime, bytes } = await readAsDataUrl(input, VIDEO_MIME_BY_EXT, "video", o);
+  return { kind: "data", dataUrl, mime, bytes };
 }
-function extractImages(resp) {
-  const parts = resp.candidates?.[0]?.content?.parts ?? [];
-  return parts.filter(
-    (p) => p.inlineData !== void 0
-  ).map((p) => ({ mimeType: p.inlineData.mimeType, data: p.inlineData.data }));
+async function resolveAudioInput(input, opts = {}) {
+  const o = normalizeOpts(opts);
+  if (isHttpUrl(input)) return { kind: "url", url: input };
+  const { dataUrl, mime, bytes } = await readAsDataUrl(input, AUDIO_MIME_BY_EXT, "audio", o);
+  return { kind: "data", dataUrl, mime, bytes };
 }
-function inlinePart(filePath) {
-  const data = fs3.readFileSync(filePath).toString("base64");
-  const mimeType = getMimeType(filePath);
-  return { inlineData: { mimeType, data } };
+function refUrl(r) {
+  return r.kind === "url" ? r.url : r.dataUrl;
 }
-function shouldUseFileApi(filePath) {
-  const stat = fs3.statSync(filePath);
-  return stat.size > 20 * 1024 * 1024;
+function normalizeOpts(opts) {
+  if (!opts) return {};
+  if (typeof opts.info === "function" && typeof opts.warn === "function") {
+    return { logger: opts };
+  }
+  return opts;
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/core/output-dir.ts
+import fs4 from "fs";
+import path4 from "path";
+var cachedOutputDir;
+function getOutputDir() {
+  if (cachedOutputDir) return cachedOutputDir;
+  const dir = process.env.MULTIX_OUTPUT_DIR ? path4.resolve(process.env.MULTIX_OUTPUT_DIR) : path4.resolve(process.cwd(), "multix-output");
+  fs4.mkdirSync(dir, { recursive: true });
+  cachedOutputDir = dir;
+  return dir;
 }
 
-// src/providers/gemini/models.ts
-var IMAGE_MODEL_DEFAULT = "gemini-3.1-flash-image-preview";
-var VIDEO_MODEL_DEFAULT = "veo-3.1-generate-preview";
-var ANALYSIS_MODEL_DEFAULT = "gemini-2.5-flash";
-var DOC_MODEL_DEFAULT = "gemini-2.5-flash";
-var IMAGEN_MODELS = /* @__PURE__ */ new Set([
-  "imagen-4.0-generate-001",
-  "imagen-4.0-ultra-generate-001",
-  "imagen-4.0-fast-generate-001"
-]);
-var GEMINI_IMAGE_MODELS = /* @__PURE__ */ new Set([
-  "gemini-3.1-flash-image-preview",
-  "gemini-3-pro-image-preview",
-  "gemini-2.5-flash-image",
-  "gemini-2.5-flash-image-preview",
-  ...IMAGEN_MODELS
-]);
-var ASPECT_RATIOS = [
-  "1:1",
-  "2:3",
-  "3:2",
-  "3:4",
-  "4:3",
-  "4:5",
-  "5:4",
-  "9:16",
-  "16:9",
-  "21:9"
-];
-var IMAGE_SIZES = ["1K", "2K", "4K"];
-function getDefaultModel(task) {
-  if (task === "generate") {
-    return process.env.IMAGE_GEN_MODEL ?? process.env.GEMINI_IMAGE_GEN_MODEL ?? IMAGE_MODEL_DEFAULT;
+// src/providers/byteplus/generators/image.ts
+var ASPECT_TO_SIZE = {
+  "1:1": "2048x2048",
+  "16:9": "2560x1440",
+  "9:16": "1440x2560",
+  "4:3": "2048x1536",
+  "3:4": "1536x2048",
+  "21:9": "2560x1080",
+  "3:2": "2048x1365",
+  "2:3": "1365x2048"
+};
+function resolveSize(opts) {
+  if (opts.size && opts.aspectRatio) {
+    opts.logger?.warn("Both --size and --aspect-ratio given; using --size.");
+    return opts.size;
   }
-  if (task === "generate-video") {
-    return process.env.VIDEO_GEN_MODEL ?? VIDEO_MODEL_DEFAULT;
+  if (opts.size) return opts.size;
+  if (opts.aspectRatio) {
+    const mapped = ASPECT_TO_SIZE[opts.aspectRatio];
+    if (!mapped) {
+      throw new Error(
+        `Unsupported --aspect-ratio '${opts.aspectRatio}'. Supported: ${Object.keys(ASPECT_TO_SIZE).join(", ")}`
+      );
+    }
+    return mapped;
   }
-  return process.env.MULTIMODAL_MODEL ?? process.env.GEMINI_MODEL ?? ANALYSIS_MODEL_DEFAULT;
+  return BYTEPLUS_DEFAULTS.imageSize;
 }
-
-// src/providers/gemini/result-formatter.ts
-import fs4 from "fs";
-import path5 from "path";
-function formatResults(results, format, outputPath) {
-  const content = renderFormat(results, format);
-  if (outputPath) {
-    fs4.mkdirSync(path5.dirname(path5.resolve(outputPath)), { recursive: true });
-    fs4.writeFileSync(outputPath, content, "utf8");
-  } else {
-    process.stdout.write(content);
+async function generateSeedream(client, opts) {
+  const logger = opts.logger;
+  const model = opts.model ?? BYTEPLUS_DEFAULTS.imageModel;
+  const resolvedInputs = [];
+  for (const input of opts.inputImages ?? []) {
+    const r = await resolveImageInput(input, logger);
+    resolvedInputs.push(refUrl(r));
   }
-}
-function renderFormat(results, format) {
-  switch (format) {
-    case "json":
-      return `${JSON.stringify(results, null, 2)}
-`;
-    case "csv":
-      return renderCsv(results);
-    case "markdown":
-      return renderMarkdown(results);
-    default:
-      return renderText(results);
+  const body = {
+    model,
+    prompt: opts.prompt,
+    response_format: "url",
+    n: opts.numImages ?? 1,
+    watermark: opts.watermark ?? true,
+    size: resolveSize(opts)
+  };
+  if (resolvedInputs.length > 0) body.image = resolvedInputs;
+  if (opts.seed !== void 0) body.seed = opts.seed;
+  logger?.debug(
+    `Seedream body: ${JSON.stringify({ ...body, image: body.image ? `[${body.image.length}]` : void 0 })}`
+  );
+  const res = await client.post("/images/generations", body, logger);
+  const items = res.data ?? [];
+  const ts = Date.now();
+  const outDir = getOutputDir();
+  const saved = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (!item) continue;
+    const url = item.url;
+    if (!url) {
+      logger?.warn(`Image ${i + 1}: no URL in response (b64_json fallback not yet supported).`);
+      continue;
+    }
+    const ext = (() => {
+      try {
+        const e = path5.extname(new URL(url).pathname);
+        return e || ".jpg";
+      } catch {
+        return ".jpg";
+      }
+    })();
+    const filename = opts.output && items.length === 1 ? path5.resolve(opts.output) : path5.join(outDir, `byteplus-image-${ts}-${i + 1}${ext}`);
+    fs5.mkdirSync(path5.dirname(filename), { recursive: true });
+    await downloadFile(url, filename);
+    saved.push({ path: filename, url, seed: item.seed });
+    logger?.success(`Saved ${filename}`);
+  }
+  return saved;
+}
+
+// src/providers/byteplus/commands/generate.ts
+function registerBytePlusGenerateCommand(parent) {
+  parent.command("generate").alias("gen").description("Generate images with BytePlus Seedream 4.0 (text-to-image, multi-image input)").requiredOption("--prompt <text>", "Text prompt").option("-m, --model <id>", "Model id (default seedream-4-0-250828)").option("--size <size>", "Image size (e.g. 1024x1024, 1K, 2K, 4K)").option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9, 9:16); maps to size").option("-n, --num-images <n>", "Number of images", "1").option("--seed <n>", "Fixed seed").option("--no-watermark", "Disable watermark").option(
+    "--input-image <path>",
+    "Reference image (URL or local path); repeatable",
+    collect,
+    []
+  ).option("--output <path>", "Save single image to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const client = createBytePlusClient();
+      const saved = await generateSeedream(client, {
+        prompt: opts.prompt,
+        model: opts.model,
+        size: opts.size,
+        aspectRatio: opts.aspectRatio,
+        numImages: Number.parseInt(opts.numImages, 10) || 1,
+        seed: opts.seed ? Number.parseInt(opts.seed, 10) : void 0,
+        watermark: opts.watermark,
+        inputImages: opts.inputImage,
+        output: opts.output,
+        logger
+      });
+      console.log(`
+Generated ${saved.length} image(s):`);
+      for (const f of saved) console.log(`  ${f.path}`);
+    }
+  );
+}
+function collect(value, prev) {
+  return [...prev, value];
+}
+
+// src/providers/byteplus/commands/image-to-image.ts
+function registerBytePlusImageToImageCommand(parent) {
+  parent.command("image-to-image").alias("i2i").description(
+    "Edit/transform image(s) with BytePlus Seedream/Seededit using one or more reference images"
+  ).requiredOption("--prompt <text>", "Text prompt describing the edit").requiredOption(
+    "--ref <path>",
+    "Reference image (URL or local path); repeatable for multi-ref",
+    collect2,
+    []
+  ).option("-m, --model <id>", "Model id (default seedream-4-0-250828)").option("--size <size>", "Image size (e.g. 1024x1024, 1K, 2K, 4K)").option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9, 9:16); maps to size").option("-n, --num-images <n>", "Number of images", "1").option("--seed <n>", "Fixed seed").option("--no-watermark", "Disable watermark").option("--output <path>", "Save single image to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      if (!opts.ref || opts.ref.length === 0) {
+        throw new Error("At least one --ref is required for image-to-image.");
+      }
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const client = createBytePlusClient();
+      const saved = await generateSeedream(client, {
+        prompt: opts.prompt,
+        model: opts.model,
+        size: opts.size,
+        aspectRatio: opts.aspectRatio,
+        numImages: Number.parseInt(opts.numImages, 10) || 1,
+        seed: opts.seed ? Number.parseInt(opts.seed, 10) : void 0,
+        watermark: opts.watermark,
+        inputImages: opts.ref,
+        output: opts.output,
+        logger
+      });
+      console.log(`
+Generated ${saved.length} image(s):`);
+      for (const f of saved) console.log(`  ${f.path}`);
+    }
+  );
+}
+function collect2(value, prev) {
+  return [...prev, value];
+}
+
+// src/providers/byteplus/commands/image-to-video.ts
+import path7 from "path";
+
+// src/core/video-thumb.ts
+init_http_client();
+import fs6 from "fs";
+import path6 from "path";
+var THUMB_KEYS = /* @__PURE__ */ new Set([
+  "cover_image_url",
+  "coverImageUrl",
+  "cover_url",
+  "coverUrl",
+  "thumbnail_url",
+  "thumbnailUrl",
+  "thumb_url",
+  "thumbUrl",
+  "preview_url",
+  "previewUrl",
+  "first_frame_url",
+  "firstFrameUrl",
+  "poster_url",
+  "posterUrl",
+  "image_url",
+  "imageUrl"
+]);
+var IMAGE_EXT_RE = /\.(jpe?g|png|webp|gif|bmp)(\?|$)/i;
+function isImageUrl(value) {
+  if (typeof value !== "string") return false;
+  if (!/^https?:\/\//i.test(value)) return false;
+  return IMAGE_EXT_RE.test(value);
+}
+function detectThumbUrl(obj) {
+  if (obj === null || obj === void 0) return null;
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      const found = detectThumbUrl(item);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (typeof obj !== "object") return null;
+  const record = obj;
+  for (const [key, value] of Object.entries(record)) {
+    if (THUMB_KEYS.has(key) && isImageUrl(value)) return value;
+  }
+  for (const value of Object.values(record)) {
+    if (value && typeof value === "object") {
+      const found = detectThumbUrl(value);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+async function downloadThumbBeside(thumbUrl, videoPath, logger) {
+  const match = thumbUrl.match(IMAGE_EXT_RE);
+  const ext = match?.[1] ? match[1].toLowerCase().replace("jpeg", "jpg") : "jpg";
+  const dir = path6.dirname(videoPath);
+  const base = path6.basename(videoPath, path6.extname(videoPath));
+  const dest = path6.join(dir, `${base}_thumb.${ext}`);
+  try {
+    await downloadFile(thumbUrl, dest);
+    logger?.success(`Saved thumb ${dest}`);
+    return dest;
+  } catch (e) {
+    logger?.warn(`Thumb download failed: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+async function maybeDownloadThumb(source, videoPath, opts = {}) {
+  if (opts.skip) return null;
+  const url = detectThumbUrl(source);
+  if (!url) {
+    opts.logger?.debug("No thumbnail URL detected in provider response");
+    return null;
+  }
+  const saved = await downloadThumbBeside(url, videoPath, opts.logger);
+  if (saved && opts.copyTo) {
+    const copyExt = path6.extname(saved);
+    const copyBase = path6.basename(opts.copyTo, path6.extname(opts.copyTo));
+    const copyDir = path6.dirname(path6.resolve(opts.copyTo));
+    const copyDest = path6.join(copyDir, `${copyBase}_thumb${copyExt}`);
+    fs6.mkdirSync(copyDir, { recursive: true });
+    fs6.copyFileSync(saved, copyDest);
+    opts.logger?.success(`Copied thumb to ${copyDest}`);
+  }
+  return saved;
+}
+
+// src/providers/leonardo/poll.ts
+var PollTimeoutError = class extends Error {
+  constructor() {
+    super("Polling timed out before the operation completed.");
+    this.name = "PollTimeoutError";
+  }
+};
+var PollFailedError = class extends Error {
+  constructor(value) {
+    super("Operation failed.");
+    this.value = value;
+    this.name = "PollFailedError";
+  }
+  value;
+};
+async function poll(opts) {
+  const interval = opts.intervalMs ?? 4e3;
+  const max = opts.maxAttempts ?? 120;
+  for (let attempt = 1; attempt <= max; attempt++) {
+    if (opts.signal?.aborted) throw new Error("Aborted");
+    const value = await opts.fetch();
+    opts.onTick?.(attempt, value);
+    if (opts.failed?.(value)) throw new PollFailedError(value);
+    if (opts.done(value)) return value;
+    await new Promise((resolve, reject) => {
+      const t = setTimeout(resolve, interval);
+      opts.signal?.addEventListener("abort", () => {
+        clearTimeout(t);
+        reject(new Error("Aborted"));
+      });
+    });
+  }
+  throw new PollTimeoutError();
+}
+
+// src/providers/byteplus/generators/video.ts
+init_http_client();
+function buildFlagSuffix(opts) {
+  const parts = [];
+  if (opts.resolution) parts.push(`--rs ${opts.resolution}`);
+  if (opts.duration !== void 0) parts.push(`--dur ${opts.duration}`);
+  if (opts.aspectRatio) parts.push(`--rt ${opts.aspectRatio}`);
+  if (opts.cameraFixed !== void 0) parts.push(`--cf ${opts.cameraFixed}`);
+  if (opts.seed !== void 0) parts.push(`--seed ${opts.seed}`);
+  if (opts.audio !== void 0) parts.push(`--wm ${opts.audio}`);
+  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}
+function buildVideoTaskBody(opts) {
+  const mode = opts.paramsMode ?? bytePlusVideoParamsMode();
+  const text = mode === "flags" ? `${opts.prompt}${buildFlagSuffix(opts)}${opts.negativePrompt ? ` negative: "${opts.negativePrompt}"` : ""}` : opts.prompt;
+  const content = [{ type: "text", text }];
+  for (const img of opts.imageInputs ?? []) {
+    content.push({ type: "image_url", image_url: { url: refUrl(img) } });
+  }
+  for (const ref of opts.references ?? []) {
+    if (ref.kind === "image") {
+      content.push({
+        type: "image_url",
+        image_url: { url: ref.url, ...ref.role ? { role: ref.role } : {} }
+      });
+    } else if (ref.kind === "video") {
+      content.push({
+        type: "video_url",
+        video_url: { url: ref.url, ...ref.role ? { role: ref.role } : {} }
+      });
+    } else {
+      content.push({
+        type: "audio_url",
+        audio_url: { url: ref.url, ...ref.role ? { role: ref.role } : {} }
+      });
+    }
+  }
+  const body = { model: opts.model, content };
+  if (mode === "structured") {
+    body.parameters = {
+      ...opts.resolution ? { resolution: opts.resolution } : {},
+      ...opts.duration !== void 0 ? { duration: opts.duration } : {},
+      ...opts.aspectRatio ? { aspect_ratio: opts.aspectRatio } : {},
+      ...opts.audio !== void 0 ? { audio: opts.audio } : {},
+      ...opts.seed !== void 0 ? { seed: opts.seed } : {},
+      ...opts.negativePrompt ? { negative_prompt: opts.negativePrompt } : {},
+      ...opts.cameraFixed !== void 0 ? { camera_fixed: opts.cameraFixed } : {}
+    };
+  }
+  return body;
+}
+async function submitVideoTask(client, body, logger) {
+  return client.post("/contents/generations/tasks", body, logger);
+}
+async function getVideoTaskStatus(client, id, logger) {
+  return client.get(`/contents/generations/tasks/${id}`, void 0, logger);
+}
+async function waitForVideoTask(client, id, opts = {}) {
+  const intervalMs = opts.intervalMs ?? 4e3;
+  const maxAttempts = opts.maxAttempts ?? (opts.waitTimeoutMs ? Math.max(1, Math.ceil(opts.waitTimeoutMs / intervalMs)) : 120);
+  return poll({
+    fetch: () => getVideoTaskStatus(client, id, opts.logger),
+    done: (v) => v.status === "succeeded",
+    failed: (v) => v.status === "failed" || v.status === "cancelled",
+    intervalMs,
+    maxAttempts,
+    onTick: (attempt, v) => opts.logger?.debug(`attempt ${attempt} \u2014 status: ${v.status}`)
+  });
+}
+async function downloadVideo(url, outputPath, logger) {
+  await downloadFile(url, outputPath);
+  logger?.success(`Saved ${outputPath}`);
+}
+
+// src/providers/byteplus/commands/image-to-video.ts
+function registerBytePlusImageToVideoCommand(parent) {
+  parent.command("image-to-video <image>").alias("i2v").description("Generate a video from an image (URL or local) via BytePlus Seedance 2.0").requiredOption("--prompt <text>", "Motion prompt").option("-m, --model <id>", "Model id", BYTEPLUS_DEFAULTS.videoModel).option("--resolution <r>", "480p|720p|1080p|2k", BYTEPLUS_DEFAULTS.videoResolution).option("--duration <n>", "Duration seconds", String(BYTEPLUS_DEFAULTS.videoDuration)).option("--aspect-ratio <r>", "Aspect ratio", BYTEPLUS_DEFAULTS.videoAspectRatio).option("--audio", "Enable audio").option("--no-audio", "Disable audio").option("--seed <n>", "Fixed seed").option("--negative <text>", "Negative prompt").option("--camera-fixed", "Lock camera").option("--last-frame <path>", "Optional last-frame image (URL or local)").option("--async", "Submit task and exit").option("--wait-timeout <ms>", "Poll timeout in ms", "600000").option("--output <path>", "Output MP4 path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (image, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const client = createBytePlusClient();
+      const first = await resolveImageInput(image, logger);
+      const refs = [];
+      if (opts.lastFrame) {
+        const last = await resolveImageInput(opts.lastFrame, logger);
+        refs.push({
+          kind: "image",
+          url: last.kind === "url" ? last.url : last.dataUrl,
+          mime: last.kind === "data" ? last.mime : void 0,
+          role: "last_frame"
+        });
+      }
+      const body = buildVideoTaskBody({
+        model: opts.model,
+        prompt: opts.prompt,
+        resolution: opts.resolution,
+        duration: Number.parseInt(opts.duration, 10),
+        aspectRatio: opts.aspectRatio,
+        audio: opts.audio,
+        seed: opts.seed ? Number.parseInt(opts.seed, 10) : void 0,
+        negativePrompt: opts.negative,
+        cameraFixed: opts.cameraFixed,
+        imageInputs: [first],
+        references: refs
+      });
+      logger.info(`Submitting i2v task (${opts.model})`);
+      const submitted = await submitVideoTask(client, body, logger);
+      const taskId = submitted.id;
+      if (opts.async) {
+        console.log(taskId);
+        console.error(`Poll with: multix byteplus status ${taskId}`);
+        return;
+      }
+      try {
+        const final = await waitForVideoTask(client, taskId, {
+          waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 6e5,
+          logger
+        });
+        const url = final.content?.video_url;
+        if (!url) {
+          logger.error(`Task succeeded but no video_url: ${JSON.stringify(final)}`);
+          process.exit(1);
+        }
+        const outPath = opts.output ?? path7.join(getOutputDir(), `byteplus-i2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
+        await downloadVideo(url, outPath, logger);
+        await maybeDownloadThumb(final, outPath, {
+          skip: opts.thumb === false,
+          copyTo: opts.output,
+          logger
+        });
+        console.log(`
+Task: ${taskId}`);
+        console.log(`Saved: ${outPath}`);
+      } catch (e) {
+        if (e instanceof PollTimeoutError) {
+          logger.error(`Timed out \u2014 multix byteplus status ${taskId}`);
+          process.exit(1);
+        }
+        if (e instanceof PollFailedError) {
+          logger.error(`Task failed: ${JSON.stringify(e.value)}`);
+          process.exit(1);
+        }
+        throw e;
+      }
+    }
+  );
+}
+
+// src/providers/byteplus/commands/reference-to-video.ts
+import path8 from "path";
+
+// src/providers/byteplus/reference-input.ts
+var MAX_TOTAL_REFS = 12;
+var MAX_IMAGE_REFS = 9;
+var MAX_VIDEO_REFS = 3;
+var MAX_AUDIO_REFS = 3;
+function parseRefSpec(input) {
+  const PLACEHOLDER = "\0";
+  const escaped = input.replace(/\\:/g, PLACEHOLDER);
+  const lastIdx = escaped.lastIndexOf(":");
+  if (lastIdx === -1) {
+    return { path: input.replace(/\\:/g, ":") };
+  }
+  const left = escaped.slice(0, lastIdx);
+  const right = escaped.slice(lastIdx + 1);
+  if (/^[a-zA-Z]$/.test(left) && /[\\/]/.test(right)) {
+    return { path: input.replace(/\\:/g, ":") };
+  }
+  if (right.length === 0) {
+    return { path: left.replace(new RegExp(PLACEHOLDER, "g"), ":") };
+  }
+  return {
+    path: left.replace(new RegExp(PLACEHOLDER, "g"), ":"),
+    role: right.replace(new RegExp(PLACEHOLDER, "g"), ":") || void 0
+  };
+}
+function toRef(kind, resolved, role) {
+  if (resolved.kind === "url") return { kind, url: resolved.url, role };
+  return { kind, url: resolved.dataUrl, mime: resolved.mime, role };
+}
+async function resolveRefSpec(kind, spec, logger) {
+  const { path: path35, role } = parseRefSpec(spec);
+  if (kind === "image") return toRef(kind, await resolveImageInput(path35, logger), role);
+  if (kind === "video") return toRef(kind, await resolveVideoInput(path35, logger), role);
+  return toRef(kind, await resolveAudioInput(path35, logger), role);
+}
+async function resolveRefSpecs(specs, logger) {
+  const out = [];
+  for (const { kind, spec } of specs) {
+    out.push(await resolveRefSpec(kind, spec, logger));
+  }
+  return out;
+}
+function validateRefCounts(refs) {
+  if (refs.length > MAX_TOTAL_REFS) {
+    throw new Error(`Too many references: ${refs.length} > ${MAX_TOTAL_REFS}`);
+  }
+  const images = refs.filter((r) => r.kind === "image").length;
+  const videos = refs.filter((r) => r.kind === "video").length;
+  const audios = refs.filter((r) => r.kind === "audio").length;
+  if (images > MAX_IMAGE_REFS)
+    throw new Error(`Too many image refs: ${images} > ${MAX_IMAGE_REFS}`);
+  if (videos > MAX_VIDEO_REFS)
+    throw new Error(`Too many video refs: ${videos} > ${MAX_VIDEO_REFS}`);
+  if (audios > MAX_AUDIO_REFS)
+    throw new Error(`Too many audio refs: ${audios} > ${MAX_AUDIO_REFS}`);
+}
+var REF_LIMITS = {
+  total: MAX_TOTAL_REFS,
+  image: MAX_IMAGE_REFS,
+  video: MAX_VIDEO_REFS,
+  audio: MAX_AUDIO_REFS
+};
+
+// src/providers/byteplus/commands/reference-to-video.ts
+function collect3(value, prev) {
+  return [...prev, value];
+}
+function registerBytePlusReferenceToVideoCommand(parent) {
+  parent.command("reference-to-video").alias("r2v").description(
+    `Generate video from multimodal references (\u2264${REF_LIMITS.image} images, \u2264${REF_LIMITS.video} videos, \u2264${REF_LIMITS.audio} audio; total \u2264${REF_LIMITS.total}). Use path:role syntax (escape literal colons with \\:).`
+  ).requiredOption("--prompt <text>", "Text prompt").option(
+    "--ref-image <spec>",
+    "Image ref (path|url[:role]); repeatable",
+    collect3,
+    []
+  ).option(
+    "--ref-video <spec>",
+    "Video ref (path|url[:role]); repeatable",
+    collect3,
+    []
+  ).option(
+    "--ref-audio <spec>",
+    "Audio ref (path|url[:role]); repeatable",
+    collect3,
+    []
+  ).option("-m, --model <id>", "Model id", BYTEPLUS_DEFAULTS.videoModel).option("--resolution <r>", "480p|720p|1080p|2k", BYTEPLUS_DEFAULTS.videoResolution).option("--duration <n>", "Duration seconds", String(BYTEPLUS_DEFAULTS.videoDuration)).option("--aspect-ratio <r>", "Aspect ratio", BYTEPLUS_DEFAULTS.videoAspectRatio).option("--audio", "Enable audio").option("--no-audio", "Disable audio").option("--seed <n>", "Fixed seed").option("--negative <text>", "Negative prompt").option("--camera-fixed", "Lock camera").option("--async", "Submit task and exit").option("--wait-timeout <ms>", "Poll timeout in ms", "600000").option("--output <path>", "Output MP4 path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const specs = [
+        ...opts.refImage.map((s) => ({ kind: "image", spec: s })),
+        ...opts.refVideo.map((s) => ({ kind: "video", spec: s })),
+        ...opts.refAudio.map((s) => ({ kind: "audio", spec: s }))
+      ];
+      if (specs.length === 0) {
+        logger.error("At least one --ref-image / --ref-video / --ref-audio is required");
+        process.exit(2);
+      }
+      const refs = await resolveRefSpecs(specs, logger);
+      validateRefCounts(refs);
+      const client = createBytePlusClient();
+      const body = buildVideoTaskBody({
+        model: opts.model,
+        prompt: opts.prompt,
+        resolution: opts.resolution,
+        duration: Number.parseInt(opts.duration, 10),
+        aspectRatio: opts.aspectRatio,
+        audio: opts.audio,
+        seed: opts.seed ? Number.parseInt(opts.seed, 10) : void 0,
+        negativePrompt: opts.negative,
+        cameraFixed: opts.cameraFixed,
+        references: refs
+      });
+      logger.info(`Submitting r2v task (${opts.model}, ${refs.length} refs)`);
+      const submitted = await submitVideoTask(client, body, logger);
+      const taskId = submitted.id;
+      if (opts.async) {
+        console.log(taskId);
+        console.error(`Poll with: multix byteplus status ${taskId}`);
+        return;
+      }
+      try {
+        const final = await waitForVideoTask(client, taskId, {
+          waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 6e5,
+          logger
+        });
+        const url = final.content?.video_url;
+        if (!url) {
+          logger.error(`Task succeeded but no video_url: ${JSON.stringify(final)}`);
+          process.exit(1);
+        }
+        const outPath = opts.output ?? path8.join(getOutputDir(), `byteplus-r2v-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
+        await downloadVideo(url, outPath, logger);
+        await maybeDownloadThumb(final, outPath, {
+          skip: opts.thumb === false,
+          copyTo: opts.output,
+          logger
+        });
+        console.log(`
+Task: ${taskId}`);
+        console.log(`Saved: ${outPath}`);
+      } catch (e) {
+        if (e instanceof PollTimeoutError) {
+          logger.error(`Timed out \u2014 multix byteplus status ${taskId}`);
+          process.exit(1);
+        }
+        if (e instanceof PollFailedError) {
+          logger.error(`Task failed: ${JSON.stringify(e.value)}`);
+          process.exit(1);
+        }
+        throw e;
+      }
+    }
+  );
+}
+
+// src/providers/byteplus/commands/status.ts
+import path9 from "path";
+function registerBytePlusStatusCommand(parent) {
+  parent.command("status <taskId>").description("Get a Seedance task's status; --wait + --download to fetch the result MP4").option("--wait", "Poll until terminal status").option("--wait-timeout <ms>", "Poll timeout in ms (with --wait)", "600000").option("--download", "Download MP4 on success (implies --wait)").option("--output <path>", "Output MP4 path (with --download)").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (taskId, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const client = createBytePlusClient();
+      const shouldWait = !!(opts.wait || opts.download);
+      try {
+        const status = shouldWait ? await waitForVideoTask(client, taskId, {
+          waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 6e5,
+          logger
+        }) : await getVideoTaskStatus(client, taskId, logger);
+        console.log(JSON.stringify(status, null, 2));
+        if (opts.download && status.status === "succeeded") {
+          const url = status.content?.video_url;
+          if (!url) {
+            logger.error("Task succeeded but no video_url present");
+            process.exit(1);
+          }
+          const outPath = opts.output ?? path9.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}.mp4`);
+          await downloadVideo(url, outPath, logger);
+          await maybeDownloadThumb(status, outPath, {
+            skip: opts.thumb === false,
+            copyTo: opts.output,
+            logger
+          });
+          console.log(`Saved: ${outPath}`);
+        }
+      } catch (e) {
+        if (e instanceof PollTimeoutError) {
+          logger.error(`Timed out waiting for task ${taskId}`);
+          process.exit(1);
+        }
+        if (e instanceof PollFailedError) {
+          logger.error(`Task failed: ${JSON.stringify(e.value)}`);
+          process.exit(1);
+        }
+        throw e;
+      }
+    }
+  );
+}
+
+// src/providers/byteplus/commands/video.ts
+import path10 from "path";
+function registerBytePlusVideoCommand(parent) {
+  parent.command("video").description("Generate a video from a text prompt via BytePlus Seedance 2.0").requiredOption("--prompt <text>", "Text prompt").option("-m, --model <id>", "Model id", BYTEPLUS_DEFAULTS.videoModel).option("--resolution <r>", "480p|720p|1080p|2k", BYTEPLUS_DEFAULTS.videoResolution).option("--duration <n>", "Duration seconds (4-15)", String(BYTEPLUS_DEFAULTS.videoDuration)).option(
+    "--aspect-ratio <r>",
+    "Aspect ratio (16:9, 9:16, 1:1, ...)",
+    BYTEPLUS_DEFAULTS.videoAspectRatio
+  ).option("--audio", "Enable audio track").option("--no-audio", "Disable audio track").option("--seed <n>", "Fixed seed").option("--negative <text>", "Negative prompt").option("--camera-fixed", "Lock camera (no motion)").option("--async", "Submit task and exit; print taskId only").option("--wait-timeout <ms>", "Poll timeout in ms", "600000").option("--output <path>", "Output MP4 path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const client = createBytePlusClient();
+      const body = buildVideoTaskBody({
+        model: opts.model,
+        prompt: opts.prompt,
+        resolution: opts.resolution,
+        duration: Number.parseInt(opts.duration, 10),
+        aspectRatio: opts.aspectRatio,
+        audio: opts.audio,
+        seed: opts.seed ? Number.parseInt(opts.seed, 10) : void 0,
+        negativePrompt: opts.negative,
+        cameraFixed: opts.cameraFixed
+      });
+      logger.info(
+        `Submitting Seedance task (${opts.model}, ${opts.resolution}, ${opts.duration}s)`
+      );
+      const submitted = await submitVideoTask(client, body, logger);
+      const taskId = submitted.id;
+      logger.debug(`taskId: ${taskId}`);
+      if (opts.async) {
+        console.log(taskId);
+        console.error(`Poll with: multix byteplus status ${taskId}`);
+        return;
+      }
+      try {
+        const final = await waitForVideoTask(client, taskId, {
+          waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 6e5,
+          logger
+        });
+        const url = final.content?.video_url;
+        if (!url) {
+          logger.error(`Task succeeded but no video_url in response: ${JSON.stringify(final)}`);
+          process.exit(1);
+        }
+        const outPath = opts.output ?? path10.join(getOutputDir(), `byteplus-video-${taskId.slice(0, 8)}-${Date.now()}.mp4`);
+        await downloadVideo(url, outPath, logger);
+        await maybeDownloadThumb(final, outPath, {
+          skip: opts.thumb === false,
+          copyTo: opts.output,
+          logger
+        });
+        console.log(`
+Task: ${taskId}`);
+        console.log(`Saved: ${outPath}`);
+      } catch (e) {
+        if (e instanceof PollTimeoutError) {
+          logger.error(
+            `Polling timed out \u2014 try --async to keep the task and check later: multix byteplus status ${taskId}`
+          );
+          process.exit(1);
+        }
+        if (e instanceof PollFailedError) {
+          logger.error(`Task failed: ${JSON.stringify(e.value)}`);
+          process.exit(1);
+        }
+        throw e;
+      }
+    }
+  );
+}
+
+// src/providers/byteplus/commands/index.ts
+function registerBytePlusCommands(program2) {
+  const byteplus = program2.command("byteplus").description("BytePlus ModelArk: Seedream image generation, Seedance video generation");
+  registerBytePlusGenerateCommand(byteplus);
+  registerBytePlusImageToImageCommand(byteplus);
+  registerBytePlusVideoCommand(byteplus);
+  registerBytePlusImageToVideoCommand(byteplus);
+  registerBytePlusReferenceToVideoCommand(byteplus);
+  registerBytePlusStatusCommand(byteplus);
+}
+
+// src/providers/gemini/commands/analyze.ts
+init_errors();
+import fs9 from "fs";
+
+// src/providers/gemini/client.ts
+import fs7 from "fs";
+import path12 from "path";
+init_errors();
+init_http_client();
+
+// src/providers/gemini/task-resolver.ts
+import path11 from "path";
+var MIME_MAP = {
+  // Audio
+  ".mp3": "audio/mp3",
+  ".wav": "audio/wav",
+  ".aac": "audio/aac",
+  ".flac": "audio/flac",
+  ".ogg": "audio/ogg",
+  ".aiff": "audio/aiff",
+  ".m4a": "audio/mp4",
+  // Image
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".heic": "image/heic",
+  ".heif": "image/heif",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+  // Video
+  ".mp4": "video/mp4",
+  ".mpeg": "video/mpeg",
+  ".mov": "video/quicktime",
+  ".avi": "video/x-msvideo",
+  ".flv": "video/x-flv",
+  ".mpg": "video/mpeg",
+  ".webm": "video/webm",
+  ".wmv": "video/x-ms-wmv",
+  ".3gpp": "video/3gpp",
+  // Document
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+};
+function getMimeType(filePath) {
+  const ext = path11.extname(filePath).toLowerCase();
+  return MIME_MAP[ext] ?? "application/octet-stream";
+}
+function requiresProcessingWait(mimeType) {
+  return mimeType.startsWith("audio/") || mimeType.startsWith("video/");
+}
+
+// src/providers/gemini/client.ts
+var BASE = "https://generativelanguage.googleapis.com";
+var FILES_BASE = `${BASE}/upload/v1beta/files`;
+var GENERATE_BASE = `${BASE}/v1beta/models`;
+function requireApiKey() {
+  const key = resolveKey("GEMINI_API_KEY");
+  if (!key)
+    throw new ConfigError(
+      "GEMINI_API_KEY is not set. Get one at https://aistudio.google.com/apikey"
+    );
+  return key;
+}
+function authHeaders(apiKey) {
+  return { "x-goog-api-key": apiKey };
+}
+async function uploadFile(filePath, opts = {}) {
+  const apiKey = requireApiKey();
+  const { timeoutMs = 3e5, logger } = opts;
+  const mimeType = getMimeType(filePath);
+  const fileBytes = fs7.readFileSync(filePath);
+  const displayName = path12.basename(filePath);
+  const boundary = `multix_${Date.now()}`;
+  const metaJson = JSON.stringify({ file: { displayName, mimeType } });
+  const body = Buffer.concat([
+    Buffer.from(
+      `--${boundary}\r
+Content-Type: application/json; charset=UTF-8\r
+\r
+${metaJson}\r
+--${boundary}\r
+Content-Type: ${mimeType}\r
+\r
+`
+    ),
+    fileBytes,
+    Buffer.from(`\r
+--${boundary}--`)
+  ]);
+  logger?.debug(`Uploading ${displayName} (${(fileBytes.length / 1024 / 1024).toFixed(2)} MB)`);
+  const resp = await globalThis.fetch(FILES_BASE, {
+    method: "POST",
+    headers: {
+      "x-goog-api-key": apiKey,
+      "Content-Type": `multipart/related; boundary=${boundary}`,
+      "Content-Length": String(body.length),
+      "X-Goog-Upload-Protocol": "multipart"
+    },
+    body,
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!resp.ok) {
+    const txt = await resp.text();
+    throw new ProviderError(
+      `File upload failed (HTTP ${resp.status}): ${txt.slice(0, 500)}`,
+      "gemini"
+    );
+  }
+  const data = await resp.json();
+  let fileRef = data.file;
+  if (requiresProcessingWait(mimeType)) {
+    const deadline = Date.now() + timeoutMs;
+    while (fileRef.state === "PROCESSING" && Date.now() < deadline) {
+      await sleep(2e3);
+      fileRef = await httpJson({
+        url: `${BASE}/v1beta/${fileRef.name}`,
+        headers: authHeaders(apiKey)
+      }).then((r) => r.file);
+      logger?.debug(`Processing... state=${fileRef.state}`);
+    }
+    if (fileRef.state === "FAILED")
+      throw new ProviderError(`File processing failed: ${filePath}`, "gemini");
+    if (fileRef.state === "PROCESSING")
+      throw new ProviderError(`Processing timeout: ${filePath}`, "gemini");
+  }
+  logger?.debug(`Uploaded: ${fileRef.name} (${fileRef.uri})`);
+  return fileRef;
+}
+async function generateContent(req) {
+  const apiKey = requireApiKey();
+  return httpJson({
+    url: `${GENERATE_BASE}/${req.model}:generateContent`,
+    method: "POST",
+    headers: authHeaders(apiKey),
+    body: {
+      contents: req.contents,
+      ...req.generationConfig ? { generationConfig: req.generationConfig } : {}
+    }
+  });
+}
+function extractText(resp) {
+  const parts = resp.candidates?.[0]?.content?.parts ?? [];
+  return parts.filter((p) => p.text !== void 0).map((p) => p.text ?? "").join("");
+}
+function extractAudio(resp) {
+  const parts = resp.candidates?.[0]?.content?.parts ?? [];
+  for (const p of parts) {
+    if (p.inlineData?.mimeType.startsWith("audio/")) {
+      return { mimeType: p.inlineData.mimeType, data: p.inlineData.data };
+    }
+  }
+  return null;
+}
+function extractImages(resp) {
+  const parts = resp.candidates?.[0]?.content?.parts ?? [];
+  return parts.filter(
+    (p) => p.inlineData !== void 0
+  ).map((p) => ({ mimeType: p.inlineData.mimeType, data: p.inlineData.data }));
+}
+function inlinePart(filePath) {
+  const data = fs7.readFileSync(filePath).toString("base64");
+  const mimeType = getMimeType(filePath);
+  return { inlineData: { mimeType, data } };
+}
+function shouldUseFileApi(filePath) {
+  const stat = fs7.statSync(filePath);
+  return stat.size > 20 * 1024 * 1024;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/providers/gemini/models.ts
+var IMAGE_MODEL_DEFAULT = "gemini-3.1-flash-image-preview";
+var IMAGE_MODEL_FALLBACK = "gemini-2.5-flash-image";
+var VIDEO_MODEL_DEFAULT = "veo-3.1-generate-preview";
+var ANALYSIS_MODEL_DEFAULT = "gemini-2.5-flash";
+var TTS_MODEL_DEFAULT = "gemini-3.1-flash-tts-preview";
+var DOC_MODEL_DEFAULT = "gemini-2.5-flash";
+var IMAGEN_MODELS = /* @__PURE__ */ new Set([
+  "imagen-4.0-generate-001",
+  "imagen-4.0-ultra-generate-001",
+  "imagen-4.0-fast-generate-001"
+]);
+var GEMINI_IMAGE_MODELS = /* @__PURE__ */ new Set([
+  "gemini-3.1-flash-image-preview",
+  "gemini-3-pro-image-preview",
+  "gemini-2.5-flash-image",
+  "gemini-2.5-flash-image-preview",
+  ...IMAGEN_MODELS
+]);
+var ASPECT_RATIOS = [
+  "1:1",
+  "2:3",
+  "3:2",
+  "3:4",
+  "4:3",
+  "4:5",
+  "5:4",
+  "9:16",
+  "16:9",
+  "21:9"
+];
+var IMAGE_SIZES = ["1K", "2K", "4K"];
+function getDefaultModel(task) {
+  if (task === "generate") {
+    return process.env.IMAGE_GEN_MODEL ?? process.env.GEMINI_IMAGE_GEN_MODEL ?? IMAGE_MODEL_DEFAULT;
+  }
+  if (task === "generate-video") {
+    return process.env.VIDEO_GEN_MODEL ?? VIDEO_MODEL_DEFAULT;
+  }
+  if (task === "generate-speech") {
+    return process.env.GEMINI_TTS_MODEL ?? process.env.TTS_MODEL ?? TTS_MODEL_DEFAULT;
+  }
+  return process.env.MULTIMODAL_MODEL ?? process.env.GEMINI_MODEL ?? ANALYSIS_MODEL_DEFAULT;
+}
+
+// src/providers/gemini/result-formatter.ts
+import fs8 from "fs";
+import path13 from "path";
+function formatResults(results, format, outputPath) {
+  const content = renderFormat(results, format);
+  if (outputPath) {
+    fs8.mkdirSync(path13.dirname(path13.resolve(outputPath)), { recursive: true });
+    fs8.writeFileSync(outputPath, content, "utf8");
+  } else {
+    process.stdout.write(content);
+  }
+}
+function renderFormat(results, format) {
+  switch (format) {
+    case "json":
+      return `${JSON.stringify(results, null, 2)}
+`;
+    case "csv":
+      return renderCsv(results);
+    case "markdown":
+      return renderMarkdown(results);
+    default:
+      return renderText(results);
   }
 }
 function renderText(results) {
@@ -481,46 +1369,727 @@ Error: ${r.error}
 `;
   }).join("\n");
 }
-function renderCsv(results) {
-  const header = "file,status,response,error\n";
-  const rows = results.map((r) => {
-    const csvCell = (v) => `"${(v ?? "").replace(/"/g, '""')}"`;
-    return [csvCell(r.file), csvCell(r.status), csvCell(r.response), csvCell(r.error)].join(",");
-  });
-  return `${header + rows.join("\n")}
-`;
+function renderCsv(results) {
+  const header = "file,status,response,error\n";
+  const rows = results.map((r) => {
+    const csvCell = (v) => `"${(v ?? "").replace(/"/g, '""')}"`;
+    return [csvCell(r.file), csvCell(r.status), csvCell(r.response), csvCell(r.error)].join(",");
+  });
+  return `${header + rows.join("\n")}
+`;
+}
+function renderMarkdown(results) {
+  const lines = ["# Results\n"];
+  for (const r of results) {
+    lines.push(`## ${r.file}
+`);
+    lines.push(`**Status**: ${r.status}
+`);
+    if (r.status === "success" && r.response) lines.push(`**Response**:
+
+${r.response}
+`);
+    if (r.status === "error") lines.push(`**Error**: ${r.error}
+`);
+    lines.push("---\n");
+  }
+  return lines.join("\n");
+}
+
+// src/providers/gemini/commands/analyze.ts
+function registerAnalyzeCommand(parent) {
+  parent.command("analyze").description("Analyze files with Gemini (images, video, audio, documents)").requiredOption("--files <paths...>", "Input file paths to analyze").option("--prompt <text>", "Analysis prompt", "Analyze this content").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file instead of stdout").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? getDefaultModel("analyze");
+      for (const f of opts.files) {
+        if (!fs9.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+      }
+      const results = [];
+      for (let i = 0; i < opts.files.length; i++) {
+        const filePath = opts.files[i];
+        logger.debug(`[${i + 1}/${opts.files.length}] Processing: ${filePath}`);
+        try {
+          const useApi = shouldUseFileApi(filePath);
+          let contentParts;
+          if (useApi) {
+            logger.debug("File >20MB \u2014 using Files API");
+            const ref = await uploadFile(filePath, { logger });
+            contentParts = [
+              { text: opts.prompt },
+              { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
+            ];
+          } else {
+            contentParts = [{ text: opts.prompt }, inlinePart(filePath)];
+          }
+          const resp = await generateContent({
+            model,
+            contents: [{ parts: contentParts }]
+          });
+          results.push({
+            file: filePath,
+            status: "success",
+            response: extractText(resp)
+          });
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
+          results.push({ file: filePath, status: "error", error: msg });
+        }
+      }
+      formatResults(results, opts.format, opts.output);
+      logger.debug(
+        `Done: ${results.filter((r) => r.status === "success").length}/${results.length} succeeded`
+      );
+      const failed = results.filter((r) => r.status === "error").length;
+      if (failed > 0) process.exit(1);
+    }
+  );
+}
+
+// src/providers/gemini/commands/extract.ts
+init_errors();
+import fs10 from "fs";
+function registerExtractCommand(parent) {
+  parent.command("extract").description("Extract structured information from files with Gemini").requiredOption("--files <paths...>", "Input file paths").requiredOption("--prompt <text>", "Extraction prompt (required)").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? getDefaultModel("extract");
+      for (const f of opts.files) {
+        if (!fs10.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+      }
+      const generationConfig = opts.format === "json" ? { responseMimeType: "application/json" } : void 0;
+      const results = [];
+      for (let i = 0; i < opts.files.length; i++) {
+        const filePath = opts.files[i];
+        logger.debug(`[${i + 1}/${opts.files.length}] Extracting: ${filePath}`);
+        try {
+          const useApi = shouldUseFileApi(filePath);
+          let contentParts;
+          if (useApi) {
+            const ref = await uploadFile(filePath, { logger });
+            contentParts = [
+              { text: opts.prompt },
+              { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
+            ];
+          } else {
+            contentParts = [{ text: opts.prompt }, inlinePart(filePath)];
+          }
+          const resp = await generateContent({
+            model,
+            contents: [{ parts: contentParts }],
+            generationConfig
+          });
+          results.push({ file: filePath, status: "success", response: extractText(resp) });
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
+          results.push({ file: filePath, status: "error", error: msg });
+        }
+      }
+      formatResults(results, opts.format, opts.output);
+      const failed = results.filter((r) => r.status === "error").length;
+      if (failed > 0) process.exit(1);
+    }
+  );
+}
+
+// src/providers/gemini/commands/generate-speech.ts
+init_errors();
+
+// src/providers/gemini/generators/speech.ts
+import fs11 from "fs";
+import path14 from "path";
+
+// src/providers/gemini/voices.ts
+var GEMINI_TTS_VOICES = [
+  "Zephyr",
+  "Puck",
+  "Charon",
+  "Kore",
+  "Fenrir",
+  "Leda",
+  "Orus",
+  "Aoede",
+  "Callirrhoe",
+  "Autonoe",
+  "Enceladus",
+  "Iapetus",
+  "Umbriel",
+  "Algieba",
+  "Despina",
+  "Erinome",
+  "Algenib",
+  "Rasalgethi",
+  "Laomedeia",
+  "Achernar",
+  "Alnilam",
+  "Schedar",
+  "Gacrux",
+  "Pulcherrima",
+  "Achird",
+  "Zubenelgenubi",
+  "Vindemiatrix",
+  "Sadachbia",
+  "Sadaltager",
+  "Sulafat"
+];
+var GEMINI_TTS_MODELS = /* @__PURE__ */ new Set([
+  "gemini-3.1-flash-tts-preview",
+  "gemini-2.5-flash-preview-tts",
+  "gemini-2.5-pro-preview-tts"
+]);
+var TTS_VOICE_DEFAULT = "Kore";
+var TTS_PCM_SAMPLE_RATE = 24e3;
+var TTS_PCM_CHANNELS = 1;
+var TTS_PCM_BITS_PER_SAMPLE = 16;
+var TTS_OUTPUT_FORMATS = ["wav", "pcm"];
+function isValidGeminiVoice(name) {
+  return GEMINI_TTS_VOICES.includes(name);
+}
+
+// src/providers/gemini/generators/speech.ts
+async function generateGeminiSpeech(opts) {
+  const { text, model, voice, speakers, outputFormat, output, logger } = opts;
+  const speechConfig = speakers && speakers.length > 0 ? {
+    multiSpeakerVoiceConfig: {
+      speakerVoiceConfigs: speakers.map((s) => ({
+        speaker: s.speaker,
+        voiceConfig: { prebuiltVoiceConfig: { voiceName: s.voice } }
+      }))
+    }
+  } : {
+    voiceConfig: { prebuiltVoiceConfig: { voiceName: voice } }
+  };
+  const generationConfig = {
+    responseModalities: ["AUDIO"],
+    speechConfig
+  };
+  logger?.debug(`Gemini TTS model=${model} mode=${speakers?.length ? "multi" : "single"}`);
+  let resp;
+  try {
+    resp = await generateContent({
+      model,
+      contents: [{ parts: [{ text }] }],
+      generationConfig
+    });
+  } catch (e) {
+    return { status: "error", error: e instanceof Error ? e.message : String(e) };
+  }
+  const audio = extractAudio(resp);
+  if (!audio) return { status: "error", error: "No audio in response" };
+  const pcmBytes = Buffer.from(audio.data, "base64");
+  const sampleRate = parseSampleRate(audio.mimeType) ?? TTS_PCM_SAMPLE_RATE;
+  const outBytes = outputFormat === "wav" ? wrapPcmInWav(pcmBytes, sampleRate, TTS_PCM_CHANNELS, TTS_PCM_BITS_PER_SAMPLE) : pcmBytes;
+  const outDir = getOutputDir();
+  const dest = path14.join(outDir, `gemini_speech_${Date.now()}.${outputFormat}`);
+  fs11.writeFileSync(dest, outBytes);
+  logger?.success(`Saved: ${dest} (${(outBytes.length / 1024).toFixed(1)} KB)`);
+  if (output) {
+    fs11.mkdirSync(path14.dirname(path14.resolve(output)), { recursive: true });
+    fs11.copyFileSync(dest, output);
+    logger?.success(`Copied to: ${output}`);
+  }
+  return { status: "success", generatedAudio: dest, model, mimeType: audio.mimeType };
+}
+function parseSampleRate(mimeType) {
+  const m = mimeType.match(/rate=(\d+)/i);
+  return m ? Number.parseInt(m[1], 10) : null;
+}
+function wrapPcmInWav(pcm, sampleRate, channels, bitsPerSample) {
+  const byteRate = sampleRate * channels * bitsPerSample / 8;
+  const blockAlign = channels * bitsPerSample / 8;
+  const dataSize = pcm.length;
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0, "ascii");
+  header.writeUInt32LE(36 + dataSize, 4);
+  header.write("WAVE", 8, "ascii");
+  header.write("fmt ", 12, "ascii");
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(channels, 22);
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(byteRate, 28);
+  header.writeUInt16LE(blockAlign, 32);
+  header.writeUInt16LE(bitsPerSample, 34);
+  header.write("data", 36, "ascii");
+  header.writeUInt32LE(dataSize, 40);
+  return Buffer.concat([header, pcm]);
+}
+
+// src/providers/gemini/commands/generate-speech.ts
+function registerGeminiGenerateSpeechCommand(parent) {
+  parent.command("generate-speech").description("Generate speech (TTS) with Gemini Flash TTS").option("--text <str>", "Text to speak (use --text or --prompt)").option("--prompt <str>", "Alias for --text").option("--model <id>", `TTS model (${[...GEMINI_TTS_MODELS].join("|")})`).option("--voice <name>", "Prebuilt voice for single-speaker mode", TTS_VOICE_DEFAULT).option(
+    "--speaker <name:voice>",
+    "Speaker mapping (repeatable, max 2 \u2014 switches to multi-speaker mode)",
+    collectSpeakers,
+    []
+  ).option("--output-format <fmt>", `Container (${TTS_OUTPUT_FORMATS.join("|")})`, "wav").option("--output <path>", "Copy output audio to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const text = opts.text ?? opts.prompt;
+      if (!text) throw new ValidationError("Either --text or --prompt is required");
+      const model = opts.model ?? getDefaultModel("generate-speech");
+      if (!GEMINI_TTS_MODELS.has(model)) {
+        throw new ValidationError(`--model must be one of: ${[...GEMINI_TTS_MODELS].join(", ")}`);
+      }
+      if (!TTS_OUTPUT_FORMATS.includes(opts.outputFormat)) {
+        throw new ValidationError(
+          `--output-format must be one of: ${TTS_OUTPUT_FORMATS.join(", ")}`
+        );
+      }
+      const speakers = opts.speaker;
+      if (speakers.length > 2) {
+        throw new ValidationError("Gemini TTS supports max 2 speakers in multi-speaker mode");
+      }
+      if (speakers.length === 0 && !isValidGeminiVoice(opts.voice)) {
+        throw new ValidationError(
+          `Invalid --voice "${opts.voice}". Valid: ${GEMINI_TTS_VOICES.join(", ")}`
+        );
+      }
+      for (const sv of speakers) {
+        if (!isValidGeminiVoice(sv.voice)) {
+          throw new ValidationError(
+            `Invalid voice "${sv.voice}" for speaker "${sv.speaker}". Valid: ${GEMINI_TTS_VOICES.join(", ")}`
+          );
+        }
+      }
+      const result = await generateGeminiSpeech({
+        text,
+        model,
+        voice: speakers.length === 0 ? opts.voice : void 0,
+        speakers: speakers.length > 0 ? speakers : void 0,
+        outputFormat: opts.outputFormat,
+        output: opts.output,
+        logger
+      });
+      if (result.status === "error") {
+        logger.error(result.error ?? "Unknown error");
+        process.exit(1);
+      }
+      console.log(`
+Generated audio: ${result.generatedAudio}`);
+    }
+  );
+}
+function collectSpeakers(value, prev) {
+  const idx = value.indexOf(":");
+  if (idx <= 0 || idx === value.length - 1) {
+    throw new ValidationError(`--speaker must be "name:voice" (got "${value}")`);
+  }
+  const speaker = value.slice(0, idx).trim();
+  const voice = value.slice(idx + 1).trim();
+  if (!speaker || !voice) {
+    throw new ValidationError(`--speaker must be "name:voice" (got "${value}")`);
+  }
+  return [...prev, { speaker, voice }];
+}
+
+// src/providers/gemini/commands/generate-video.ts
+import fs12 from "fs";
+import path15 from "path";
+init_errors();
+init_http_client();
+var BASE2 = "https://generativelanguage.googleapis.com";
+function registerGenerateVideoCommand(parent) {
+  parent.command("generate-video").description("Generate video with Veo via Gemini API [EXPERIMENTAL]").requiredOption("--prompt <text>", "Video generation prompt").option("--model <id>", "Veo model to use").option("--resolution <res>", "Video resolution: 720p|1080p", "1080p").option("--aspect-ratio <ratio>", "Aspect ratio", "16:9").option(
+    "--reference-images <paths...>",
+    "Reference images (first=opening frame, second=closing)"
+  ).option("--upload-timeout <ms>", "Upload timeout in ms", "120000").option("--output <path>", "Copy generated video to this path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const apiKey = resolveKey("GEMINI_API_KEY");
+      if (!apiKey) throw new ValidationError("GEMINI_API_KEY is not set");
+      const model = opts.model ?? getDefaultModel("generate-video");
+      if (!model.startsWith("veo-")) {
+        throw new ValidationError(
+          `Video generation requires a Veo model (got '${model}'). Use: veo-3.1-generate-preview, veo-3.0-generate-001, etc.`
+        );
+      }
+      if (!["720p", "1080p"].includes(opts.resolution)) {
+        throw new ValidationError("--resolution must be 720p or 1080p");
+      }
+      if (!ASPECT_RATIOS.includes(opts.aspectRatio)) {
+        throw new ValidationError(`Invalid aspect ratio: ${opts.aspectRatio}`);
+      }
+      logger.debug(`Submitting video generation with ${model}...`);
+      logger.info("This may take 30s\u20136 minutes. Veo requires billing.");
+      const config = {
+        aspectRatio: opts.aspectRatio,
+        resolution: opts.resolution
+      };
+      const contentParts = [{ text: opts.prompt }];
+      if (opts.referenceImages?.length) {
+        for (const imgPath of opts.referenceImages.slice(0, 2)) {
+          if (!fs12.existsSync(imgPath))
+            throw new ValidationError(`Reference image not found: ${imgPath}`);
+          const data = fs12.readFileSync(imgPath).toString("base64");
+          const ext = path15.extname(imgPath).toLowerCase();
+          const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
+          contentParts.push({ inlineData: { mimeType, data } });
+        }
+      }
+      const headers = { "x-goog-api-key": apiKey, "Content-Type": "application/json" };
+      let operation;
+      try {
+        operation = await httpJson({
+          url: `${BASE2}/v1beta/models/${model}:generateVideos`,
+          method: "POST",
+          headers,
+          body: {
+            contents: [{ parts: contentParts }],
+            generationConfig: config
+          }
+        });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new ProviderError(`Video generation submit failed: ${msg}`, "gemini");
+      }
+      const operationName = operation.name;
+      logger.debug(`Operation: ${operationName}`);
+      const deadline = Date.now() + 10 * 60 * 1e3;
+      let done = false;
+      let finalOp = operation;
+      while (!done && Date.now() < deadline) {
+        await sleep2(1e4);
+        finalOp = await httpJson({
+          url: `${BASE2}/v1beta/${operationName}`,
+          headers
+        });
+        done = finalOp.done === true;
+        if (!done)
+          logger.debug(
+            `Still generating... (${Math.round((deadline - Date.now()) / 1e3)}s left)`
+          );
+      }
+      if (!done) throw new ProviderError("Video generation timed out after 10 minutes", "gemini");
+      if (finalOp.error)
+        throw new ProviderError(`Veo error: ${JSON.stringify(finalOp.error)}`, "gemini");
+      const videoUri = finalOp.response?.generatedSamples?.[0]?.video?.uri ?? finalOp.response?.generatedVideos?.[0]?.video?.uri;
+      if (!videoUri) {
+        throw new ProviderError(
+          `Unexpected Veo response structure: ${JSON.stringify(finalOp.response)}`,
+          "gemini"
+        );
+      }
+      const outDir = getOutputDir();
+      const dest = path15.join(outDir, `veo_generated_${Date.now()}.mp4`);
+      const { downloadFile: downloadFile2 } = await Promise.resolve().then(() => (init_http_client(), http_client_exports));
+      await downloadFile2(videoUri, dest);
+      logger.success(`Saved video: ${dest}`);
+      if (opts.output) {
+        fs12.mkdirSync(path15.dirname(path15.resolve(opts.output)), { recursive: true });
+        fs12.copyFileSync(dest, opts.output);
+        logger.success(`Copied to: ${opts.output}`);
+      }
+      await maybeDownloadThumb(finalOp.response, dest, {
+        skip: opts.thumb === false,
+        copyTo: opts.output,
+        logger
+      });
+      console.log(`
+Generated video: ${dest}`);
+    }
+  );
+}
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/providers/gemini/commands/generate.ts
+init_errors();
+import fs13 from "fs";
+import path16 from "path";
+function registerGenerateCommand(parent) {
+  parent.command("generate").description("Generate images with Gemini (Nano Banana / Imagen 4)").requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", "Gemini image model to use").option("--aspect-ratio <ratio>", `Aspect ratio (${ASPECT_RATIOS.join("|")})`, "1:1").option("--num-images <n>", "Number of images to generate (1-4)", "1").option("--size <sz>", `Image size (${IMAGE_SIZES.join("|")})`).option("--output <path>", "Copy first generated image to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? getDefaultModel("generate");
+      const numImages = Math.min(Math.max(Number.parseInt(opts.numImages, 10) || 1, 1), 4);
+      if (!ASPECT_RATIOS.includes(opts.aspectRatio)) {
+        throw new ValidationError(
+          `Invalid aspect ratio: ${opts.aspectRatio}. Valid: ${ASPECT_RATIOS.join(", ")}`
+        );
+      }
+      if (opts.size && !IMAGE_SIZES.includes(opts.size)) {
+        throw new ValidationError(`Invalid size: ${opts.size}. Valid: ${IMAGE_SIZES.join(", ")}`);
+      }
+      logger.debug(`Generating ${numImages} image(s) with model: ${model}`);
+      logger.debug(`Aspect ratio: ${opts.aspectRatio}${opts.size ? `, size: ${opts.size}` : ""}`);
+      const imageConfig = { aspectRatio: opts.aspectRatio };
+      if (opts.size) imageConfig.imageSize = opts.size;
+      const generationConfig = {
+        responseModalities: ["IMAGE"],
+        imageConfig
+      };
+      const savedFiles = [];
+      for (let i = 0; i < numImages; i++) {
+        try {
+          const resp = await generateContent({
+            model,
+            contents: [{ parts: [{ text: opts.prompt }] }],
+            generationConfig
+          });
+          const images = extractImages(resp);
+          if (images.length === 0) {
+            logger.warn(
+              `Request ${i + 1}: no images in response \u2014 model may not support image generation`
+            );
+            continue;
+          }
+          for (const img of images) {
+            const outDir = getOutputDir();
+            const ext = img.mimeType.includes("png") ? "png" : "jpg";
+            const fname = `gemini_generated_${Date.now()}_${i}.${ext}`;
+            const dest = path16.join(outDir, fname);
+            fs13.writeFileSync(dest, Buffer.from(img.data, "base64"));
+            savedFiles.push(dest);
+            logger.success(`Saved: ${dest}`);
+          }
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          logger.error(`Generation failed: ${msg}`);
+          process.exit(1);
+        }
+      }
+      if (savedFiles.length === 0) {
+        logger.error("No images were generated");
+        process.exit(1);
+      }
+      if (opts.output && savedFiles[0]) {
+        fs13.mkdirSync(path16.dirname(path16.resolve(opts.output)), { recursive: true });
+        fs13.copyFileSync(savedFiles[0], opts.output);
+        logger.success(`Copied to: ${opts.output}`);
+      }
+      console.log(`
+Generated ${savedFiles.length} image(s):`);
+      for (const f of savedFiles) console.log(`  ${f}`);
+    }
+  );
+}
+
+// src/providers/gemini/commands/image-to-image.ts
+import fs14 from "fs";
+import path17 from "path";
+var SOFT_LIMIT_BYTES = 5 * 1024 * 1024;
+var HARD_LIMIT_BYTES = 7 * 1024 * 1024;
+function registerGeminiImageToImageCommand(parent) {
+  parent.command("image-to-image").alias("i2i").description(
+    "Edit/compose images with Gemini 2.5 Flash Image (Nano Banana) using one or more reference images"
+  ).requiredOption("--prompt <text>", "Text prompt describing the edit/transformation").requiredOption(
+    "--ref <path>",
+    "Reference image (URL or local path); repeatable for multi-ref",
+    collect4,
+    []
+  ).option("-m, --model <id>", `Gemini image model (default ${IMAGE_MODEL_FALLBACK})`).option("--output <path>", "Save first generated image to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      if (!opts.ref || opts.ref.length === 0) {
+        throw new Error("At least one --ref is required for image-to-image.");
+      }
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? IMAGE_MODEL_FALLBACK;
+      const parts = [];
+      for (const r of opts.ref) {
+        const resolved = await resolveImageInput(r, {
+          logger,
+          softLimitBytes: SOFT_LIMIT_BYTES,
+          hardLimitBytes: HARD_LIMIT_BYTES
+        });
+        if (resolved.kind === "url") {
+          const buf = await fetchUrlAsBuffer(resolved.url);
+          const mime = sniffImageMime(buf, resolved.url);
+          if (buf.byteLength > HARD_LIMIT_BYTES) {
+            throw new Error(
+              `Reference ${resolved.url} is ${(buf.byteLength / 1024 / 1024).toFixed(1)}MB \u2014 exceeds Gemini ${HARD_LIMIT_BYTES / 1024 / 1024}MB inline cap.`
+            );
+          }
+          parts.push({ inlineData: { mimeType: mime, data: buf.toString("base64") } });
+        } else {
+          const data = resolved.dataUrl.split(",", 2)[1] ?? "";
+          parts.push({ inlineData: { mimeType: resolved.mime, data } });
+        }
+      }
+      parts.push({ text: opts.prompt });
+      logger.debug(`Calling ${model} with ${opts.ref.length} reference image(s)`);
+      const req = {
+        model,
+        contents: [{ parts }],
+        generationConfig: { responseModalities: ["IMAGE"] }
+      };
+      const resp = await generateContent(req);
+      const images = extractImages(resp);
+      if (images.length === 0) {
+        logger.error(
+          "No images in response \u2014 model may have refused or doesn't support image output."
+        );
+        process.exit(1);
+      }
+      const outDir = getOutputDir();
+      const ts = Date.now();
+      const saved = [];
+      for (let i = 0; i < images.length; i++) {
+        const img = images[i];
+        if (!img) continue;
+        const ext = img.mimeType.includes("png") ? "png" : "jpg";
+        const dest = path17.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
+        fs14.writeFileSync(dest, Buffer.from(img.data, "base64"));
+        saved.push(dest);
+        logger.success(`Saved: ${dest}`);
+      }
+      if (opts.output && saved[0]) {
+        fs14.mkdirSync(path17.dirname(path17.resolve(opts.output)), { recursive: true });
+        fs14.copyFileSync(saved[0], opts.output);
+        logger.success(`Copied to: ${opts.output}`);
+      }
+      console.log(`
+Generated ${saved.length} image(s):`);
+      for (const f of saved) console.log(`  ${f}`);
+    }
+  );
+}
+function collect4(value, prev) {
+  return [...prev, value];
+}
+async function fetchUrlAsBuffer(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+  const arr = await res.arrayBuffer();
+  return Buffer.from(arr);
+}
+function sniffImageMime(buf, url) {
+  if (buf.length >= 4) {
+    if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "image/jpeg";
+    if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71)
+      return "image/png";
+    if (buf[0] === 71 && buf[1] === 73 && buf[2] === 70) return "image/gif";
+    if (buf.length >= 12 && buf.slice(0, 4).toString() === "RIFF" && buf.slice(8, 12).toString() === "WEBP")
+      return "image/webp";
+  }
+  const ext = path17.extname(new URL(url).pathname).toLowerCase();
+  if (ext === ".png") return "image/png";
+  if (ext === ".webp") return "image/webp";
+  if (ext === ".gif") return "image/gif";
+  return "image/jpeg";
 }
-function renderMarkdown(results) {
-  const lines = ["# Results\n"];
-  for (const r of results) {
-    lines.push(`## ${r.file}
-`);
-    lines.push(`**Status**: ${r.status}
-`);
-    if (r.status === "success" && r.response) lines.push(`**Response**:
 
-${r.response}
-`);
-    if (r.status === "error") lines.push(`**Error**: ${r.error}
-`);
-    lines.push("---\n");
+// src/providers/gemini/commands/image-to-video.ts
+import fs15 from "fs";
+import path18 from "path";
+init_errors();
+init_http_client();
+var BASE3 = "https://generativelanguage.googleapis.com";
+function imagePart(imgPath) {
+  if (!fs15.existsSync(imgPath)) {
+    throw new ValidationError(`Image not found: ${imgPath}`);
   }
-  return lines.join("\n");
+  const data = fs15.readFileSync(imgPath).toString("base64");
+  const ext = path18.extname(imgPath).toLowerCase();
+  const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
+  return { inlineData: { mimeType, data } };
+}
+function sleep3(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function registerGeminiImageToVideoCommand(parent) {
+  parent.command("image-to-video <imagePath>").alias("i2v").description("Generate video from a starting image with Veo (image-to-video) [EXPERIMENTAL]").requiredOption("--prompt <text>", "Motion/scene prompt").option("--last-frame <path>", "Optional closing frame image (Veo 3.1)").option("--model <id>", "Veo model id").option("--resolution <res>", "720p|1080p", "1080p").option("--aspect-ratio <ratio>", "Aspect ratio", "16:9").option("--output <path>", "Copy generated video to this path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (imagePath, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const apiKey = resolveKey("GEMINI_API_KEY");
+      if (!apiKey) throw new ValidationError("GEMINI_API_KEY is not set");
+      const model = opts.model ?? getDefaultModel("generate-video");
+      if (!model.startsWith("veo-")) {
+        throw new ValidationError(
+          `Image-to-video requires a Veo model (got '${model}'). Try veo-3.1-generate-preview.`
+        );
+      }
+      if (!["720p", "1080p"].includes(opts.resolution)) {
+        throw new ValidationError("--resolution must be 720p or 1080p");
+      }
+      if (!ASPECT_RATIOS.includes(opts.aspectRatio)) {
+        throw new ValidationError(`Invalid aspect ratio: ${opts.aspectRatio}`);
+      }
+      const contentParts = [
+        { text: opts.prompt },
+        imagePart(imagePath)
+      ];
+      if (opts.lastFrame) contentParts.push(imagePart(opts.lastFrame));
+      const headers = { "x-goog-api-key": apiKey, "Content-Type": "application/json" };
+      logger.info(
+        "Submitting image-to-video. This may take 30s\u20136 minutes. Veo requires billing."
+      );
+      let operation;
+      try {
+        operation = await httpJson({
+          url: `${BASE3}/v1beta/models/${model}:generateVideos`,
+          method: "POST",
+          headers,
+          body: {
+            contents: [{ parts: contentParts }],
+            generationConfig: { aspectRatio: opts.aspectRatio, resolution: opts.resolution }
+          }
+        });
+      } catch (e) {
+        throw new ProviderError(
+          `Submit failed: ${e instanceof Error ? e.message : String(e)}`,
+          "gemini"
+        );
+      }
+      const operationName = operation.name;
+      logger.debug(`Operation: ${operationName}`);
+      const deadline = Date.now() + 10 * 60 * 1e3;
+      let finalOp = operation;
+      while (!finalOp.done && Date.now() < deadline) {
+        await sleep3(1e4);
+        finalOp = await httpJson({ url: `${BASE3}/v1beta/${operationName}`, headers });
+        if (!finalOp.done) {
+          logger.debug(`Still generating... ${Math.round((deadline - Date.now()) / 1e3)}s left`);
+        }
+      }
+      if (!finalOp.done) throw new ProviderError("Veo timed out after 10 minutes", "gemini");
+      if (finalOp.error) {
+        throw new ProviderError(`Veo error: ${JSON.stringify(finalOp.error)}`, "gemini");
+      }
+      const videoUri = finalOp.response?.generatedSamples?.[0]?.video?.uri ?? finalOp.response?.generatedVideos?.[0]?.video?.uri;
+      if (!videoUri) {
+        throw new ProviderError(
+          `Unexpected Veo response: ${JSON.stringify(finalOp.response)}`,
+          "gemini"
+        );
+      }
+      const dest = path18.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
+      await downloadFile(videoUri, dest);
+      logger.success(`Saved video: ${dest}`);
+      if (opts.output) {
+        fs15.mkdirSync(path18.dirname(path18.resolve(opts.output)), { recursive: true });
+        fs15.copyFileSync(dest, opts.output);
+        logger.success(`Copied to: ${opts.output}`);
+      }
+      await maybeDownloadThumb(finalOp.response, dest, {
+        skip: opts.thumb === false,
+        copyTo: opts.output,
+        logger
+      });
+      console.log(`
+Generated video: ${dest}`);
+    }
+  );
 }
 
-// src/providers/gemini/commands/analyze.ts
-function registerAnalyzeCommand(parent) {
-  parent.command("analyze").description("Analyze files with Gemini (images, video, audio, documents)").requiredOption("--files <paths...>", "Input file paths to analyze").option("--prompt <text>", "Analysis prompt", "Analyze this content").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file instead of stdout").option("-v, --verbose", "Verbose logging").action(
+// src/providers/gemini/commands/transcribe.ts
+init_errors();
+import fs16 from "fs";
+function registerTranscribeCommand(parent) {
+  parent.command("transcribe").description("Transcribe audio or video files with Gemini").requiredOption("--files <paths...>", "Audio/video file paths to transcribe").option("--prompt <text>", "Transcription prompt", "Generate a transcript with timestamps").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      const model = opts.model ?? getDefaultModel("analyze");
+      const model = opts.model ?? getDefaultModel("transcribe");
       for (const f of opts.files) {
-        if (!fs5.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs16.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
       }
       const results = [];
       for (let i = 0; i < opts.files.length; i++) {
         const filePath = opts.files[i];
-        logger.debug(`[${i + 1}/${opts.files.length}] Processing: ${filePath}`);
+        logger.debug(`[${i + 1}/${opts.files.length}] Transcribing: ${filePath}`);
         try {
           const useApi = shouldUseFileApi(filePath);
           let contentParts;
@@ -550,312 +2119,710 @@ function registerAnalyzeCommand(parent) {
         }
       }
       formatResults(results, opts.format, opts.output);
-      logger.debug(
-        `Done: ${results.filter((r) => r.status === "success").length}/${results.length} succeeded`
-      );
       const failed = results.filter((r) => r.status === "error").length;
       if (failed > 0) process.exit(1);
     }
   );
 }
 
-// src/providers/gemini/commands/extract.ts
+// src/providers/gemini/commands/index.ts
+function registerGeminiCommands(program2) {
+  const gemini = program2.command("gemini").description(
+    "Gemini AI operations: analyze, transcribe, extract, generate images/video/speech"
+  );
+  registerAnalyzeCommand(gemini);
+  registerTranscribeCommand(gemini);
+  registerExtractCommand(gemini);
+  registerGenerateCommand(gemini);
+  registerGeminiImageToImageCommand(gemini);
+  registerGenerateVideoCommand(gemini);
+  registerGeminiImageToVideoCommand(gemini);
+  registerGeminiGenerateSpeechCommand(gemini);
+}
+
+// src/providers/leonardo/commands/generate.ts
+init_http_client();
+import fs17 from "fs";
+import path19 from "path";
+
+// src/providers/leonardo/client.ts
 init_errors();
-import fs6 from "fs";
-function registerExtractCommand(parent) {
-  parent.command("extract").description("Extract structured information from files with Gemini").requiredOption("--files <paths...>", "Input file paths").requiredOption("--prompt <text>", "Extraction prompt (required)").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
-    async (opts) => {
-      const logger = createLogger({ verbose: opts.verbose ?? false });
-      const model = opts.model ?? getDefaultModel("extract");
-      for (const f of opts.files) {
-        if (!fs6.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+init_http_client();
+
+// src/providers/leonardo/models.ts
+var DEFAULT_LEONARDO_BASE_URL = "https://cloud.leonardo.ai/api/rest/v1";
+var DEFAULT_LEONARDO_MODEL_ID = "7b592283-e8a7-4c5a-9ba6-d18c31f258b9";
+var LEONARDO_DEFAULTS = {
+  modelId: process.env.LEONARDO_DEFAULT_MODEL ?? DEFAULT_LEONARDO_MODEL_ID,
+  videoModel: process.env.LEONARDO_VIDEO_MODEL ?? "MOTION2",
+  width: 1024,
+  height: 1024,
+  numImages: 1
+};
+var LEONARDO_VIDEO_MODELS = [
+  { id: "MOTION2", name: "Motion 2.0", modes: ["t2v", "i2v"] },
+  { id: "MOTION2FAST", name: "Motion 2.0 Fast", modes: ["t2v", "i2v"] },
+  { id: "VEO3", name: "Veo 3.0", modes: ["t2v", "i2v"] },
+  { id: "VEO3FAST", name: "Veo 3.0 Fast", modes: ["t2v"] },
+  { id: "VEO3_1", name: "Veo 3.1", modes: ["t2v", "i2v"] },
+  { id: "KLING2_1", name: "Kling 2.1 Pro", modes: ["t2v", "i2v"] },
+  { id: "Kling2_5", name: "Kling 2.5 Turbo", modes: ["t2v", "i2v"] },
+  { id: "kling-2.6", name: "Kling 2.6", modes: ["t2v", "i2v"] },
+  { id: "kling-3.0", name: "Kling 3.0", modes: ["t2v"] },
+  { id: "kling-video-o-1", name: "Kling O1", modes: ["t2v", "i2v"] },
+  { id: "kling-video-o-3", name: "Kling O3", modes: ["t2v", "i2v"] },
+  { id: "hailuo-2_3", name: "Hailuo 2.3", modes: ["t2v", "i2v"] },
+  { id: "ltxv-2.0-pro", name: "LTX 2.0 Pro", modes: ["t2v", "i2v"] },
+  { id: "ltxv-2.3-pro", name: "LTX 2.3 Pro", modes: ["t2v", "i2v"] },
+  { id: "seedance-2.0", name: "Seedance 2.0", modes: ["t2v", "i2v"] },
+  { id: "seedance-2.0-fast", name: "Seedance 2.0 Fast", modes: ["t2v", "i2v"] }
+];
+var LEONARDO_VIDEO_RESOLUTIONS = [
+  "RESOLUTION_480",
+  "RESOLUTION_720",
+  "RESOLUTION_1080"
+];
+var LEONARDO_V2_VIDEO_MODELS = /* @__PURE__ */ new Set([
+  "kling-2.6",
+  "kling-3.0",
+  "kling-video-o-1",
+  "kling-video-o-3",
+  "hailuo-2_3",
+  "ltxv-2.0-pro",
+  "ltxv-2.3-pro",
+  "seedance-2.0",
+  "seedance-2.0-fast"
+]);
+function isGptImageModel(modelId) {
+  return typeof modelId === "string" && modelId.startsWith("gpt-image-");
+}
+
+// src/providers/leonardo/client.ts
+function requireLeonardoKey() {
+  const key = resolveKey("LEONARDO_API_KEY");
+  if (!key) {
+    throw new ConfigError(
+      "LEONARDO_API_KEY is not set. Get one at https://app.leonardo.ai/settings/api-keys"
+    );
+  }
+  return key;
+}
+function leonardoBaseUrl() {
+  return resolveKey("LEONARDO_BASE_URL") ?? DEFAULT_LEONARDO_BASE_URL;
+}
+var LeonardoClient = class {
+  constructor(apiKey, baseUrl = leonardoBaseUrl()) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  apiKey;
+  baseUrl;
+  async request(path35, opts = {}) {
+    const base = this.baseUrl.replace(/\/$/, "");
+    const v2Override = path35.startsWith("v2:");
+    const finalBase = v2Override ? base.replace(/\/v1$/, "/v2") : base;
+    const finalPath = v2Override ? path35.slice(3) : path35;
+    const url = new URL(finalBase + finalPath);
+    if (opts.query) {
+      for (const [k, v] of Object.entries(opts.query)) {
+        if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
       }
-      const generationConfig = opts.format === "json" ? { responseMimeType: "application/json" } : void 0;
-      const results = [];
-      for (let i = 0; i < opts.files.length; i++) {
-        const filePath = opts.files[i];
-        logger.debug(`[${i + 1}/${opts.files.length}] Extracting: ${filePath}`);
-        try {
-          const useApi = shouldUseFileApi(filePath);
-          let contentParts;
-          if (useApi) {
-            const ref = await uploadFile(filePath, { logger });
-            contentParts = [
-              { text: opts.prompt },
-              { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
-            ];
-          } else {
-            contentParts = [{ text: opts.prompt }, inlinePart(filePath)];
+    }
+    opts.logger?.debug(`${opts.method ?? "GET"} ${url.toString()}`);
+    return httpJson({
+      url: url.toString(),
+      method: opts.method ?? "GET",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${this.apiKey}`
+      },
+      body: opts.body,
+      timeoutMs: opts.timeoutMs ?? 12e4
+    });
+  }
+  get(path35, query, logger) {
+    return this.request(path35, { method: "GET", query, logger });
+  }
+  post(path35, body, logger) {
+    return this.request(path35, { method: "POST", body, logger });
+  }
+  delete(path35, logger) {
+    return this.request(path35, { method: "DELETE", logger });
+  }
+};
+function createLeonardoClient() {
+  return new LeonardoClient(requireLeonardoKey(), leonardoBaseUrl());
+}
+
+// src/providers/leonardo/commands/generate.ts
+function extFromUrl(url, fallback = ".png") {
+  try {
+    const u = new URL(url);
+    const e = path19.extname(u.pathname);
+    return e.length > 0 ? e : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function autoFilename(generationId, index, ext) {
+  const e = ext.startsWith(".") ? ext : `.${ext}`;
+  return `leonardo-${generationId.slice(0, 8)}-${String(index).padStart(2, "0")}${e}`;
+}
+function registerLeonardoGenerateCommand(parent) {
+  parent.command("generate <prompt>").alias("gen").description("Generate images from a text prompt via Leonardo").option("-m, --model <id>", "Model UUID or GPT-image id").option("-w, --width <n>", "Image width").option("-h, --height <n>", "Image height").option("-n, --num <n>", "Number of images").option("--alchemy", "Enable Alchemy").option("--ultra", "Enable Ultra mode").option("--contrast <n>", "Contrast").option("--style <uuid>", "Style UUID").option("--seed <n>", "Seed").option("--negative <text>", "Negative prompt").option("--enhance", "Enhance prompt").option("--quality <level>", "GPT Image quality: LOW|MEDIUM|HIGH", "HIGH").option("--output <path>", "Copy first image to this path (single-image only)").option("--no-download", "Skip downloading; print URLs only").option("--wait-timeout <ms>", "Polling timeout in milliseconds", "480000").option("-v, --verbose", "Verbose logging").action(
+    async (prompt, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const client = createLeonardoClient();
+      const input = {
+        prompt,
+        modelId: opts.model ?? LEONARDO_DEFAULTS.modelId,
+        width: opts.width ? Number.parseInt(opts.width, 10) : LEONARDO_DEFAULTS.width,
+        height: opts.height ? Number.parseInt(opts.height, 10) : LEONARDO_DEFAULTS.height,
+        num_images: opts.num ? Number.parseInt(opts.num, 10) : LEONARDO_DEFAULTS.numImages,
+        alchemy: opts.alchemy,
+        ultra: opts.ultra,
+        contrast: opts.contrast ? Number.parseFloat(opts.contrast) : void 0,
+        styleUUID: opts.style,
+        seed: opts.seed ? Number.parseInt(opts.seed, 10) : void 0,
+        negative_prompt: opts.negative,
+        enhancePrompt: opts.enhance
+      };
+      logger.info(
+        `Submitting generation (${input.width}x${input.height}, n=${input.num_images})`
+      );
+      let generationId;
+      if (isGptImageModel(input.modelId)) {
+        const v2Body = {
+          public: false,
+          model: input.modelId,
+          parameters: {
+            prompt: input.prompt,
+            quantity: input.num_images ?? 1,
+            width: input.width,
+            height: input.height,
+            quality: opts.quality,
+            prompt_enhance: input.enhancePrompt ? "ON" : "OFF",
+            ...input.seed !== void 0 ? { seed: input.seed } : {}
           }
-          const resp = await generateContent({
-            model,
-            contents: [{ parts: contentParts }],
-            generationConfig
-          });
-          results.push({ file: filePath, status: "success", response: extractText(resp) });
+        };
+        const v2Res = await client.post(
+          "v2:/generations",
+          v2Body,
+          logger
+        );
+        generationId = v2Res.generate.generationId;
+      } else {
+        const createRes = await client.post(
+          "/generations",
+          input,
+          logger
+        );
+        generationId = createRes.sdGenerationJob.generationId;
+      }
+      logger.debug(`generationId: ${generationId}`);
+      logger.info("Polling for completion...");
+      const waitTimeout = Number.parseInt(opts.waitTimeout, 10) || 48e4;
+      const intervalMs = 4e3;
+      const final = await poll({
+        fetch: () => client.get(`/generations/${generationId}`),
+        done: (v) => v.generations_by_pk?.status === "COMPLETE" && (v.generations_by_pk?.generated_images?.length ?? 0) > 0,
+        failed: (v) => v.generations_by_pk?.status === "FAILED",
+        intervalMs,
+        maxAttempts: Math.ceil(waitTimeout / intervalMs),
+        onTick: (attempt, v) => logger.debug(`attempt ${attempt} \u2014 status: ${v.generations_by_pk?.status ?? "?"}`)
+      });
+      const images = final.generations_by_pk?.generated_images ?? [];
+      if (opts.download === false) {
+        for (const img of images) console.log(img.url);
+        return;
+      }
+      const outDir = getOutputDir();
+      const saved = [];
+      for (let i = 0; i < images.length; i++) {
+        const img = images[i];
+        if (!img) continue;
+        const ext = extFromUrl(img.url);
+        const filename = autoFilename(generationId, i + 1, ext);
+        const filepath = path19.join(outDir, filename);
+        try {
+          await downloadFile(img.url, filepath);
+          saved.push(filepath);
+          logger.success(`Saved ${filepath}`);
         } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
-          results.push({ file: filePath, status: "error", error: msg });
+          logger.warn(`Download failed for ${img.id}: ${e instanceof Error ? e.message : e}`);
         }
       }
-      formatResults(results, opts.format, opts.output);
-      const failed = results.filter((r) => r.status === "error").length;
-      if (failed > 0) process.exit(1);
+      if (opts.output && saved[0]) {
+        const dest = path19.resolve(opts.output);
+        fs17.mkdirSync(path19.dirname(dest), { recursive: true });
+        fs17.copyFileSync(saved[0], dest);
+        logger.success(`Copied to ${dest}`);
+      }
+      console.log(`
+Generated ${saved.length} image(s):`);
+      for (const f of saved) console.log(`  ${f}`);
     }
   );
 }
 
-// src/providers/gemini/commands/generate-video.ts
-import fs8 from "fs";
-import path7 from "path";
-init_errors();
+// src/providers/leonardo/commands/image-to-image.ts
 init_http_client();
-
-// src/core/output-dir.ts
-import fs7 from "fs";
-import path6 from "path";
-var cachedOutputDir;
-function getOutputDir() {
-  if (cachedOutputDir) return cachedOutputDir;
-  const dir = process.env.MULTIX_OUTPUT_DIR ? path6.resolve(process.env.MULTIX_OUTPUT_DIR) : path6.resolve(process.cwd(), "multix-output");
-  fs7.mkdirSync(dir, { recursive: true });
-  cachedOutputDir = dir;
-  return dir;
+import fs18 from "fs";
+import path20 from "path";
+function extFromUrl2(url, fallback = ".png") {
+  try {
+    return path20.extname(new URL(url).pathname) || fallback;
+  } catch {
+    return fallback;
+  }
 }
-
-// src/providers/gemini/commands/generate-video.ts
-var BASE2 = "https://generativelanguage.googleapis.com";
-function registerGenerateVideoCommand(parent) {
-  parent.command("generate-video").description("Generate video with Veo via Gemini API [EXPERIMENTAL]").requiredOption("--prompt <text>", "Video generation prompt").option("--model <id>", "Veo model to use").option("--resolution <res>", "Video resolution: 720p|1080p", "1080p").option("--aspect-ratio <ratio>", "Aspect ratio", "16:9").option(
-    "--reference-images <paths...>",
-    "Reference images (first=opening frame, second=closing)"
-  ).option("--upload-timeout <ms>", "Upload timeout in ms", "120000").option("--output <path>", "Copy generated video to this path").option("-v, --verbose", "Verbose logging").action(
+function registerLeonardoImageToImageCommand(parent) {
+  parent.command("image-to-image").alias("i2i").description("Generate an image conditioned on an existing Leonardo image id (init image)").requiredOption("--prompt <text>", "Text prompt describing the desired output").requiredOption("--ref <imageId>", "Existing Leonardo image id to use as init image").option("--image-type <type>", "GENERATED | UPLOADED", "GENERATED").option("--init-strength <n>", "Init image strength (0.0-0.9)", "0.5").option("-m, --model <id>", "Model UUID").option("-w, --width <n>", "Image width").option("-h, --height <n>", "Image height").option("-n, --num <n>", "Number of images").option("--seed <n>", "Seed").option("--negative <text>", "Negative prompt").option("--output <path>", "Copy first image to this path (single-image only)").option("--no-download", "Skip downloading; print URLs only").option("--wait-timeout <ms>", "Polling timeout in milliseconds", "480000").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      const apiKey = resolveKey("GEMINI_API_KEY");
-      if (!apiKey) throw new ValidationError("GEMINI_API_KEY is not set");
-      const model = opts.model ?? getDefaultModel("generate-video");
-      if (!model.startsWith("veo-")) {
-        throw new ValidationError(
-          `Video generation requires a Veo model (got '${model}'). Use: veo-3.1-generate-preview, veo-3.0-generate-001, etc.`
-        );
-      }
-      if (!["720p", "1080p"].includes(opts.resolution)) {
-        throw new ValidationError("--resolution must be 720p or 1080p");
+      const imageType = opts.imageType.toUpperCase();
+      if (imageType !== "GENERATED" && imageType !== "UPLOADED") {
+        logger.error(`--image-type must be GENERATED or UPLOADED, got '${opts.imageType}'`);
+        process.exit(2);
       }
-      if (!ASPECT_RATIOS.includes(opts.aspectRatio)) {
-        throw new ValidationError(`Invalid aspect ratio: ${opts.aspectRatio}`);
+      const initStrength = Number.parseFloat(opts.initStrength);
+      if (Number.isNaN(initStrength) || initStrength < 0 || initStrength > 0.9) {
+        logger.error("--init-strength must be a number in [0.0, 0.9]");
+        process.exit(2);
       }
-      logger.debug(`Submitting video generation with ${model}...`);
-      logger.info("This may take 30s\u20136 minutes. Veo requires billing.");
-      const config = {
-        aspectRatio: opts.aspectRatio,
-        resolution: opts.resolution
+      const client = createLeonardoClient();
+      const body = {
+        prompt: opts.prompt,
+        modelId: opts.model ?? LEONARDO_DEFAULTS.modelId,
+        width: opts.width ? Number.parseInt(opts.width, 10) : LEONARDO_DEFAULTS.width,
+        height: opts.height ? Number.parseInt(opts.height, 10) : LEONARDO_DEFAULTS.height,
+        num_images: opts.num ? Number.parseInt(opts.num, 10) : LEONARDO_DEFAULTS.numImages,
+        init_strength: initStrength
       };
-      const contentParts = [{ text: opts.prompt }];
-      if (opts.referenceImages?.length) {
-        for (const imgPath of opts.referenceImages.slice(0, 2)) {
-          if (!fs8.existsSync(imgPath))
-            throw new ValidationError(`Reference image not found: ${imgPath}`);
-          const data = fs8.readFileSync(imgPath).toString("base64");
-          const ext = path7.extname(imgPath).toLowerCase();
-          const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
-          contentParts.push({ inlineData: { mimeType, data } });
-        }
-      }
-      const headers = { "x-goog-api-key": apiKey, "Content-Type": "application/json" };
-      let operation;
-      try {
-        operation = await httpJson({
-          url: `${BASE2}/v1beta/models/${model}:generateVideos`,
-          method: "POST",
-          headers,
-          body: {
-            contents: [{ parts: contentParts }],
-            generationConfig: config
-          }
-        });
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        throw new ProviderError(`Video generation submit failed: ${msg}`, "gemini");
-      }
-      const operationName = operation.name;
-      logger.debug(`Operation: ${operationName}`);
-      const deadline = Date.now() + 10 * 60 * 1e3;
-      let done = false;
-      let finalOp = operation;
-      while (!done && Date.now() < deadline) {
-        await sleep2(1e4);
-        finalOp = await httpJson({
-          url: `${BASE2}/v1beta/${operationName}`,
-          headers
-        });
-        done = finalOp.done === true;
-        if (!done)
-          logger.debug(
-            `Still generating... (${Math.round((deadline - Date.now()) / 1e3)}s left)`
-          );
+      if (imageType === "GENERATED") {
+        body.init_generation_image_id = opts.ref;
+      } else {
+        body.init_image_id = opts.ref;
       }
-      if (!done) throw new ProviderError("Video generation timed out after 10 minutes", "gemini");
-      if (finalOp.error)
-        throw new ProviderError(`Veo error: ${JSON.stringify(finalOp.error)}`, "gemini");
-      const videoUri = finalOp.response?.generatedSamples?.[0]?.video?.uri ?? finalOp.response?.generatedVideos?.[0]?.video?.uri;
-      if (!videoUri) {
-        throw new ProviderError(
-          `Unexpected Veo response structure: ${JSON.stringify(finalOp.response)}`,
-          "gemini"
-        );
+      if (opts.seed) body.seed = Number.parseInt(opts.seed, 10);
+      if (opts.negative) body.negative_prompt = opts.negative;
+      logger.info(`Submitting image-to-image (init=${opts.ref}, type=${imageType})`);
+      const createRes = await client.post("/generations", body, logger);
+      const generationId = createRes.sdGenerationJob.generationId;
+      logger.debug(`generationId: ${generationId}`);
+      logger.info("Polling for completion...");
+      const waitTimeout = Number.parseInt(opts.waitTimeout, 10) || 48e4;
+      const intervalMs = 4e3;
+      const final = await poll({
+        fetch: () => client.get(`/generations/${generationId}`),
+        done: (v) => v.generations_by_pk?.status === "COMPLETE" && (v.generations_by_pk?.generated_images?.length ?? 0) > 0,
+        failed: (v) => v.generations_by_pk?.status === "FAILED",
+        intervalMs,
+        maxAttempts: Math.ceil(waitTimeout / intervalMs),
+        onTick: (attempt, v) => logger.debug(`attempt ${attempt} \u2014 status: ${v.generations_by_pk?.status ?? "?"}`)
+      });
+      const images = final.generations_by_pk?.generated_images ?? [];
+      if (opts.download === false) {
+        for (const img of images) console.log(img.url);
+        return;
       }
       const outDir = getOutputDir();
-      const dest = path7.join(outDir, `veo_generated_${Date.now()}.mp4`);
-      const { downloadFile: downloadFile2 } = await Promise.resolve().then(() => (init_http_client(), http_client_exports));
-      await downloadFile2(videoUri, dest);
-      logger.success(`Saved video: ${dest}`);
-      if (opts.output) {
-        fs8.mkdirSync(path7.dirname(path7.resolve(opts.output)), { recursive: true });
-        fs8.copyFileSync(dest, opts.output);
-        logger.success(`Copied to: ${opts.output}`);
+      const saved = [];
+      for (let i = 0; i < images.length; i++) {
+        const img = images[i];
+        if (!img) continue;
+        const ext = extFromUrl2(img.url);
+        const filename = `leonardo-i2i-${generationId.slice(0, 8)}-${String(i + 1).padStart(2, "0")}${ext}`;
+        const filepath = path20.join(outDir, filename);
+        try {
+          await downloadFile(img.url, filepath);
+          saved.push(filepath);
+          logger.success(`Saved ${filepath}`);
+        } catch (e) {
+          logger.warn(`Download failed: ${e instanceof Error ? e.message : e}`);
+        }
+      }
+      if (opts.output && saved[0]) {
+        const dest = path20.resolve(opts.output);
+        fs18.mkdirSync(path20.dirname(dest), { recursive: true });
+        fs18.copyFileSync(saved[0], dest);
+        logger.success(`Copied to ${dest}`);
       }
       console.log(`
-Generated video: ${dest}`);
+Generated ${saved.length} image(s):`);
+      for (const f of saved) console.log(`  ${f}`);
     }
   );
 }
-function sleep2(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
 
-// src/providers/gemini/commands/generate.ts
-init_errors();
-import fs9 from "fs";
-import path8 from "path";
-function registerGenerateCommand(parent) {
-  parent.command("generate").description("Generate images with Gemini (Nano Banana / Imagen 4)").requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", "Gemini image model to use").option("--aspect-ratio <ratio>", `Aspect ratio (${ASPECT_RATIOS.join("|")})`, "1:1").option("--num-images <n>", "Number of images to generate (1-4)", "1").option("--size <sz>", `Image size (${IMAGE_SIZES.join("|")})`).option("--output <path>", "Copy first generated image to this path").option("-v, --verbose", "Verbose logging").action(
-    async (opts) => {
+// src/providers/leonardo/commands/video.ts
+init_http_client();
+import path21 from "path";
+function v2DimsFor(resolution) {
+  if (resolution === "RESOLUTION_1080") return { width: 1920, height: 1080 };
+  if (resolution === "RESOLUTION_480") return { width: 854, height: 480 };
+  return { width: 1280, height: 720 };
+}
+function registerLeonardoVideoCommand(parent) {
+  parent.command("video <prompt>").description("Generate a video from a text prompt via Leonardo (text-to-video)").option("--model <model>", "Video model (e.g. MOTION2, VEO3, kling-2.6)").option(
+    "--resolution <r>",
+    "Resolution (RESOLUTION_480|RESOLUTION_720|RESOLUTION_1080)",
+    "RESOLUTION_720"
+  ).option("--enhance", "Enable prompt enhance").option("--frame-interpolation", "Enable frame interpolation (v1 only)").option("--wait", "Poll until COMPLETE/FAILED instead of returning the job id").option("--wait-timeout <ms>", "Poll timeout in ms (with --wait)", "600000").option("--download", "Download the generated video on success (implies --wait)").option("--output <path>", "Output MP4 path (with --download)").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (prompt, opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      const model = opts.model ?? getDefaultModel("generate");
-      const numImages = Math.min(Math.max(Number.parseInt(opts.numImages, 10) || 1, 1), 4);
-      if (!ASPECT_RATIOS.includes(opts.aspectRatio)) {
-        throw new ValidationError(
-          `Invalid aspect ratio: ${opts.aspectRatio}. Valid: ${ASPECT_RATIOS.join(", ")}`
+      const model = opts.model ?? LEONARDO_DEFAULTS.videoModel;
+      const client = createLeonardoClient();
+      logger.info(`Submitting text-to-video (${model})`);
+      let jobId;
+      if (LEONARDO_V2_VIDEO_MODELS.has(model)) {
+        const { width, height } = v2DimsFor(opts.resolution);
+        const v2Res = await client.post(
+          "v2:/generations",
+          {
+            public: false,
+            model,
+            parameters: {
+              prompt,
+              duration: 8,
+              mode: opts.resolution,
+              prompt_enhance: opts.enhance ? "ON" : "OFF",
+              width,
+              height
+            }
+          },
+          logger
+        );
+        jobId = v2Res.generate.generationId;
+      } else {
+        const res = await client.post(
+          "/generations-text-to-video",
+          {
+            prompt,
+            model,
+            resolution: opts.resolution,
+            promptEnhance: !!opts.enhance,
+            frameInterpolation: !!opts.frameInterpolation
+          },
+          logger
         );
+        jobId = res.motionVideoGenerationJob?.generationId;
       }
-      if (opts.size && !IMAGE_SIZES.includes(opts.size)) {
-        throw new ValidationError(`Invalid size: ${opts.size}. Valid: ${IMAGE_SIZES.join(", ")}`);
+      if (!jobId) {
+        logger.error("No generationId returned by Leonardo");
+        process.exit(1);
       }
-      logger.debug(`Generating ${numImages} image(s) with model: ${model}`);
-      logger.debug(`Aspect ratio: ${opts.aspectRatio}${opts.size ? `, size: ${opts.size}` : ""}`);
-      const imageConfig = { aspectRatio: opts.aspectRatio };
-      if (opts.size) imageConfig.imageSize = opts.size;
-      const generationConfig = {
-        responseModalities: ["IMAGE"],
-        imageConfig
+      const shouldWait = !!(opts.wait || opts.download);
+      if (!shouldWait) {
+        console.log(jobId);
+        console.error(`Poll with: multix leonardo status ${jobId}`);
+        return;
+      }
+      await pollAndDownload(client, jobId, {
+        waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 6e5,
+        download: !!opts.download,
+        output: opts.output,
+        thumb: opts.thumb !== false,
+        logger,
+        basename: "leonardo-video"
+      });
+    }
+  );
+}
+async function pollAndDownload(client, jobId, opts) {
+  const { logger } = opts;
+  let res;
+  try {
+    res = await poll({
+      fetch: () => client.get(`/generations/${jobId}`, void 0, logger),
+      done: (v) => v.generations_by_pk?.status === "COMPLETE",
+      failed: (v) => v.generations_by_pk?.status === "FAILED",
+      intervalMs: 5e3,
+      maxAttempts: Math.max(1, Math.ceil(opts.waitTimeoutMs / 5e3)),
+      onTick: (n, v) => logger.debug(`attempt ${n} \u2014 status: ${v.generations_by_pk?.status}`)
+    });
+  } catch (e) {
+    if (e instanceof PollTimeoutError) {
+      logger.error(`Timed out \u2014 multix leonardo status ${jobId}`);
+      process.exit(1);
+    }
+    if (e instanceof PollFailedError) {
+      logger.error(`Generation failed: ${JSON.stringify(e.value)}`);
+      process.exit(1);
+    }
+    throw e;
+  }
+  const gen = res.generations_by_pk;
+  if (!gen) {
+    logger.error("No generation in response");
+    process.exit(1);
+  }
+  const videoUrl = gen.generated_images?.find(
+    (img) => typeof img.url === "string" && /\.(mp4|webm|mov)(\?|$)/i.test(img.url)
+  )?.url ?? gen.generated_images?.[0]?.motionMP4URL;
+  if (!opts.download) {
+    if (typeof videoUrl === "string") console.log(videoUrl);
+    return;
+  }
+  if (typeof videoUrl !== "string") {
+    logger.error(`No video URL in completed generation: ${JSON.stringify(gen)}`);
+    process.exit(1);
+  }
+  const outPath = opts.output ?? path21.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
+  await downloadFile(videoUrl, outPath);
+  logger.success(`Saved ${outPath}`);
+  await maybeDownloadThumb(gen, outPath, {
+    skip: !opts.thumb,
+    copyTo: opts.output,
+    logger
+  });
+  console.log(`
+Job: ${jobId}`);
+  console.log(`Saved: ${outPath}`);
+}
+
+// src/providers/leonardo/commands/image-to-video.ts
+function registerLeonardoImageToVideoCommand(parent) {
+  parent.command("image-to-video <imageId>").alias("i2v").description("Generate a video from an existing Leonardo image (image-to-video)").requiredOption("--prompt <text>", "Motion / scene prompt for the video").option("--image-type <type>", "GENERATED | UPLOADED", "GENERATED").option("--model <model>", "Video model (e.g. MOTION2, VEO3, KLING2_5)").option(
+    "--resolution <r>",
+    "Resolution (RESOLUTION_480|RESOLUTION_720|RESOLUTION_1080)",
+    "RESOLUTION_720"
+  ).option("--duration <n>", "Duration seconds (model-dependent: 4|5|6|8|10)").option("--seed <n>", "Fixed seed").option("--negative <text>", "Negative prompt").option("--enhance", "Enable prompt enhance").option("--frame-interpolation", "Enable frame interpolation").option("--wait", "Poll until COMPLETE/FAILED instead of returning the job id").option("--wait-timeout <ms>", "Poll timeout in ms (with --wait)", "600000").option("--download", "Download the generated video on success (implies --wait)").option("--output <path>", "Output MP4 path (with --download)").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (imageId, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const imageType = opts.imageType.toUpperCase();
+      if (imageType !== "GENERATED" && imageType !== "UPLOADED") {
+        logger.error(`--image-type must be GENERATED or UPLOADED, got '${opts.imageType}'`);
+        process.exit(2);
+      }
+      const model = opts.model ?? LEONARDO_DEFAULTS.videoModel;
+      const client = createLeonardoClient();
+      logger.info(`Submitting image-to-video (${model}, image=${imageId}, ${imageType})`);
+      const body = {
+        prompt: opts.prompt,
+        imageId,
+        imageType,
+        model,
+        resolution: opts.resolution,
+        promptEnhance: !!opts.enhance,
+        frameInterpolation: !!opts.frameInterpolation
       };
-      const savedFiles = [];
-      for (let i = 0; i < numImages; i++) {
-        try {
-          const resp = await generateContent({
-            model,
-            contents: [{ parts: [{ text: opts.prompt }] }],
-            generationConfig
-          });
-          const images = extractImages(resp);
-          if (images.length === 0) {
-            logger.warn(
-              `Request ${i + 1}: no images in response \u2014 model may not support image generation`
-            );
-            continue;
-          }
-          for (const img of images) {
-            const outDir = getOutputDir();
-            const ext = img.mimeType.includes("png") ? "png" : "jpg";
-            const fname = `gemini_generated_${Date.now()}_${i}.${ext}`;
-            const dest = path8.join(outDir, fname);
-            fs9.writeFileSync(dest, Buffer.from(img.data, "base64"));
-            savedFiles.push(dest);
-            logger.success(`Saved: ${dest}`);
-          }
-        } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          logger.error(`Generation failed: ${msg}`);
+      if (opts.duration) body.duration = Number.parseInt(opts.duration, 10);
+      if (opts.seed) body.seed = Number.parseInt(opts.seed, 10);
+      if (opts.negative) body.negativePrompt = opts.negative;
+      const res = await client.post(
+        "/generations-image-to-video",
+        body,
+        logger
+      );
+      const jobId = res.motionVideoGenerationJob?.generationId;
+      if (!jobId) {
+        logger.error(`No generationId returned by Leonardo: ${JSON.stringify(res)}`);
+        process.exit(1);
+      }
+      const shouldWait = !!(opts.wait || opts.download);
+      if (!shouldWait) {
+        console.log(jobId);
+        console.error(`Poll with: multix leonardo status ${jobId}`);
+        return;
+      }
+      await pollAndDownload(client, jobId, {
+        waitTimeoutMs: Number.parseInt(opts.waitTimeout, 10) || 6e5,
+        download: !!opts.download,
+        output: opts.output,
+        thumb: opts.thumb !== false,
+        logger,
+        basename: "leonardo-i2v"
+      });
+    }
+  );
+}
+
+// src/providers/leonardo/commands/me.ts
+function registerLeonardoMeCommand(parent) {
+  parent.command("me").description("Show authenticated Leonardo user info and remaining API credits").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const client = createLeonardoClient();
+    const info = await client.get("/me", void 0, logger);
+    const u = info.user_details?.[0];
+    if (!u) {
+      logger.warn("No user info returned.");
+      return;
+    }
+    logger.success(`User: ${u.user.username} (${u.user.id})`);
+    console.log(`Tokens: ${u.subscriptionTokens} | API credit: ${u.apiCredit ?? "n/a"}`);
+  });
+}
+
+// src/providers/leonardo/commands/models.ts
+function registerLeonardoModelsCommand(parent) {
+  parent.command("models").description("List Leonardo platform image models").option("--limit <n>", "Limit number of results").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const client = createLeonardoClient();
+    const res = await client.get(
+      "/platformModels",
+      void 0,
+      logger
+    );
+    const limit = opts.limit ? Number.parseInt(opts.limit, 10) : void 0;
+    const models = limit ? res.custom_models.slice(0, limit) : res.custom_models;
+    for (const m of models) {
+      console.log(`${m.id}	${m.name}`);
+    }
+    logger.debug(`${models.length} model(s)`);
+  });
+}
+
+// src/providers/leonardo/commands/status.ts
+init_http_client();
+import path22 from "path";
+var VIDEO_KEYS = ["motionMP4URL", "url"];
+var IMAGE_EXT_RE2 = /\.(jpe?g|png|webp|gif)(\?|$)/i;
+var VIDEO_EXT_RE = /\.(mp4|webm|mov|m4v)(\?|$)/i;
+function collectAssetUrls(gen) {
+  const videos = [];
+  const images = [];
+  for (const img of gen.generated_images ?? []) {
+    if (!img.url) continue;
+    if (VIDEO_EXT_RE.test(img.url)) videos.push(img.url);
+    else if (IMAGE_EXT_RE2.test(img.url)) images.push(img.url);
+    else images.push(img.url);
+    for (const k of VIDEO_KEYS) {
+      const extra = img[k];
+      if (typeof extra === "string" && VIDEO_EXT_RE.test(extra)) videos.push(extra);
+    }
+  }
+  return { videos, images };
+}
+function registerLeonardoStatusCommand(parent) {
+  parent.command("status <generationId>").description("Get a Leonardo generation's status and asset URLs").option("--wait", "Poll until COMPLETE or FAILED").option("--wait-timeout <ms>", "Poll timeout in ms (with --wait)", "600000").option("--download", "Download assets on success (implies --wait)").option("--output <path>", "Output directory or single-file path (with --download)").option("--no-thumb", "Skip downloading thumbnails if the API returns them").option("-v, --verbose", "Verbose logging").action(
+    async (generationId, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const client = createLeonardoClient();
+      const shouldWait = !!(opts.wait || opts.download);
+      const fetchOnce = () => client.get(`/generations/${generationId}`, void 0, logger);
+      let res;
+      try {
+        res = shouldWait ? await poll({
+          fetch: fetchOnce,
+          done: (v) => v.generations_by_pk?.status === "COMPLETE",
+          failed: (v) => v.generations_by_pk?.status === "FAILED",
+          intervalMs: 5e3,
+          maxAttempts: Math.max(
+            1,
+            Math.ceil((Number.parseInt(opts.waitTimeout, 10) || 6e5) / 5e3)
+          ),
+          onTick: (n, v) => logger.debug(`attempt ${n} \u2014 status: ${v.generations_by_pk?.status}`)
+        }) : await fetchOnce();
+      } catch (e) {
+        if (e instanceof PollTimeoutError) {
+          logger.error(`Timed out waiting for generation ${generationId}`);
+          process.exit(1);
+        }
+        if (e instanceof PollFailedError) {
+          logger.error(`Generation failed: ${JSON.stringify(e.value)}`);
           process.exit(1);
         }
+        throw e;
       }
-      if (savedFiles.length === 0) {
-        logger.error("No images were generated");
-        process.exit(1);
+      const gen = res.generations_by_pk;
+      if (!gen) {
+        logger.warn("No generation found.");
+        return;
       }
-      if (opts.output && savedFiles[0]) {
-        fs9.mkdirSync(path8.dirname(path8.resolve(opts.output)), { recursive: true });
-        fs9.copyFileSync(savedFiles[0], opts.output);
-        logger.success(`Copied to: ${opts.output}`);
+      console.error(`status: ${gen.status}`);
+      const { videos, images } = collectAssetUrls(gen);
+      for (const u of [...videos, ...images]) console.log(u);
+      if (!opts.download || gen.status !== "COMPLETE") {
+        if (opts.download) logger.warn(`Cannot download \u2014 status is '${gen.status}'`);
+        return;
+      }
+      const outDir = getOutputDir();
+      let idx = 0;
+      for (const url of videos) {
+        const dest = opts.output && videos.length === 1 && images.length === 0 ? opts.output : path22.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
+        await downloadFile(url, dest);
+        logger.success(`Saved ${dest}`);
+        await maybeDownloadThumb(gen, dest, {
+          skip: opts.thumb === false,
+          copyTo: opts.output,
+          logger
+        });
+        idx++;
+      }
+      for (const url of images) {
+        const m = url.match(IMAGE_EXT_RE2);
+        const ext = m?.[1] ? m[1].toLowerCase().replace("jpeg", "jpg") : "png";
+        const dest = path22.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
+        await downloadFile(url, dest);
+        logger.success(`Saved ${dest}`);
+        idx++;
       }
-      console.log(`
-Generated ${savedFiles.length} image(s):`);
-      for (const f of savedFiles) console.log(`  ${f}`);
     }
   );
 }
 
-// src/providers/gemini/commands/transcribe.ts
-init_errors();
-import fs10 from "fs";
-function registerTranscribeCommand(parent) {
-  parent.command("transcribe").description("Transcribe audio or video files with Gemini").requiredOption("--files <paths...>", "Audio/video file paths to transcribe").option("--prompt <text>", "Transcription prompt", "Generate a transcript with timestamps").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
-    async (opts) => {
+// src/providers/leonardo/commands/upscale.ts
+function registerLeonardoUpscaleCommands(parent) {
+  parent.command("upscale <generatedImageId>").description("Upscale a generated image via Leonardo Universal Upscaler").option("--style <style>", "Upscaler style (GENERAL, CINEMATIC, ...)", "GENERAL").option("--strength <n>", "Creativity strength (0-1)", "0.35").option("--multiplier <n>", "Upscale multiplier (1-2)", "1.5").option("-v, --verbose", "Verbose logging").action(
+    async (generatedImageId, opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      const model = opts.model ?? getDefaultModel("transcribe");
-      for (const f of opts.files) {
-        if (!fs10.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
-      }
-      const results = [];
-      for (let i = 0; i < opts.files.length; i++) {
-        const filePath = opts.files[i];
-        logger.debug(`[${i + 1}/${opts.files.length}] Transcribing: ${filePath}`);
-        try {
-          const useApi = shouldUseFileApi(filePath);
-          let contentParts;
-          if (useApi) {
-            logger.debug("File >20MB \u2014 using Files API");
-            const ref = await uploadFile(filePath, { logger });
-            contentParts = [
-              { text: opts.prompt },
-              { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
-            ];
-          } else {
-            contentParts = [{ text: opts.prompt }, inlinePart(filePath)];
-          }
-          const resp = await generateContent({
-            model,
-            contents: [{ parts: contentParts }]
-          });
-          results.push({
-            file: filePath,
-            status: "success",
-            response: extractText(resp)
-          });
-        } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
-          results.push({ file: filePath, status: "error", error: msg });
-        }
-      }
-      formatResults(results, opts.format, opts.output);
-      const failed = results.filter((r) => r.status === "error").length;
-      if (failed > 0) process.exit(1);
+      const client = createLeonardoClient();
+      logger.info(`Submitting upscale for image ${generatedImageId}`);
+      const res = await client.post(
+        "/variations/universal-upscaler",
+        {
+          generatedImageId,
+          upscalerStyle: opts.style,
+          creativityStrength: Number.parseFloat(opts.strength),
+          upscaleMultiplier: Number.parseFloat(opts.multiplier)
+        },
+        logger
+      );
+      const variationId = res.universalUpscaler.id;
+      logger.success(`variationId: ${variationId}`);
+      console.log(variationId);
+      console.error(`Use: multix leonardo variation ${variationId}`);
     }
   );
+  parent.command("variation <variationId>").description("Fetch a Leonardo variation/upscale result by ID").option("-v, --verbose", "Verbose logging").action(async (variationId, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const client = createLeonardoClient();
+    const res = await client.get(
+      `/variations/${variationId}`,
+      void 0,
+      logger
+    );
+    for (const v of res.generated_image_variation_generic ?? []) {
+      console.log(`${v.status}	${v.url ?? ""}`);
+    }
+  });
 }
 
-// src/providers/gemini/commands/index.ts
-function registerGeminiCommands(program2) {
-  const gemini = program2.command("gemini").description("Gemini AI operations: analyze, transcribe, extract, generate images/video");
-  registerAnalyzeCommand(gemini);
-  registerTranscribeCommand(gemini);
-  registerExtractCommand(gemini);
-  registerGenerateCommand(gemini);
-  registerGenerateVideoCommand(gemini);
+// src/providers/leonardo/commands/video-models.ts
+function registerLeonardoVideoModelsCommand(parent) {
+  parent.command("video-models").description("List supported Leonardo video models (static enum from Leonardo docs)").action(() => {
+    for (const m of LEONARDO_VIDEO_MODELS) {
+      console.log(`${m.id}	${m.name}	[${m.modes.join(",")}]`);
+    }
+    console.error(`
+Resolutions: ${LEONARDO_VIDEO_RESOLUTIONS.join(", ")}`);
+    console.error("Source: https://docs.leonardo.ai/llms.txt");
+  });
+}
+
+// src/providers/leonardo/commands/index.ts
+function registerLeonardoCommands(program2) {
+  const leonardo = program2.command("leonardo").description("Leonardo.Ai: image/video generation, upscaling, account info");
+  registerLeonardoGenerateCommand(leonardo);
+  registerLeonardoImageToImageCommand(leonardo);
+  registerLeonardoVideoCommand(leonardo);
+  registerLeonardoImageToVideoCommand(leonardo);
+  registerLeonardoVideoModelsCommand(leonardo);
+  registerLeonardoUpscaleCommands(leonardo);
+  registerLeonardoStatusCommand(leonardo);
+  registerLeonardoModelsCommand(leonardo);
+  registerLeonardoMeCommand(leonardo);
 }
 
 // src/providers/minimax/commands/generate-music.ts
@@ -918,7 +2885,7 @@ async function pollAsyncTask(taskId, taskType, apiKey, opts = {}) {
     if (status === "Failed" || status === "Error") {
       throw new ProviderError(`Task ${taskId} failed: ${JSON.stringify(result)}`, "minimax");
     }
-    await sleep3(intervalMs);
+    await sleep4(intervalMs);
     elapsed += intervalMs;
   }
   throw new ProviderError(`Task ${taskId} timed out after ${timeoutMs / 1e3}s`, "minimax");
@@ -937,14 +2904,14 @@ async function downloadMinimaxFile(fileId, apiKey, dest, logger) {
   await downloadFile(downloadUrl, dest);
   return dest;
 }
-function sleep3(ms) {
+function sleep4(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
 // src/providers/minimax/generators/music.ts
 init_http_client();
-import fs11 from "fs";
-import path9 from "path";
+import fs19 from "fs";
+import path23 from "path";
 async function generateMinimaxMusic(opts) {
   const {
     apiKey,
@@ -989,14 +2956,14 @@ async function generateMinimaxMusic(opts) {
   }
   const durationMs = resp.extra_info?.music_duration ?? 0;
   const outDir = getOutputDir();
-  const dest = path9.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
+  const dest = path23.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
   try {
     if (audioData.startsWith("http")) {
       const bytes = await fetchBytes(audioData);
-      fs11.writeFileSync(dest, bytes);
+      fs19.writeFileSync(dest, bytes);
     } else {
       const audioBytes = Buffer.from(audioData, "hex");
-      fs11.writeFileSync(dest, audioBytes);
+      fs19.writeFileSync(dest, audioBytes);
     }
   } catch (e) {
     return {
@@ -1007,8 +2974,8 @@ async function generateMinimaxMusic(opts) {
   const durSec = durationMs / 1e3;
   logger?.success(`Saved: ${dest} (${durSec.toFixed(1)}s)`);
   if (output) {
-    fs11.mkdirSync(path9.dirname(path9.resolve(output)), { recursive: true });
-    fs11.copyFileSync(dest, output);
+    fs19.mkdirSync(path23.dirname(path23.resolve(output)), { recursive: true });
+    fs19.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, durationMs, model };
 }
@@ -1082,8 +3049,8 @@ Generated music: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/speech.ts
-import fs12 from "fs";
-import path10 from "path";
+import fs20 from "fs";
+import path24 from "path";
 async function generateMinimaxSpeech(opts) {
   const {
     apiKey,
@@ -1130,12 +3097,12 @@ async function generateMinimaxSpeech(opts) {
   const audioBytes = Buffer.from(audioHex, "hex");
   const ext = ["mp3", "wav", "flac"].includes(outputFormat) ? outputFormat : "mp3";
   const outDir = getOutputDir();
-  const dest = path10.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
-  fs12.writeFileSync(dest, audioBytes);
+  const dest = path24.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
+  fs20.writeFileSync(dest, audioBytes);
   logger?.success(`Saved: ${dest} (${(audioBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs12.mkdirSync(path10.dirname(path10.resolve(output)), { recursive: true });
-    fs12.copyFileSync(dest, output);
+    fs20.mkdirSync(path24.dirname(path24.resolve(output)), { recursive: true });
+    fs20.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, model };
 }
@@ -1182,8 +3149,8 @@ Generated audio: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/video.ts
-import fs13 from "fs";
-import path11 from "path";
+import fs21 from "fs";
+import path25 from "path";
 async function generateMinimaxVideo(opts) {
   const {
     apiKey,
@@ -1193,6 +3160,7 @@ async function generateMinimaxVideo(opts) {
     resolution = "1080P",
     firstFrame,
     output,
+    thumb,
     logger
   } = opts;
   const payload = { prompt, model, duration, resolution };
@@ -1228,19 +3196,24 @@ async function generateMinimaxVideo(opts) {
     return { status: "error", error: `No file_id in poll result: ${JSON.stringify(pollResult)}` };
   }
   const outDir = getOutputDir();
-  const dest = path11.join(outDir, `minimax_video_${Date.now()}.mp4`);
+  const dest = path25.join(outDir, `minimax_video_${Date.now()}.mp4`);
   try {
     await downloadMinimaxFile(fileId, apiKey, dest, logger);
   } catch (e) {
     return { status: "error", error: e instanceof Error ? e.message : String(e) };
   }
   const elapsed = (Date.now() - start) / 1e3;
-  const stat = fs13.statSync(dest);
+  const stat = fs21.statSync(dest);
   const fileSizeMb = stat.size / (1024 * 1024);
   if (output) {
-    fs13.mkdirSync(path11.dirname(path11.resolve(output)), { recursive: true });
-    fs13.copyFileSync(dest, output);
+    fs21.mkdirSync(path25.dirname(path25.resolve(output)), { recursive: true });
+    fs21.copyFileSync(dest, output);
   }
+  await maybeDownloadThumb(pollResult, dest, {
+    skip: thumb === false,
+    copyTo: output,
+    logger
+  });
   logger?.debug(`Generated in ${elapsed.toFixed(1)}s, size: ${fileSizeMb.toFixed(2)} MB`);
   return {
     status: "success",
@@ -1253,7 +3226,7 @@ async function generateMinimaxVideo(opts) {
 
 // src/providers/minimax/commands/generate-video.ts
 function registerMinimaxGenerateVideoCommand(parent) {
-  parent.command("generate-video").description("Generate video with MiniMax Hailuo models (async)").requiredOption("--prompt <text>", "Video generation prompt").option("--model <id>", `Model (${[...MINIMAX_VIDEO_MODELS].join("|")})`).option("--duration <n>", `Duration in seconds (${VIDEO_DURATIONS.join("|")})`, "6").option("--resolution <res>", `Resolution (${VIDEO_RESOLUTIONS.join("|")})`, "1080P").option("--first-frame <url>", "First frame image URL").option("--output <path>", "Copy generated video to this path").option("-v, --verbose", "Verbose logging").action(
+  parent.command("generate-video").description("Generate video with MiniMax Hailuo models (async)").requiredOption("--prompt <text>", "Video generation prompt").option("--model <id>", `Model (${[...MINIMAX_VIDEO_MODELS].join("|")})`).option("--duration <n>", `Duration in seconds (${VIDEO_DURATIONS.join("|")})`, "6").option("--resolution <res>", `Resolution (${VIDEO_RESOLUTIONS.join("|")})`, "1080P").option("--first-frame <url>", "First frame image URL").option("--output <path>", "Copy generated video to this path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const apiKey = requireMinimaxKey();
@@ -1278,6 +3251,7 @@ function registerMinimaxGenerateVideoCommand(parent) {
         resolution,
         firstFrame: opts.firstFrame,
         output: opts.output,
+        thumb: opts.thumb,
         logger
       });
       if (result.status === "error") {
@@ -1296,8 +3270,8 @@ Generated video: ${result.generatedVideo}`);
 // src/providers/minimax/generators/image.ts
 init_errors();
 init_http_client();
-import fs14 from "fs";
-import path12 from "path";
+import fs22 from "fs";
+import path26 from "path";
 async function generateMinimaxImage(opts) {
   const {
     apiKey,
@@ -1335,8 +3309,8 @@ async function generateMinimaxImage(opts) {
     try {
       const bytes = await fetchBytes(url);
       const fname = `minimax_image_${Date.now()}_${i}.png`;
-      const dest = path12.join(outDir, fname);
-      fs14.writeFileSync(dest, bytes);
+      const dest = path26.join(outDir, fname);
+      fs22.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -1347,8 +3321,8 @@ async function generateMinimaxImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs14.mkdirSync(path12.dirname(path12.resolve(output)), { recursive: true });
-    fs14.copyFileSync(savedFiles[0], output);
+    fs22.mkdirSync(path26.dirname(path26.resolve(output)), { recursive: true });
+    fs22.copyFileSync(savedFiles[0], output);
   }
   return { status: "success", generatedImages: savedFiles, model };
 }
@@ -1381,18 +3355,101 @@ Generated ${result.generatedImages?.length ?? 0} image(s):`);
   );
 }
 
+// src/providers/minimax/commands/image-to-image.ts
+init_errors();
+init_http_client();
+import fs23 from "fs";
+import path27 from "path";
+function registerMinimaxImageToImageCommand(parent) {
+  parent.command("image-to-image").alias("i2i").description(
+    "MiniMax character/subject preservation. CAVEAT: NOT free-form image editing \u2014 the --ref image is used only as a character/face reference for a NEW scene described by --prompt."
+  ).requiredOption("--prompt <text>", "Prompt describing the desired NEW scene/composition").requiredOption(
+    "--ref <path>",
+    "Subject reference image (URL or local path) \u2014 character/face reference only, single image"
+  ).option("--model <id>", "Model id (default image-01)").option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 1:1, 16:9)", "1:1").option("--num-images <n>", "Number of images (1-9)", "1").option("--output <path>", "Copy first image to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const apiKey = requireMinimaxKey();
+      const model = opts.model ?? TASK_DEFAULTS.image;
+      const numImages = Math.min(Math.max(Number.parseInt(opts.numImages, 10) || 1, 1), 9);
+      logger.warn(
+        "MiniMax i2i preserves a CHARACTER reference only. It does not edit the input image. If you need free-form edits, use byteplus, gemini, openrouter, or leonardo image-to-image."
+      );
+      const resolved = await resolveImageInput(opts.ref, { logger });
+      const imageFile = refUrl(resolved);
+      const payload = {
+        model,
+        prompt: opts.prompt,
+        aspect_ratio: opts.aspectRatio,
+        n: numImages,
+        response_format: "url",
+        prompt_optimizer: true,
+        subject_reference: [
+          {
+            type: "character",
+            image_file: imageFile
+          }
+        ]
+      };
+      logger.debug(`MiniMax i2i: model=${model}, ref=${opts.ref}, n=${numImages}`);
+      let resp;
+      try {
+        resp = await apiPost("image_generation", payload, apiKey, {
+          logger
+        });
+      } catch (e) {
+        logger.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+      }
+      const imageUrls = resp.data?.image_urls ?? [];
+      if (imageUrls.length === 0) {
+        logger.error("No images in response");
+        process.exit(1);
+      }
+      const outDir = getOutputDir();
+      const ts = Date.now();
+      const saved = [];
+      for (let i = 0; i < imageUrls.length; i++) {
+        const url = imageUrls[i];
+        if (!url) continue;
+        try {
+          const bytes = await fetchBytes(url);
+          const dest = path27.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
+          fs23.writeFileSync(dest, bytes);
+          saved.push(dest);
+          logger.success(`Saved: ${dest}`);
+        } catch (e) {
+          throw new ProviderError(
+            `Failed to download image: ${e instanceof Error ? e.message : String(e)}`,
+            "minimax"
+          );
+        }
+      }
+      if (opts.output && saved[0]) {
+        fs23.mkdirSync(path27.dirname(path27.resolve(opts.output)), { recursive: true });
+        fs23.copyFileSync(saved[0], opts.output);
+        logger.success(`Copied to: ${opts.output}`);
+      }
+      console.log(`
+Generated ${saved.length} image(s):`);
+      for (const f of saved) console.log(`  ${f}`);
+    }
+  );
+}
+
 // src/providers/minimax/commands/index.ts
 function registerMinimaxCommands(program2) {
   const minimax = program2.command("minimax").description("MiniMax generation: images, video, speech, and music");
   registerMinimaxGenerateCommand(minimax);
+  registerMinimaxImageToImageCommand(minimax);
   registerMinimaxGenerateVideoCommand(minimax);
   registerMinimaxGenerateSpeechCommand(minimax);
   registerMinimaxGenerateMusicCommand(minimax);
 }
 
 // src/providers/openrouter/client.ts
-import fs15 from "fs";
-import path13 from "path";
+import fs24 from "fs";
+import path28 from "path";
 init_errors();
 init_http_client();
 var OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions";
@@ -1481,8 +3538,8 @@ async function generateOpenRouterImage(opts) {
     if (!url) continue;
     try {
       const bytes = await fetchBytes(url);
-      const dest = path13.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
-      fs15.writeFileSync(dest, bytes);
+      const dest = path28.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
+      fs24.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -1493,8 +3550,8 @@ async function generateOpenRouterImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs15.mkdirSync(path13.dirname(path13.resolve(output)), { recursive: true });
-    fs15.writeFileSync(output, fs15.readFileSync(savedFiles[0]));
+    fs24.mkdirSync(path28.dirname(path28.resolve(output)), { recursive: true });
+    fs24.writeFileSync(output, fs24.readFileSync(savedFiles[0]));
   }
   return { status: "success", generatedImages: savedFiles, model: usedModel };
 }
@@ -1528,10 +3585,328 @@ Generated ${result.generatedImages?.length ?? 0} image(s):`);
   );
 }
 
+// src/providers/openrouter/commands/image-to-image.ts
+import fs25 from "fs";
+import path29 from "path";
+init_errors();
+init_http_client();
+var DEFAULT_MODEL = "google/gemini-2.5-flash-image";
+var SOFT_LIMIT_BYTES2 = 5 * 1024 * 1024;
+var HARD_LIMIT_BYTES2 = 8 * 1024 * 1024;
+function registerOpenRouterImageToImageCommand(parent) {
+  parent.command("image-to-image").alias("i2i").description("Edit/transform images via OpenRouter (default: google/gemini-2.5-flash-image)").requiredOption("--prompt <text>", "Text prompt describing the edit").requiredOption(
+    "--ref <path>",
+    "Reference image (URL or local path); repeatable (most models accept 1)",
+    collect5,
+    []
+  ).option("-m, --model <id>", `OpenRouter model id (default ${DEFAULT_MODEL})`).option("--output <path>", "Save first generated image to this path").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      if (!opts.ref || opts.ref.length === 0) {
+        throw new Error("At least one --ref is required for image-to-image.");
+      }
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? resolveKey("OPENROUTER_IMAGE_MODEL") ?? DEFAULT_MODEL;
+      const resolvedRefs = [];
+      for (const r of opts.ref) {
+        const resolved = await resolveImageInput(r, {
+          logger,
+          softLimitBytes: SOFT_LIMIT_BYTES2,
+          hardLimitBytes: HARD_LIMIT_BYTES2
+        });
+        resolvedRefs.push(refUrl(resolved));
+      }
+      logger.debug(`OpenRouter i2i: model=${model}, refs=${resolvedRefs.length}`);
+      const saved = await runImageToImage({
+        prompt: opts.prompt,
+        model,
+        refs: resolvedRefs,
+        output: opts.output,
+        logger
+      });
+      console.log(`
+Generated ${saved.length} image(s):`);
+      for (const f of saved) console.log(`  ${f}`);
+      console.log(`Model used: ${model}`);
+    }
+  );
+}
+function collect5(value, prev) {
+  return [...prev, value];
+}
+async function runImageToImage(opts) {
+  const apiKey = requireOpenRouterKey();
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  const referer = resolveKey("OPENROUTER_SITE_URL");
+  const title = resolveKey("OPENROUTER_APP_NAME") ?? "multix";
+  if (referer) headers["HTTP-Referer"] = referer;
+  if (title) headers["X-Title"] = title;
+  const content = opts.refs.map((url) => ({
+    type: "image_url",
+    image_url: { url }
+  }));
+  content.push({ type: "text", text: opts.prompt });
+  const payload = {
+    model: opts.model,
+    messages: [{ role: "user", content }],
+    modalities: opts.model.includes("gemini") ? ["image", "text"] : ["image"]
+  };
+  const data = await httpJson({
+    url: OPENROUTER_API_URL,
+    method: "POST",
+    headers,
+    body: payload,
+    timeoutMs: 24e4
+  });
+  const messageImages = data.choices?.[0]?.message?.images ?? [];
+  if (messageImages.length === 0) {
+    throw new ProviderError(
+      `No images in response \u2014 model '${opts.model}' may not support image-to-image`,
+      "openrouter"
+    );
+  }
+  const outDir = getOutputDir();
+  const ts = Date.now();
+  const saved = [];
+  for (let i = 0; i < messageImages.length; i++) {
+    const url = messageImages[i]?.image_url?.url;
+    if (!url) continue;
+    const bytes = await fetchBytes(url);
+    const dest = path29.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
+    fs25.writeFileSync(dest, bytes);
+    saved.push(dest);
+    opts.logger.success(`Saved: ${dest}`);
+  }
+  if (opts.output && saved[0]) {
+    fs25.mkdirSync(path29.dirname(path29.resolve(opts.output)), { recursive: true });
+    fs25.copyFileSync(saved[0], opts.output);
+    opts.logger.success(`Copied to: ${opts.output}`);
+  }
+  return saved;
+}
+
+// src/providers/openrouter/video-client.ts
+init_http_client();
+var OPENROUTER_VIDEOS_URL = "https://openrouter.ai/api/v1/videos";
+function authHeaders3(apiKey) {
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  const referer = resolveKey("OPENROUTER_SITE_URL");
+  const title = resolveKey("OPENROUTER_APP_NAME") ?? "multix";
+  if (referer) headers["HTTP-Referer"] = referer;
+  if (title) headers["X-Title"] = title;
+  return headers;
+}
+async function submitVideoJob(body, apiKey = requireOpenRouterKey()) {
+  return httpJson({
+    url: OPENROUTER_VIDEOS_URL,
+    method: "POST",
+    headers: authHeaders3(apiKey),
+    body,
+    timeoutMs: 12e4
+  });
+}
+async function pollVideoJob(jobId, apiKey = requireOpenRouterKey()) {
+  return httpJson({
+    url: `${OPENROUTER_VIDEOS_URL}/${jobId}`,
+    headers: authHeaders3(apiKey)
+  });
+}
+function videoContentUrl(jobId) {
+  return `${OPENROUTER_VIDEOS_URL}/${jobId}/content`;
+}
+async function listVideoModels(apiKey = requireOpenRouterKey()) {
+  return httpJson({
+    url: `${OPENROUTER_VIDEOS_URL}/models`,
+    headers: authHeaders3(apiKey)
+  });
+}
+
+// src/providers/openrouter/commands/video-status.ts
+import fs26 from "fs";
+import path30 from "path";
+async function downloadOpenRouterVideo(opts) {
+  const { jobId, logger, source } = opts;
+  const apiKey = requireOpenRouterKey();
+  const url = videoContentUrl(jobId);
+  const dest = path30.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
+  const r = await globalThis.fetch(url, { headers: { Authorization: `Bearer ${apiKey}` } });
+  if (!r.ok) {
+    logger.error(`Download HTTP ${r.status}`);
+    process.exit(1);
+  }
+  if (!r.body) {
+    logger.error("Empty response body");
+    process.exit(1);
+  }
+  fs26.mkdirSync(path30.dirname(dest), { recursive: true });
+  const ws = fs26.createWriteStream(dest);
+  const { pipeline: pipeline2 } = await import("stream/promises");
+  await pipeline2(r.body, ws);
+  logger.success(`Saved ${dest}`);
+  if (opts.output) {
+    fs26.mkdirSync(path30.dirname(path30.resolve(opts.output)), { recursive: true });
+    fs26.copyFileSync(dest, opts.output);
+    logger.success(`Copied to ${opts.output}`);
+  }
+  await maybeDownloadThumb(source, dest, {
+    skip: opts.thumb === false,
+    copyTo: opts.output,
+    logger
+  });
+  return dest;
+}
+function registerOpenRouterVideoStatusCommand(parent) {
+  parent.command("video-status <jobId>").description("Poll an OpenRouter video generation job").option("--wait", "Poll until status is 'completed' or 'failed'").option("--wait-timeout <ms>", "Poll timeout in ms (with --wait)", "600000").option("--download", "If completed, download the video (implies --wait)").option("--output <path>", "Copy downloaded video to this path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (jobId, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const shouldWait = !!(opts.wait || opts.download);
+      let res;
+      try {
+        res = shouldWait ? await poll({
+          fetch: () => pollVideoJob(jobId),
+          done: (v) => v.status === "completed",
+          failed: (v) => v.status === "failed",
+          intervalMs: 5e3,
+          maxAttempts: Math.max(
+            1,
+            Math.ceil((Number.parseInt(opts.waitTimeout, 10) || 6e5) / 5e3)
+          ),
+          onTick: (n, v) => logger.debug(`attempt ${n} \u2014 status: ${v.status}`)
+        }) : await pollVideoJob(jobId);
+      } catch (e) {
+        if (e instanceof PollTimeoutError) {
+          logger.error(`Timed out waiting for job ${jobId}`);
+          process.exit(1);
+        }
+        if (e instanceof PollFailedError) {
+          logger.error(`Job failed: ${JSON.stringify(e.value)}`);
+          process.exit(1);
+        }
+        throw e;
+      }
+      console.error(`status: ${res.status}`);
+      for (const u of res.unsigned_urls ?? []) console.log(u);
+      if (opts.download && res.status === "completed") {
+        await downloadOpenRouterVideo({
+          jobId,
+          output: opts.output,
+          thumb: opts.thumb,
+          logger,
+          source: res
+        });
+      } else if (opts.download) {
+        logger.warn(`Cannot download \u2014 status is '${res.status}', not 'completed'`);
+      }
+      if (res.usage?.cost !== void 0) {
+        logger.debug(`cost: ${res.usage.cost}${res.usage.is_byok ? " (BYOK)" : ""}`);
+      }
+    }
+  );
+}
+
+// src/providers/openrouter/commands/image-to-video.ts
+function registerOpenRouterImageToVideoCommand(parent) {
+  parent.command("image-to-video").alias("i2v").description("Submit an image-to-video job to OpenRouter (async, returns job id)").requiredOption("--prompt <text>", "Motion/scene prompt").requiredOption("--image-url <url>", "First-frame image URL (https)").option("--last-frame-url <url>", "Optional last-frame image URL").option("--model <id>", "OpenRouter video model id (e.g. google/veo-3.1)").option("--resolution <r>", "Resolution hint (e.g. 720p, 1080p)").option("--aspect-ratio <r>", "Aspect ratio hint (e.g. 16:9, 9:16)").option("--duration <n>", "Duration seconds").option("--seed <n>", "Fixed seed").option("--wait", "Poll until status is 'completed' or 'failed'").option("--wait-timeout <ms>", "Poll timeout in ms (with --wait)", "600000").option("--download", "Download the generated video on success (implies --wait)").option("--output <path>", "Copy downloaded video to this path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
+    async (opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const model = opts.model ?? resolveKey("OPENROUTER_VIDEO_MODEL") ?? "google/veo-3.1";
+      const frame_images = [
+        {
+          type: "image_url",
+          image_url: { url: opts.imageUrl },
+          frame_type: "first_frame"
+        }
+      ];
+      if (opts.lastFrameUrl) {
+        frame_images.push({
+          type: "image_url",
+          image_url: { url: opts.lastFrameUrl },
+          frame_type: "last_frame"
+        });
+      }
+      const body = {
+        model,
+        prompt: opts.prompt,
+        frame_images
+      };
+      if (opts.resolution) body.resolution = opts.resolution;
+      if (opts.aspectRatio) body.aspect_ratio = opts.aspectRatio;
+      if (opts.duration) body.duration = Number.parseInt(opts.duration, 10);
+      if (opts.seed) body.seed = Number.parseInt(opts.seed, 10);
+      logger.info(`Submitting image-to-video job (model=${model})`);
+      const res = await submitVideoJob(body);
+      logger.success(`Job ${res.id} (status: ${res.status})`);
+      const shouldWait = !!(opts.wait || opts.download);
+      if (!shouldWait) {
+        console.log(res.id);
+        console.error(`Poll with: multix openrouter video-status ${res.id}`);
+        return;
+      }
+      let final;
+      try {
+        final = await poll({
+          fetch: () => pollVideoJob(res.id),
+          done: (v) => v.status === "completed",
+          failed: (v) => v.status === "failed",
+          intervalMs: 5e3,
+          maxAttempts: Math.max(
+            1,
+            Math.ceil((Number.parseInt(opts.waitTimeout, 10) || 6e5) / 5e3)
+          ),
+          onTick: (n, v) => logger.debug(`attempt ${n} \u2014 status: ${v.status}`)
+        });
+      } catch (e) {
+        if (e instanceof PollTimeoutError) {
+          logger.error(`Timed out \u2014 multix openrouter video-status ${res.id}`);
+          process.exit(1);
+        }
+        if (e instanceof PollFailedError) {
+          logger.error(`Job failed: ${JSON.stringify(e.value)}`);
+          process.exit(1);
+        }
+        throw e;
+      }
+      console.error(`status: ${final.status}`);
+      for (const u of final.unsigned_urls ?? []) console.log(u);
+      if (opts.download) {
+        await downloadOpenRouterVideo({
+          jobId: res.id,
+          output: opts.output,
+          thumb: opts.thumb,
+          logger,
+          source: final
+        });
+      }
+    }
+  );
+}
+
+// src/providers/openrouter/commands/video-models.ts
+function registerOpenRouterVideoModelsCommand(parent) {
+  parent.command("video-models").description("List available OpenRouter video models").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const res = await listVideoModels();
+    const list = res.data ?? res.models ?? [];
+    for (const m of list) {
+      console.log(`${m.id}	${m.name ?? ""}`);
+    }
+    logger.debug(`${list.length} model(s)`);
+  });
+}
+
 // src/providers/openrouter/commands/index.ts
 function registerOpenRouterCommands(program2) {
-  const openrouter = program2.command("openrouter").description("OpenRouter image generation via chat completions API");
+  const openrouter = program2.command("openrouter").description("OpenRouter image + video generation");
   registerOpenRouterGenerateCommand(openrouter);
+  registerOpenRouterImageToImageCommand(openrouter);
+  registerOpenRouterImageToVideoCommand(openrouter);
+  registerOpenRouterVideoStatusCommand(openrouter);
+  registerOpenRouterVideoModelsCommand(openrouter);
 }
 
 // src/commands/check-helpers/binary-check.ts
@@ -1585,6 +3960,8 @@ To configure multix, set at least one provider API key:
     Gemini / AI Studio : https://aistudio.google.com/apikey
     OpenRouter         : https://openrouter.ai/settings/keys
     MiniMax            : https://platform.minimax.io/user-center/basic-information/interface-key
+    Leonardo.Ai        : https://app.leonardo.ai/settings/api-keys
+    BytePlus           : https://console.byteplus.com/auth/api-keys
 
   Option A \u2014 user global config (recommended):
     echo 'GEMINI_API_KEY=your-key' >> ~/.multix/.env
@@ -1604,6 +3981,48 @@ var FFMPEG_HINT = "ffmpeg not found \u2014 media optimize/split/batch commands u
 var MAGICK_HINT = "ImageMagick (magick) not found \u2014 image optimization unavailable.\n  Linux: sudo apt-get install imagemagick\n  macOS: brew install imagemagick\n  Windows: https://imagemagick.org/script/download.php";
 
 // src/commands/check.ts
+var PROVIDERS = [
+  {
+    name: "Gemini",
+    envPrimary: "GEMINI_API_KEY",
+    optional: false,
+    link: "https://aistudio.google.com/apikey"
+  },
+  {
+    name: "OpenRouter",
+    envPrimary: "OPENROUTER_API_KEY",
+    optional: true,
+    link: "https://openrouter.ai/settings/keys"
+  },
+  {
+    name: "MiniMax",
+    envPrimary: "MINIMAX_API_KEY",
+    optional: true,
+    link: "https://platform.minimax.io/user-center/basic-information/interface-key"
+  },
+  {
+    name: "Leonardo.Ai",
+    envPrimary: "LEONARDO_API_KEY",
+    optional: true,
+    link: "https://app.leonardo.ai/settings/api-keys"
+  },
+  {
+    name: "BytePlus",
+    envPrimary: "BYTEPLUS_API_KEY",
+    envFallback: "ARK_API_KEY",
+    optional: true,
+    link: "https://console.byteplus.com/auth/api-keys"
+  }
+];
+function resolveProviderKey(p) {
+  const primary = resolveKey(p.envPrimary);
+  if (primary) return { key: primary, envUsed: p.envPrimary };
+  if (p.envFallback) {
+    const fb = resolveKey(p.envFallback);
+    if (fb) return { key: fb, envUsed: p.envFallback };
+  }
+  return {};
+}
 function registerCheckCommand(program2) {
   program2.command("check").description("Validate multix setup: tooling, API keys, and live Gemini connectivity").option("-v, --verbose", "Verbose output").action(async (opts) => {
     const logger = createLogger({ verbose: opts.verbose ?? false });
@@ -1624,29 +4043,28 @@ function registerCheckCommand(program2) {
       if (opts.verbose) console.log(`  ${MAGICK_HINT}`);
     }
     logger.header("API Keys");
-    const geminiKey = resolveKey("GEMINI_API_KEY");
-    const openrouterKey = resolveKey("OPENROUTER_API_KEY");
-    const minimaxKey = resolveKey("MINIMAX_API_KEY");
-    if (geminiKey) {
-      logger.success(`GEMINI_API_KEY found \u2014 ${redact(geminiKey)}`);
-    } else {
-      logger.warn("GEMINI_API_KEY not set (Gemini analyze/transcribe/doc features unavailable)");
-    }
-    if (openrouterKey) {
-      logger.success(`OPENROUTER_API_KEY found \u2014 ${redact(openrouterKey)}`);
-    } else {
-      logger.info("OPENROUTER_API_KEY not set (optional)");
-    }
-    if (minimaxKey) {
-      logger.success(`MINIMAX_API_KEY found \u2014 ${redact(minimaxKey)}`);
-    } else {
-      logger.info("MINIMAX_API_KEY not set (optional)");
+    let anyKey = false;
+    const resolved = /* @__PURE__ */ new Map();
+    for (const p of PROVIDERS) {
+      const r = resolveProviderKey(p);
+      resolved.set(p.name, r);
+      if (r.key) anyKey = true;
+      const envLabel = r.envUsed ?? p.envPrimary;
+      if (r.key) {
+        logger.success(`${envLabel} found \u2014 ${redact(r.key)}`);
+      } else if (p.optional) {
+        const fbNote = p.envFallback ? ` (or ${p.envFallback})` : "";
+        logger.info(`${p.envPrimary}${fbNote} not set (optional)`);
+      } else {
+        logger.warn(`${p.envPrimary} not set (${p.name} features unavailable)`);
+      }
     }
-    if (!geminiKey && !openrouterKey && !minimaxKey) {
+    if (!anyKey) {
       logger.header("No Provider Keys Configured");
       console.log(SETUP_HINTS);
       process.exit(1);
     }
+    const geminiKey = resolved.get("Gemini")?.key;
     if (geminiKey) {
       logger.header("Gemini Connectivity");
       logger.info("Pinging Gemini models endpoint...");
@@ -1668,7 +4086,7 @@ function registerCheckCommand(program2) {
           "  Full Gemini multimodal setup (analyze, transcribe, generate, doc convert)"
         );
       } else {
-        console.log("  Image generation via OpenRouter/MiniMax available");
+        console.log("  Image generation via OpenRouter/MiniMax/Leonardo/BytePlus available");
         console.log("  Add GEMINI_API_KEY for analysis, transcription, and doc conversion");
       }
     } else {
@@ -1680,8 +4098,8 @@ function registerCheckCommand(program2) {
 
 // src/commands/doc/convert.ts
 init_errors();
-import fs16 from "fs";
-import path14 from "path";
+import fs27 from "fs";
+import path31 from "path";
 
 // src/commands/doc/default-prompt.ts
 var DEFAULT_CONVERT_PROMPT = `Convert this document to clean, well-formatted Markdown.
@@ -1702,18 +4120,18 @@ async function convertDocuments(opts) {
   const model = opts.model ?? DOC_MODEL_DEFAULT;
   const prompt = opts.prompt ?? DEFAULT_CONVERT_PROMPT;
   for (const f of inputs) {
-    if (!fs16.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
+    if (!fs27.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
   }
   let outputPath;
   if (output) {
-    outputPath = path14.resolve(output);
+    outputPath = path31.resolve(output);
   } else if (autoName && inputs.length === 1 && inputs[0]) {
-    const base = path14.basename(inputs[0], path14.extname(inputs[0]));
-    outputPath = path14.join(getOutputDir(), `${base}-extraction.md`);
+    const base = path31.basename(inputs[0], path31.extname(inputs[0]));
+    outputPath = path31.join(getOutputDir(), `${base}-extraction.md`);
   } else {
-    outputPath = path14.join(getOutputDir(), "document-extraction.md");
+    outputPath = path31.join(getOutputDir(), "document-extraction.md");
   }
-  fs16.mkdirSync(path14.dirname(outputPath), { recursive: true });
+  fs27.mkdirSync(path31.dirname(outputPath), { recursive: true });
   const results = [];
   for (let i = 0; i < inputs.length; i++) {
     const filePath = inputs[i];
@@ -1745,7 +4163,7 @@ async function convertDocuments(opts) {
         if (attempt < 2) {
           const wait = 2 ** attempt * 1e3;
           logger?.debug(`Retry ${attempt + 1} after ${wait / 1e3}s: ${errorMsg}`);
-          await sleep4(wait);
+          await sleep5(wait);
         }
       }
     }
@@ -1764,7 +4182,7 @@ async function convertDocuments(opts) {
 `);
   for (const r of results) {
     lines.push(`
-## ${path14.basename(r.file)}
+## ${path31.basename(r.file)}
 `);
     if (r.status === "success" && r.markdown) {
       lines.push(`${r.markdown}
@@ -1777,7 +4195,7 @@ async function convertDocuments(opts) {
     }
     lines.push("\n---\n");
   }
-  fs16.writeFileSync(outputPath, lines.join("\n"), "utf8");
+  fs27.writeFileSync(outputPath, lines.join("\n"), "utf8");
   const succeeded = results.filter((r) => r.status === "success").length;
   console.log(`
 ${"=".repeat(50)}`);
@@ -1793,7 +4211,7 @@ ${"=".repeat(50)}`);
   const failed = results.filter((r) => r.status === "error").length;
   if (failed > 0) process.exit(1);
 }
-function sleep4(ms) {
+function sleep5(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
@@ -1823,12 +4241,12 @@ function registerDocCommands(program2) {
 
 // src/commands/media/index.ts
 init_errors();
-import fs19 from "fs";
-import path17 from "path";
+import fs30 from "fs";
+import path34 from "path";
 
 // src/commands/media/batch.ts
-import fs17 from "fs";
-import path15 from "path";
+import fs28 from "fs";
+import path32 from "path";
 
 // src/commands/media/detect-type.ts
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
@@ -2024,10 +4442,10 @@ async function batchOptimize(opts) {
     verbose,
     logger
   } = opts;
-  fs17.mkdirSync(outputDir, { recursive: true });
-  const entries = fs17.readdirSync(inputDir);
+  fs28.mkdirSync(outputDir, { recursive: true });
+  const entries = fs28.readdirSync(inputDir);
   const mediaFiles = entries.filter((f) => {
-    const ext = path15.extname(f).toLowerCase();
+    const ext = path32.extname(f).toLowerCase();
     return ALL_EXTS.has(ext);
   });
   if (mediaFiles.length === 0) {
@@ -2038,9 +4456,9 @@ async function batchOptimize(opts) {
   let succeeded = 0;
   const errors = [];
   for (const file of mediaFiles) {
-    const inputPath = path15.join(inputDir, file);
-    const outputPath = path15.join(outputDir, file);
-    const ext = path15.extname(file).toLowerCase();
+    const inputPath = path32.join(inputDir, file);
+    const outputPath = path32.join(outputDir, file);
+    const ext = path32.extname(file).toLowerCase();
     const kind = extToKind(ext);
     logger?.debug(`Processing: ${file}`);
     try {
@@ -2077,8 +4495,8 @@ async function batchOptimize(opts) {
 
 // src/commands/media/split-video.ts
 init_errors();
-import fs18 from "fs";
-import path16 from "path";
+import fs29 from "fs";
+import path33 from "path";
 async function splitVideo(opts) {
   await assertFfmpeg();
   const { input, outputDir, chunkDuration = 3600, verbose, logger } = opts;
@@ -2089,10 +4507,10 @@ async function splitVideo(opts) {
     logger?.info("Video is short enough \u2014 no splitting needed");
     return [input];
   }
-  fs18.mkdirSync(outputDir, { recursive: true });
-  const ext = path16.extname(input) || ".mp4";
-  const baseName = path16.basename(input, ext);
-  const outputPattern = path16.join(outputDir, `${baseName}_chunk_%03d${ext}`);
+  fs29.mkdirSync(outputDir, { recursive: true });
+  const ext = path33.extname(input) || ".mp4";
+  const baseName = path33.basename(input, ext);
+  const outputPattern = path33.join(outputDir, `${baseName}_chunk_%03d${ext}`);
   logger?.debug(`Splitting into ~${numChunks} chunks of ${chunkDuration}s each`);
   const args = [
     "-i",
@@ -2111,8 +4529,8 @@ async function splitVideo(opts) {
   await runFfmpeg(args, { verbose, logger });
   const files = [];
   for (let i = 0; i < numChunks + 1; i++) {
-    const fname = path16.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
-    if (fs18.existsSync(fname)) files.push(fname);
+    const fname = path33.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
+    if (fs29.existsSync(fname)) files.push(fname);
   }
   logger?.success(`Created ${files.length} chunks in ${outputDir}`);
   return files;
@@ -2126,9 +4544,9 @@ function registerMediaCommands(program2) {
   media.command("optimize").description("Optimize a single media file (video, audio, or image)").requiredOption("--input <file>", "Input media file").requiredOption("--output <file>", "Output file path").option("--target-size <MB>", "Target file size in MB").option("--quality <n>", "Quality: video CRF (0-51) or image (1-100)", "85").option("--max-width <px>", "Max image/video width in pixels", "1920").option("--bitrate <rate>", "Audio bitrate (e.g. 64k)", "64k").option("--resolution <WxH>", "Force video resolution (e.g. 1920x1080)").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs19.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
-      fs19.mkdirSync(path17.dirname(path17.resolve(opts.output)), { recursive: true });
-      const ext = path17.extname(opts.input).toLowerCase();
+      if (!fs30.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      fs30.mkdirSync(path34.dirname(path34.resolve(opts.output)), { recursive: true });
+      const ext = path34.extname(opts.input).toLowerCase();
       const kind = extToKind(ext);
       if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
       const quality = Number.parseInt(opts.quality, 10);
@@ -2168,7 +4586,7 @@ function registerMediaCommands(program2) {
   media.command("split").description("Split a long video into fixed-duration chunks").requiredOption("--input <file>", "Input video file").option("--output-dir <dir>", "Output directory for chunks", "./chunks").option("--chunk-duration <sec>", "Chunk duration in seconds", "3600").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs19.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      if (!fs30.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
       const chunks = await splitVideo({
         input: opts.input,
         outputDir: opts.outputDir,
@@ -2184,7 +4602,7 @@ Created ${chunks.length} chunk(s) in ${opts.outputDir}`);
   media.command("batch").description("Batch optimize all media files in a directory").requiredOption("--input-dir <dir>", "Input directory").requiredOption("--output-dir <dir>", "Output directory").option("--quality <n>", "Quality setting", "85").option("--max-width <px>", "Max image/video width", "1920").option("--bitrate <rate>", "Audio bitrate", "64k").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs19.existsSync(opts.inputDir))
+      if (!fs30.existsSync(opts.inputDir))
         throw new ValidationError(`Input dir not found: ${opts.inputDir}`);
       const result = await batchOptimize({
         inputDir: opts.inputDir,
@@ -2211,6 +4629,8 @@ function registerCommands(program2) {
   registerGeminiCommands(program2);
   registerMinimaxCommands(program2);
   registerOpenRouterCommands(program2);
+  registerLeonardoCommands(program2);
+  registerBytePlusCommands(program2);
   registerMediaCommands(program2);
   registerDocCommands(program2);
 }