egaki 0.4.1 → 0.6.0

package/dist/cli.js

@@ -10,7 +10,8 @@
 import { goke } from 'goke';
 import { z } from 'zod';
 import dedent from 'string-dedent';
-import { generateImage as aiGenerateImage, generateText, experimental_generateVideo as aiGenerateVideo, } from 'ai';
+import { APICallError, generateImage as aiGenerateImage, generateText, experimental_generateVideo as aiGenerateVideo, NoImageGeneratedError, NoVideoGeneratedError, RetryError, } from 'ai';
+import { select, isCancel, cancel } from '@clack/prompts';
 import fs from 'node:fs';
 import path from 'node:path';
 import pc from 'picocolors';
@@ -18,25 +19,18 @@ import { createParser } from 'eventsource-parser';
 import pkg from '../package.json' with { type: 'json' };
 import { injectCredentialsToEnv, PROVIDERS, getChatGptAuth, saveChatGptAuth, getKeyStatus, } from './credentials.js';
 import { IMAGE_MODELS, VIDEO_MODELS, DEFAULT_MODEL, DEFAULT_VIDEO_MODEL, getModelConfig, createImageModel, createTextModel, createVideoModel, shouldUseResponsesApi, } from './models.js';
-import { VIDEO_CATALOG } from './video-model-catalog.js';
+import { CATALOG, VIDEO_CATALOG, describeProviderValues, } from './model-catalog.js';
 import { loginInteractive, loginNonInteractive, showLoginStatus, removeLogin, readKeyFromStdin, } from './login.js';
 import { subscribeInteractive, subscribeNonInteractive, unsubscribe, showUsage, } from './subscription.js';
 import { getValidChatGptAuth } from './chatgpt-auth.js';
 const cli = goke('egaki');
 process.title = 'egaki';
-// Print clean error output for unhandled rejections (e.g. AI SDK APICallError).
-// The AI SDK errors include request bodies, response headers, and other noisy
-// properties that get dumped by Node's default handler. We strip those and just
-// print the message + stack trace.
 process.on('uncaughtException', (err) => {
-    console.error(pc.red(err.message));
-    if (err.stack) {
-        const lines = err.stack.split('\n');
-        const stackOnly = lines.filter((l) => l.trimStart().startsWith('at '));
-        if (stackOnly.length > 0) {
-            console.error(pc.dim(stackOnly.join('\n')));
-        }
-    }
+    printErrorDetails(err);
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+    printErrorDetails(reason);
     process.exit(1);
 });
 // ─── login command ───────────────────────────────────────────────────────────
