@mrgoonie/multix 0.7.2 → 0.8.0

package/dist/cli.js

@@ -95,151 +95,6 @@ var init_errors = __esm({
   }
 });
 
-// src/core/fetch-json.ts
-function parseRetryAfter(value, now = Date.now()) {
-  if (!value) return void 0;
-  const trimmed = value.trim();
-  if (/^\d+(\.\d+)?$/.test(trimmed)) return Math.round(Number(trimmed) * 1e3);
-  const date = Date.parse(trimmed);
-  if (Number.isNaN(date)) return void 0;
-  return Math.max(0, date - now);
-}
-async function httpErrorFromResponse(response, url) {
-  let snippet = "";
-  try {
-    const text = await response.text();
-    snippet = text.slice(0, SNIPPET_MAX);
-  } catch {
-    snippet = "(could not read body)";
-  }
-  return new HttpError(
-    response.status,
-    snippet,
-    url,
-    parseRetryAfter(response.headers.get("retry-after"))
-  );
-}
-async function fetchJson(opts) {
-  const { url, method = "GET", headers = {}, body, timeoutMs = DEFAULT_TIMEOUT_MS } = opts;
-  const doFetch = opts.fetch ?? ((input, init2) => globalThis.fetch(input, init2));
-  const init = {
-    method,
-    headers: {
-      "Content-Type": "application/json",
-      ...headers
-    },
-    signal: AbortSignal.timeout(timeoutMs)
-  };
-  if (body !== void 0) {
-    init.body = JSON.stringify(body);
-  }
-  let response;
-  try {
-    response = await doFetch(url, init);
-  } catch (cause) {
-    const msg = cause instanceof Error ? cause.message : String(cause);
-    throw new HttpError(0, msg, url);
-  }
-  if (!response.ok) {
-    throw await httpErrorFromResponse(response, url);
-  }
-  let text;
-  try {
-    text = await response.text();
-  } catch (cause) {
-    const msg = cause instanceof Error ? cause.message : String(cause);
-    throw new HttpError(0, `Failed to read response body: ${msg}`, url);
-  }
-  if (text.trim() === "") return void 0;
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new HttpError(
-      response.status,
-      `Invalid JSON response: ${text.slice(0, SNIPPET_MAX)}`,
-      url
-    );
-  }
-}
-var DEFAULT_TIMEOUT_MS, SNIPPET_MAX;
-var init_fetch_json = __esm({
-  "src/core/fetch-json.ts"() {
-    "use strict";
-    init_errors();
-    DEFAULT_TIMEOUT_MS = 12e4;
-    SNIPPET_MAX = 500;
-  }
-});
-
-// src/core/http-client.ts
-var http_client_exports = {};
-__export(http_client_exports, {
-  downloadFile: () => downloadFile,
-  fetchBytes: () => fetchBytes,
-  httpJson: () => httpJson
-});
-import { once } from "events";
-import fs4 from "fs";
-import path4 from "path";
-import { pipeline } from "stream/promises";
-async function httpJson(opts) {
-  return fetchJson(opts);
-}
-async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS, headers) {
-  fs4.mkdirSync(path4.dirname(dest), { recursive: true });
-  let response;
-  try {
-    response = await globalThis.fetch(url, {
-      signal: AbortSignal.timeout(timeoutMs),
-      ...headers ? { headers } : {}
-    });
-  } catch (cause) {
-    const msg = cause instanceof Error ? cause.message : String(cause);
-    throw new HttpError(0, msg, url);
-  }
-  if (!response.ok) {
-    throw new HttpError(response.status, "(download failed)", url);
-  }
-  if (!response.body) {
-    throw new HttpError(0, "Response body is null", url);
-  }
-  const fileStream = fs4.createWriteStream(dest);
-  try {
-    await pipeline(response.body, fileStream);
-  } catch (err2) {
-    if (!fileStream.closed) await once(fileStream, "close");
-    throw err2;
-  }
-}
-async function fetchBytes(urlOrDataUri) {
-  if (urlOrDataUri.startsWith("data:")) {
-    const commaIdx = urlOrDataUri.indexOf(",");
-    if (commaIdx === -1) throw new Error("Malformed data URI: missing comma");
-    const encoded = urlOrDataUri.slice(commaIdx + 1);
-    return Buffer.from(encoded, "base64");
-  }
-  let response;
-  try {
-    response = await globalThis.fetch(urlOrDataUri, {
-      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
-    });
-  } catch (cause) {
-    const msg = cause instanceof Error ? cause.message : String(cause);
-    throw new HttpError(0, msg, urlOrDataUri);
-  }
-  if (!response.ok) {
-    throw new HttpError(response.status, "(bytes fetch failed)", urlOrDataUri);
-  }
-  return Buffer.from(await response.arrayBuffer());
-}
-var init_http_client = __esm({
-  "src/core/http-client.ts"() {
-    "use strict";
-    init_errors();
-    init_fetch_json();
-  }
-});
-
 // src/cli.ts
 import { createRequire as createRequire2 } from "module";
 import { Command } from "commander";
