egaki 0.6.0 → 0.7.0

package/dist/cli/generate.js

@@ -0,0 +1,604 @@
+// Programmatic API for egaki image and video generation.
+// Returns Error | Result (errore style) instead of process.exit/console.error.
+//
+// Two variants for each function:
+//   - `generateImage(opts)` — cached, writes to public/generated/, returns { src: string }
+//   - `generateImageUncached(opts)` — raw, returns bytes in GenerateImageResult
+//
+// The CLI uses *Uncached variants. The cached variants are for the Vite MDX
+// video framework and .server.tsx components.
+//
+// Usage:
+//   import { generateImage, generateImageUncached } from 'egaki/generate'
+//   const cached = await generateImage({ prompt: 'a sunset' })
+//   if (!(cached instanceof Error)) cached.src // '/generated/image/sunset-a1b2c3d4.png'
+//   const raw = await generateImageUncached({ prompt: 'a sunset' })
+//   if (!(raw instanceof Error)) raw.images[0].uint8Array // raw bytes
+import { generateImage as aiGenerateImage, generateText, experimental_generateVideo as aiGenerateVideo, } from 'ai';
+import { createParser } from 'eventsource-parser';
+import { injectCredentialsToEnv, getChatGptAuth, saveChatGptAuth, } from './credentials.js';
+import { getModelConfig, createImageModel, createTextModel, createVideoModel, shouldUseResponsesApi, DEFAULT_MODEL, DEFAULT_VIDEO_MODEL, ValidationError, } from './models.js';
+export { ValidationError };
+import { getValidChatGptAuth } from './chatgpt-auth.js';
+export 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:
+            return {};
+    }
+}
+export function buildVideoProviderOptions(provider, opts) {
+    switch (provider) {
+        case 'xai': {
+            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 };
+            }
+            if (Object.keys(base).length === 0)
+                return undefined;
+            const xaiOpts = { ...base };
+            return { xai: xaiOpts };
+        }
+        case 'bytedance': {
+            const bytedanceOpts = {
+                ...(opts.resolution ? { resolution: opts.resolution } : {}),
+                ...(opts.referenceImages ? { referenceImages: opts.referenceImages } : {}),
+            };
+            if (Object.keys(bytedanceOpts).length === 0)
+                return undefined;
+            return { bytedance: bytedanceOpts };
+        }
+        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;
+    }
+}
+// ─── cost calculation ────────────────────────────────────────────────────────
+export function calculateCost(cost, usage, count = 1) {
+    if (cost.type === 'per-image') {
+        return cost.perImage * count;
+    }
+    if (cost.type === 'per-token' && usage.inputTokens != null && usage.outputTokens != null) {
+        return ((usage.inputTokens * cost.inputPerM + usage.outputTokens * cost.outputPerM) / 1_000_000);
+    }
+    if (cost.type === 'per-video-second') {
+        const durationSec = usage.durationSeconds ?? cost.defaultDurationSec;
+        const resolution = normalizeResolutionKey(usage.resolution);
+        const hasVideoInput = usage.hasVideoInput ?? false;
+        const tier = cost.tiers.find((t) => normalizeResolutionKey(t.resolution) === resolution &&
+            (t.hasVideoInput == null || t.hasVideoInput === hasVideoInput)) ??
+            cost.tiers.find((t) => normalizeResolutionKey(t.resolution) === resolution) ??
+            cost.tiers[0];
+        if (!tier) {
+            return null;
+        }
+        return tier.costPerSecond * durationSec * count;
+    }
+    return null;
+}
+function normalizeResolutionKey(input) {
+    if (!input)
+        return undefined;
+    const normalized = input.trim().toLowerCase();
+    if (normalized === '1920x1080')
+        return '1080p';
+    if (normalized === '1280x720')
+        return '720p';
+    if (normalized === '854x480' || normalized === '848x480')
+        return '480p';
+    return normalized;
+}
+// ─── image byte helpers ──────────────────────────────────────────────────────
+function inferImageMediaType(image) {
+    if (image.length >= 8 && image[0] === 0x89 && image[1] === 0x50 && image[2] === 0x4e && image[3] === 0x47) {
+        return 'image/png';
+    }
+    if (image.length >= 3 && image[0] === 0xff && image[1] === 0xd8 && image[2] === 0xff) {
+        return 'image/jpeg';
+    }
+    if (image.length >= 12 &&
+        image[0] === 0x52 && image[1] === 0x49 && image[2] === 0x46 && image[3] === 0x46 &&
+        image[8] === 0x57 && image[9] === 0x45 && image[10] === 0x42 && image[11] === 0x50) {
+        return 'image/webp';
+    }
+    if (image.length >= 6 &&
+        image[0] === 0x47 && image[1] === 0x49 && image[2] === 0x46 && image[3] === 0x38) {
+        return 'image/gif';
+    }
+    return 'image/png';
+}
+function imageBytesToDataUrl(image) {
+    const mediaType = inferImageMediaType(image);
+    return `data:${mediaType};base64,${Buffer.from(image).toString('base64')}`;
+}
+function chatGptImageSizeFromAspectRatio(aspectRatio) {
+    switch (aspectRatio) {
+        case '1:1':
+            return '1024x1024';
+        case '3:2':
+            return '1536x1024';
+        case '2:3':
+            return '1024x1536';
+        default:
+            return undefined;
+    }
+}
+function isAspectRatio(input) {
+    return /^\d+:\d+$/.test(input);
+}
+/** Convert any thrown value into an Error instance. */
+function toError(err) {
+    if (err instanceof Error)
+        return err;
+    return new Error(String(err));
+}
+// ─── generateImage ───────────────────────────────────────────────────────────
+/**
+ * Generate images from a text prompt. Auto-detects which generation strategy
+ * to use (image API, text model, or ChatGPT Responses API) based on model ID.
+ * Shares credentials and subscription with the CLI.
+ */
+export async function generateImageUncached(opts) {
+    injectCredentialsToEnv();
+    const model = opts.model ?? DEFAULT_MODEL;
+    const count = opts.count ?? 1;
+    const config = getModelConfig(model);
+    if (config instanceof Error)
+        return config;
+    const parsedAspectRatio = opts.aspectRatio && isAspectRatio(opts.aspectRatio)
+        ? opts.aspectRatio
+        : undefined;
+    const inputImages = opts.inputImages ?? [];
+    // ChatGPT OAuth + OpenAI image models → Responses API path
+    const useResponsesApi = config.strategy === 'image' && shouldUseResponsesApi(model);
+    if (useResponsesApi) {
+        return generateWithResponsesApi({
+            prompt: opts.prompt,
+            model,
+            count,
+            aspectRatio: parsedAspectRatio,
+            seed: opts.seed,
+            maskImage: opts.maskImage,
+            inputImages,
+        });
+    }
+    if (config.strategy === 'image') {
+        return generateWithImageModel({
+            prompt: opts.prompt,
+            model,
+            count,
+            aspectRatio: parsedAspectRatio,
+            seed: opts.seed,
+            inputImages,
+            maskImage: opts.maskImage,
+            allowPeople: opts.allowPeople ?? false,
+            quality: opts.quality,
+            resolution: opts.resolution,
+            outputFormat: opts.outputFormat,
+            negativePrompt: opts.negativePrompt,
+        });
+    }
+    // Text model path (Gemini multimodal)
+    return generateWithTextModelPath({
+        prompt: opts.prompt,
+        model,
+        inputImages,
+        imageSize: opts.imageSize,
+        aspectRatio: opts.aspectRatio,
+    });
+}
+// ─── generateVideo ───────────────────────────────────────────────────────────
+/**
+ * Generate videos from a text prompt (or image+text for i2v models).
+ * Shares credentials and subscription with the CLI.
+ */
+export async function generateVideoUncached(opts) {
+    injectCredentialsToEnv();
+    const model = opts.model ?? DEFAULT_VIDEO_MODEL;
+    const count = opts.count ?? 1;
+    const config = getModelConfig(model);
+    if (config instanceof Error)
+        return config;
+    if (config.strategy !== 'video') {
+        return new ValidationError(`Model ${model} is not a video model`);
+    }
+    const isVideoInputMode = opts.mode === 'edit-video' || opts.mode === 'extend-video';
+    // Validate mode-specific required inputs
+    if (isVideoInputMode && !opts.videoUrl) {
+        return new ValidationError(`videoUrl is required with mode ${opts.mode}`);
+    }
+    if (opts.mode === 'reference-to-video' && (!opts.referenceImages || opts.referenceImages.length === 0)) {
+        return new ValidationError('referenceImages is required with mode reference-to-video');
+    }
+    if (opts.referenceImages?.length && !config.providerOptions?.some((opt) => opt.flag === 'reference-images')) {
+        return new ValidationError(`Model ${model} does not support referenceImages`);
+    }
+    if (opts.videoUrl && !config.providerOptions?.some((opt) => opt.flag === 'video-url')) {
+        return new ValidationError(`Model ${model} does not support video URL input for editing/extension`);
+    }
+    const videoModel = await createVideoModel(model);
+    if (videoModel instanceof Error)
+        return videoModel;
+    const providerOptions = buildVideoProviderOptions(config.provider, {
+        resolution: opts.resolution,
+        mode: opts.mode,
+        videoUrl: opts.videoUrl,
+        referenceImages: opts.referenceImages,
+        negativePrompt: opts.negativePrompt,
+        model,
+    });
+    let result;
+    try {
+        result = await aiGenerateVideo({
+            model: videoModel,
+            prompt: opts.inputImage
+                ? { image: opts.inputImage, text: opts.prompt }
+                : opts.prompt,
+            n: count,
+            ...(opts.aspectRatio ? { aspectRatio: opts.aspectRatio } : {}),
+            ...(opts.resolution ? { resolution: opts.resolution } : {}),
+            ...(opts.duration != null ? { duration: opts.duration } : {}),
+            ...(opts.fps != null ? { fps: opts.fps } : {}),
+            ...(opts.seed != null ? { seed: opts.seed } : {}),
+            ...(providerOptions ? { providerOptions } : {}),
+        });
+    }
+    catch (err) {
+        return toError(err);
+    }
+    const videos = result.videos.map((v) => ({
+        uint8Array: v.uint8Array,
+        mediaType: v.mediaType,
+    }));
+    const cost = calculateCost(config.cost, {
+        videosGenerated: result.videos.length,
+        durationSeconds: opts.duration,
+        resolution: opts.resolution,
+        hasVideoInput: Boolean(opts.inputImage || opts.videoUrl || opts.referenceImages?.length),
+    }, result.videos.length);
+    return {
+        videos,
+        model,
+        cost,
+        warnings: result.warnings,
+        responses: result.responses,
+    };
+}
+// ─── internal generation paths ───────────────────────────────────────────────
+async function generateWithImageModel(opts) {
+    const imagePrompt = opts.inputImages.length > 0
+        ? { text: opts.prompt, images: opts.inputImages, ...(opts.maskImage ? { mask: opts.maskImage } : {}) }
+        : opts.prompt;
+    const config = getModelConfig(opts.model);
+    if (config instanceof Error)
+        return config;
+    const imageModel = await createImageModel(opts.model);
+    if (imageModel instanceof Error)
+        return imageModel;
+    const providerOptions = buildImageProviderOptions(config.provider, {
+        aspectRatio: opts.aspectRatio,
+        allowPeople: opts.allowPeople,
+        quality: opts.quality,
+        resolution: opts.resolution,
+        outputFormat: opts.outputFormat,
+        negativePrompt: opts.negativePrompt,
+    });
+    let result;
+    try {
+        result = await aiGenerateImage({
+            model: imageModel,
+            prompt: imagePrompt,
+            n: opts.count,
+            ...(opts.aspectRatio ? { aspectRatio: opts.aspectRatio } : {}),
+            ...(opts.seed !== undefined ? { seed: opts.seed } : {}),
+            providerOptions,
+        });
+    }
+    catch (err) {
+        return toError(err);
+    }
+    const images = result.images.map((img) => ({
+        uint8Array: img.uint8Array,
+        mediaType: img.mediaType,
+    }));
+    const cost = calculateCost(config.cost, result.usage, result.images.length);
+    return {
+        images,
+        model: opts.model,
+        cost,
+        usage: result.usage,
+        warnings: result.warnings,
+    };
+}
+async function generateWithTextModelPath(opts) {
+    const textModel = await createTextModel(opts.model);
+    if (textModel instanceof Error)
+        return textModel;
+    const config = getModelConfig(opts.model);
+    if (config instanceof Error)
+        return config;
+    const messages = opts.inputImages.length > 0
+        ? [
+            {
+                role: 'user',
+                content: [
+                    { type: 'text', text: opts.prompt },
+                    ...opts.inputImages.map((img) => ({
+                        type: 'image',
+                        image: img,
+                    })),
+                ],
+            },
+        ]
+        : undefined;
+    const googleOpts = {
+        responseModalities: ['TEXT', 'IMAGE'],
+        ...(opts.imageSize || opts.aspectRatio
+            ? {
+                imageConfig: {
+                    ...(opts.imageSize ? { imageSize: opts.imageSize } : {}),
+                    ...(opts.aspectRatio ? { aspectRatio: opts.aspectRatio } : {}),
+                },
+            }
+            : {}),
+    };
+    const providerOptionsKey = config.provider === 'vertex' ? 'vertex' : 'google';
+    let result;
+    try {
+        result = await generateText({
+            model: textModel,
+            ...(messages ? { messages } : { prompt: opts.prompt }),
+            providerOptions: {
+                [providerOptionsKey]: googleOpts,
+            },
+        });
+    }
+    catch (err) {
+        return toError(err);
+    }
+    const imageFiles = result.files.filter((f) => f.mediaType.startsWith('image/'));
+    if (imageFiles.length === 0) {
+        return new Error('No images generated by the text model.');
+    }
+    const images = imageFiles.map((f) => ({
+        uint8Array: f.uint8Array,
+        mediaType: f.mediaType,
+    }));
+    const cost = calculateCost(config.cost, result.usage, imageFiles.length);
+    return {
+        images,
+        model: opts.model,
+        cost,
+        usage: result.usage,
+        text: result.text || undefined,
+    };
+}
+async function generateWithResponsesApi(opts) {
+    if (opts.count !== 1) {
+        return new ValidationError('ChatGPT image generation currently supports exactly one output image.');
+    }
+    if (opts.seed !== undefined) {
+        return new ValidationError('ChatGPT image generation does not support seed.');
+    }
+    if (opts.maskImage) {
+        return new ValidationError('ChatGPT image generation does not support mask yet.');
+    }
+    const size = opts.aspectRatio ? chatGptImageSizeFromAspectRatio(opts.aspectRatio) : undefined;
+    if (opts.aspectRatio && !size) {
+        return new ValidationError('ChatGPT image generation only supports aspect ratios 1:1, 3:2, or 2:3.');
+    }
+    const storedAuth = getChatGptAuth();
+    if (!storedAuth?.accountId) {
+        return new ValidationError('Missing ChatGPT account metadata. Please run `egaki login --provider chatgpt` again.');
+    }
+    const auth = await getValidChatGptAuth(storedAuth, saveChatGptAuth);
+    if (auth instanceof Error)
+        return auth;
+    const content = [
+        { type: 'input_text', text: opts.prompt },
+        ...opts.inputImages.map((image) => ({
+            type: 'input_image',
+            image_url: imageBytesToDataUrl(image),
+        })),
+    ];
+    let response;
+    try {
+        response = await fetch('https://chatgpt.com/backend-api/codex/responses', {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${auth.access}`,
+                ...(auth.accountId && { 'ChatGPT-Account-ID': auth.accountId }),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: 'gpt-5.4',
+                instructions: 'You are Codex.',
+                input: [
+                    {
+                        type: 'message',
+                        role: 'user',
+                        content,
+                    },
+                ],
+                tools: [
+                    {
+                        type: 'image_generation',
+                        model: opts.model,
+                        size: 'auto',
+                        quality: 'auto',
+                        output_format: 'png',
+                        output_compression: 100,
+                        moderation: 'auto',
+                        ...(size ? { size } : {}),
+                    },
+                ],
+                tool_choice: 'auto',
+                parallel_tool_calls: true,
+                stream: true,
+                store: false,
+                include: [],
+            }),
+        });
+    }
+    catch (err) {
+        return toError(err);
+    }
+    if (!response.ok || !response.body) {
+        const body = await response.text().catch(() => '');
+        return new Error(`ChatGPT image generation failed: ${response.status}${body ? ` ${body}` : ''}`);
+    }
+    let imageBase64;
+    let revisedPrompt = null;
+    const parser = createParser({
+        onEvent: (message) => {
+            if (!message.data)
+                return;
+            try {
+                const event = JSON.parse(message.data);
+                if (event.type === 'response.image_generation_call.partial_image' &&
+                    event.partial_image_b64 &&
+                    !imageBase64) {
+                    imageBase64 = event.partial_image_b64;
+                }
+                if (event.type === 'response.output_item.done' &&
+                    event.item?.type === 'image_generation_call') {
+                    if (event.item.result)
+                        imageBase64 = event.item.result;
+                    revisedPrompt = event.item.revised_prompt ?? revisedPrompt;
+                }
+            }
+            catch {
+                // Ignore keepalive and partial parse noise.
+            }
+        },
+    });
+    const decoder = new TextDecoder();
+    for await (const chunk of response.body) {
+        parser.feed(decoder.decode(chunk, { stream: true }));
+    }
+    parser.feed(decoder.decode());
+    if (!imageBase64) {
+        return new Error('No images generated by ChatGPT.');
+    }
+    const imageBytes = new Uint8Array(Buffer.from(imageBase64, 'base64'));
+    return {
+        images: [{ uint8Array: imageBytes, mediaType: 'image/png' }],
+        model: opts.model,
+        cost: null,
+        revisedPrompt,
+    };
+}
+// ─── cached generateImage ───────────────────────────────────────────────────
+import { cachedGenerate } from './cached-generate.js';
+import { extensionFromMediaType } from './cache-utils.js';
+export const generateImage = cachedGenerate({
+    namespace: 'image',
+    prefixFrom: (p) => p.prompt,
+    modelFrom: (p) => p.model,
+    generate: async (params) => {
+        const result = await generateImageUncached(params);
+        if (result instanceof Error)
+            throw result;
+        const file = result.images[0];
+        if (!file)
+            throw new Error('No image generated');
+        return file;
+    },
+    serialize: (file) => ({
+        bytes: file.uint8Array,
+        extension: extensionFromMediaType(file.mediaType),
+    }),
+});
+// ─── cached generateVideo ───────────────────────────────────────────────────
+export const generateVideo = cachedGenerate({
+    namespace: 'video',
+    prefixFrom: (p) => p.prompt,
+    modelFrom: (p) => p.model,
+    generate: async (params) => {
+        const result = await generateVideoUncached(params);
+        if (result instanceof Error)
+            throw result;
+        const file = result.videos[0];
+        if (!file)
+            throw new Error('No video generated');
+        return file;
+    },
+    serialize: (file) => ({
+        bytes: file.uint8Array,
+        extension: extensionFromMediaType(file.mediaType),
+    }),
+});
+// ─── re-export speech generation ─────────────────────────────────────────────
+export { generateSpeech, generateSpeechUncached, calculateSpeechCost, } from './speech-generate.js';
+// ─── re-export transcription ─────────────────────────────────────────────────
+export { transcribeAudio, transcribeAudioUncached, calculateTranscriptionCost, segmentsToWordTimestamps, wordTimestampsToCaptions, } from './transcription-generate.js';

package/dist/cli/generate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate.test.d.ts.map

package/dist/cli/generate.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.test.d.ts","sourceRoot":"","sources":["../../src/cli/generate.test.ts"],"names":[],"mappings":""}