@@ -75,8 +69,8 @@ cli
     }
     // Non-interactive: --provider + --key or stdin
     if (options.provider) {
-        // ChatGPT uses browser OAuth — skip key reading
-        if (options.provider === 'chatgpt') {
+        // OAuth providers use browser flow — skip key reading
+        if (options.provider === 'chatgpt' || options.provider === 'xai-oauth') {
             await loginNonInteractive({ provider: options.provider, key: '' });
             return;
         }
@@ -144,7 +138,7 @@ cli
       from the model ID: imagen-* uses the image API, everything else uses
       the text API with image output enabled.
     `)
-    .option('-m, --model [model]', z.enum(IMAGE_MODELS).default(DEFAULT_MODEL).describe('Model ID for generation'))
+    .option('-m, --model [model]', z.string().describe('Model ID for generation. If omitted, shows an interactive picker (or uses default in non-TTY mode)'))
     .option('-o, --output [path]', z
     .string()
     .default('egaki-output.png')
@@ -163,6 +157,18 @@ cli
     .option('--mask [file]', z
     .string()
     .describe('Mask image for inpainting. Accepts a local file path or URL (http/https). White areas in the mask are replaced with generated content. Used together with --input'))
+    .option('--quality [level]', z
+    .string()
+    .describe(`Image quality level. ${describeProviderValues('quality', [CATALOG])}`))
+    .option('--resolution [res]', z
+    .string()
+    .describe(`Output resolution. ${describeProviderValues('resolution', [CATALOG])}`))
+    .option('--output-format [format]', z
+    .string()
+    .describe(`Output image format. ${describeProviderValues('output-format', [CATALOG])}`))
+    .option('--negative-prompt [text]', z
+    .string()
+    .describe('Describe what to avoid in the generated image (Fal models)'))
     .option('--allow-people', 'Allow generating images of people (Imagen blocks people by default)')
     .option('--json', 'Output result metadata as JSON to stdout (model, usage, warnings, file paths)')
     .option('--stdout', 'Write raw image bytes to stdout instead of saving to a file. Useful for piping to other tools')
@@ -187,10 +193,7 @@ cli
     .action(async (prompt, options) => {
     // Inject stored API keys as env vars before calling the AI SDK.
     injectCredentialsToEnv();
-    // goke infers schema .default() values via Zod's input type, which leaves
-    // options.model / options.output / options.count as `T | undefined` even
-    // though the runtime always resolves them. Apply the same defaults here.
-    const model = options.model ?? DEFAULT_MODEL;
+    const model = options.model ?? await resolveImageModel();
     const outputPath = options.output ?? 'egaki-output.png';
     const count = options.count ?? 1;
     const config = getModelConfig(model);
@@ -235,6 +238,10 @@ cli
             inputImages,
             maskImage,
             allowPeople: options.allowPeople || false,
+            quality: options.quality,
+            resolution: options.resolution,
+            outputFormat: options.outputFormat,
+            negativePrompt: options.negativePrompt,
             json: options.json || false,
             stdout: options.stdout || false,
         });
@@ -261,7 +268,7 @@ cli
       Agent note: video generation can be slow. When invoking this command from
       automation, use a command timeout of at least 5 minutes.
     `)
-    .option('-m, --model [model]', z.enum(VIDEO_MODELS).default(DEFAULT_VIDEO_MODEL).describe('Video model ID for generation'))
+    .option('-m, --model [model]', z.string().describe('Video model ID for generation. If omitted, shows an interactive picker (or uses default in non-TTY mode)'))
     .option('-o, --output [path]', z
     .string()
     .default('egaki-output.mp4')
@@ -270,13 +277,22 @@ cli
     .option('--aspect-ratio [ratio]', z.string().describe('Video aspect ratio in WIDTH:HEIGHT format (e.g. 16:9, 9:16)'))
     .option('--resolution [resolution]', z
     .string()
-    .describe('Video resolution in WIDTHxHEIGHT or provider format (e.g. 1280x720, 720p)'))
-    .option('--duration [seconds]', z.number().describe('Video duration in seconds (provider/model-specific limits apply)'))
+    .describe(`Video resolution. ${describeProviderValues('resolution', [VIDEO_CATALOG])}. Google: 720p, 1080p, 4k`))
+    .option('--duration [seconds]', z.number().describe('Video duration in seconds. Veo: 4-8s. xAI Grok: 1-15s. Kling: 5-10s. Wan: 2-15s'))
     .option('--fps [fps]', z.number().describe('Frames per second for video models that support fps override'))
     .option('--seed [seed]', z.number().describe('Seed for reproducible video generation (model support varies)'))
     .option('-i, --input [file]', z
     .string()
-    .describe('Optional reference image for image-to-video. Accepts local file path or URL (http/https)'))
+    .describe('Input file for video generation. For i2v: a reference image. For edit-video/extend-video: a source video. Accepts local file paths or URLs'))
+    .option('--mode [mode]', z
+    .enum(['edit-video', 'extend-video', 'reference-to-video'])
+    .describe(`Video operation mode. ${describeProviderValues('mode', [VIDEO_CATALOG])}`))
+    .option('--reference-images [path]', z
+    .array(z.string())
+    .describe('Reference images for R2V generation, repeatable, 1-7 files or URLs (xAI)'))
+    .option('--negative-prompt [text]', z
+    .string()
+    .describe('Describe what to avoid in the generated video (Fal models)'))
     .option('--json', 'Output result metadata as JSON to stdout (model, usage, warnings, file paths)')
     .option('--stdout', 'Write raw video bytes to stdout instead of saving to a file. Useful for piping to other tools')
     .example('# Generate a video')