@@ -447,7 +302,135 @@ function resolveKey(name) {
 
 // src/providers/byteplus/client.ts
 init_errors();
-init_http_client();
+
+// src/core/http-client.ts
+init_errors();
+import { once } from "events";
+import fs4 from "fs";
+import path4 from "path";
+import { pipeline } from "stream/promises";
+
+// src/core/fetch-json.ts
+init_errors();
+var DEFAULT_TIMEOUT_MS = 12e4;
+var SNIPPET_MAX = 500;
+function parseRetryAfter(value, now = Date.now()) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (/^\d+(\.\d+)?$/.test(trimmed)) return Math.round(Number(trimmed) * 1e3);
+  const date = Date.parse(trimmed);
+  if (Number.isNaN(date)) return void 0;
+  return Math.max(0, date - now);
+}
+async function httpErrorFromResponse(response, url) {
+  let snippet = "";
+  try {
+    const text = await response.text();
+    snippet = text.slice(0, SNIPPET_MAX);
+  } catch {
+    snippet = "(could not read body)";
+  }
+  return new HttpError(
+    response.status,
+    snippet,
+    url,
+    parseRetryAfter(response.headers.get("retry-after"))
+  );
+}
+async function fetchJson(opts) {
+  const { url, method = "GET", headers: headers2 = {}, body, timeoutMs = DEFAULT_TIMEOUT_MS } = opts;
+  const doFetch = opts.fetch ?? ((input, init2) => globalThis.fetch(input, init2));
+  const init = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers2
+    },
+    signal: AbortSignal.timeout(timeoutMs)
+  };
+  if (body !== void 0) {
+    init.body = JSON.stringify(body);
+  }
+  let response;
+  try {
+    response = await doFetch(url, init);
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, msg, url);
+  }
+  if (!response.ok) {
+    throw await httpErrorFromResponse(response, url);
+  }
+  let text;
+  try {
+    text = await response.text();
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, `Failed to read response body: ${msg}`, url);
+  }
+  if (text.trim() === "") return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new HttpError(
+      response.status,
+      `Invalid JSON response: ${text.slice(0, SNIPPET_MAX)}`,
+      url
+    );
+  }
+}
+
+// src/core/http-client.ts
+async function httpJson(opts) {
+  return fetchJson(opts);
+}
+async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS, headers2) {
+  fs4.mkdirSync(path4.dirname(dest), { recursive: true });
+  let response;
+  try {
+    response = await globalThis.fetch(url, {
+      signal: AbortSignal.timeout(timeoutMs),
+      ...headers2 ? { headers: headers2 } : {}
+    });
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, msg, url);
+  }
+  if (!response.ok) {
+    throw new HttpError(response.status, "(download failed)", url);
+  }
+  if (!response.body) {
+    throw new HttpError(0, "Response body is null", url);
+  }
+  const fileStream = fs4.createWriteStream(dest);
+  try {
+    await pipeline(response.body, fileStream);
+  } catch (err2) {
+    if (!fileStream.closed) await once(fileStream, "close");
+    throw err2;
+  }
+}
+async function fetchBytes(urlOrDataUri) {
+  if (urlOrDataUri.startsWith("data:")) {
+    const commaIdx = urlOrDataUri.indexOf(",");
+    if (commaIdx === -1) throw new Error("Malformed data URI: missing comma");
+    const encoded = urlOrDataUri.slice(commaIdx + 1);
+    return Buffer.from(encoded, "base64");
+  }
+  let response;
+  try {
+    response = await globalThis.fetch(urlOrDataUri, {
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, msg, urlOrDataUri);
+  }
+  if (!response.ok) {
+    throw new HttpError(response.status, "(bytes fetch failed)", urlOrDataUri);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
 
 // src/providers/byteplus/models.ts
 var DEFAULT_BYTEPLUS_BASE_URL = "https://ark.ap-southeast.bytepluses.com/api/v3";
@@ -527,7 +510,6 @@ function createBytePlusClient() {
 }
 
 // src/providers/byteplus/generators/three-d.ts
-init_http_client();
 function buildThreeDTaskBody(opts) {
   const promptText = (opts.prompt ?? "").trim();
   const flagPart = opts.flags?.trim() ?? "";
@@ -835,7 +817,6 @@ function finalizeGeneratedImages(files, opts) {
 }
 
 // src/providers/byteplus/generators/image.ts
-init_http_client();
 import fs7 from "fs";
 import path7 from "path";
 var ASPECT_TO_SIZE = {
@@ -999,7 +980,6 @@ function collect2(value, prev) {
 import path9 from "path";
 
 // src/core/video-thumb.ts
-init_http_client();
 import fs8 from "fs";
 import path8 from "path";
 var THUMB_KEYS = /* @__PURE__ */ new Set([
@@ -1084,7 +1064,6 @@ async function maybeDownloadThumb(source, videoPath, opts = {}) {
 }
 
 // src/providers/byteplus/generators/video.ts
-init_http_client();
 function buildFlagSuffix(opts) {
   const parts = [];
   if (opts.resolution) parts.push(`--rs ${opts.resolution}`);
@@ -1895,7 +1874,6 @@ function registerCloudflareCommands(program2) {
 import fs10 from "fs";
 import path14 from "path";
 init_errors();
-init_http_client();
 
 // src/providers/elevenlabs/models.ts
 var ELEVENLABS_BASE_URL = "https://api.elevenlabs.io/v1";
@@ -2004,19 +1982,19 @@ async function apiPostBinary(endpoint2, body, apiKey, opts = {}) {
   if (opts.query) {
     for (const [k, v] of Object.entries(opts.query)) url.searchParams.set(k, v);
   }
-  const headers = authHeaders(apiKey);
+  const headers2 = authHeaders(apiKey);
   let init;
   if (body instanceof FormData) {
     init = {
       method: "POST",
-      headers,
+      headers: headers2,
       body,
       signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2)
     };
   } else {
     init = {
       method: "POST",
-      headers: { ...headers, "Content-Type": "application/json" },
+      headers: { ...headers2, "Content-Type": "application/json" },
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2)
     };
@@ -2185,7 +2163,6 @@ function registerCloneCommand(parent) {
 
 // src/providers/elevenlabs/commands/dub.ts
 init_errors();
-init_http_client();
 import fs12 from "fs";
 import path16 from "path";
 function registerDubCommand(parent) {
@@ -2669,7 +2646,6 @@ var FAL_DEFAULTS = {
 };
 
 // src/providers/fal/run-helpers.ts
-init_http_client();
 import fs16 from "fs";
 import path19 from "path";
 
@@ -2706,7 +2682,6 @@ init_redact();
 // src/providers/fal/client.ts
 init_errors();
 init_errors();
-init_http_client();
 init_redact();
 function requireFalKey() {
   const key = resolveKey("FAL_KEY");
@@ -3115,10 +3090,72 @@ init_errors();
 import fs20 from "fs";
 
 // src/providers/gemini/client.ts
+init_errors();
 import fs18 from "fs";
 import path22 from "path";
+
+// src/providers/gemini/key-pool.ts
 init_errors();
-init_http_client();
+var PRIMARY_KEY_ENV = "GEMINI_API_KEY";
+var DEFAULT_COOLDOWN_MS = 6e4;
+var cooldownUntil = /* @__PURE__ */ new Map();
+function listGeminiKeys(env = process.env) {
+  const numbered = Object.keys(env).map((name) => ({ name, match: /^GEMINI_API_KEY_(\d+)$/.exec(name) })).filter((e) => e.match !== null).sort((a, b) => Number(a.match[1]) - Number(b.match[1])).map((e) => e.name);
+  const seen = /* @__PURE__ */ new Set();
+  const keys = [];
+  for (const name of [PRIMARY_KEY_ENV, ...numbered]) {
+    const value = env[name]?.trim();
+    if (!value || seen.has(value)) continue;
+    seen.add(value);
+    keys.push({ name, value });
+  }
+  return keys;
+}
+function isGeminiRateLimitError(error) {
+  if (!(error instanceof HttpError)) return false;
+  if (error.status === 429) return true;
+  return (error.status === 400 || error.status === 403) && error.snippet.includes("RESOURCE_EXHAUSTED");
+}
+function cooldownMs(error) {
+  if (!(error instanceof HttpError)) return DEFAULT_COOLDOWN_MS;
+  if (error.retryAfterMs !== void 0 && error.retryAfterMs > 0) return error.retryAfterMs;
+  const delay = /"retryDelay"\s*:\s*"(\d+(?:\.\d+)?)s"/.exec(error.snippet);
+  if (delay?.[1]) return Math.ceil(Number(delay[1]) * 1e3);
+  return DEFAULT_COOLDOWN_MS;
+}
+function keysToTry(keys, now) {
+  const until = (k) => cooldownUntil.get(k.value) ?? 0;
+  const ready = keys.filter((k) => until(k) <= now);
+  if (ready.length > 0) return ready;
+  const soonest = [...keys].sort((a, b) => until(a) - until(b))[0];
+  return soonest ? [soonest] : [];
+}
+async function withGeminiKey(fn, opts = {}) {
+  const now = opts.now ?? Date.now;
+  const keys = listGeminiKeys(opts.env);
+  if (keys.length === 0) {
+    throw new ConfigError(
+      "GEMINI_API_KEY is not set. Get one at https://aistudio.google.com/apikey"
+    );
+  }
+  const ordered = keysToTry(keys, now());
+  let lastError;
+  for (const [i, key] of ordered.entries()) {
+    try {
+      return await fn(key.value, key.name);
+    } catch (error) {
+      if (!isGeminiRateLimitError(error)) throw error;
+      lastError = error;
+      cooldownUntil.set(key.value, now() + cooldownMs(error));
+      const next = ordered[i + 1];
+      if (next) opts.logger?.warn(`${key.name} is rate-limited; retrying with ${next.name}`);
+    }
+  }
+  if (keys.length > 1) {
+    opts.logger?.warn(`All ${keys.length} Gemini keys are rate-limited; try again later`);
+  }
+  throw lastError;
+}
 
 // src/providers/gemini/task-resolver.ts
 import path21 from "path";
@@ -3173,19 +3210,16 @@ function requiresProcessingWait(mimeType) {
 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 withKey(opts, fn) {
+  return opts.apiKey ? fn(opts.apiKey) : withGeminiKey(fn, { logger: opts.logger });
 }
 function authHeaders2(apiKey) {
   return { "x-goog-api-key": apiKey };
 }
 async function uploadFile(filePath, opts = {}) {
-  const apiKey = requireApiKey();
+  return withKey(opts, (apiKey) => uploadFileWithKey(filePath, apiKey, opts));
+}
+async function uploadFileWithKey(filePath, apiKey, opts) {
   const { timeoutMs = 3e5, logger } = opts;
   const mimeType = getMimeType(filePath);
   const fileBytes = fs18.readFileSync(filePath);
@@ -3221,10 +3255,7 @@ Content-Type: ${mimeType}\r
   });
   if (!resp.ok) {
     const txt = await resp.text();
-    throw new ProviderError(
-      `File upload failed (HTTP ${resp.status}): ${txt.slice(0, 500)}`,
-      "gemini"
-    );
+    throw new HttpError(resp.status, `File upload failed: ${txt.slice(0, 500)}`, FILES_BASE);
   }
   const data = await resp.json();
   let fileRef = data.file;
@@ -3246,26 +3277,30 @@ Content-Type: ${mimeType}\r
   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: authHeaders2(apiKey),
-    body: {
-      contents: req.contents,
-      ...req.generationConfig ? { generationConfig: req.generationConfig } : {}
-    }
-  });
+async function generateContent(req, opts = {}) {
+  return withKey(
+    opts,
+    (apiKey) => httpJson({
+      url: `${GENERATE_BASE}/${req.model}:generateContent`,
+      method: "POST",
+      headers: authHeaders2(apiKey),
+      body: {
+        contents: req.contents,
+        ...req.generationConfig ? { generationConfig: req.generationConfig } : {}
+      }
+    })
+  );
 }
-async function createInteraction(body) {
-  const apiKey = requireApiKey();
-  return httpJson({
-    url: `${BASE}/v1beta/interactions`,
-    method: "POST",
-    headers: authHeaders2(apiKey),
-    body
-  });
+async function createInteraction(body, opts = {}) {
+  return withKey(
+    opts,
+    (apiKey) => httpJson({
+      url: `${BASE}/v1beta/interactions`,
+      method: "POST",
+      headers: authHeaders2(apiKey),
+      body
+    })
+  );
 }
 function extractInteractionAudio(resp) {
   let found = null;
@@ -3444,22 +3479,30 @@ function registerAnalyzeCommand(parent) {
         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 }]
-          });
+          const resp = await withGeminiKey(
+            async (apiKey) => {
+              const useApi = shouldUseFileApi(filePath);
+              let contentParts;
+              if (useApi) {
+                logger.debug("File >20MB \u2014 using Files API");
+                const ref = await uploadFile(filePath, { logger, apiKey });
+                contentParts = [
+                  { text: opts.prompt },
+                  { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
+                ];
+              } else {
+                contentParts = [{ text: opts.prompt }, inlinePart(filePath)];
+              }
+              return generateContent(
+                {
+                  model,
+                  contents: [{ parts: contentParts }]
+                },
+                { apiKey }
+              );
+            },
+            { logger }
+          );
           results.push({
             file: filePath,
             status: "success",
@@ -3498,22 +3541,30 @@ function registerExtractCommand(parent) {
         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
-          });
+          const resp = await withGeminiKey(
+            async (apiKey) => {
+              const useApi = shouldUseFileApi(filePath);
+              let contentParts;
+              if (useApi) {
+                const ref = await uploadFile(filePath, { logger, apiKey });
+                contentParts = [
+                  { text: opts.prompt },
+                  { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
+                ];
+              } else {
+                contentParts = [{ text: opts.prompt }, inlinePart(filePath)];
+              }
+              return generateContent(
+                {
+                  model,
+                  contents: [{ parts: contentParts }],
+                  generationConfig
+                },
+                { apiKey }
+              );
+            },
+            { logger }
+          );
           results.push({ file: filePath, status: "success", response: extractText(resp) });
         } catch (e) {
           const msg = e instanceof Error ? e.message : String(e);
@@ -3617,11 +3668,14 @@ async function generateGeminiSpeech(opts) {
   logger?.debug(`Gemini TTS model=${model} mode=${speakers?.length ? "multi" : "single"}`);
   let resp;
   try {
-    resp = await generateContent({
-      model,
-      contents: [{ parts: [{ text }] }],
-      generationConfig
-    });
+    resp = await generateContent(
+      {
+        model,
+        contents: [{ parts: [{ text }] }],
+        generationConfig
+      },
+      { logger }
+    );
   } catch (e) {
     return { status: "error", error: e instanceof Error ? e.message : String(e) };
   }
@@ -3657,7 +3711,7 @@ async function generateInteractionsSpeech(opts) {
   }
   let resp;
   try {
-    resp = await createInteraction(buildInteractionsSpeechBody(opts));
+    resp = await createInteraction(buildInteractionsSpeechBody(opts), { logger });
   } catch (e) {
     return { status: "error", error: e instanceof Error ? e.message : String(e) };
   }
@@ -3813,20 +3867,194 @@ function collectSpeakers(value, prev) {
 }
 
 // src/providers/gemini/commands/generate-video.ts
-import fs23 from "fs";
+init_errors();
+import fs24 from "fs";
 import path25 from "path";
+
+// src/providers/gemini/veo.ts
+import fs23 from "fs";
+
+// src/core/async-poll.ts
+init_errors();
+var PollTimeoutError2 = class extends MultixError {
+  constructor(message, lastStatus) {
+    super(message, "POLL_TIMEOUT");
+    this.lastStatus = lastStatus;
+    this.name = "PollTimeoutError";
+  }
+  lastStatus;
+};
+function isTransientHttpError(error) {
+  if (!(error instanceof HttpError)) return false;
+  return error.status === 0 || error.status === 429 || error.status >= 500;
+}
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function pollUntil2(opts) {
+  const now = opts.now ?? Date.now;
+  const sleep5 = opts.sleep ?? defaultSleep;
+  const random = opts.random ?? Math.random;
+  const isTransient = opts.isTransientError ?? isTransientHttpError;
+  const maxInterval = opts.maxIntervalMs ?? 15e3;
+  const minInterval = opts.minIntervalMs ?? 500;
+  const factor = opts.backoffFactor ?? 1.5;
+  const jitter = opts.jitter ?? true;
+  const deadline = now() + opts.timeoutMs;
+  let interval = opts.intervalMs ?? 3e3;
+  let attempt = 0;
+  let last;
+  let lastError;
+  for (; ; ) {
+    attempt++;
+    let retryAfterMs;
+    try {
+      last = await opts.fetchStatus({ remainingMs: Math.max(1, deadline - now()), attempt });
+      lastError = void 0;
+      opts.onPoll?.(last, attempt);
+      if (opts.isTerminal(last)) return last;
+    } catch (error) {
+      if (!isTransient(error)) throw error;
+      lastError = error;
+      if (error instanceof HttpError) retryAfterMs = error.retryAfterMs;
+    }
+    const remaining = deadline - now();
+    if (remaining <= 0) {
+      const hint = opts.resumeHint ? ` ${opts.resumeHint}` : "";
+      const cause = lastError instanceof Error ? ` Last error: ${lastError.message}.` : "";
+      throw new PollTimeoutError2(
+        `Timed out after ${opts.timeoutMs}ms waiting for job.${cause}${hint}`,
+        last
+      );
+    }
+    let delay = retryAfterMs ?? interval;
+    if (jitter && retryAfterMs === void 0) delay *= 0.8 + random() * 0.4;
+    await sleep5(Math.min(Math.max(delay, minInterval), remaining));
+    interval = Math.min(interval * factor, maxInterval);
+  }
+}
+
+// src/providers/gemini/veo.ts
 init_errors();
-init_http_client();
-var BASE2 = "https://generativelanguage.googleapis.com";
+var API_HOST = "generativelanguage.googleapis.com";
+var BASE2 = `https://${API_HOST}/v1beta`;
+var VEO_IMAGE_TYPES = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/webp"]);
+var VEO_TIMEOUT_MS = 10 * 60 * 1e3;
+function veoImageFromFile(imgPath) {
+  if (!fs23.existsSync(imgPath)) throw new ValidationError(`Image not found: ${imgPath}`);
+  const detected = getMimeType(imgPath);
+  const mimeType = detected === "application/octet-stream" ? "image/jpeg" : detected;
+  if (!VEO_IMAGE_TYPES.has(mimeType)) {
+    throw new ValidationError(`Veo accepts JPEG, PNG or WebP images: ${imgPath} (${mimeType})`);
+  }
+  return { bytesBase64Encoded: fs23.readFileSync(imgPath).toString("base64"), mimeType };
+}
+function veoFramesFromPaths(paths = []) {
+  if (paths.length > 2) {
+    throw new ValidationError(
+      "--reference-images accepts at most two images (opening frame, closing frame)"
+    );
+  }
+  const [first, last] = paths;
+  return {
+    image: first ? veoImageFromFile(first) : void 0,
+    lastFrame: last ? veoImageFromFile(last) : void 0
+  };
+}
+function modelPath(model) {
+  return model.replace(/^models\//, "");
+}
+function buildVeoRequest(opts) {
+  const instance = { prompt: opts.prompt };
+  if (opts.image) instance.image = opts.image;
+  if (opts.lastFrame) instance.lastFrame = opts.lastFrame;
+  return {
+    instances: [instance],
+    parameters: { aspectRatio: opts.aspectRatio, resolution: opts.resolution }
+  };
+}
+function extractVeoVideoUri(op) {
+  const r = op.response ?? {};
+  return r.generateVideoResponse?.generatedSamples?.[0]?.video?.uri ?? r.generatedSamples?.[0]?.video?.uri ?? r.generatedVideos?.[0]?.video?.uri;
+}
+function headers(apiKey) {
+  return { "x-goog-api-key": apiKey };
+}
+async function submitVeo(apiKey, model, body) {
+  try {
+    return await httpJson({
+      url: `${BASE2}/models/${modelPath(model)}:predictLongRunning`,
+      method: "POST",
+      headers: headers(apiKey),
+      body
+    });
+  } catch (e) {
+    if (e instanceof HttpError) throw e;
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new ProviderError(`Veo submit failed: ${msg}`, "gemini");
+  }
+}
+async function waitForVeo(apiKey, operation, logger, opts = {}) {
+  if (operation.done) return checkVeoResult(operation);
+  const finalOp = await pollUntil2({
+    fetchStatus: ({ remainingMs }) => httpJson({
+      url: `${BASE2}/${operation.name}`,
+      headers: headers(apiKey),
+      timeoutMs: Math.min(remainingMs, 6e4)
+    }),
+    isTerminal: (op) => op.done === true,
+    timeoutMs: opts.timeoutMs ?? VEO_TIMEOUT_MS,
+    intervalMs: opts.intervalMs ?? 1e4,
+    maxIntervalMs: 2e4,
+    sleep: opts.sleep,
+    onPoll: (op, attempt) => {
+      if (!op.done) logger.debug(`Still generating... (poll ${attempt})`);
+    },
+    resumeHint: `Operation (still running server-side): ${operation.name}`
+  });
+  return checkVeoResult(finalOp);
+}
+function checkVeoResult(op) {
+  if (op.error) throw new ProviderError(`Veo error: ${JSON.stringify(op.error)}`, "gemini");
+  return op;
+}
+async function downloadVeoVideo(apiKey, uri, dest) {
+  let host = "";
+  try {
+    host = new URL(uri).hostname;
+  } catch {
+    throw new ProviderError("Veo returned an invalid video URI", "gemini");
+  }
+  await downloadFile(uri, dest, 3e5, host === API_HOST ? headers(apiKey) : void 0);
+}
+async function runVeo(model, request, dest, logger) {
+  const body = buildVeoRequest(request);
+  const { apiKey, operation } = await withGeminiKey(
+    async (key) => ({ apiKey: key, operation: await submitVeo(key, model, body) }),
+    { logger }
+  );
+  logger.debug(`Operation: ${operation.name}`);
+  const finalOp = await waitForVeo(apiKey, operation, logger);
+  const uri = extractVeoVideoUri(finalOp);
+  if (!uri) {
+    throw new ProviderError(
+      `Unexpected Veo response structure: ${JSON.stringify(finalOp.response)}`,
+      "gemini"
+    );
+  }
+  await downloadVeoVideo(apiKey, uri, dest);
+  return finalOp;
+}
+
+// src/providers/gemini/commands/generate-video.ts
 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(
+  ).option("--upload-timeout <ms>", "Deprecated and ignored (images are sent inline)").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");
+      if (opts.uploadTimeout !== void 0) {
+        logger.warn("--upload-timeout is deprecated and ignored (images are sent inline)");
+      }
       const model = opts.model ?? getDefaultModel("generate-video");
       if (!model.startsWith("veo-")) {
         throw new ValidationError(
@@ -3841,72 +4069,23 @@ function registerGenerateVideoCommand(parent) {
       }
       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 (!fs23.existsSync(imgPath))
-            throw new ValidationError(`Reference image not found: ${imgPath}`);
-          const data = fs23.readFileSync(imgPath).toString("base64");
-          const ext = path25.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 sleep3(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 = path25.join(outDir, `veo_generated_${Date.now()}.mp4`);
-      const { downloadFile: downloadFile2 } = await Promise.resolve().then(() => (init_http_client(), http_client_exports));
-      await downloadFile2(videoUri, dest);
+      const frames = veoFramesFromPaths(opts.referenceImages);
+      const dest = path25.join(getOutputDir(), `veo_generated_${Date.now()}.mp4`);
+      const finalOp = await runVeo(
+        model,
+        {
+          prompt: opts.prompt,
+          ...frames,
+          aspectRatio: opts.aspectRatio,
+          resolution: opts.resolution
+        },
+        dest,
+        logger
+      );
       logger.success(`Saved video: ${dest}`);
       if (opts.output) {
-        fs23.mkdirSync(path25.dirname(path25.resolve(opts.output)), { recursive: true });
-        fs23.copyFileSync(dest, opts.output);
+        fs24.mkdirSync(path25.dirname(path25.resolve(opts.output)), { recursive: true });
+        fs24.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -3919,13 +4098,10 @@ Generated video: ${dest}`);
     }
   );
 }
-function sleep3(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
 
 // src/providers/gemini/commands/generate.ts
 init_errors();
-import fs24 from "fs";
+import fs25 from "fs";
 import path26 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").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
@@ -3952,11 +4128,14 @@ function registerGenerateCommand(parent) {
       const savedFiles = [];
       for (let i = 0; i < numImages; i++) {
         try {
-          const resp = await generateContent({
-            model,
-            contents: [{ parts: [{ text: opts.prompt }] }],
-            generationConfig
-          });
+          const resp = await generateContent(
+            {
+              model,
+              contents: [{ parts: [{ text: opts.prompt }] }],
+              generationConfig
+            },
+            { logger }
+          );
           const images = extractImages(resp);
           if (images.length === 0) {
             logger.warn(
@@ -3969,7 +4148,7 @@ function registerGenerateCommand(parent) {
             const ext = img.mimeType.includes("png") ? "png" : "jpg";
             const fname = `gemini_generated_${Date.now()}_${i}.${ext}`;
             const dest = path26.join(outDir, fname);
-            fs24.writeFileSync(dest, Buffer.from(img.data, "base64"));
+            fs25.writeFileSync(dest, Buffer.from(img.data, "base64"));
             savedFiles.push(dest);
             logger.success(`Saved: ${dest}`);
           }
@@ -3984,8 +4163,8 @@ function registerGenerateCommand(parent) {
         process.exit(1);
       }
       if (opts.output && savedFiles[0]) {
-        fs24.mkdirSync(path26.dirname(path26.resolve(opts.output)), { recursive: true });
-        fs24.copyFileSync(savedFiles[0], opts.output);
+        fs25.mkdirSync(path26.dirname(path26.resolve(opts.output)), { recursive: true });
+        fs25.copyFileSync(savedFiles[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       const finalImages = finalizeGeneratedImages(savedFiles, { ...opts, logger });
@@ -3997,7 +4176,7 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/gemini/commands/image-to-image.ts
-import fs25 from "fs";
+import fs26 from "fs";
 import path27 from "path";
 var SOFT_LIMIT_BYTES = 5 * 1024 * 1024;
 var HARD_LIMIT_BYTES = 7 * 1024 * 1024;
@@ -4044,7 +4223,7 @@ function registerGeminiImageToImageCommand(parent) {
         contents: [{ parts }],
         generationConfig: { responseModalities: ["IMAGE"] }
       };
-      const resp = await generateContent(req);
+      const resp = await generateContent(req, { logger });
       const images = extractImages(resp);
       if (images.length === 0) {
         logger.error(
@@ -4060,13 +4239,13 @@ function registerGeminiImageToImageCommand(parent) {
         if (!img) continue;
         const ext = img.mimeType.includes("png") ? "png" : "jpg";
         const dest = path27.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
-        fs25.writeFileSync(dest, Buffer.from(img.data, "base64"));
+        fs26.writeFileSync(dest, Buffer.from(img.data, "base64"));
         saved.push(dest);
         logger.success(`Saved: ${dest}`);
       }
       if (opts.output && saved[0]) {
-        fs25.mkdirSync(path27.dirname(path27.resolve(opts.output)), { recursive: true });
-        fs25.copyFileSync(saved[0], opts.output);
+        fs26.mkdirSync(path27.dirname(path27.resolve(opts.output)), { recursive: true });
+        fs26.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -4102,29 +4281,13 @@ function sniffImageMime(buf, url) {
 }
 
 // src/providers/gemini/commands/image-to-video.ts
-import fs26 from "fs";
-import path28 from "path";
 init_errors();
-init_http_client();
-var BASE3 = "https://generativelanguage.googleapis.com";
-function imagePart(imgPath) {
-  if (!fs26.existsSync(imgPath)) {
-    throw new ValidationError(`Image not found: ${imgPath}`);
-  }
-  const data = fs26.readFileSync(imgPath).toString("base64");
-  const ext = path28.extname(imgPath).toLowerCase();
-  const mimeType = ext === ".png" ? "image/png" : "image/jpeg";
-  return { inlineData: { mimeType, data } };
-}
-function sleep4(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
+import fs27 from "fs";
+import path28 from "path";
 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(
@@ -4137,60 +4300,26 @@ function registerGeminiImageToVideoCommand(parent) {
       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 sleep4(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 = path28.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
-      await downloadFile(videoUri, dest);
+      const finalOp = await runVeo(
+        model,
+        {
+          prompt: opts.prompt,
+          image: veoImageFromFile(imagePath),
+          lastFrame: opts.lastFrame ? veoImageFromFile(opts.lastFrame) : void 0,
+          aspectRatio: opts.aspectRatio,
+          resolution: opts.resolution
+        },
+        dest,
+        logger
+      );
       logger.success(`Saved video: ${dest}`);
       if (opts.output) {
-        fs26.mkdirSync(path28.dirname(path28.resolve(opts.output)), { recursive: true });
-        fs26.copyFileSync(dest, opts.output);
+        fs27.mkdirSync(path28.dirname(path28.resolve(opts.output)), { recursive: true });
+        fs27.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -4206,36 +4335,44 @@ Generated video: ${dest}`);
 
 // src/providers/gemini/commands/transcribe.ts
 init_errors();
-import fs27 from "fs";
+import fs28 from "fs";
 function registerTranscribeCommand2(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("transcribe");
       for (const f of opts.files) {
-        if (!fs27.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs28.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 }]
-          });
+          const resp = await withGeminiKey(
+            async (apiKey) => {
+              const useApi = shouldUseFileApi(filePath);
+              let contentParts;
+              if (useApi) {
+                logger.debug("File >20MB \u2014 using Files API");
+                const ref = await uploadFile(filePath, { logger, apiKey });
+                contentParts = [
+                  { text: opts.prompt },
+                  { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
+                ];
+              } else {
+                contentParts = [{ text: opts.prompt }, inlinePart(filePath)];
+              }
+              return generateContent(
+                {
+                  model,
+                  contents: [{ parts: contentParts }]
+                },
+                { apiKey }
+              );
+            },
+            { logger }
+          );
           results.push({
             file: filePath,
             status: "success",
@@ -4270,13 +4407,11 @@ function registerGeminiCommands(program2) {
 }
 
 // src/providers/leonardo/commands/generate.ts
-init_http_client();
-import fs28 from "fs";
+import fs29 from "fs";
 import path29 from "path";
 
 // src/providers/leonardo/client.ts
 init_errors();
-init_http_client();
 
 // src/providers/leonardo/models.ts
 var DEFAULT_LEONARDO_BASE_URL = "https://cloud.leonardo.ai/api/rest/v1";
@@ -4483,8 +4618,8 @@ function registerLeonardoGenerateCommand(parent) {
       }
       if (opts.output && saved[0]) {
         const dest = path29.resolve(opts.output);
-        fs28.mkdirSync(path29.dirname(dest), { recursive: true });
-        fs28.copyFileSync(saved[0], dest);
+        fs29.mkdirSync(path29.dirname(dest), { recursive: true });
+        fs29.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -4496,8 +4631,7 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/leonardo/commands/image-to-image.ts
-init_http_client();
-import fs29 from "fs";
+import fs30 from "fs";
 import path30 from "path";
 function extFromUrl3(url, fallback = ".png") {
   try {
@@ -4574,8 +4708,8 @@ function registerLeonardoImageToImageCommand(parent) {
       }
       if (opts.output && saved[0]) {
         const dest = path30.resolve(opts.output);
-        fs29.mkdirSync(path30.dirname(dest), { recursive: true });
-        fs29.copyFileSync(saved[0], dest);
+        fs30.mkdirSync(path30.dirname(dest), { recursive: true });
+        fs30.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -4587,7 +4721,6 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/leonardo/commands/video.ts
-init_http_client();
 import path31 from "path";
 function v2DimsFor(resolution) {
   if (resolution === "RESOLUTION_1080") return { width: 1920, height: 1080 };
@@ -4805,7 +4938,6 @@ function registerLeonardoModelsCommand(parent) {
 }
 
 // src/providers/leonardo/commands/status.ts
-init_http_client();
 import path32 from "path";
 var VIDEO_KEYS = ["motionMP4URL", "url"];
 var IMAGE_EXT_RE2 = /\.(jpe?g|png|webp|gif)(\?|$)/i;
@@ -4963,7 +5095,6 @@ init_errors();
 
 // src/providers/minimax/client.ts
 init_errors();
-init_http_client();
 var MINIMAX_BASE_URL = "https://api.minimax.io/v1";
 function requireMinimaxKey() {
   const key = resolveKey("MINIMAX_API_KEY");
@@ -5018,7 +5149,7 @@ async function pollAsyncTask(taskId, taskType, apiKey, opts = {}) {
     if (status === "Failed" || status === "Error") {
       throw new ProviderError(`Task ${taskId} failed: ${JSON.stringify(result)}`, "minimax");
     }
-    await sleep5(intervalMs);
+    await sleep3(intervalMs);
     elapsed += intervalMs;
   }
   throw new ProviderError(`Task ${taskId} timed out after ${timeoutMs / 1e3}s`, "minimax");
@@ -5037,13 +5168,12 @@ async function downloadMinimaxFile(fileId, apiKey, dest, logger) {
   await downloadFile(downloadUrl, dest);
   return dest;
 }
-function sleep5(ms) {
+function sleep3(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
 // src/providers/minimax/generators/music.ts
-init_http_client();
-import fs30 from "fs";
+import fs31 from "fs";
 import path33 from "path";
 async function generateMinimaxMusic(opts) {
   const {
@@ -5093,10 +5223,10 @@ async function generateMinimaxMusic(opts) {
   try {
     if (audioData.startsWith("http")) {
       const bytes = await fetchBytes(audioData);
-      fs30.writeFileSync(dest, bytes);
+      fs31.writeFileSync(dest, bytes);
     } else {
       const audioBytes = Buffer.from(audioData, "hex");
-      fs30.writeFileSync(dest, audioBytes);
+      fs31.writeFileSync(dest, audioBytes);
     }
   } catch (e) {
     return {
@@ -5107,8 +5237,8 @@ async function generateMinimaxMusic(opts) {
   const durSec = durationMs / 1e3;
   logger?.success(`Saved: ${dest} (${durSec.toFixed(1)}s)`);
   if (output) {
-    fs30.mkdirSync(path33.dirname(path33.resolve(output)), { recursive: true });
-    fs30.copyFileSync(dest, output);
+    fs31.mkdirSync(path33.dirname(path33.resolve(output)), { recursive: true });
+    fs31.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, durationMs, model };
 }
@@ -5182,7 +5312,7 @@ Generated music: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/speech.ts
-import fs31 from "fs";
+import fs32 from "fs";
 import path34 from "path";
 async function generateMinimaxSpeech(opts) {
   const {
@@ -5231,11 +5361,11 @@ async function generateMinimaxSpeech(opts) {
   const ext = ["mp3", "wav", "flac"].includes(outputFormat) ? outputFormat : "mp3";
   const outDir = getOutputDir();
   const dest = path34.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
-  fs31.writeFileSync(dest, audioBytes);
+  fs32.writeFileSync(dest, audioBytes);
   logger?.success(`Saved: ${dest} (${(audioBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs31.mkdirSync(path34.dirname(path34.resolve(output)), { recursive: true });
-    fs31.copyFileSync(dest, output);
+    fs32.mkdirSync(path34.dirname(path34.resolve(output)), { recursive: true });
+    fs32.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, model };
 }
@@ -5282,7 +5412,7 @@ Generated audio: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/video.ts
-import fs32 from "fs";
+import fs33 from "fs";
 import path35 from "path";
 async function generateMinimaxVideo(opts) {
   const {
@@ -5336,11 +5466,11 @@ async function generateMinimaxVideo(opts) {
     return { status: "error", error: e instanceof Error ? e.message : String(e) };
   }
   const elapsed = (Date.now() - start) / 1e3;
-  const stat = fs32.statSync(dest);
+  const stat = fs33.statSync(dest);
   const fileSizeMb = stat.size / (1024 * 1024);
   if (output) {
-    fs32.mkdirSync(path35.dirname(path35.resolve(output)), { recursive: true });
-    fs32.copyFileSync(dest, output);
+    fs33.mkdirSync(path35.dirname(path35.resolve(output)), { recursive: true });
+    fs33.copyFileSync(dest, output);
   }
   await maybeDownloadThumb(pollResult, dest, {
     skip: thumb === false,
@@ -5402,8 +5532,7 @@ Generated video: ${result.generatedVideo}`);
 
 // src/providers/minimax/generators/image.ts
 init_errors();
-init_http_client();
-import fs33 from "fs";
+import fs34 from "fs";
 import path36 from "path";
 async function generateMinimaxImage(opts) {
   const {
@@ -5443,7 +5572,7 @@ async function generateMinimaxImage(opts) {
       const bytes = await fetchBytes(url);
       const fname = `minimax_image_${Date.now()}_${i}.png`;
       const dest = path36.join(outDir, fname);
-      fs33.writeFileSync(dest, bytes);
+      fs34.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -5454,8 +5583,8 @@ async function generateMinimaxImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs33.mkdirSync(path36.dirname(path36.resolve(output)), { recursive: true });
-    fs33.copyFileSync(savedFiles[0], output);
+    fs34.mkdirSync(path36.dirname(path36.resolve(output)), { recursive: true });
+    fs34.copyFileSync(savedFiles[0], output);
   }
   return { status: "success", generatedImages: savedFiles, model };
 }
@@ -5494,8 +5623,7 @@ Generated ${finalImages.length} image(s):`);
 
 // src/providers/minimax/commands/image-to-image.ts
 init_errors();
-init_http_client();
-import fs34 from "fs";
+import fs35 from "fs";
 import path37 from "path";
 function registerMinimaxImageToImageCommand(parent) {
   parent.command("image-to-image").alias("i2i").description(
@@ -5552,7 +5680,7 @@ function registerMinimaxImageToImageCommand(parent) {
         try {
           const bytes = await fetchBytes(url);
           const dest = path37.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
-          fs34.writeFileSync(dest, bytes);
+          fs35.writeFileSync(dest, bytes);
           saved.push(dest);
           logger.success(`Saved: ${dest}`);
         } catch (e) {
@@ -5563,8 +5691,8 @@ function registerMinimaxImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        fs34.mkdirSync(path37.dirname(path37.resolve(opts.output)), { recursive: true });
-        fs34.copyFileSync(saved[0], opts.output);
+        fs35.mkdirSync(path37.dirname(path37.resolve(opts.output)), { recursive: true });
+        fs35.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -5698,15 +5826,13 @@ function validateKnownSpeakerPairing(names = [], refs = []) {
 }
 
 // src/providers/openai/openai-audio.ts
-init_http_client();
-import fs36 from "fs";
+import fs37 from "fs";
 import path39 from "path";
 
 // src/providers/openai/client.ts
-import fs35 from "fs";
+import fs36 from "fs";
 import path38 from "path";
 init_errors();
-init_http_client();
 var DEFAULT_TIMEOUT_MS3 = 24e4;
 function requireOpenAIKey() {
   const key = resolveKey("OPENAI_API_KEY");
@@ -5772,8 +5898,8 @@ async function postOpenAIBinary(pathname, body, apiKey, timeoutMs = DEFAULT_TIME
 }
 function fileFromPath(filePath) {
   const abs = path38.resolve(filePath);
-  if (!fs35.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
-  const bytes = fs35.readFileSync(abs);
+  if (!fs36.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
+  const bytes = fs36.readFileSync(abs);
   return new File([new Uint8Array(bytes)], path38.basename(abs));
 }
 
@@ -5833,11 +5959,11 @@ async function generateOpenAISpeech(opts) {
   const bytes = await postOpenAIBinary("/audio/speech", buildSpeechBody(opts), requireOpenAIKey());
   const ext = extFromAudioFormat(opts.outputFormat);
   const dest = path39.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
-  fs36.writeFileSync(dest, bytes);
+  fs37.writeFileSync(dest, bytes);
   opts.logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
   if (opts.output) {
-    fs36.mkdirSync(path39.dirname(path39.resolve(opts.output)), { recursive: true });
-    fs36.copyFileSync(dest, opts.output);
+    fs37.mkdirSync(path39.dirname(path39.resolve(opts.output)), { recursive: true });
+    fs37.copyFileSync(dest, opts.output);
   }
   return dest;
 }
@@ -5860,8 +5986,8 @@ async function transcribeOpenAIAudio(opts) {
   const text = typeof data.text === "string" ? data.text : void 0;
   const ext = opts.format === "text" ? "txt" : "json";
   const dest = opts.output ? path39.resolve(opts.output) : path39.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
-  fs36.mkdirSync(path39.dirname(dest), { recursive: true });
-  fs36.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
+  fs37.mkdirSync(path39.dirname(dest), { recursive: true });
+  fs37.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
   opts.logger?.success(`Saved transcript: ${dest}`);
   return { path: dest, text };
 }
@@ -5888,7 +6014,7 @@ Generated audio: ${dest}`);
 }
 
 // src/providers/openai/codex-image-driver.ts
-import fs37 from "fs";
+import fs38 from "fs";
 import os2 from "os";
 import path40 from "path";
 import { execa } from "execa";
@@ -5940,11 +6066,11 @@ async function runCodexImageGeneration(opts) {
   const runner = opts.runner ?? defaultRunner;
   const ext = extFromImageFormat(opts.outputFormat);
   const dest = opts.output ? path40.resolve(opts.output) : path40.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
-  fs37.mkdirSync(path40.dirname(dest), { recursive: true });
-  const tmp = fs37.mkdtempSync(path40.join(os2.tmpdir(), "multix-codex-image-"));
+  fs38.mkdirSync(path40.dirname(dest), { recursive: true });
+  const tmp = fs38.mkdtempSync(path40.join(os2.tmpdir(), "multix-codex-image-"));
   const schema = path40.join(tmp, "schema.json");
   const result = path40.join(tmp, "result.json");
-  fs37.writeFileSync(
+  fs38.writeFileSync(
     schema,
     JSON.stringify({
       type: "object",
@@ -5974,7 +6100,7 @@ async function runCodexImageGeneration(opts) {
   if (res.exitCode !== 0) {
     throw new ProviderError(`Codex image driver failed: ${res.stderr || res.stdout}`, "openai");
   }
-  if (!fs37.existsSync(dest) || fs37.statSync(dest).size === 0) {
+  if (!fs38.existsSync(dest) || fs38.statSync(dest).size === 0) {
     throw new ProviderError(`Codex did not create a non-empty image at ${dest}`, "openai");
   }
   return { path: dest };
@@ -5991,8 +6117,7 @@ function buildCodexPrompt(userPrompt, outputPath) {
 
 // src/providers/openai/openai-image.ts
 init_errors();
-init_http_client();
-import fs38 from "fs";
+import fs39 from "fs";
 import path41 from "path";
 function buildImageGenerationBody(opts) {
   return {
@@ -6027,13 +6152,13 @@ function saveOpenAIImages(opts) {
     const b64 = items[i]?.b64_json;
     if (!b64) throw new ProviderError("No b64_json in OpenAI image response", "openai");
     const dest = path41.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
-    fs38.writeFileSync(dest, Buffer.from(b64, "base64"));
+    fs39.writeFileSync(dest, Buffer.from(b64, "base64"));
     saved.push(dest);
     opts.logger?.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs38.mkdirSync(path41.dirname(path41.resolve(opts.output)), { recursive: true });
-    fs38.copyFileSync(saved[0], opts.output);
+    fs39.mkdirSync(path41.dirname(path41.resolve(opts.output)), { recursive: true });
+    fs39.copyFileSync(saved[0], opts.output);
     opts.logger?.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -6231,10 +6356,9 @@ function registerOpenAICommands(program2) {
 }
 
 // src/providers/openrouter/client.ts
-import fs39 from "fs";
+import fs40 from "fs";
 import path42 from "path";
 init_errors();
-init_http_client();
 
 // src/providers/openrouter/payload.ts
 var IMAGE_ONLY_MODEL_PREFIXES = [
@@ -6247,15 +6371,15 @@ function resolveModalities(model) {
   return IMAGE_ONLY_MODEL_PREFIXES.some((p) => lower.startsWith(p)) ? ["image"] : ["image", "text"];
 }
 function buildOpenRouterHeaders(apiKey) {
-  const headers = {
+  const headers2 = {
     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;
+  if (referer) headers2["HTTP-Referer"] = referer;
+  if (title) headers2["X-Title"] = title;
+  return headers2;
 }
 function extractImagesFromResponse(data) {
   const out = { urls: [] };
@@ -6398,7 +6522,7 @@ async function generateOpenRouterImage(opts) {
     try {
       const bytes = await fetchBytes(url);
       const dest = path42.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
-      fs39.writeFileSync(dest, bytes);
+      fs40.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -6409,8 +6533,8 @@ async function generateOpenRouterImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs39.mkdirSync(path42.dirname(path42.resolve(output)), { recursive: true });
-    fs39.writeFileSync(output, fs39.readFileSync(savedFiles[0]));
+    fs40.mkdirSync(path42.dirname(path42.resolve(output)), { recursive: true });
+    fs40.writeFileSync(output, fs40.readFileSync(savedFiles[0]));
   }
   return { status: "success", generatedImages: savedFiles, model: usedModel };
 }
@@ -6451,10 +6575,9 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/openrouter/commands/image-to-image.ts
-import fs40 from "fs";
+import fs41 from "fs";
 import path43 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;
@@ -6519,7 +6642,7 @@ function parseStrength(raw) {
 }
 async function runImageToImage(opts) {
   const apiKey = requireOpenRouterKey();
-  const headers = buildOpenRouterHeaders(apiKey);
+  const headers2 = buildOpenRouterHeaders(apiKey);
   const payload = buildI2IPayload({
     prompt: opts.prompt,
     model: opts.model,
@@ -6530,7 +6653,7 @@ async function runImageToImage(opts) {
   const data = await httpJson({
     url: OPENROUTER_API_URL,
     method: "POST",
-    headers,
+    headers: headers2,
     body: payload,
     timeoutMs: 24e4
   });
@@ -6546,31 +6669,30 @@ async function runImageToImage(opts) {
     if (!url) continue;
     const bytes = await fetchBytes(url);
     const dest = path43.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
-    fs40.writeFileSync(dest, bytes);
+    fs41.writeFileSync(dest, bytes);
     saved.push(dest);
     opts.logger.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs40.mkdirSync(path43.dirname(path43.resolve(opts.output)), { recursive: true });
-    fs40.copyFileSync(saved[0], opts.output);
+    fs41.mkdirSync(path43.dirname(path43.resolve(opts.output)), { recursive: true });
+    fs41.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 authHeaders5(apiKey) {
-  const headers = {
+  const headers2 = {
     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;
+  if (referer) headers2["HTTP-Referer"] = referer;
+  if (title) headers2["X-Title"] = title;
+  return headers2;
 }
 async function submitVideoJob(body, apiKey = requireOpenRouterKey()) {
   return httpJson({
@@ -6598,7 +6720,7 @@ async function listVideoModels(apiKey = requireOpenRouterKey()) {
 }
 
 // src/providers/openrouter/commands/video-status.ts
-import fs41 from "fs";
+import fs42 from "fs";
 import path44 from "path";
 async function downloadOpenRouterVideo(opts) {
   const { jobId, logger, source } = opts;
@@ -6614,14 +6736,14 @@ async function downloadOpenRouterVideo(opts) {
     logger.error("Empty response body");
     process.exit(1);
   }
-  fs41.mkdirSync(path44.dirname(dest), { recursive: true });
-  const ws = fs41.createWriteStream(dest);
+  fs42.mkdirSync(path44.dirname(dest), { recursive: true });
+  const ws = fs42.createWriteStream(dest);
   const { pipeline: pipeline2 } = await import("stream/promises");
   await pipeline2(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
-    fs41.mkdirSync(path44.dirname(path44.resolve(opts.output)), { recursive: true });
-    fs41.copyFileSync(dest, opts.output);
+    fs42.mkdirSync(path44.dirname(path44.resolve(opts.output)), { recursive: true });
+    fs42.copyFileSync(dest, opts.output);
     logger.success(`Copied to ${opts.output}`);
   }
   await maybeDownloadThumb(source, dest, {
@@ -6807,7 +6929,6 @@ async function checkBinary(binary, versionFlag = "--version") {
 
 // src/commands/check-helpers/gemini-ping.ts
 init_errors();
-init_http_client();
 var MODELS_URL = "https://generativelanguage.googleapis.com/v1beta/models";
 async function pingGemini(apiKey) {
   try {
@@ -6912,6 +7033,10 @@ var PROVIDERS = [
   }
 ];
 function resolveProviderKey(p) {
+  if (p.envPrimary === "GEMINI_API_KEY") {
+    const first = listGeminiKeys()[0];
+    return first ? { key: first.value, envUsed: first.name } : {};
+  }
   const primary = resolveKey(p.envPrimary);
   if (primary) return { key: primary, envUsed: p.envPrimary };
   if (p.envFallback) {
@@ -6963,6 +7088,14 @@ function registerCheckCommand(program2) {
       const envLabel = r.envUsed ?? p.envPrimary;
       if (r.key) {
         logger.success(`${envLabel} found \u2014 ${redact(r.key)}`);
+        if (p.name === "Gemini") {
+          const pool = listGeminiKeys();
+          if (pool.length > 1) {
+            logger.info(
+              `Gemini key rotation: ${pool.length} keys (${pool.map((k) => k.name).join(", ")})`
+            );
+          }
+        }
       } else if (p.optional) {
         const fbNote = p.envFallback ? ` (or ${p.envFallback})` : "";
         logger.info(`${p.envPrimary}${fbNote} not set (optional)`);
@@ -7008,14 +7141,18 @@ function registerCheckCommand(program2) {
     if (geminiKey) {
       logger.header("Gemini Connectivity");
       logger.info("Pinging Gemini models endpoint...");
-      const ping = await pingGemini(geminiKey);
-      if (ping.status === "success") {
-        logger.success(`Gemini API reachable \u2014 ${ping.modelCount ?? 0} models available`);
-      } else if (ping.status === "auth_error") {
-        logger.error(`Gemini auth failed \u2014 check GEMINI_API_KEY: ${ping.error ?? ""}`);
-        exitCode = 1;
-      } else {
-        logger.warn(`Gemini network error (API may be down): ${ping.error ?? ""}`);
+      for (const key of listGeminiKeys()) {
+        const ping = await pingGemini(key.value);
+        if (ping.status === "success") {
+          logger.success(
+            `${key.name}: Gemini API reachable \u2014 ${ping.modelCount ?? 0} models available`
+          );
+        } else if (ping.status === "auth_error") {
+          logger.error(`Gemini auth failed \u2014 check ${key.name}: ${ping.error ?? ""}`);
+          exitCode = 1;
+        } else {
+          logger.warn(`${key.name}: Gemini network error (API may be down): ${ping.error ?? ""}`);
+        }
       }
     }
     logger.header("Summary");
@@ -7040,7 +7177,7 @@ function registerCheckCommand(program2) {
 
 // src/commands/doc/convert.ts
 init_errors();
-import fs42 from "fs";
+import fs43 from "fs";
 import path45 from "path";
 
 // src/commands/doc/default-prompt.ts
@@ -7062,7 +7199,7 @@ async function convertDocuments(opts) {
   const model = opts.model ?? DOC_MODEL_DEFAULT;
   const prompt = opts.prompt ?? DEFAULT_CONVERT_PROMPT;
   for (const f of inputs) {
-    if (!fs42.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
+    if (!fs43.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
   }
   let outputPath;
   if (output) {
@@ -7073,7 +7210,7 @@ async function convertDocuments(opts) {
   } else {
     outputPath = path45.join(getOutputDir(), "document-extraction.md");
   }
-  fs42.mkdirSync(path45.dirname(outputPath), { recursive: true });
+  fs43.mkdirSync(path45.dirname(outputPath), { recursive: true });
   const results = [];
   for (let i = 0; i < inputs.length; i++) {
     const filePath = inputs[i];
@@ -7082,30 +7219,39 @@ async function convertDocuments(opts) {
     let errorMsg;
     for (let attempt = 0; attempt < 3; attempt++) {
       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: prompt },
-            { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
-          ];
-        } else {
-          contentParts = [{ text: prompt }, inlinePart(filePath)];
-        }
-        const resp = await generateContent({
-          model,
-          contents: [{ parts: contentParts }]
-        });
+        const resp = await withGeminiKey(
+          async (apiKey) => {
+            const useApi = shouldUseFileApi(filePath);
+            let contentParts;
+            if (useApi) {
+              logger?.debug("File >20MB \u2014 using Files API");
+              const ref = await uploadFile(filePath, { logger, apiKey });
+              contentParts = [
+                { text: prompt },
+                { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
+              ];
+            } else {
+              contentParts = [{ text: prompt }, inlinePart(filePath)];
+            }
+            return generateContent(
+              {
+                model,
+                contents: [{ parts: contentParts }]
+              },
+              { apiKey }
+            );
+          },
+          { logger }
+        );
         markdown = extractText(resp);
         break;
       } catch (e) {
         errorMsg = e instanceof Error ? e.message : String(e);
+        if (isGeminiRateLimitError(e)) break;
         if (attempt < 2) {
           const wait = 2 ** attempt * 1e3;
           logger?.debug(`Retry ${attempt + 1} after ${wait / 1e3}s: ${errorMsg}`);
-          await sleep6(wait);
+          await sleep4(wait);
         }
       }
     }
@@ -7137,7 +7283,7 @@ async function convertDocuments(opts) {
     }
     lines.push("\n---\n");
   }
-  fs42.writeFileSync(outputPath, lines.join("\n"), "utf8");
+  fs43.writeFileSync(outputPath, lines.join("\n"), "utf8");
   const succeeded = results.filter((r) => r.status === "success").length;
   console.log(`
 ${"=".repeat(50)}`);
@@ -7153,7 +7299,7 @@ ${"=".repeat(50)}`);
   const failed = results.filter((r) => r.status === "error").length;
   if (failed > 0) process.exit(1);
 }
-function sleep6(ms) {
+function sleep4(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
@@ -7185,11 +7331,11 @@ function registerDocCommands(program2) {
 
 // src/commands/media/index.ts
 init_errors();
-import fs45 from "fs";
+import fs46 from "fs";
 import path48 from "path";
 
 // src/commands/media/batch.ts
-import fs43 from "fs";
+import fs44 from "fs";
 import path46 from "path";
 
 // src/commands/media/detect-type.ts
@@ -7386,8 +7532,8 @@ async function batchOptimize(opts) {
     verbose,
     logger
   } = opts;
-  fs43.mkdirSync(outputDir, { recursive: true });
-  const entries = fs43.readdirSync(inputDir);
+  fs44.mkdirSync(outputDir, { recursive: true });
+  const entries = fs44.readdirSync(inputDir);
   const mediaFiles = entries.filter((f) => {
     const ext = path46.extname(f).toLowerCase();
     return ALL_EXTS.has(ext);
@@ -7439,7 +7585,7 @@ async function batchOptimize(opts) {
 
 // src/commands/media/split-video.ts
 init_errors();
-import fs44 from "fs";
+import fs45 from "fs";
 import path47 from "path";
 async function splitVideo(opts) {
   await assertFfmpeg();
@@ -7451,7 +7597,7 @@ async function splitVideo(opts) {
     logger?.info("Video is short enough \u2014 no splitting needed");
     return [input];
   }
-  fs44.mkdirSync(outputDir, { recursive: true });
+  fs45.mkdirSync(outputDir, { recursive: true });
   const ext = path47.extname(input) || ".mp4";
   const baseName = path47.basename(input, ext);
   const outputPattern = path47.join(outputDir, `${baseName}_chunk_%03d${ext}`);
@@ -7474,7 +7620,7 @@ async function splitVideo(opts) {
   const files = [];
   for (let i = 0; i < numChunks + 1; i++) {
     const fname = path47.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
-    if (fs44.existsSync(fname)) files.push(fname);
+    if (fs45.existsSync(fname)) files.push(fname);
   }
   logger?.success(`Created ${files.length} chunks in ${outputDir}`);
   return files;
@@ -7488,8 +7634,8 @@ 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 (!fs45.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
-      fs45.mkdirSync(path48.dirname(path48.resolve(opts.output)), { recursive: true });
+      if (!fs46.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      fs46.mkdirSync(path48.dirname(path48.resolve(opts.output)), { recursive: true });
       const ext = path48.extname(opts.input).toLowerCase();
       const kind = extToKind(ext);
       if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
@@ -7530,7 +7676,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 (!fs45.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      if (!fs46.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
       const chunks = await splitVideo({
         input: opts.input,
         outputDir: opts.outputDir,
@@ -7546,7 +7692,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 (!fs45.existsSync(opts.inputDir))
+      if (!fs46.existsSync(opts.inputDir))
         throw new ValidationError(`Input dir not found: ${opts.inputDir}`);
       const result = await batchOptimize({
         inputDir: opts.inputDir,
@@ -7569,7 +7715,6 @@ Processed: ${result.succeeded}/${result.total} files`);
 
 // src/commands/update.ts
 init_errors();
-init_http_client();
 import { createRequire } from "module";
 import { execa as execa5 } from "execa";
 
@@ -7734,11 +7879,6 @@ function registerCommands(program2) {
 // src/core/index.ts
 init_errors();
 init_redact();
-init_http_client();
-init_fetch_json();
-
-// src/core/async-poll.ts
-init_errors();
 
 // src/cli.ts
 loadEnv();