@mrgoonie/multix 0.0.8 → 0.1.0-beta.1

package/dist/cli.js

@@ -110,11 +110,14 @@ async function httpJson(opts) {
   }
   return response.json();
 }
-async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS) {
+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) });
+    response = await globalThis.fetch(url, {
+      headers,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
   } catch (cause) {
     const msg = cause instanceof Error ? cause.message : String(cause);
     throw new HttpError(0, msg, url);
@@ -414,9 +417,9 @@ var BytePlusClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path41, opts = {}) {
+  async request(path46, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const url = new URL(base + path41);
+    const url = new URL(base + path46);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
         if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
@@ -434,14 +437,14 @@ var BytePlusClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path41, query, logger) {
-    return this.request(path41, { method: "GET", query, logger });
+  get(path46, query, logger) {
+    return this.request(path46, { method: "GET", query, logger });
   }
-  post(path41, body, logger) {
-    return this.request(path41, { method: "POST", body, logger });
+  post(path46, body, logger) {
+    return this.request(path46, { method: "POST", body, logger });
   }
-  delete(path41, logger) {
-    return this.request(path41, { method: "DELETE", logger });
+  delete(path46, logger) {
+    return this.request(path46, { method: "DELETE", logger });
   }
 };
 function createBytePlusClient() {
@@ -990,10 +993,10 @@ function toRef(kind, resolved, role) {
   return { kind, url: resolved.dataUrl, mime: resolved.mime, role };
 }
 async function resolveRefSpec(kind, spec, logger) {
-  const { path: path41, role } = parseRefSpec(spec);
-  if (kind === "image") return toRef(kind, await resolveImageInput(path41, logger), role);
-  if (kind === "video") return toRef(kind, await resolveVideoInput(path41, logger), role);
-  return toRef(kind, await resolveAudioInput(path41, logger), role);
+  const { path: path46, role } = parseRefSpec(spec);
+  if (kind === "image") return toRef(kind, await resolveImageInput(path46, logger), role);
+  if (kind === "video") return toRef(kind, await resolveVideoInput(path46, logger), role);
+  return toRef(kind, await resolveAudioInput(path46, logger), role);
 }
 async function resolveRefSpecs(specs, logger) {
   const out = [];
@@ -1325,8 +1328,8 @@ function requireElevenLabsKey() {
 function authHeaders(apiKey, extra) {
   return { "xi-api-key": apiKey, ...extra ?? {} };
 }
-function apiGet(endpoint, apiKey, query) {
-  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`);
+function apiGet(endpoint2, apiKey, query) {
+  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`);
   if (query) {
     for (const [k, v] of Object.entries(query)) {
       if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
@@ -1334,8 +1337,8 @@ function apiGet(endpoint, apiKey, query) {
   }
   return httpJson({ url: url.toString(), headers: authHeaders(apiKey) });
 }
-function apiPostJson(endpoint, payload, apiKey, opts = {}) {
-  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`);
+function apiPostJson(endpoint2, payload, apiKey, opts = {}) {
+  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`);
   if (opts.query) {
     for (const [k, v] of Object.entries(opts.query)) url.searchParams.set(k, v);
   }
@@ -1347,8 +1350,8 @@ function apiPostJson(endpoint, payload, apiKey, opts = {}) {
     timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2
   });
 }
-async function apiDelete(endpoint, apiKey) {
-  const url = `${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`;
+async function apiDelete(endpoint2, apiKey) {
+  const url = `${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`;
   const res = await globalThis.fetch(url, {
     method: "DELETE",
     headers: authHeaders(apiKey),
@@ -1359,8 +1362,8 @@ async function apiDelete(endpoint, apiKey) {
     throw new HttpError(res.status, text.slice(0, 500), url);
   }
 }
-async function apiPostBinary(endpoint, body, apiKey, opts = {}) {
-  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`);
+async function apiPostBinary(endpoint2, body, apiKey, opts = {}) {
+  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`);
   if (opts.query) {
     for (const [k, v] of Object.entries(opts.query)) url.searchParams.set(k, v);
   }
@@ -1394,8 +1397,8 @@ async function apiPostBinary(endpoint, body, apiKey, opts = {}) {
   }
   return Buffer.from(await res.arrayBuffer());
 }
-async function apiPostMultipart(endpoint, form, apiKey, opts = {}) {
-  const url = `${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`;
+async function apiPostMultipart(endpoint2, form, apiKey, opts = {}) {
+  const url = `${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`;
   let res;
   try {
     res = await globalThis.fetch(url, {
@@ -2076,7 +2079,7 @@ function requiresProcessingWait(mimeType) {
 var BASE = "https://generativelanguage.googleapis.com";
 var FILES_BASE = `${BASE}/upload/v1beta/files`;
 var GENERATE_BASE = `${BASE}/v1beta/models`;
-function requireApiKey() {
+function requireGeminiApiKey() {
   const key = resolveKey("GEMINI_API_KEY");
   if (!key)
     throw new ConfigError(
@@ -2084,11 +2087,14 @@ function requireApiKey() {
     );
   return key;
 }
-function authHeaders2(apiKey) {
+function geminiAuthHeaders(apiKey) {
   return { "x-goog-api-key": apiKey };
 }
+function unwrapGeminiFileRef(response) {
+  return "file" in response ? response.file : response;
+}
 async function uploadFile(filePath, opts = {}) {
-  const apiKey = requireApiKey();
+  const apiKey = requireGeminiApiKey();
   const { timeoutMs = 3e5, logger } = opts;
   const mimeType = getMimeType(filePath);
   const fileBytes = fs12.readFileSync(filePath);
@@ -2137,8 +2143,8 @@ Content-Type: ${mimeType}\r
       await sleep(2e3);
       fileRef = await httpJson({
         url: `${BASE}/v1beta/${fileRef.name}`,
-        headers: authHeaders2(apiKey)
-      }).then((r) => r.file);
+        headers: geminiAuthHeaders(apiKey)
+      }).then(unwrapGeminiFileRef);
       logger?.debug(`Processing... state=${fileRef.state}`);
     }
     if (fileRef.state === "FAILED")
@@ -2150,11 +2156,11 @@ Content-Type: ${mimeType}\r
   return fileRef;
 }
 async function generateContent(req) {
-  const apiKey = requireApiKey();
+  const apiKey = requireGeminiApiKey();
   return httpJson({
     url: `${GENERATE_BASE}/${req.model}:generateContent`,
     method: "POST",
-    headers: authHeaders2(apiKey),
+    headers: geminiAuthHeaders(apiKey),
     body: {
       contents: req.contents,
       ...req.generationConfig ? { generationConfig: req.generationConfig } : {}
@@ -2196,10 +2202,12 @@ function sleep(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 IMAGE_MODEL_LITE = "gemini-3.1-flash-lite-image";
 var VIDEO_MODEL_DEFAULT = "veo-3.1-generate-preview";
-var ANALYSIS_MODEL_DEFAULT = "gemini-2.5-flash";
+var TEXT_MODEL_DEFAULT = "gemini-3.5-flash";
+var ANALYSIS_MODEL_DEFAULT = TEXT_MODEL_DEFAULT;
 var TTS_MODEL_DEFAULT = "gemini-3.1-flash-tts-preview";
-var DOC_MODEL_DEFAULT = "gemini-2.5-flash";
+var DOC_MODEL_DEFAULT = TEXT_MODEL_DEFAULT;
 var IMAGEN_MODELS = /* @__PURE__ */ new Set([
   "imagen-4.0-generate-001",
   "imagen-4.0-ultra-generate-001",
@@ -2210,6 +2218,7 @@ var GEMINI_IMAGE_MODELS = /* @__PURE__ */ new Set([
   "gemini-3-pro-image-preview",
   "gemini-2.5-flash-image",
   "gemini-2.5-flash-image-preview",
+  IMAGE_MODEL_LITE,
   ...IMAGEN_MODELS
 ]);
 var ASPECT_RATIOS = [
@@ -2225,6 +2234,15 @@ var ASPECT_RATIOS = [
   "21:9"
 ];
 var IMAGE_SIZES = ["1K", "2K", "4K"];
+function resolveImageOptions(model, aspectRatio, requestedSize) {
+  if (model !== IMAGE_MODEL_LITE) {
+    return { aspectRatio, ...requestedSize ? { imageSize: requestedSize } : {} };
+  }
+  if (requestedSize && requestedSize !== "1K") {
+    throw new Error(`${IMAGE_MODEL_LITE} supports only 1K image output.`);
+  }
+  return { aspectRatio, imageSize: "1K" };
+}
 function getDefaultModel(task) {
   if (task === "generate") {
     return process.env.IMAGE_GEN_MODEL ?? process.env.GEMINI_IMAGE_GEN_MODEL ?? IMAGE_MODEL_DEFAULT;
@@ -2709,6 +2727,13 @@ function sleep2(ms) {
 init_errors();
 import fs18 from "fs";
 import path22 from "path";
+function buildImageGenerationConfig(model, aspectRatio, size) {
+  const imageOptions = resolveImageOptions(model, aspectRatio, size);
+  return {
+    responseModalities: ["IMAGE"],
+    imageConfig: imageOptions
+  };
+}
 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) => {
@@ -2725,12 +2750,11 @@ function registerGenerateCommand(parent) {
       }
       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 generationConfig = buildImageGenerationConfig(
+        model,
+        opts.aspectRatio,
+        opts.size
+      );
       const savedFiles = [];
       for (let i = 0; i < numImages; i++) {
         try {
@@ -2782,6 +2806,10 @@ import fs19 from "fs";
 import path23 from "path";
 var SOFT_LIMIT_BYTES = 5 * 1024 * 1024;
 var HARD_LIMIT_BYTES = 7 * 1024 * 1024;
+function buildImageToImageGenerationConfig(model, aspectRatio, size) {
+  const imageOptions = resolveImageOptions(model, aspectRatio, size);
+  return imageOptions.imageSize ? { responseModalities: ["IMAGE"], imageConfig: imageOptions } : void 0;
+}
 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"
@@ -2790,13 +2818,26 @@ function registerGeminiImageToImageCommand(parent) {
     "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(
+  ).option("-m, --model <id>", `Gemini image model (default ${IMAGE_MODEL_FALLBACK})`).option("--aspect-ratio <ratio>", `Aspect ratio (${ASPECT_RATIOS.join("|")})`, "1:1").option("--size <sz>", `Image size (${IMAGE_SIZES.join("|")})`).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;
+      if (model === IMAGE_MODEL_LITE && opts.ref.length > 1) {
+        logger.warn(
+          `${IMAGE_MODEL_LITE} is not optimized for multiple reference images; use one when possible.`
+        );
+      }
+      if (!ASPECT_RATIOS.includes(opts.aspectRatio)) {
+        throw new Error(
+          `Invalid aspect ratio: ${opts.aspectRatio}. Valid: ${ASPECT_RATIOS.join(", ")}`
+        );
+      }
+      if (opts.size && !IMAGE_SIZES.includes(opts.size)) {
+        throw new Error(`Invalid size: ${opts.size}. Valid: ${IMAGE_SIZES.join(", ")}`);
+      }
       const parts = [];
       for (const r of opts.ref) {
         const resolved = await resolveImageInput(r, {
@@ -2820,10 +2861,15 @@ function registerGeminiImageToImageCommand(parent) {
       }
       parts.push({ text: opts.prompt });
       logger.debug(`Calling ${model} with ${opts.ref.length} reference image(s)`);
+      const generationConfig = buildImageToImageGenerationConfig(
+        model,
+        opts.aspectRatio,
+        opts.size
+      );
       const req = {
         model,
         contents: [{ parts }],
-        generationConfig: { responseModalities: ["IMAGE"] }
+        ...generationConfig ? { generationConfig } : {}
       };
       const resp = await generateContent(req);
       const images = extractImages(resp);
@@ -2984,16 +3030,186 @@ Generated video: ${dest}`);
   );
 }
 
-// src/providers/gemini/commands/transcribe.ts
+// src/providers/gemini/commands/omni-video.ts
 init_errors();
 import fs21 from "fs";
+import path25 from "path";
+
+// src/providers/gemini/interactions.ts
+init_errors();
+init_http_client();
+var BASE4 = "https://generativelanguage.googleapis.com/v1beta";
+var OMNI_MODEL = "gemini-omni-flash-preview";
+function buildOmniInteractionPayload(request) {
+  return {
+    model: OMNI_MODEL,
+    input: buildOmniInput(request),
+    response_format: { type: "video", delivery: "uri" },
+    store: true,
+    ...request.previousInteractionId ? { previous_interaction_id: request.previousInteractionId } : {}
+  };
+}
+async function createOmniInteraction(request) {
+  const apiKey = requireGeminiApiKey();
+  const raw = await httpJson({
+    url: `${BASE4}/interactions`,
+    method: "POST",
+    headers: geminiAuthHeaders(apiKey),
+    body: buildOmniInteractionPayload(request)
+  });
+  if (!raw.id)
+    throw new ProviderError("Omni response did not include an interaction ID.", "gemini");
+  return { interactionId: raw.id, video: extractOmniVideo(raw) };
+}
+function buildOmniInput(request) {
+  const parts = [{ type: "text", text: request.prompt }];
+  for (const image of request.images ?? []) {
+    parts.push({ type: "image", data: image.data, mime_type: image.mimeType });
+  }
+  if (request.videoFileUri) parts.push({ type: "document", uri: request.videoFileUri });
+  return parts;
+}
+function extractOmniVideo(raw) {
+  for (const step of raw.steps ?? []) {
+    if (step.type !== "model_output") continue;
+    for (const content of step.content ?? []) {
+      if (content.type !== "video") continue;
+      const mimeType = content.mime_type ?? "video/mp4";
+      if (content.data) return { kind: "inline", data: content.data, mimeType };
+      if (content.uri) return { kind: "uri", uri: content.uri, mimeType };
+    }
+  }
+  throw new ProviderError("Omni response did not include a generated video.", "gemini");
+}
+async function waitForGeminiFile(fileUri, timeoutMs = 3e5) {
+  const apiKey = requireGeminiApiKey();
+  const name = fileNameFromUri(fileUri);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const response = await httpJson({
+      url: `${BASE4}/${name}`,
+      headers: geminiAuthHeaders(apiKey)
+    });
+    const file = unwrapGeminiFile(response);
+    if (file.state === "ACTIVE") return file;
+    if (file.state === "FAILED") throw new ProviderError("Generated Omni video failed.", "gemini");
+    await sleep4(5e3);
+  }
+  throw new ProviderError("Timed out waiting for generated Omni video.", "gemini");
+}
+async function downloadGeminiFile(fileUri, destination) {
+  const apiKey = requireGeminiApiKey();
+  await downloadFile(fileUri, destination, void 0, geminiAuthHeaders(apiKey));
+}
+function fileNameFromUri(fileUri) {
+  const pathname = new URL(fileUri).pathname;
+  const match = pathname.match(/\/(files\/[^/:]+)(?::download)?$/);
+  if (!match?.[1]) throw new ProviderError(`Unexpected Gemini file URI: ${fileUri}`, "gemini");
+  return match[1];
+}
+function unwrapGeminiFile(response) {
+  return "file" in response ? response.file : response;
+}
+function selectGeminiDownloadUri(file, fallbackUri) {
+  return file.downloadUri ?? fallbackUri;
+}
+function sleep4(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/providers/gemini/commands/omni-video.ts
+function registerOmniVideoCommand(parent) {
+  parent.command("omni-video").description("Generate or edit video with Gemini Omni Flash [PAID PREVIEW]").requiredOption("--prompt <text>", "Video prompt or concise edit instruction").option("--image <paths...>", "Local image guidance files").option("--video <path>", "One local video to edit (not available in EEA/CH/UK)").option("--previous-interaction-id <id>", "Continue a prior Gemini-stored interaction").option("--upload-timeout <ms>", "Files API processing timeout in ms", "300000").option("--output <path>", "Copy generated video to this path").option("-v, --verbose", "Verbose logging").addHelpText(
+    "after",
+    "\nPreview, paid-tier API. Outputs 3-10 second 720p videos. Audio references, video extension/interpolation, voice editing, and multiple videos are unsupported. Follow-up edits require provider-side stored interactions; no local history is kept."
+  ).action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    validateInputs(opts);
+    const images = (opts.image ?? []).map(readImage);
+    const videoFile = opts.video ? await uploadFile(opts.video, { timeoutMs: parseTimeout(opts.uploadTimeout), logger }) : void 0;
+    const result = await createOmniInteraction({
+      prompt: opts.prompt,
+      images,
+      videoFileUri: videoFile?.uri,
+      previousInteractionId: opts.previousInteractionId
+    });
+    const destination = path25.join(getOutputDir(), `gemini_omni_${Date.now()}.mp4`);
+    if (result.video.kind === "inline") {
+      fs21.writeFileSync(destination, Buffer.from(result.video.data, "base64"));
+    } else {
+      const generated = await waitForGeminiFile(result.video.uri);
+      await downloadGeminiFile(selectGeminiDownloadUri(generated, result.video.uri), destination);
+    }
+    const metadataPath = `${destination}.json`;
+    fs21.writeFileSync(
+      metadataPath,
+      `${JSON.stringify(buildOmniVideoMetadata(opts, result.interactionId), null, 2)}
+`
+    );
+    if (opts.output) {
+      fs21.mkdirSync(path25.dirname(path25.resolve(opts.output)), { recursive: true });
+      fs21.copyFileSync(destination, opts.output);
+      fs21.copyFileSync(metadataPath, `${opts.output}.json`);
+    }
+    logger.success(`Saved video: ${destination}`);
+    logger.success(`Saved metadata: ${metadataPath}`);
+    if (opts.output) logger.success(`Copied to: ${opts.output}`);
+    console.log(`Interaction ID: ${result.interactionId}`);
+  });
+}
+function buildOmniVideoMetadata(opts, interactionId) {
+  return {
+    provider: "gemini",
+    model: "gemini-omni-flash-preview",
+    prompt: opts.prompt,
+    inputFiles: [...opts.image ?? [], ...opts.video ? [opts.video] : []].map(
+      (filePath) => path25.basename(filePath)
+    ),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    interactionId
+  };
+}
+function validateInputs(opts) {
+  if (opts.video && opts.image?.length) {
+    throw new ValidationError("Use either --video or --image guidance, not both.");
+  }
+  if (opts.video) {
+    requireLocalFile(opts.video, "video");
+    if (!getMimeType(opts.video).startsWith("video/")) {
+      throw new ValidationError(`Unsupported video file: ${opts.video}`);
+    }
+  }
+  for (const imagePath of opts.image ?? []) {
+    requireLocalFile(imagePath, "image");
+    if (!getMimeType(imagePath).startsWith("image/")) {
+      throw new ValidationError(`Unsupported image file: ${imagePath}`);
+    }
+  }
+}
+function requireLocalFile(filePath, label) {
+  if (/^https?:\/\//i.test(filePath)) throw new ValidationError(`${label} URLs are not supported.`);
+  if (!fs21.existsSync(filePath)) throw new ValidationError(`${label} file not found: ${filePath}`);
+}
+function readImage(filePath) {
+  return { data: fs21.readFileSync(filePath).toString("base64"), mimeType: getMimeType(filePath) };
+}
+function parseTimeout(value) {
+  const timeout = Number.parseInt(value, 10);
+  if (!Number.isFinite(timeout) || timeout <= 0)
+    throw new ValidationError("--upload-timeout must be positive.");
+  return timeout;
+}
+
+// src/providers/gemini/commands/transcribe.ts
+init_errors();
+import fs22 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 (!fs21.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+        if (!fs22.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
       }
       const results = [];
       for (let i = 0; i < opts.files.length; i++) {
@@ -3046,13 +3262,14 @@ function registerGeminiCommands(program2) {
   registerGeminiImageToImageCommand(gemini);
   registerGenerateVideoCommand(gemini);
   registerGeminiImageToVideoCommand(gemini);
+  registerOmniVideoCommand(gemini);
   registerGeminiGenerateSpeechCommand(gemini);
 }
 
 // src/providers/leonardo/commands/generate.ts
 init_http_client();
-import fs22 from "fs";
-import path25 from "path";
+import fs23 from "fs";
+import path26 from "path";
 
 // src/providers/leonardo/client.ts
 init_errors();
@@ -3126,11 +3343,11 @@ var LeonardoClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path41, opts = {}) {
+  async request(path46, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const v2Override = path41.startsWith("v2:");
+    const v2Override = path46.startsWith("v2:");
     const finalBase = v2Override ? base.replace(/\/v1$/, "/v2") : base;
-    const finalPath = v2Override ? path41.slice(3) : path41;
+    const finalPath = v2Override ? path46.slice(3) : path46;
     const url = new URL(finalBase + finalPath);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
@@ -3149,14 +3366,14 @@ var LeonardoClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path41, query, logger) {
-    return this.request(path41, { method: "GET", query, logger });
+  get(path46, query, logger) {
+    return this.request(path46, { method: "GET", query, logger });
   }
-  post(path41, body, logger) {
-    return this.request(path41, { method: "POST", body, logger });
+  post(path46, body, logger) {
+    return this.request(path46, { method: "POST", body, logger });
   }
-  delete(path41, logger) {
-    return this.request(path41, { method: "DELETE", logger });
+  delete(path46, logger) {
+    return this.request(path46, { method: "DELETE", logger });
   }
 };
 function createLeonardoClient() {
@@ -3167,7 +3384,7 @@ function createLeonardoClient() {
 function extFromUrl(url, fallback = ".png") {
   try {
     const u = new URL(url);
-    const e = path25.extname(u.pathname);
+    const e = path26.extname(u.pathname);
     return e.length > 0 ? e : fallback;
   } catch {
     return fallback;
@@ -3252,7 +3469,7 @@ function registerLeonardoGenerateCommand(parent) {
         if (!img) continue;
         const ext = extFromUrl(img.url);
         const filename = autoFilename(generationId, i + 1, ext);
-        const filepath = path25.join(outDir, filename);
+        const filepath = path26.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -3262,9 +3479,9 @@ function registerLeonardoGenerateCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path25.resolve(opts.output);
-        fs22.mkdirSync(path25.dirname(dest), { recursive: true });
-        fs22.copyFileSync(saved[0], dest);
+        const dest = path26.resolve(opts.output);
+        fs23.mkdirSync(path26.dirname(dest), { recursive: true });
+        fs23.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       console.log(`
@@ -3276,11 +3493,11 @@ Generated ${saved.length} image(s):`);
 
 // src/providers/leonardo/commands/image-to-image.ts
 init_http_client();
-import fs23 from "fs";
-import path26 from "path";
+import fs24 from "fs";
+import path27 from "path";
 function extFromUrl2(url, fallback = ".png") {
   try {
-    return path26.extname(new URL(url).pathname) || fallback;
+    return path27.extname(new URL(url).pathname) || fallback;
   } catch {
     return fallback;
   }
@@ -3342,7 +3559,7 @@ function registerLeonardoImageToImageCommand(parent) {
         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 = path26.join(outDir, filename);
+        const filepath = path27.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -3352,9 +3569,9 @@ function registerLeonardoImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path26.resolve(opts.output);
-        fs23.mkdirSync(path26.dirname(dest), { recursive: true });
-        fs23.copyFileSync(saved[0], dest);
+        const dest = path27.resolve(opts.output);
+        fs24.mkdirSync(path27.dirname(dest), { recursive: true });
+        fs24.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       console.log(`
@@ -3366,7 +3583,7 @@ Generated ${saved.length} image(s):`);
 
 // src/providers/leonardo/commands/video.ts
 init_http_client();
-import path27 from "path";
+import path28 from "path";
 function v2DimsFor(resolution) {
   if (resolution === "RESOLUTION_1080") return { width: 1920, height: 1080 };
   if (resolution === "RESOLUTION_480") return { width: 854, height: 480 };
@@ -3477,7 +3694,7 @@ async function pollAndDownload(client, jobId, opts) {
     logger.error(`No video URL in completed generation: ${JSON.stringify(gen)}`);
     process.exit(1);
   }
-  const outPath = opts.output ?? path27.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
+  const outPath = opts.output ?? path28.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
   await downloadFile(videoUrl, outPath);
   logger.success(`Saved ${outPath}`);
   await maybeDownloadThumb(gen, outPath, {
@@ -3584,7 +3801,7 @@ function registerLeonardoModelsCommand(parent) {
 
 // src/providers/leonardo/commands/status.ts
 init_http_client();
-import path28 from "path";
+import path29 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;
@@ -3649,7 +3866,7 @@ function registerLeonardoStatusCommand(parent) {
       const outDir = getOutputDir();
       let idx = 0;
       for (const url of videos) {
-        const dest = opts.output && videos.length === 1 && images.length === 0 ? opts.output : path28.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
+        const dest = opts.output && videos.length === 1 && images.length === 0 ? opts.output : path29.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         await maybeDownloadThumb(gen, dest, {
@@ -3662,7 +3879,7 @@ function registerLeonardoStatusCommand(parent) {
       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 = path28.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
+        const dest = path29.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         idx++;
@@ -3750,19 +3967,19 @@ function requireMinimaxKey() {
   }
   return key;
 }
-function authHeaders3(apiKey) {
+function authHeaders2(apiKey) {
   return {
     Authorization: `Bearer ${apiKey}`,
     "Content-Type": "application/json"
   };
 }
-async function apiPost(endpoint, payload, apiKey, opts = {}) {
-  const url = `${MINIMAX_BASE_URL}/${endpoint}`;
+async function apiPost(endpoint2, payload, apiKey, opts = {}) {
+  const url = `${MINIMAX_BASE_URL}/${endpoint2}`;
   opts.logger?.debug(`POST ${url}`);
   const data = await httpJson({
     url,
     method: "POST",
-    headers: authHeaders3(apiKey),
+    headers: authHeaders2(apiKey),
     body: payload,
     timeoutMs: opts.timeoutMs ?? 12e4
   });
@@ -3775,10 +3992,10 @@ async function apiPost(endpoint, payload, apiKey, opts = {}) {
   }
   return data;
 }
-async function apiGet2(endpoint, params, apiKey) {
-  const url = new URL(`${MINIMAX_BASE_URL}/${endpoint}`);
+async function apiGet2(endpoint2, params, apiKey) {
+  const url = new URL(`${MINIMAX_BASE_URL}/${endpoint2}`);
   for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
-  return httpJson({ url: url.toString(), headers: authHeaders3(apiKey) });
+  return httpJson({ url: url.toString(), headers: authHeaders2(apiKey) });
 }
 async function pollAsyncTask(taskId, taskType, apiKey, opts = {}) {
   const { intervalMs = 1e4, timeoutMs = 6e5, logger } = opts;
@@ -3794,7 +4011,7 @@ async function pollAsyncTask(taskId, taskType, apiKey, opts = {}) {
     if (status === "Failed" || status === "Error") {
       throw new ProviderError(`Task ${taskId} failed: ${JSON.stringify(result)}`, "minimax");
     }
-    await sleep4(intervalMs);
+    await sleep5(intervalMs);
     elapsed += intervalMs;
   }
   throw new ProviderError(`Task ${taskId} timed out after ${timeoutMs / 1e3}s`, "minimax");
@@ -3813,14 +4030,14 @@ async function downloadMinimaxFile(fileId, apiKey, dest, logger) {
   await downloadFile(downloadUrl, dest);
   return dest;
 }
-function sleep4(ms) {
+function sleep5(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
 // src/providers/minimax/generators/music.ts
 init_http_client();
-import fs24 from "fs";
-import path29 from "path";
+import fs25 from "fs";
+import path30 from "path";
 async function generateMinimaxMusic(opts) {
   const {
     apiKey,
@@ -3865,14 +4082,14 @@ async function generateMinimaxMusic(opts) {
   }
   const durationMs = resp.extra_info?.music_duration ?? 0;
   const outDir = getOutputDir();
-  const dest = path29.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
+  const dest = path30.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
   try {
     if (audioData.startsWith("http")) {
       const bytes = await fetchBytes(audioData);
-      fs24.writeFileSync(dest, bytes);
+      fs25.writeFileSync(dest, bytes);
     } else {
       const audioBytes = Buffer.from(audioData, "hex");
-      fs24.writeFileSync(dest, audioBytes);
+      fs25.writeFileSync(dest, audioBytes);
     }
   } catch (e) {
     return {
@@ -3883,8 +4100,8 @@ async function generateMinimaxMusic(opts) {
   const durSec = durationMs / 1e3;
   logger?.success(`Saved: ${dest} (${durSec.toFixed(1)}s)`);
   if (output) {
-    fs24.mkdirSync(path29.dirname(path29.resolve(output)), { recursive: true });
-    fs24.copyFileSync(dest, output);
+    fs25.mkdirSync(path30.dirname(path30.resolve(output)), { recursive: true });
+    fs25.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, durationMs, model };
 }
@@ -3958,8 +4175,8 @@ Generated music: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/speech.ts
-import fs25 from "fs";
-import path30 from "path";
+import fs26 from "fs";
+import path31 from "path";
 async function generateMinimaxSpeech(opts) {
   const {
     apiKey,
@@ -4006,12 +4223,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 = path30.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
-  fs25.writeFileSync(dest, audioBytes);
+  const dest = path31.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
+  fs26.writeFileSync(dest, audioBytes);
   logger?.success(`Saved: ${dest} (${(audioBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs25.mkdirSync(path30.dirname(path30.resolve(output)), { recursive: true });
-    fs25.copyFileSync(dest, output);
+    fs26.mkdirSync(path31.dirname(path31.resolve(output)), { recursive: true });
+    fs26.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, model };
 }
@@ -4058,8 +4275,8 @@ Generated audio: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/video.ts
-import fs26 from "fs";
-import path31 from "path";
+import fs27 from "fs";
+import path32 from "path";
 async function generateMinimaxVideo(opts) {
   const {
     apiKey,
@@ -4105,18 +4322,18 @@ async function generateMinimaxVideo(opts) {
     return { status: "error", error: `No file_id in poll result: ${JSON.stringify(pollResult)}` };
   }
   const outDir = getOutputDir();
-  const dest = path31.join(outDir, `minimax_video_${Date.now()}.mp4`);
+  const dest = path32.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 = fs26.statSync(dest);
+  const stat = fs27.statSync(dest);
   const fileSizeMb = stat.size / (1024 * 1024);
   if (output) {
-    fs26.mkdirSync(path31.dirname(path31.resolve(output)), { recursive: true });
-    fs26.copyFileSync(dest, output);
+    fs27.mkdirSync(path32.dirname(path32.resolve(output)), { recursive: true });
+    fs27.copyFileSync(dest, output);
   }
   await maybeDownloadThumb(pollResult, dest, {
     skip: thumb === false,
@@ -4179,8 +4396,8 @@ Generated video: ${result.generatedVideo}`);
 // src/providers/minimax/generators/image.ts
 init_errors();
 init_http_client();
-import fs27 from "fs";
-import path32 from "path";
+import fs28 from "fs";
+import path33 from "path";
 async function generateMinimaxImage(opts) {
   const {
     apiKey,
@@ -4218,8 +4435,8 @@ async function generateMinimaxImage(opts) {
     try {
       const bytes = await fetchBytes(url);
       const fname = `minimax_image_${Date.now()}_${i}.png`;
-      const dest = path32.join(outDir, fname);
-      fs27.writeFileSync(dest, bytes);
+      const dest = path33.join(outDir, fname);
+      fs28.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -4230,8 +4447,8 @@ async function generateMinimaxImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs27.mkdirSync(path32.dirname(path32.resolve(output)), { recursive: true });
-    fs27.copyFileSync(savedFiles[0], output);
+    fs28.mkdirSync(path33.dirname(path33.resolve(output)), { recursive: true });
+    fs28.copyFileSync(savedFiles[0], output);
   }
   return { status: "success", generatedImages: savedFiles, model };
 }
@@ -4267,8 +4484,8 @@ Generated ${result.generatedImages?.length ?? 0} image(s):`);
 // src/providers/minimax/commands/image-to-image.ts
 init_errors();
 init_http_client();
-import fs28 from "fs";
-import path33 from "path";
+import fs29 from "fs";
+import path34 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."
@@ -4323,8 +4540,8 @@ function registerMinimaxImageToImageCommand(parent) {
         if (!url) continue;
         try {
           const bytes = await fetchBytes(url);
-          const dest = path33.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
-          fs28.writeFileSync(dest, bytes);
+          const dest = path34.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
+          fs29.writeFileSync(dest, bytes);
           saved.push(dest);
           logger.success(`Saved: ${dest}`);
         } catch (e) {
@@ -4335,8 +4552,8 @@ function registerMinimaxImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        fs28.mkdirSync(path33.dirname(path33.resolve(opts.output)), { recursive: true });
-        fs28.copyFileSync(saved[0], opts.output);
+        fs29.mkdirSync(path34.dirname(path34.resolve(opts.output)), { recursive: true });
+        fs29.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       console.log(`
@@ -4356,9 +4573,636 @@ function registerMinimaxCommands(program2) {
   registerMinimaxGenerateMusicCommand(minimax);
 }
 
+// src/providers/openai/commands/generate-speech.ts
+init_errors();
+
+// src/providers/openai/models.ts
+init_errors();
+var OPENAI_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_OPENAI_IMAGE_MODEL = "gpt-image-2";
+var DEFAULT_OPENAI_TTS_MODEL = "gpt-4o-mini-tts";
+var DEFAULT_OPENAI_STT_MODEL = "gpt-4o-transcribe";
+var OPENAI_IMAGE_OUTPUT_FORMATS = ["png", "jpeg", "webp"];
+var OPENAI_IMAGE_QUALITIES = ["low", "medium", "high"];
+var OPENAI_IMAGE_SIZES = ["1024x1024", "1024x1536", "1536x1024", "auto"];
+var OPENAI_TTS_OUTPUT_FORMATS = ["mp3", "opus", "aac", "flac", "wav", "pcm"];
+var OPENAI_TTS_VOICES = [
+  "alloy",
+  "ash",
+  "ballad",
+  "cedar",
+  "coral",
+  "echo",
+  "fable",
+  "marin",
+  "nova",
+  "onyx",
+  "sage",
+  "shimmer",
+  "verse"
+];
+var OPENAI_TRANSCRIPT_FORMATS = ["json", "text", "diarized_json"];
+function isOneOf(value, values) {
+  return values.includes(value);
+}
+function extFromImageFormat(format) {
+  if (format === "jpeg") return "jpg";
+  return format;
+}
+function extFromAudioFormat(format) {
+  return format;
+}
+function parseImageFormat(value) {
+  if (!isOneOf(value, OPENAI_IMAGE_OUTPUT_FORMATS)) {
+    throw new ValidationError(`--format must be one of: ${OPENAI_IMAGE_OUTPUT_FORMATS.join(", ")}`);
+  }
+  return value;
+}
+function parseImageQuality(value) {
+  if (!isOneOf(value, OPENAI_IMAGE_QUALITIES)) {
+    throw new ValidationError(`--quality must be one of: ${OPENAI_IMAGE_QUALITIES.join(", ")}`);
+  }
+  return value;
+}
+function parseImageSize(value) {
+  if (!isOneOf(value, OPENAI_IMAGE_SIZES)) {
+    throw new ValidationError(`--size must be one of: ${OPENAI_IMAGE_SIZES.join(", ")}`);
+  }
+  return value;
+}
+function parseDriver(value) {
+  if (!isOneOf(value, ["api", "codex", "auto"])) {
+    throw new ValidationError("--driver must be one of: api, codex, auto");
+  }
+  return value;
+}
+function parseNumImages(value) {
+  if (!/^\d+$/.test(value)) {
+    throw new ValidationError("--num-images must be an integer from 1 to 10");
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (parsed < 1 || parsed > 10) {
+    throw new ValidationError("--num-images must be an integer from 1 to 10");
+  }
+  return parsed;
+}
+function parseTtsFormat(value) {
+  if (!isOneOf(value, OPENAI_TTS_OUTPUT_FORMATS)) {
+    throw new ValidationError(
+      `--output-format must be one of: ${OPENAI_TTS_OUTPUT_FORMATS.join(", ")}`
+    );
+  }
+  return value;
+}
+function validateTtsVoice(value) {
+  if (!isOneOf(value, OPENAI_TTS_VOICES)) {
+    throw new ValidationError(`--voice must be one of: ${OPENAI_TTS_VOICES.join(", ")}`);
+  }
+}
+function parseTranscriptFormat(value) {
+  if (!isOneOf(value, OPENAI_TRANSCRIPT_FORMATS)) {
+    throw new ValidationError(`--format must be one of: ${OPENAI_TRANSCRIPT_FORMATS.join(", ")}`);
+  }
+  return value;
+}
+function resolveTranscriptionRequestFormat(cliFormat, model) {
+  if (cliFormat === "diarized_json") {
+    if (model !== "gpt-4o-transcribe-diarize") {
+      throw new ValidationError("--format diarized_json requires gpt-4o-transcribe-diarize");
+    }
+    return "diarized_json";
+  }
+  return "json";
+}
+function validateKnownSpeakerPairing(names = [], refs = []) {
+  if (names.length !== refs.length) {
+    throw new ValidationError(
+      "--known-speaker-name and --known-speaker-reference must have equal counts"
+    );
+  }
+  if (names.length > 4) {
+    throw new ValidationError("OpenAI diarization supports up to 4 known speakers");
+  }
+}
+
+// src/providers/openai/openai-audio.ts
+init_http_client();
+import fs31 from "fs";
+import path36 from "path";
+
+// src/providers/openai/client.ts
+import fs30 from "fs";
+import path35 from "path";
+init_errors();
+init_http_client();
+var DEFAULT_TIMEOUT_MS3 = 24e4;
+function requireOpenAIKey() {
+  const key = resolveKey("OPENAI_API_KEY");
+  if (!key) {
+    throw new ConfigError(
+      "OPENAI_API_KEY is not set. Get one at https://platform.openai.com/api-keys"
+    );
+  }
+  return key;
+}
+function endpoint(pathname) {
+  return `${OPENAI_BASE_URL}/${pathname.replace(/^\//, "")}`;
+}
+function authHeaders3(apiKey, extra) {
+  return { Authorization: `Bearer ${apiKey}`, ...extra ?? {} };
+}
+function postOpenAIJson(pathname, body, apiKey, timeoutMs = DEFAULT_TIMEOUT_MS3) {
+  return httpJson({
+    url: endpoint(pathname),
+    method: "POST",
+    headers: authHeaders3(apiKey, { "Content-Type": "application/json" }),
+    body,
+    timeoutMs
+  });
+}
+async function postOpenAIForm(pathname, form, apiKey, timeoutMs = DEFAULT_TIMEOUT_MS3) {
+  const url = endpoint(pathname);
+  let res;
+  try {
+    res = await globalThis.fetch(url, {
+      method: "POST",
+      headers: authHeaders3(apiKey),
+      body: form,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (cause) {
+    throw new HttpError(0, cause instanceof Error ? cause.message : String(cause), url);
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new HttpError(res.status, text.slice(0, 500), url);
+  }
+  return res.json();
+}
+async function postOpenAIBinary(pathname, body, apiKey, timeoutMs = DEFAULT_TIMEOUT_MS3) {
+  const url = endpoint(pathname);
+  let res;
+  try {
+    res = await globalThis.fetch(url, {
+      method: "POST",
+      headers: authHeaders3(apiKey, { "Content-Type": "application/json" }),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (cause) {
+    throw new HttpError(0, cause instanceof Error ? cause.message : String(cause), url);
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new HttpError(res.status, text.slice(0, 500), url);
+  }
+  return Buffer.from(await res.arrayBuffer());
+}
+function fileFromPath(filePath) {
+  const abs = path35.resolve(filePath);
+  if (!fs30.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
+  const bytes = fs30.readFileSync(abs);
+  return new File([new Uint8Array(bytes)], path35.basename(abs));
+}
+
+// src/providers/openai/openai-audio.ts
+function buildSpeechBody(opts) {
+  const body = {
+    model: opts.model ?? DEFAULT_OPENAI_TTS_MODEL,
+    input: opts.text,
+    voice: opts.voice,
+    response_format: opts.outputFormat
+  };
+  if (opts.instructions) body.instructions = opts.instructions;
+  return body;
+}
+async function buildTranscriptionForm(opts) {
+  const model = opts.model ?? DEFAULT_OPENAI_STT_MODEL;
+  const form = new FormData();
+  form.append("file", opts.input);
+  form.append("model", model);
+  form.append("response_format", resolveTranscriptionRequestFormat(opts.cliFormat, model));
+  if (opts.language) form.append("language", opts.language);
+  if (opts.chunkingStrategy) form.append("chunking_strategy", opts.chunkingStrategy);
+  const names = opts.knownSpeakerNames ?? [];
+  const refs = opts.knownSpeakerReferences ?? [];
+  validateKnownSpeakerPairing(names, refs);
+  for (const name of names) form.append("known_speaker_names[]", name);
+  for (const ref of refs) {
+    form.append("known_speaker_references[]", await resolveAudioReferenceDataUrl(ref));
+  }
+  return form;
+}
+async function resolveAudioReferenceDataUrl(ref) {
+  const resolved = await resolveAudioInput(ref);
+  if (resolved.kind === "data") return resolved.dataUrl;
+  const bytes = await fetchBytes(resolved.url);
+  return `data:${audioMimeFromReference(resolved.url)};base64,${bytes.toString("base64")}`;
+}
+function audioMimeFromReference(ref) {
+  const pathname = new URL(ref).pathname;
+  const ext = path36.extname(pathname).toLowerCase();
+  switch (ext) {
+    case ".mp3":
+      return "audio/mpeg";
+    case ".wav":
+      return "audio/wav";
+    case ".m4a":
+      return "audio/mp4";
+    case ".flac":
+      return "audio/flac";
+    case ".ogg":
+      return "audio/ogg";
+    default:
+      return "application/octet-stream";
+  }
+}
+async function generateOpenAISpeech(opts) {
+  const bytes = await postOpenAIBinary("/audio/speech", buildSpeechBody(opts), requireOpenAIKey());
+  const ext = extFromAudioFormat(opts.outputFormat);
+  const dest = path36.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
+  fs31.writeFileSync(dest, bytes);
+  opts.logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
+  if (opts.output) {
+    fs31.mkdirSync(path36.dirname(path36.resolve(opts.output)), { recursive: true });
+    fs31.copyFileSync(dest, opts.output);
+  }
+  return dest;
+}
+async function transcribeOpenAIAudio(opts) {
+  const form = await buildTranscriptionForm({
+    input: fileFromPath(opts.inputPath),
+    model: opts.model,
+    cliFormat: opts.format,
+    language: opts.language,
+    chunkingStrategy: opts.chunkingStrategy ?? (opts.model === "gpt-4o-transcribe-diarize" || opts.format === "diarized_json" ? "auto" : void 0),
+    knownSpeakerNames: opts.knownSpeakerNames,
+    knownSpeakerReferences: opts.knownSpeakerReferences
+  });
+  const data = await postOpenAIForm(
+    "/audio/transcriptions",
+    form,
+    requireOpenAIKey(),
+    6e5
+  );
+  const text = typeof data.text === "string" ? data.text : void 0;
+  const ext = opts.format === "text" ? "txt" : "json";
+  const dest = opts.output ? path36.resolve(opts.output) : path36.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
+  fs31.mkdirSync(path36.dirname(dest), { recursive: true });
+  fs31.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
+  opts.logger?.success(`Saved transcript: ${dest}`);
+  return { path: dest, text };
+}
+
+// src/providers/openai/commands/generate-speech.ts
+function registerOpenAIGenerateSpeechCommand(parent) {
+  parent.command("generate-speech").description("Generate speech with OpenAI TTS").option("--text <str>", "Text to speak").option("--prompt <str>", "Alias for --text").option("--model <id>", "TTS model", process.env.OPENAI_TTS_MODEL ?? DEFAULT_OPENAI_TTS_MODEL).option("--voice <name>", "OpenAI voice", "marin").option("--instructions <text>", "Voice/style instructions").option("--output-format <fmt>", "mp3|opus|aac|flac|wav|pcm", "mp3").option("--output <path>", "Copy generated audio to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const text = opts.text ?? opts.prompt;
+    if (!text) throw new ValidationError("Either --text or --prompt is required");
+    validateTtsVoice(opts.voice);
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const dest = await generateOpenAISpeech({
+      text,
+      model: opts.model,
+      voice: opts.voice,
+      outputFormat: parseTtsFormat(opts.outputFormat),
+      instructions: opts.instructions,
+      output: opts.output,
+      logger
+    });
+    console.log(`
+Generated audio: ${dest}`);
+  });
+}
+
+// src/providers/openai/codex-image-driver.ts
+import fs32 from "fs";
+import os2 from "os";
+import path37 from "path";
+import { execa } from "execa";
+init_errors();
+var defaultRunner = async (cmd, args, opts) => {
+  const res = await execa(cmd, args, {
+    cwd: opts?.cwd,
+    env: opts?.env,
+    reject: false,
+    timeout: opts?.timeoutMs
+  });
+  return { stdout: res.stdout, stderr: res.stderr, exitCode: res.exitCode ?? 0 };
+};
+async function checkCodexAuthenticated(runner = defaultRunner) {
+  try {
+    const res = await runner("codex", ["login", "status"], { timeoutMs: 15e3 });
+    return res.exitCode === 0 && /Logged in using ChatGPT/i.test(`${res.stdout}
+${res.stderr}`);
+  } catch {
+    return false;
+  }
+}
+async function resolveImageDriver(opts) {
+  const hasApiKey = opts.hasApiKey ?? Boolean(resolveKey("OPENAI_API_KEY"));
+  const codexAuthCheck = opts.codexAuthCheck ?? (() => checkCodexAuthenticated());
+  if (opts.requested === "api") {
+    if (!hasApiKey) throw new ConfigError("OPENAI_API_KEY is required for --driver api");
+    return "api";
+  }
+  if (opts.requested === "codex") {
+    if (!await codexAuthCheck()) throw new ConfigError("Codex driver requires `codex login`");
+    return "codex";
+  }
+  if (hasApiKey) return "api";
+  if (await codexAuthCheck()) return "codex";
+  throw new ConfigError(
+    "Set OPENAI_API_KEY or run `codex login` for the experimental image driver"
+  );
+}
+function sanitizeCodexEnv() {
+  const keep = ["PATH", "HOME", "CODEX_HOME", "TMPDIR", "TEMP", "LANG", "LC_ALL"];
+  const env = {};
+  for (const key of keep) {
+    if (process.env[key]) env[key] = process.env[key];
+  }
+  return env;
+}
+async function runCodexImageGeneration(opts) {
+  const runner = opts.runner ?? defaultRunner;
+  const ext = extFromImageFormat(opts.outputFormat);
+  const dest = opts.output ? path37.resolve(opts.output) : path37.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
+  fs32.mkdirSync(path37.dirname(dest), { recursive: true });
+  const tmp = fs32.mkdtempSync(path37.join(os2.tmpdir(), "multix-codex-image-"));
+  const schema = path37.join(tmp, "schema.json");
+  const result = path37.join(tmp, "result.json");
+  fs32.writeFileSync(
+    schema,
+    JSON.stringify({
+      type: "object",
+      properties: { status: { type: "string" }, path: { type: "string" } },
+      required: ["status", "path"],
+      additionalProperties: false
+    })
+  );
+  const args = [
+    "exec",
+    "--ephemeral",
+    "--skip-git-repo-check",
+    "--cd",
+    tmp,
+    "--output-schema",
+    schema,
+    "--output-last-message",
+    result
+  ];
+  for (const ref of opts.refs ?? []) args.push("--image", ref);
+  args.push(buildCodexPrompt(opts.prompt, dest));
+  const res = await runner("codex", args, {
+    cwd: tmp,
+    env: sanitizeCodexEnv(),
+    timeoutMs: 6e5
+  });
+  if (res.exitCode !== 0) {
+    throw new ProviderError(`Codex image driver failed: ${res.stderr || res.stdout}`, "openai");
+  }
+  if (!fs32.existsSync(dest) || fs32.statSync(dest).size === 0) {
+    throw new ProviderError(`Codex did not create a non-empty image at ${dest}`, "openai");
+  }
+  return { path: dest };
+}
+function buildCodexPrompt(userPrompt, outputPath) {
+  return [
+    `Create exactly one image at ${outputPath}.`,
+    "Do not modify any repository files.",
+    "Use the attached reference images if present.",
+    `Image request: ${userPrompt}`,
+    `Reply with JSON only: {"status":"ok","path":"${outputPath}"}.`
+  ].join(" ");
+}
+
+// src/providers/openai/openai-image.ts
+init_errors();
+init_http_client();
+import fs33 from "fs";
+import path38 from "path";
+function buildImageGenerationBody(opts) {
+  return {
+    model: opts.model ?? DEFAULT_OPENAI_IMAGE_MODEL,
+    prompt: opts.prompt,
+    size: opts.size ?? "1024x1024",
+    quality: opts.quality ?? "medium",
+    output_format: opts.outputFormat,
+    n: opts.numImages ?? 1
+  };
+}
+async function buildImageEditForm(opts) {
+  const form = new FormData();
+  form.append("model", opts.model);
+  form.append("prompt", opts.prompt);
+  form.append("size", opts.size);
+  form.append("quality", opts.quality);
+  form.append("output_format", opts.outputFormat);
+  for (const ref of opts.refs) {
+    form.append("image[]", new File([new Uint8Array(ref.bytes)], ref.filename, { type: ref.mime }));
+  }
+  return form;
+}
+function saveOpenAIImages(opts) {
+  const items = opts.data ?? [];
+  if (items.length === 0) throw new ProviderError("No images in OpenAI response", "openai");
+  const outDir = getOutputDir();
+  const ext = extFromImageFormat(opts.format);
+  const ts = Date.now();
+  const saved = [];
+  for (let i = 0; i < items.length; i++) {
+    const b64 = items[i]?.b64_json;
+    if (!b64) throw new ProviderError("No b64_json in OpenAI image response", "openai");
+    const dest = path38.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
+    fs33.writeFileSync(dest, Buffer.from(b64, "base64"));
+    saved.push(dest);
+    opts.logger?.success(`Saved: ${dest}`);
+  }
+  if (opts.output && saved[0]) {
+    fs33.mkdirSync(path38.dirname(path38.resolve(opts.output)), { recursive: true });
+    fs33.copyFileSync(saved[0], opts.output);
+    opts.logger?.success(`Copied to: ${opts.output}`);
+  }
+  return saved;
+}
+async function resolveImageRefBytes(ref) {
+  if (isHttpUrl(ref)) {
+    const bytes2 = await fetchBytes(ref);
+    const pathname = new URL(ref).pathname;
+    const filename = path38.basename(pathname) || "reference.png";
+    return { filename, bytes: bytes2, mime: sniffImageMime2(bytes2, filename) };
+  }
+  const file = fileFromPath(ref);
+  const bytes = Buffer.from(await file.arrayBuffer());
+  return { filename: file.name, bytes, mime: file.type || sniffImageMime2(bytes, file.name) };
+}
+async function generateOpenAIImage(opts) {
+  const data = await postOpenAIJson(
+    "/images/generations",
+    buildImageGenerationBody(opts),
+    requireOpenAIKey()
+  );
+  return saveOpenAIImages({
+    data: data.data,
+    task: "image",
+    format: opts.outputFormat,
+    output: opts.output,
+    logger: opts.logger
+  });
+}
+async function editOpenAIImage(opts) {
+  const refs = await Promise.all(opts.refs.map((ref) => resolveImageRefBytes(ref)));
+  const form = await buildImageEditForm({
+    prompt: opts.prompt,
+    refs,
+    model: opts.model ?? DEFAULT_OPENAI_IMAGE_MODEL,
+    size: opts.size ?? "1024x1024",
+    quality: opts.quality ?? "medium",
+    outputFormat: opts.outputFormat
+  });
+  const data = await postOpenAIForm("/images/edits", form, requireOpenAIKey());
+  return saveOpenAIImages({
+    data: data.data,
+    task: "image-edit",
+    format: opts.outputFormat,
+    output: opts.output,
+    logger: opts.logger
+  });
+}
+function sniffImageMime2(buf, name) {
+  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.slice(0, 4).toString() === "RIFF" && buf.slice(8, 12).toString() === "WEBP")
+    return "image/webp";
+  const ext = path38.extname(name).toLowerCase();
+  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
+  if (ext === ".webp") return "image/webp";
+  return "image/png";
+}
+
+// src/providers/openai/commands/generate.ts
+function registerOpenAIGenerateCommand(parent) {
+  parent.command("generate").description("Generate images with OpenAI Image API or experimental Codex driver").requiredOption("--prompt <text>", "Text prompt").option("--driver <driver>", "api|codex|auto", "auto").option(
+    "-m, --model <id>",
+    "Image model",
+    resolveKey("OPENAI_IMAGE_MODEL") ?? DEFAULT_OPENAI_IMAGE_MODEL
+  ).option("--size <size>", "1024x1024|1024x1536|1536x1024|auto", "1024x1024").option("--quality <q>", "low|medium|high", "medium").option("--format <fmt>", "png|jpeg|webp", "png").option("-n, --num-images <n>", "Number of images for API driver", "1").option("--output <path>", "Save first image to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const outputFormat = parseImageFormat(opts.format);
+    const driver = await resolveImageDriver({ requested: parseDriver(opts.driver) });
+    const saved = driver === "codex" ? [
+      (await runCodexImageGeneration({
+        prompt: opts.prompt,
+        outputFormat,
+        output: opts.output
+      })).path
+    ] : await generateOpenAIImage({
+      prompt: opts.prompt,
+      model: opts.model,
+      size: parseImageSize(opts.size),
+      quality: parseImageQuality(opts.quality),
+      outputFormat,
+      numImages: parseNumImages(opts.numImages),
+      output: opts.output,
+      logger
+    });
+    console.log(`
+Generated ${saved.length} image(s):`);
+    for (const file of saved) console.log(`  ${file}`);
+  });
+}
+
+// src/providers/openai/commands/image-to-image.ts
+init_errors();
+function registerOpenAIImageToImageCommand(parent) {
+  parent.command("image-to-image").alias("i2i").description("Edit images with OpenAI Image API or experimental Codex driver").requiredOption("--prompt <text>", "Text prompt describing the edit").requiredOption(
+    "--ref <path>",
+    "Reference image path or URL; repeatable",
+    collect5,
+    []
+  ).option("--driver <driver>", "api|codex|auto", "auto").option(
+    "-m, --model <id>",
+    "Image model",
+    resolveKey("OPENAI_IMAGE_MODEL") ?? DEFAULT_OPENAI_IMAGE_MODEL
+  ).option("--size <size>", "1024x1024|1024x1536|1536x1024|auto", "1024x1024").option("--quality <q>", "low|medium|high", "medium").option("--format <fmt>", "png|jpeg|webp", "png").option("--output <path>", "Save first image to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    if (!opts.ref || opts.ref.length === 0) {
+      throw new ValidationError("At least one --ref is required for image-to-image.");
+    }
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const outputFormat = parseImageFormat(opts.format);
+    const driver = await resolveImageDriver({ requested: parseDriver(opts.driver) });
+    const saved = driver === "codex" ? [
+      (await runCodexImageGeneration({
+        prompt: opts.prompt,
+        refs: opts.ref,
+        outputFormat,
+        output: opts.output
+      })).path
+    ] : await editOpenAIImage({
+      prompt: opts.prompt,
+      refs: opts.ref,
+      model: opts.model,
+      size: parseImageSize(opts.size),
+      quality: parseImageQuality(opts.quality),
+      outputFormat,
+      output: opts.output,
+      logger
+    });
+    console.log(`
+Generated ${saved.length} image(s):`);
+    for (const file of saved) console.log(`  ${file}`);
+  });
+}
+function collect5(value, prev) {
+  return [...prev, value];
+}
+
+// src/providers/openai/commands/transcribe.ts
+function registerOpenAITranscribeCommand(parent) {
+  parent.command("transcribe").description("Transcribe audio/video with OpenAI STT").requiredOption("--input <path>", "Audio or video file").option("--model <id>", "STT model", process.env.OPENAI_STT_MODEL ?? DEFAULT_OPENAI_STT_MODEL).option("--format <fmt>", "json|text|diarized_json", "text").option("--language <code>", "ISO language code").option("--chunking-strategy <strategy>", "e.g. auto").option(
+    "--known-speaker-name <name>",
+    "Known speaker name; repeatable",
+    collect6,
+    []
+  ).option(
+    "--known-speaker-reference <path>",
+    "2-10s reference audio; repeatable",
+    collect6,
+    []
+  ).option("--output <path>", "Save transcript to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const result = await transcribeOpenAIAudio({
+      inputPath: opts.input,
+      model: opts.model,
+      format: parseTranscriptFormat(opts.format),
+      language: opts.language,
+      chunkingStrategy: opts.chunkingStrategy,
+      knownSpeakerNames: opts.knownSpeakerName,
+      knownSpeakerReferences: opts.knownSpeakerReference,
+      output: opts.output,
+      logger
+    });
+    if (opts.format === "text" && result.text) console.log(`
+${result.text.trim()}`);
+  });
+}
+function collect6(value, prev) {
+  return [...prev, value];
+}
+
+// src/providers/openai/commands/index.ts
+function registerOpenAICommands(program2) {
+  const openai = program2.command("openai").description("OpenAI image generation/editing, TTS, STT, and experimental Codex image driver");
+  registerOpenAIGenerateCommand(openai);
+  registerOpenAIImageToImageCommand(openai);
+  registerOpenAIGenerateSpeechCommand(openai);
+  registerOpenAITranscribeCommand(openai);
+}
+
 // src/providers/openrouter/client.ts
-import fs29 from "fs";
-import path34 from "path";
+import fs34 from "fs";
+import path39 from "path";
 init_errors();
 init_http_client();
 
@@ -4523,8 +5367,8 @@ async function generateOpenRouterImage(opts) {
     if (!url) continue;
     try {
       const bytes = await fetchBytes(url);
-      const dest = path34.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
-      fs29.writeFileSync(dest, bytes);
+      const dest = path39.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
+      fs34.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -4535,8 +5379,8 @@ async function generateOpenRouterImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs29.mkdirSync(path34.dirname(path34.resolve(output)), { recursive: true });
-    fs29.writeFileSync(output, fs29.readFileSync(savedFiles[0]));
+    fs34.mkdirSync(path39.dirname(path39.resolve(output)), { recursive: true });
+    fs34.writeFileSync(output, fs34.readFileSync(savedFiles[0]));
   }
   return { status: "success", generatedImages: savedFiles, model: usedModel };
 }
@@ -4571,8 +5415,8 @@ Generated ${result.generatedImages?.length ?? 0} image(s):`);
 }
 
 // src/providers/openrouter/commands/image-to-image.ts
-import fs30 from "fs";
-import path35 from "path";
+import fs35 from "fs";
+import path40 from "path";
 init_errors();
 init_http_client();
 var DEFAULT_MODEL = "google/gemini-2.5-flash-image";
@@ -4582,7 +5426,7 @@ 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,
+    collect7,
     []
   ).option("-m, --model <id>", `OpenRouter model id (default ${DEFAULT_MODEL})`).option("--strength <n>", "Recraft init-image strength 0..1 (Recraft models only)").option("--output <path>", "Save first generated image to this path").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
@@ -4623,7 +5467,7 @@ Generated ${saved.length} image(s):`);
     }
   );
 }
-function collect5(value, prev) {
+function collect7(value, prev) {
   return [...prev, value];
 }
 function parseStrength(raw) {
@@ -4662,14 +5506,14 @@ async function runImageToImage(opts) {
     const url = parsed.urls[i];
     if (!url) continue;
     const bytes = await fetchBytes(url);
-    const dest = path35.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
-    fs30.writeFileSync(dest, bytes);
+    const dest = path40.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
+    fs35.writeFileSync(dest, bytes);
     saved.push(dest);
     opts.logger.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs30.mkdirSync(path35.dirname(path35.resolve(opts.output)), { recursive: true });
-    fs30.copyFileSync(saved[0], opts.output);
+    fs35.mkdirSync(path40.dirname(path40.resolve(opts.output)), { recursive: true });
+    fs35.copyFileSync(saved[0], opts.output);
     opts.logger.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -4715,13 +5559,13 @@ async function listVideoModels(apiKey = requireOpenRouterKey()) {
 }
 
 // src/providers/openrouter/commands/video-status.ts
-import fs31 from "fs";
-import path36 from "path";
+import fs36 from "fs";
+import path41 from "path";
 async function downloadOpenRouterVideo(opts) {
   const { jobId, logger, source } = opts;
   const apiKey = requireOpenRouterKey();
   const url = videoContentUrl(jobId);
-  const dest = path36.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
+  const dest = path41.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}`);
@@ -4731,14 +5575,14 @@ async function downloadOpenRouterVideo(opts) {
     logger.error("Empty response body");
     process.exit(1);
   }
-  fs31.mkdirSync(path36.dirname(dest), { recursive: true });
-  const ws = fs31.createWriteStream(dest);
+  fs36.mkdirSync(path41.dirname(dest), { recursive: true });
+  const ws = fs36.createWriteStream(dest);
   const { pipeline: pipeline2 } = await import("stream/promises");
   await pipeline2(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
-    fs31.mkdirSync(path36.dirname(path36.resolve(opts.output)), { recursive: true });
-    fs31.copyFileSync(dest, opts.output);
+    fs36.mkdirSync(path41.dirname(path41.resolve(opts.output)), { recursive: true });
+    fs36.copyFileSync(dest, opts.output);
     logger.success(`Copied to ${opts.output}`);
   }
   await maybeDownloadThumb(source, dest, {
@@ -4898,10 +5742,10 @@ function registerOpenRouterCommands(program2) {
 }
 
 // src/commands/check-helpers/binary-check.ts
-import { execa } from "execa";
+import { execa as execa2 } from "execa";
 async function checkBinary(binary) {
   try {
-    const result = await execa(binary, ["--version"], { reject: true, all: true });
+    const result = await execa2(binary, ["--version"], { reject: true, all: true });
     const version = (result.stdout || result.stderr || "").split("\n")[0]?.trim();
     return { available: true, version, binary };
   } catch (e) {
@@ -4982,6 +5826,12 @@ var PROVIDERS = [
     optional: true,
     link: "https://openrouter.ai/settings/keys"
   },
+  {
+    name: "OpenAI",
+    envPrimary: "OPENAI_API_KEY",
+    optional: true,
+    link: "https://platform.openai.com/api-keys"
+  },
   {
     name: "MiniMax",
     envPrimary: "MINIMAX_API_KEY",
@@ -5017,6 +5867,10 @@ function resolveProviderKey(p) {
   }
   return {};
 }
+async function checkCodexImageReadiness(hasAnyProviderKey, verbose = false, checker = checkCodexAuthenticated) {
+  if (hasAnyProviderKey && !verbose) return false;
+  return checker();
+}
 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 });
@@ -5053,10 +5907,25 @@ function registerCheckCommand(program2) {
         logger.warn(`${p.envPrimary} not set (${p.name} features unavailable)`);
       }
     }
+    const shouldCheckCodex = !anyKey || opts.verbose;
+    let codexReady = false;
+    if (shouldCheckCodex) {
+      logger.header("Codex Image Driver");
+      logger.info("Checking Codex login status...");
+      codexReady = await checkCodexImageReadiness(anyKey, opts.verbose ?? false);
+      if (codexReady) {
+        logger.success("Codex authenticated \u2014 experimental OpenAI image driver available");
+      } else {
+        logger.info("Codex image driver unavailable (run `codex login` to enable it)");
+      }
+    }
     if (!anyKey) {
-      logger.header("No Provider Keys Configured");
-      console.log(SETUP_HINTS);
-      process.exit(1);
+      if (!codexReady) {
+        logger.header("No Provider Keys Configured");
+        console.log(SETUP_HINTS);
+        process.exit(1);
+      }
+      anyKey = true;
     }
     const geminiKey = resolved.get("Gemini")?.key;
     if (geminiKey) {
@@ -5079,9 +5948,11 @@ function registerCheckCommand(program2) {
         console.log(
           "  Full Gemini multimodal setup (analyze, transcribe, generate, doc convert)"
         );
+      } else if (resolved.get("OpenAI")?.key) {
+        console.log("  OpenAI API setup available (images, TTS, STT)");
       } else {
-        console.log("  Image generation via OpenRouter/MiniMax/Leonardo/BytePlus available");
-        console.log("  Add GEMINI_API_KEY for analysis, transcription, and doc conversion");
+        console.log("  Image generation via configured providers or experimental Codex driver");
+        console.log("  Add API keys for full provider features");
       }
     } else {
       logger.error("One or more checks failed \u2014 see above");
@@ -5092,8 +5963,8 @@ function registerCheckCommand(program2) {
 
 // src/commands/doc/convert.ts
 init_errors();
-import fs32 from "fs";
-import path37 from "path";
+import fs37 from "fs";
+import path42 from "path";
 
 // src/commands/doc/default-prompt.ts
 var DEFAULT_CONVERT_PROMPT = `Convert this document to clean, well-formatted Markdown.
@@ -5114,18 +5985,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 (!fs32.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
+    if (!fs37.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
   }
   let outputPath;
   if (output) {
-    outputPath = path37.resolve(output);
+    outputPath = path42.resolve(output);
   } else if (autoName && inputs.length === 1 && inputs[0]) {
-    const base = path37.basename(inputs[0], path37.extname(inputs[0]));
-    outputPath = path37.join(getOutputDir(), `${base}-extraction.md`);
+    const base = path42.basename(inputs[0], path42.extname(inputs[0]));
+    outputPath = path42.join(getOutputDir(), `${base}-extraction.md`);
   } else {
-    outputPath = path37.join(getOutputDir(), "document-extraction.md");
+    outputPath = path42.join(getOutputDir(), "document-extraction.md");
   }
-  fs32.mkdirSync(path37.dirname(outputPath), { recursive: true });
+  fs37.mkdirSync(path42.dirname(outputPath), { recursive: true });
   const results = [];
   for (let i = 0; i < inputs.length; i++) {
     const filePath = inputs[i];
@@ -5157,7 +6028,7 @@ async function convertDocuments(opts) {
         if (attempt < 2) {
           const wait = 2 ** attempt * 1e3;
           logger?.debug(`Retry ${attempt + 1} after ${wait / 1e3}s: ${errorMsg}`);
-          await sleep5(wait);
+          await sleep6(wait);
         }
       }
     }
@@ -5176,7 +6047,7 @@ async function convertDocuments(opts) {
 `);
   for (const r of results) {
     lines.push(`
-## ${path37.basename(r.file)}
+## ${path42.basename(r.file)}
 `);
     if (r.status === "success" && r.markdown) {
       lines.push(`${r.markdown}
@@ -5189,7 +6060,7 @@ async function convertDocuments(opts) {
     }
     lines.push("\n---\n");
   }
-  fs32.writeFileSync(outputPath, lines.join("\n"), "utf8");
+  fs37.writeFileSync(outputPath, lines.join("\n"), "utf8");
   const succeeded = results.filter((r) => r.status === "success").length;
   console.log(`
 ${"=".repeat(50)}`);
@@ -5205,7 +6076,7 @@ ${"=".repeat(50)}`);
   const failed = results.filter((r) => r.status === "error").length;
   if (failed > 0) process.exit(1);
 }
-function sleep5(ms) {
+function sleep6(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
@@ -5235,12 +6106,12 @@ function registerDocCommands(program2) {
 
 // src/commands/media/index.ts
 init_errors();
-import fs35 from "fs";
-import path40 from "path";
+import fs40 from "fs";
+import path45 from "path";
 
 // src/commands/media/batch.ts
-import fs33 from "fs";
-import path38 from "path";
+import fs38 from "fs";
+import path43 from "path";
 
 // src/commands/media/detect-type.ts
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
@@ -5259,10 +6130,10 @@ init_errors();
 
 // src/commands/media/ffmpeg-runner.ts
 init_errors();
-import { execa as execa2 } from "execa";
+import { execa as execa3 } from "execa";
 async function assertFfmpeg() {
   try {
-    await execa2("ffmpeg", ["-version"], { reject: true });
+    await execa3("ffmpeg", ["-version"], { reject: true });
   } catch (e) {
     if (e.code === "ENOENT") {
       throw new ValidationError(
@@ -5275,7 +6146,7 @@ async function runFfmpeg(args, opts = {}) {
   const { verbose, logger } = opts;
   logger?.debug(`ffmpeg ${args.join(" ")}`);
   try {
-    const result = await execa2("ffmpeg", args, { reject: true, all: true });
+    const result = await execa3("ffmpeg", args, { reject: true, all: true });
     if (verbose && result.stderr) logger?.debug(result.stderr);
   } catch (e) {
     const err2 = e;
@@ -5285,7 +6156,7 @@ async function runFfmpeg(args, opts = {}) {
 }
 async function getMediaInfo(filePath) {
   try {
-    const result = await execa2(
+    const result = await execa3(
       "ffprobe",
       ["-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", filePath],
       { reject: true }
@@ -5348,10 +6219,10 @@ async function optimizeAudio(opts) {
 
 // src/commands/media/magick-runner.ts
 init_errors();
-import { execa as execa3 } from "execa";
+import { execa as execa4 } from "execa";
 async function assertMagick() {
   try {
-    await execa3("magick", ["-version"], { reject: true });
+    await execa4("magick", ["-version"], { reject: true });
   } catch (e) {
     if (e.code === "ENOENT") {
       throw new ValidationError(
@@ -5364,7 +6235,7 @@ async function runMagick(args, opts = {}) {
   const { verbose, logger } = opts;
   logger?.debug(`magick ${args.join(" ")}`);
   try {
-    const result = await execa3("magick", args, { reject: true, all: true });
+    const result = await execa4("magick", args, { reject: true, all: true });
     if (verbose && result.stderr) logger?.debug(result.stderr);
   } catch (e) {
     const err2 = e;
@@ -5436,10 +6307,10 @@ async function batchOptimize(opts) {
     verbose,
     logger
   } = opts;
-  fs33.mkdirSync(outputDir, { recursive: true });
-  const entries = fs33.readdirSync(inputDir);
+  fs38.mkdirSync(outputDir, { recursive: true });
+  const entries = fs38.readdirSync(inputDir);
   const mediaFiles = entries.filter((f) => {
-    const ext = path38.extname(f).toLowerCase();
+    const ext = path43.extname(f).toLowerCase();
     return ALL_EXTS.has(ext);
   });
   if (mediaFiles.length === 0) {
@@ -5450,9 +6321,9 @@ async function batchOptimize(opts) {
   let succeeded = 0;
   const errors = [];
   for (const file of mediaFiles) {
-    const inputPath = path38.join(inputDir, file);
-    const outputPath = path38.join(outputDir, file);
-    const ext = path38.extname(file).toLowerCase();
+    const inputPath = path43.join(inputDir, file);
+    const outputPath = path43.join(outputDir, file);
+    const ext = path43.extname(file).toLowerCase();
     const kind = extToKind(ext);
     logger?.debug(`Processing: ${file}`);
     try {
@@ -5489,8 +6360,8 @@ async function batchOptimize(opts) {
 
 // src/commands/media/split-video.ts
 init_errors();
-import fs34 from "fs";
-import path39 from "path";
+import fs39 from "fs";
+import path44 from "path";
 async function splitVideo(opts) {
   await assertFfmpeg();
   const { input, outputDir, chunkDuration = 3600, verbose, logger } = opts;
@@ -5501,10 +6372,10 @@ async function splitVideo(opts) {
     logger?.info("Video is short enough \u2014 no splitting needed");
     return [input];
   }
-  fs34.mkdirSync(outputDir, { recursive: true });
-  const ext = path39.extname(input) || ".mp4";
-  const baseName = path39.basename(input, ext);
-  const outputPattern = path39.join(outputDir, `${baseName}_chunk_%03d${ext}`);
+  fs39.mkdirSync(outputDir, { recursive: true });
+  const ext = path44.extname(input) || ".mp4";
+  const baseName = path44.basename(input, ext);
+  const outputPattern = path44.join(outputDir, `${baseName}_chunk_%03d${ext}`);
   logger?.debug(`Splitting into ~${numChunks} chunks of ${chunkDuration}s each`);
   const args = [
     "-i",
@@ -5523,8 +6394,8 @@ async function splitVideo(opts) {
   await runFfmpeg(args, { verbose, logger });
   const files = [];
   for (let i = 0; i < numChunks + 1; i++) {
-    const fname = path39.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
-    if (fs34.existsSync(fname)) files.push(fname);
+    const fname = path44.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
+    if (fs39.existsSync(fname)) files.push(fname);
   }
   logger?.success(`Created ${files.length} chunks in ${outputDir}`);
   return files;
@@ -5538,9 +6409,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 (!fs35.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
-      fs35.mkdirSync(path40.dirname(path40.resolve(opts.output)), { recursive: true });
-      const ext = path40.extname(opts.input).toLowerCase();
+      if (!fs40.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      fs40.mkdirSync(path45.dirname(path45.resolve(opts.output)), { recursive: true });
+      const ext = path45.extname(opts.input).toLowerCase();
       const kind = extToKind(ext);
       if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
       const quality = Number.parseInt(opts.quality, 10);
@@ -5580,7 +6451,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 (!fs35.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      if (!fs40.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
       const chunks = await splitVideo({
         input: opts.input,
         outputDir: opts.outputDir,
@@ -5596,7 +6467,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 (!fs35.existsSync(opts.inputDir))
+      if (!fs40.existsSync(opts.inputDir))
         throw new ValidationError(`Input dir not found: ${opts.inputDir}`);
       const result = await batchOptimize({
         inputDir: opts.inputDir,
@@ -5622,6 +6493,7 @@ function registerCommands(program2) {
   registerCheckCommand(program2);
   registerGeminiCommands(program2);
   registerMinimaxCommands(program2);
+  registerOpenAICommands(program2);
   registerOpenRouterCommands(program2);
   registerLeonardoCommands(program2);
   registerBytePlusCommands(program2);