@@ -291,8 +307,7 @@ cli
     .example('egaki video "waves crashing on cliffs" -n 2 -o waves.mp4')
     .action(async (prompt, options) => {
     injectCredentialsToEnv();
-    // Apply the same .default(...) values goke's input-type inference drops.
-    const model = options.model ?? DEFAULT_VIDEO_MODEL;
+    const model = options.model ?? await resolveVideoModel();
     const outputPath = options.output ?? 'egaki-output.mp4';
     const count = options.count ?? 1;
     const config = getModelConfig(model);
@@ -305,9 +320,34 @@ cli
         console.error(pc.dim(`Prompt: ${prompt}`));
         console.error(pc.dim('Mode: Video API (experimental_generateVideo)'));
     }
-    const inputImage = options.input
-        ? await readInputSource(options.input)
-        : undefined;
+    // Determine how --input is used based on --mode:
+    // - edit-video / extend-video: input is a source video, passed as videoUrl (needs URL)
+    // - everything else (i2v, t2v): input is a reference image, passed as bytes
+    const isVideoInputMode = options.mode === 'edit-video' || options.mode === 'extend-video';
+    // Validate mode-specific required inputs
+    if (isVideoInputMode && !options.input) {
+        console.error(pc.red(`--input is required with --mode ${options.mode}. Pass a local video file or URL.`));
+        process.exit(1);
+    }
+    if (options.mode === 'reference-to-video' && (!options.referenceImages || options.referenceImages.length === 0)) {
+        console.error(pc.red('--reference-images is required with --mode reference-to-video. Pass 1-7 image files or URLs.'));
+        process.exit(1);
+    }
+    let inputImage;
+    let videoUrl;
+    if (options.input && isVideoInputMode) {
+        // Upload local file or use URL directly for video editing/extension
+        videoUrl = await resolveToUrl(options.input);
+    }
+    else if (options.input) {
+        // Read as bytes for image-to-video
+        inputImage = await readInputSource(options.input);
+    }
+    // Resolve --reference-images: upload local files to get URLs
+    let resolvedReferenceImages = options.referenceImages;
+    if (resolvedReferenceImages) {
+        resolvedReferenceImages = await Promise.all(resolvedReferenceImages.map((ref) => resolveToUrl(ref)));
+    }
     await generateWithVideoModel({
         prompt,
         model,
@@ -319,6 +359,10 @@ cli
         fps: options.fps,
         seed: options.seed,
         inputImage,
+        mode: options.mode,
+        videoUrl,
+        referenceImages: resolvedReferenceImages,
+        negativePrompt: options.negativePrompt,
         json: options.json || false,
         stdout: options.stdout || false,
     });
@@ -336,13 +380,12 @@ cli
     .describe('Filter by model type: image (image+text-image), video, or all'))
     .option('--json', 'Output as JSON instead of YAML')
     .action(async (options) => {
-    const { CATALOG } = await import('./model-catalog.js');
     const yaml = await import('js-yaml');
     const providerStatuses = Object.fromEntries(Object.keys(PROVIDERS).map((provider) => [provider, getKeyStatus(provider)]));
     let models = options.type === 'video'
-        ? VIDEO_CATALOG
+        ? [...VIDEO_CATALOG]
         : options.type === 'image'
-            ? CATALOG
+            ? [...CATALOG]
             : [...CATALOG, ...VIDEO_CATALOG];
     if (options.provider) {
         models = models.filter((m) => m.provider === options.provider);
@@ -389,12 +432,269 @@ cli
         console.log(yaml.dump(output, { lineWidth: 120, noRefs: true }));
     }
 });
+/** Upload gateway base URL for temporary file uploads. */
+const UPLOAD_GATEWAY_BASE = 'https://egaki.org';
+/** Max upload size in bytes (must match gateway limit). */
+const MAX_UPLOAD_SIZE = 100 * 1024 * 1024;
 cli.help();
 cli.version(pkg.version);
-cli.parse();
+await cli.parse();
+async function runProviderCall(operation, call) {
+    const result = await call().catch((error) => {
+        printErrorDetails(error, operation);
+        process.exit(1);
+    });
+    return result;
+}
+function printErrorDetails(error, operation) {
+    const prefix = operation ? `${operation} failed` : 'Command failed';
+    console.error(pc.red(pc.bold(prefix)));
+    if (APICallError.isInstance(error)) {
+        printKeyValue('name', error.name);
+        printKeyValue('message', error.message);
+        printKeyValue('statusCode', error.statusCode);
+        printKeyValue('url', error.url);
+        printKeyValue('isRetryable', error.isRetryable);
+        printJsonBlock('responseBody', parseJsonLike(error.responseBody));
+        printJsonBlock('responseHeaders', error.responseHeaders);
+        printJsonBlock('requestBodyValues', error.requestBodyValues);
+        printJsonBlock('data', error.data);
+        printCause(error.cause);
+        printStack(error);
+        return;
+    }
+    if (NoImageGeneratedError.isInstance(error) || NoVideoGeneratedError.isInstance(error)) {
+        printKeyValue('name', error.name);
+        printKeyValue('message', error.message);
+        printJsonBlock('responses', error.responses);
+        printCause(error.cause);
+        printStack(error);
+        return;
+    }
+    if (RetryError.isInstance(error)) {
+        printKeyValue('name', error.name);
+        printKeyValue('message', error.message);
+        printKeyValue('reason', error.reason);
+        printJsonBlock('errors', error.errors.map((e) => serializeUnknown(e)));
+        printCause(error.cause);
+        printStack(error);
+        return;
+    }
+    if (error instanceof Error) {
+        printKeyValue('name', error.name);
+        printKeyValue('message', error.message);
+        printJsonBlock('details', serializeOwnProperties(error));
+        printCause(error.cause);
+        printStack(error);
+        return;
+    }
+    printJsonBlock('error', serializeUnknown(error));
+}
+function printKeyValue(key, value) {
+    if (value === undefined)
+        return;
+    console.error(`${pc.dim(`${key}:`)} ${String(value)}`);
+}
+function printJsonBlock(label, value) {
+    if (value === undefined)
+        return;
+    const serialized = stableStringify(value);
+    if (!serialized || serialized === '{}')
+        return;
+    console.error(pc.dim(`${label}:`));
+    console.error(serialized);
+}
+function printCause(cause) {
+    if (cause === undefined)
+        return;
+    console.error(pc.dim('cause:'));
+    console.error(stableStringify(serializeUnknown(cause)));
+}
+function printStack(error) {
+    if (!error.stack)
+        return;
+    console.error(pc.dim('stack:'));
+    console.error(pc.dim(error.stack));
+}
+function parseJsonLike(value) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function serializeUnknown(value) {
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            ...serializeOwnProperties(value),
+            ...(value.cause === undefined ? {} : { cause: serializeUnknown(value.cause) }),
+            ...(value.stack ? { stack: value.stack } : {}),
+        };
+    }
+    return value;
+}
+function serializeOwnProperties(error) {
+    return Object.fromEntries(Object.entries(error).map(([key, value]) => [key, serializeUnknown(value)]));
+}
+function stableStringify(value) {
+    const seen = new WeakSet();
+    return JSON.stringify(value, (_key, item) => {
+        if (typeof item === 'bigint')
+            return item.toString();
+        if (item instanceof Date)
+            return item.toISOString();
+        if (typeof item !== 'object' || item === null)
+            return item;
+        if (seen.has(item))
+            return '[Circular]';
+        seen.add(item);
+        return item;
+    }, 2);
+}
+// ─── interactive model pickers ──────────────────────────────────────────────
+/** Curated image models shown in the interactive picker, ordered by recommendation. */
+const FEATURED_IMAGE_MODELS = [
+    'imagen-4.0-generate-001',
+    'imagen-4.0-ultra-generate-001',
+    'imagen-4.0-fast-generate-001',
+    'gemini-2.5-flash-image',
+    'gemini-3.1-flash-image-preview',
+    'nano-banana-pro-preview',
+    'gpt-image-2',
+    'gpt-image-1.5',
+    'chatgpt-image-latest',
+    'flux-kontext-pro',
+    'flux-kontext-max',
+    'flux-pro-1.1-ultra',
+    'recraft-v4',
+    'dall-e-3',
+    'grok-imagine-image-pro',
+];
+/**
+ * Resolve the image model: show interactive picker in TTY, use default otherwise.
+ */
+async function resolveImageModel() {
+    const isTTY = process.stdin.isTTY && process.stderr.isTTY;
+    if (!isTTY)
+        return DEFAULT_MODEL;
+    const options = FEATURED_IMAGE_MODELS
+        .map((id) => CATALOG.find((m) => m.id === id))
+        .filter(Boolean)
+        .map((m) => {
+        const cost = m.cost.type === 'per-image'
+            ? pc.dim(`$${m.cost.perImage}/img`)
+            : m.cost.type === 'per-token'
+                ? pc.dim(`$${m.cost.outputPerM}/M out`)
+                : '';
+        return {
+            value: m.id,
+            label: `${m.name} ${cost}`,
+            hint: m.id,
+        };
+    });
+    const selected = await select({
+        message: 'Select an image model',
+        options,
+    });
+    if (isCancel(selected)) {
+        cancel('Cancelled.');
+        process.exit(0);
+    }
+    return selected;
+}
+/**
+ * Resolve the video model: show interactive picker in TTY, use default otherwise.
+ */
+async function resolveVideoModel() {
+    const isTTY = process.stdin.isTTY && process.stderr.isTTY;
+    if (!isTTY)
+        return DEFAULT_VIDEO_MODEL;
+    const options = VIDEO_CATALOG.map((m) => {
+        const dur = m.features.durationRangeSec
+            ? pc.dim(`${m.features.durationRangeSec.min}-${m.features.durationRangeSec.max}s`)
+            : '';
+        return {
+            value: m.id,
+            label: `${m.name} ${dur}`,
+            hint: m.id,
+        };
+    });
+    const selected = await select({
+        message: 'Select a video model',
+        options,
+    });
+    if (isCancel(selected)) {
+        cancel('Cancelled.');
+        process.exit(0);
+    }
+    return selected;
+}
 function isUrl(input) {
     return /^https?:\/\//i.test(input);
 }
+function mimeTypeFromExtension(ext) {
+    const map = {
+        '.mp4': 'video/mp4',
+        '.webm': 'video/webm',
+        '.mov': 'video/quicktime',
+        '.avi': 'video/x-msvideo',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.webp': 'image/webp',
+        '.gif': 'image/gif',
+    };
+    return map[ext.toLowerCase()] || 'application/octet-stream';
+}
+/**
+ * Upload a local file to the egaki gateway and return the public URL.
+ * Used when a flag that expects a URL receives a local file path instead.
+ */
+async function uploadFileToGateway(filePath) {
+    const resolved = path.resolve(filePath);
+    if (!fs.existsSync(resolved)) {
+        console.error(pc.red(`File not found: ${resolved}`));
+        process.exit(1);
+    }
+    const stat = fs.statSync(resolved);
+    if (stat.size > MAX_UPLOAD_SIZE) {
+        console.error(pc.red(`File too large: ${resolved} (${Math.round(stat.size / 1024 / 1024)}MB). Maximum is ${MAX_UPLOAD_SIZE / 1024 / 1024}MB`));
+        process.exit(1);
+    }
+    const ext = path.extname(resolved);
+    const contentType = mimeTypeFromExtension(ext);
+    const fileBytes = fs.readFileSync(resolved);
+    console.error(pc.dim(`Uploading ${filePath}...`));
+    const response = await fetch(`${UPLOAD_GATEWAY_BASE}/upload`, {
+        method: 'POST',
+        headers: { 'Content-Type': contentType },
+        body: fileBytes,
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        console.error(pc.red(`Upload failed: ${response.status} ${response.statusText}`));
+        if (body)
+            console.error(pc.dim(body));
+        process.exit(1);
+    }
+    const result = await response.json();
+    console.error(pc.dim(`Uploaded: ${result.url}`));
+    return result.url;
+}
+/**
+ * Resolve a value that should be a URL: if it's already a URL, return as-is.
+ * If it's a local file path, upload it to the gateway and return the public URL.
+ */
+async function resolveToUrl(input) {
+    if (isUrl(input))
+        return input;
+    return uploadFileToGateway(input);
+}
 async function readInputSource(input) {
     if (isUrl(input)) {
         console.error(pc.dim(`Fetching ${input}...`));
@@ -418,72 +718,159 @@ async function readInputImages(inputs) {
     }
     return Promise.all(inputs.map((f) => readInputSource(f)));
 }
+function buildImageProviderOptions(provider, opts) {
+    switch (provider) {
+        case 'google': {
+            const googleOpts = {
+                ...(opts.allowPeople ? { personGeneration: 'allow_all' } : {}),
+                ...(opts.aspectRatio ? { aspectRatio: opts.aspectRatio } : {}),
+            };
+            return { google: googleOpts };
+        }
+        case 'vertex': {
+            const vertexOpts = {
+                ...(opts.allowPeople ? { personGeneration: 'allow_all' } : {}),
+                ...(opts.negativePrompt ? { negativePrompt: opts.negativePrompt } : {}),
+            };
+            return { vertex: vertexOpts };
+        }
+        case 'xai': {
+            const xaiOpts = {
+                ...(opts.quality ? { quality: opts.quality } : {}),
+                ...(opts.resolution ? { resolution: opts.resolution } : {}),
+                ...(opts.outputFormat ? { output_format: opts.outputFormat } : {}),
+            };
+            return { xai: xaiOpts };
+        }
+        case 'openai': {
+            const openaiOpts = {
+                ...(opts.quality ? { quality: opts.quality } : {}),
+                ...(opts.outputFormat ? { outputFormat: opts.outputFormat } : {}),
+            };
+            return { openai: openaiOpts };
+        }
+        case 'fal': {
+            const falOpts = {
+                ...(opts.outputFormat ? { outputFormat: opts.outputFormat } : {}),
+                ...(opts.negativePrompt ? { negativePrompt: opts.negativePrompt } : {}),
+            };
+            return { fal: falOpts };
+        }
+        default:
+            // Providers routed through the gateway (bfl, recraft, etc.) pass options
+            // as-is since they don't have local SDK types.
+            return {};
+    }
+}
+function buildVideoProviderOptions(provider, opts) {
+    switch (provider) {
+        case 'xai': {
+            // xAI video modes are a discriminated union; build the correct variant.
+            const base = {
+                ...(opts.resolution ? { resolution: opts.resolution } : {}),
+            };
+            if (opts.mode === 'edit-video' && opts.videoUrl) {
+                const xaiOpts = { ...base, mode: 'edit-video', videoUrl: opts.videoUrl };
+                return { xai: xaiOpts };
+            }
+            if (opts.mode === 'extend-video' && opts.videoUrl) {
+                const xaiOpts = { ...base, mode: 'extend-video', videoUrl: opts.videoUrl };
+                return { xai: xaiOpts };
+            }
+            if (opts.mode === 'reference-to-video' && opts.referenceImages) {
+                const xaiOpts = { ...base, mode: 'reference-to-video', referenceImageUrls: opts.referenceImages };
+                return { xai: xaiOpts };
+            }
+            // Default: text-to-video or image-to-video (no mode)
+            if (Object.keys(base).length === 0)
+                return undefined;
+            const xaiOpts = { ...base };
+            return { xai: xaiOpts };
+        }
+        case 'fal': {
+            const falOpts = {
+                ...(opts.resolution ? { resolution: opts.resolution } : {}),
+                ...(opts.negativePrompt ? { negativePrompt: opts.negativePrompt } : {}),
+            };
+            if (Object.keys(falOpts).length === 0)
+                return undefined;
+            return { fal: falOpts };
+        }
+        case 'google': {
+            const googleOpts = {
+                ...(opts.negativePrompt ? { negativePrompt: opts.negativePrompt } : {}),
+            };
+            if (Object.keys(googleOpts).length === 0)
+                return undefined;
+            return { google: googleOpts };
+        }
+        case 'vertex': {
+            const vertexOpts = {
+                ...(opts.negativePrompt ? { negativePrompt: opts.negativePrompt } : {}),
+            };
+            if (Object.keys(vertexOpts).length === 0)
+                return undefined;
+            return { vertex: vertexOpts };
+        }
+        default:
+            return undefined;
+    }
+}
 // Generate using the dedicated generateImage API (Imagen models)
-async function generateWithImageModel({ prompt, model, outputPath, count, aspectRatio, seed, inputImages, maskImage, allowPeople, json, stdout, }) {
+async function generateWithImageModel({ prompt, model, outputPath, count, aspectRatio, seed, inputImages, maskImage, allowPeople, quality, resolution, outputFormat, negativePrompt, json, stdout, }) {
     // Build the prompt: plain string or multimodal with reference images
     const imagePrompt = inputImages.length > 0
         ? { text: prompt, images: inputImages, ...(maskImage ? { mask: maskImage } : {}) }
         : prompt;
     const config = getModelConfig(model);
     const imageModel = await createImageModel(model);
-    // Use the correct providerOptions key based on provider (google vs vertex)
-    const providerOptionsKey = config.provider === 'vertex' ? 'vertex' : 'google';
+    // Build type-safe provider options using the SDK types with `satisfies`.
+    // Each provider has its own shape; we switch on provider to get compile-time safety.
+    const providerOptions = buildImageProviderOptions(config.provider, {
+        aspectRatio,
+        allowPeople,
+        quality,
+        resolution,
+        outputFormat,
+        negativePrompt,
+    });
     if (!stdout) {
         console.error(pc.cyan('Generating...'));
     }
-    const result = await aiGenerateImage({
+    const result = await runProviderCall('Image generation', () => aiGenerateImage({
         model: imageModel,
         prompt: imagePrompt,
         n: count,
         ...(aspectRatio ? { aspectRatio } : {}),
         ...(seed !== undefined ? { seed } : {}),
-        providerOptions: {
-            [providerOptionsKey]: {
-                ...(allowPeople ? { personGeneration: 'allow_all' } : {}),
-                ...(aspectRatio ? { aspectRatio } : {}),
-            },
-        },
-    });
+        providerOptions,
+    }));
+    const files = result.images.map((img) => ({
+        uint8Array: img.uint8Array,
+        mediaType: img.mediaType,
+    }));
     if (stdout) {
-        // Write first image to stdout for piping
-        const image = result.images[0];
-        if (image) {
-            process.stdout.write(Buffer.from(image.uint8Array));
-        }
+        writeFirstToStdout(files);
         return;
     }
-    const savedFiles = [];
-    for (let i = 0; i < result.images.length; i++) {
-        const image = result.images[i];
-        const ext = extensionFromMediaType(image.mediaType);
-        const filePath = result.images.length === 1
-            ? ensureExtension(outputPath, ext)
-            : insertIndex(outputPath, i, ext);
-        fs.writeFileSync(filePath, image.uint8Array);
-        console.error(pc.green(`Saved: ${filePath}`));
-        savedFiles.push(filePath);
-    }
+    const savedFiles = saveGeneratedFiles(files, outputPath);
     const cost = calculateCost(config.cost, result.usage, result.images.length);
-    if (cost != null) {
-        console.error(pc.dim(`Cost: ${formatCost(cost)}`));
-    }
+    printCost(cost);
     if (json) {
-        const output = {
+        console.log(JSON.stringify({
             model,
             files: savedFiles,
             count: result.images.length,
             cost,
             usage: result.usage,
             warnings: result.warnings,
-        };
-        console.log(JSON.stringify(output, null, 2));
+        }, null, 2));
     }
 }
 // Generate using generateText with responseModalities (Gemini multimodal models)
 async function generateWithTextModel({ prompt, model, outputPath, inputImages, imageSize, aspectRatio, json, stdout, }) {
     const textModel = await createTextModel(model);
     const config = getModelConfig(model);
-    const providerOptionsKey = config.provider === 'vertex' ? 'vertex' : 'google';
     if (!stdout) {
         console.error(pc.cyan('Generating...'));
     }
@@ -502,65 +889,49 @@ async function generateWithTextModel({ prompt, model, outputPath, inputImages, i
             },
         ]
         : undefined;
-    const result = await generateText({
+    const googleOpts = {
+        responseModalities: ['TEXT', 'IMAGE'],
+        ...(imageSize || aspectRatio
+            ? {
+                imageConfig: {
+                    ...(imageSize ? { imageSize } : {}),
+                    ...(aspectRatio ? { aspectRatio: aspectRatio } : {}),
+                },
+            }
+            : {}),
+    };
+    const providerOptionsKey = config.provider === 'vertex' ? 'vertex' : 'google';
+    const result = await runProviderCall('Text/image generation', () => generateText({
         model: textModel,
         ...(messages ? { messages } : { prompt }),
         providerOptions: {
-            [providerOptionsKey]: {
-                responseModalities: ['TEXT', 'IMAGE'],
-                ...(imageSize || aspectRatio
-                    ? {
-                        imageConfig: {
-                            ...(imageSize ? { imageSize } : {}),
-                            ...(aspectRatio ? { aspectRatio } : {}),
-                        },
-                    }
-                    : {}),
-            },
+            [providerOptionsKey]: googleOpts,
         },
-    });
-    const imageFiles = result.files.filter((f) => {
-        return f.mediaType.startsWith('image/');
-    });
+    }));
+    const imageFiles = result.files.filter((f) => f.mediaType.startsWith('image/'));
     if (imageFiles.length === 0) {
         console.error(pc.red('No images generated.'));
         process.exit(1);
     }
     if (stdout) {
-        const file = imageFiles[0];
-        if (file) {
-            process.stdout.write(Buffer.from(file.uint8Array));
-        }
+        writeFirstToStdout(imageFiles);
         return;
     }
-    const savedFiles = [];
-    for (let i = 0; i < imageFiles.length; i++) {
-        const file = imageFiles[i];
-        const ext = extensionFromMediaType(file.mediaType);
-        const filePath = imageFiles.length === 1
-            ? ensureExtension(outputPath, ext)
-            : insertIndex(outputPath, i, ext);
-        fs.writeFileSync(filePath, file.uint8Array);
-        console.error(pc.green(`Saved: ${filePath}`));
-        savedFiles.push(filePath);
-    }
+    const savedFiles = saveGeneratedFiles(imageFiles, outputPath);
     const cost = calculateCost(config.cost, result.usage, imageFiles.length);
-    if (cost != null) {
-        console.error(pc.dim(`Cost: ${formatCost(cost)}`));
-    }
+    printCost(cost);
     if (result.text && !json) {
         console.error(pc.dim(result.text));
     }
     if (json) {
-        const output = {
+        console.log(JSON.stringify({
             model,
             files: savedFiles,
             count: imageFiles.length,
             text: result.text || null,
             cost,
             usage: result.usage,
-        };
-        console.log(JSON.stringify(output, null, 2));
+        }, null, 2));
     }
 }
 // Generate using the OpenAI Responses API with imageGeneration tool.
@@ -706,12 +1077,28 @@ async function generateWithResponsesApi({ prompt, model, outputPath, count, aspe
     }
 }
 // Generate using experimental_generateVideo (video models)
-async function generateWithVideoModel({ prompt, model, outputPath, count, aspectRatio, resolution, duration, fps, seed, inputImage, json, stdout, }) {
+async function generateWithVideoModel({ prompt, model, outputPath, count, aspectRatio, resolution, duration, fps, seed, inputImage, mode, videoUrl, referenceImages, negativePrompt, json, stdout, }) {
     const videoModel = await createVideoModel(model);
+    const config = getModelConfig(model);
+    // Validate that the model supports video-url input before building options.
+    // Only models with a 'video-url' providerOption (currently xAI) accept edit/extend mode.
+    if (videoUrl && !config.providerOptions?.some((opt) => opt.flag === 'video-url')) {
+        console.error(pc.red(`Model ${model} does not support video URL input for editing/extension`));
+        process.exit(1);
+    }
+    // Build type-safe provider options for video generation.
+    const providerOptions = buildVideoProviderOptions(config.provider, {
+        resolution,
+        mode,
+        videoUrl,
+        referenceImages,
+        negativePrompt,
+        model,
+    });
     if (!stdout) {
         console.error(pc.cyan('Generating...'));
     }
-    const result = await aiGenerateVideo({
+    const result = await runProviderCall('Video generation', () => aiGenerateVideo({
         model: videoModel,
         prompt: inputImage
             ? { image: inputImage, text: prompt }
@@ -722,44 +1109,67 @@ async function generateWithVideoModel({ prompt, model, outputPath, count, aspect
         ...(duration != null ? { duration } : {}),
         ...(fps != null ? { fps } : {}),
         ...(seed != null ? { seed } : {}),
-    });
+        ...(providerOptions ? { providerOptions } : {}),
+    }));
+    const files = result.videos.map((v) => ({
+        uint8Array: v.uint8Array,
+        mediaType: v.mediaType,
+    }));
     if (stdout) {
-        const video = result.videos[0];
-        if (video) {
-            process.stdout.write(Buffer.from(video.uint8Array));
-        }
+        writeFirstToStdout(files);
         return;
     }
-    const savedFiles = [];
-    for (let i = 0; i < result.videos.length; i++) {
-        const video = result.videos[i];
-        const ext = extensionFromMediaType(video.mediaType);
-        const filePath = result.videos.length === 1
-            ? ensureExtension(outputPath, ext)
-            : insertIndex(outputPath, i, ext);
-        fs.writeFileSync(filePath, video.uint8Array);
-        console.error(pc.green(`Saved: ${filePath}`));
-        savedFiles.push(filePath);
-    }
-    const config = getModelConfig(model);
+    const savedFiles = saveGeneratedFiles(files, outputPath);
     const cost = calculateCost(config.cost, {
         videosGenerated: result.videos.length,
         durationSeconds: duration,
         resolution,
     }, result.videos.length);
-    if (cost != null) {
-        console.error(pc.dim(`Cost: ${formatCost(cost)}`));
-    }
+    printCost(cost);
     if (json) {
-        const output = {
+        console.log(JSON.stringify({
             model,
             files: savedFiles,
             count: result.videos.length,
             cost,
             warnings: result.warnings,
             responses: result.responses,
-        };
-        console.log(JSON.stringify(output, null, 2));
+        }, null, 2));
+    }
+}
+/**
+ * Save generated files to disk. Returns the list of saved file paths.
+ * Handles single vs multi-file naming with index suffixes.
+ */
+function saveGeneratedFiles(files, outputPath) {
+    const savedFiles = [];
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const ext = extensionFromMediaType(file.mediaType);
+        const filePath = files.length === 1
+            ? ensureExtension(outputPath, ext)
+            : insertIndex(outputPath, i, ext);
+        fs.writeFileSync(filePath, file.uint8Array);
+        console.error(pc.green(`Saved: ${filePath}`));
+        savedFiles.push(filePath);
+    }
+    return savedFiles;
+}
+/**
+ * Print estimated cost to stderr if calculable.
+ */
+function printCost(cost) {
+    if (cost != null) {
+        console.error(pc.dim(`Cost: ${formatCost(cost)}`));
+    }
+}
+/**
+ * Write the first file's raw bytes to stdout (for piping to other tools).
+ */
+function writeFirstToStdout(files) {
+    const file = files[0];
+    if (file) {
+        process.stdout.write(Buffer.from(file.uint8Array));
     }
 }
 // ─── cost helpers ────────────────────────────────────────────────────────────