egaki 0.0.2 → 0.1.0

package/dist/antigravity-image.js

@@ -0,0 +1,285 @@
+// Antigravity image generation bridge for egaki.
+// Handles direct Antigravity OAuth requests without provider fallback.
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import pc from 'picocolors';
+import { getAntigravityAuth, saveAntigravityAuth } from './credentials.js';
+import { getValidAntigravityAccessToken } from './antigravity-auth.js';
+export async function generateWithAntigravityModel({ prompt, model, outputPath, inputImages, aspectRatio, count, json, stdout, }) {
+    const auth = getAntigravityAuth();
+    if (!auth) {
+        console.error(pc.red('Missing Antigravity OAuth login. Run: egaki login --provider antigravity'));
+        process.exit(1);
+    }
+    const token = await getValidAntigravityAccessToken(auth, (updated) => {
+        saveAntigravityAuth(updated);
+    });
+    if (token instanceof Error) {
+        console.error(pc.red(token.message));
+        process.exit(1);
+    }
+    if (!stdout) {
+        console.error(pc.cyan('Generating...'));
+    }
+    const actualModel = resolveAntigravityModel(model);
+    const projectCandidates = [
+        process.env['ANTIGRAVITY_PROJECT_ID'],
+        token.projectId,
+        ...getGcloudProjectIds(),
+    ].filter((value, index, array) => {
+        return Boolean(value) && array.indexOf(value) === index;
+    });
+    const userParts = [{ text: prompt }];
+    for (const image of inputImages) {
+        userParts.push({
+            inlineData: {
+                mimeType: detectImageMimeType(image),
+                data: Buffer.from(image).toString('base64'),
+            },
+        });
+    }
+    const baseRequest = {
+        sessionId: `egaki-${crypto.randomUUID()}`,
+        systemInstruction: {
+            role: 'user',
+            parts: [{ text: 'You are an AI image generator. Generate images based on user descriptions.' }],
+        },
+        contents: [
+            {
+                role: 'user',
+                parts: userParts,
+            },
+        ],
+        generationConfig: {
+            candidateCount: count,
+            imageConfig: {
+                aspectRatio: aspectRatio || '1:1',
+            },
+        },
+        safetySettings: [
+            { category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_ONLY_HIGH' },
+            { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_ONLY_HIGH' },
+            { category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_ONLY_HIGH' },
+            { category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_ONLY_HIGH' },
+        ],
+    };
+    const antigravityAttempts = projectCandidates.map((projectId) => {
+        return {
+            mode: `antigravity:${projectId}`,
+            endpoints: [
+                'https://daily-cloudcode-pa.sandbox.googleapis.com',
+                'https://autopush-cloudcode-pa.sandbox.googleapis.com',
+                'https://cloudcode-pa.googleapis.com',
+            ],
+            payload: {
+                project: projectId,
+                model: actualModel,
+                requestType: 'agent',
+                userAgent: 'antigravity',
+                requestId: `agent-${crypto.randomUUID()}`,
+                request: baseRequest,
+            },
+        };
+    });
+    const attemptConfigs = antigravityAttempts;
+    let lastError = 'Unknown Antigravity API error';
+    let responseBody;
+    let successfulProjectId;
+    for (const attempt of attemptConfigs) {
+        for (const endpoint of attempt.endpoints) {
+            const response = await fetch(`${endpoint}/v1internal:generateContent`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${token.accessToken}`,
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'google-api-nodejs-client/9.15.1',
+                    'X-Goog-Api-Client': 'gl-node/22.17.0',
+                    'Client-Metadata': 'ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI',
+                },
+                body: JSON.stringify(attempt.payload),
+            });
+            const text = await response.text();
+            if (!response.ok) {
+                lastError = formatAntigravityError({
+                    mode: attempt.mode,
+                    status: response.status,
+                    bodyText: text,
+                });
+                continue;
+            }
+            responseBody = JSON.parse(text);
+            if (typeof attempt.payload.project === 'string' && attempt.payload.project.length > 0) {
+                successfulProjectId = attempt.payload.project;
+            }
+            break;
+        }
+        if (responseBody) {
+            break;
+        }
+    }
+    if (!responseBody) {
+        console.error(pc.red(lastError));
+        process.exit(1);
+    }
+    if (successfulProjectId && successfulProjectId !== auth.projectId) {
+        saveAntigravityAuth({ ...auth, projectId: successfulProjectId });
+    }
+    const generatedImages = extractAntigravityImages(responseBody);
+    if (generatedImages.length === 0) {
+        console.error(pc.red('No images generated by Antigravity response'));
+        process.exit(1);
+    }
+    if (stdout) {
+        process.stdout.write(generatedImages[0].bytes);
+        return;
+    }
+    const savedFiles = [];
+    for (let i = 0; i < generatedImages.length; i++) {
+        const generated = generatedImages[i];
+        const filePath = generatedImages.length === 1
+            ? ensureExtension(outputPath, extensionFromMediaType(generated.mediaType))
+            : insertIndex(outputPath, i, extensionFromMediaType(generated.mediaType));
+        fs.writeFileSync(filePath, generated.bytes);
+        console.error(pc.green(`Saved: ${filePath}`));
+        savedFiles.push(filePath);
+    }
+    if (json) {
+        console.log(JSON.stringify({
+            model,
+            files: savedFiles,
+            count: savedFiles.length,
+            provider: 'antigravity',
+            projectId: token.projectId,
+        }, null, 2));
+    }
+}
+function resolveAntigravityModel(modelId) {
+    if (modelId.startsWith('antigravity-')) {
+        return modelId.slice('antigravity-'.length);
+    }
+    return modelId;
+}
+function getGcloudProjectIds() {
+    try {
+        const output = execFileSync('gcloud', ['projects', 'list', '--format=value(projectId)', '--limit=50'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return output
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function detectImageMimeType(bytes) {
+    if (bytes.length > 3 &&
+        bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47) {
+        return 'image/png';
+    }
+    if (bytes.length > 2 && bytes[0] === 0xff && bytes[1] === 0xd8) {
+        return 'image/jpeg';
+    }
+    if (bytes.length > 12 &&
+        bytes[0] === 0x52 &&
+        bytes[1] === 0x49 &&
+        bytes[2] === 0x46 &&
+        bytes[3] === 0x46 &&
+        bytes[8] === 0x57 &&
+        bytes[9] === 0x45 &&
+        bytes[10] === 0x42 &&
+        bytes[11] === 0x50) {
+        return 'image/webp';
+    }
+    return 'image/png';
+}
+function extractAntigravityImages(payload) {
+    const root = payload && typeof payload === 'object' && 'response' in payload
+        ? payload.response
+        : payload;
+    if (!root || typeof root !== 'object') {
+        return [];
+    }
+    const candidates = root.candidates;
+    if (!candidates || candidates.length === 0) {
+        return [];
+    }
+    const images = [];
+    for (const candidate of candidates) {
+        for (const part of candidate.content?.parts || []) {
+            const data = part.inlineData?.data;
+            if (!data)
+                continue;
+            const mediaType = part.inlineData?.mimeType || 'image/png';
+            images.push({
+                bytes: new Uint8Array(Buffer.from(data, 'base64')),
+                mediaType,
+            });
+        }
+    }
+    return images;
+}
+function formatAntigravityError({ mode, status, bodyText, }) {
+    const payload = parseAntigravityErrorPayload(bodyText);
+    const message = payload?.error?.message || bodyText;
+    const metadata = payload?.error?.details?.find((detail) => detail.metadata)?.metadata;
+    const links = payload?.error?.details
+        ?.flatMap((detail) => detail.links || [])
+        .filter((link) => Boolean(link?.url));
+    const verificationUrl = metadata?.['validation_url']
+        || links?.find((link) => /verify/i.test(link.description || ''))?.url;
+    if (verificationUrl) {
+        return [
+            `${mode} API error ${status}: account verification required`,
+            `Verify your Google account here: ${verificationUrl}`,
+            `Backend message: ${message}`,
+        ].join('\n');
+    }
+    const activationUrl = metadata?.['activationUrl']
+        || metadata?.['activation_url']
+        || links?.find((link) => /activation|console|api/i.test(link.description || ''))?.url;
+    if (activationUrl) {
+        return [
+            `${mode} API error ${status}: API access not configured`,
+            `Enable required API here: ${activationUrl}`,
+            `Backend message: ${message}`,
+        ].join('\n');
+    }
+    return `${mode} API error ${status}: ${message}`;
+}
+function parseAntigravityErrorPayload(bodyText) {
+    try {
+        return JSON.parse(bodyText);
+    }
+    catch {
+        return null;
+    }
+}
+function extensionFromMediaType(mediaType) {
+    const map = {
+        'image/png': '.png',
+        'image/jpeg': '.jpg',
+        'image/webp': '.webp',
+        'image/gif': '.gif',
+    };
+    return map[mediaType] || '.png';
+}
+function ensureExtension(filePath, ext) {
+    const parsed = path.parse(filePath);
+    if (parsed.ext) {
+        return filePath;
+    }
+    return filePath + ext;
+}
+function insertIndex(filePath, index, ext) {
+    const parsed = path.parse(filePath);
+    const finalExt = parsed.ext || ext;
+    return path.join(parsed.dir, `${parsed.name}-${index}${finalExt}`);
+}

package/dist/cli.js

@@ -10,13 +10,14 @@
 import { goke } from 'goke';
 import { z } from 'zod';
 import dedent from 'string-dedent';
-import { generateImage as aiGenerateImage, generateText } from 'ai';
+import { generateImage as aiGenerateImage, generateText, experimental_generateVideo as aiGenerateVideo, } from 'ai';
 import fs from 'node:fs';
 import path from 'node:path';
 import pc from 'picocolors';
 import pkg from '../package.json' with { type: 'json' };
 import { injectCredentialsToEnv, PROVIDERS } from './credentials.js';
-import { IMAGE_MODELS, DEFAULT_MODEL, getModelConfig, createImageModel, createTextModel, } from './models.js';
+import { IMAGE_MODELS, VIDEO_MODELS, DEFAULT_MODEL, DEFAULT_VIDEO_MODEL, getModelConfig, createImageModel, createTextModel, createVideoModel, } from './models.js';
+import { VIDEO_CATALOG } from './video-model-catalog.js';
 import { loginInteractive, loginNonInteractive, showLoginStatus, removeLogin, readKeyFromStdin, } from './login.js';
 import { subscribeInteractive, subscribeNonInteractive, unsubscribe, showUsage, } from './subscription.js';
 const cli = goke('egaki');
@@ -87,15 +88,17 @@ cli
       Egaki subscription avoids managing one key per provider.
       Three plans: Starter ($9/mo, 100 credits), Pro ($29/mo, 500 credits),
       Unlimited ($99/mo, 2000 credits). One credit ≈ one standard image.
-      Interactive mode: pick a plan, enter email, get checkout URL.
-      Non-interactive: pass --email to get the checkout URL directly.
+      Interactive mode: pick a plan and get a checkout URL (email prefill optional).
+      Non-interactive: --email is optional and only pre-fills checkout.
     `)
-    .option('-e, --email [email]', z.string().describe('Email for the subscription (skips interactive prompt)'))
+    .option('-e, --email [email]', z.string().describe('Optional email prefill for checkout (skips interactive prompt)'))
     .option('--plan [plan]', z.string().describe('Plan ID: starter, pro, or unlimited (default: pro)'))
     .example('# Interactive subscribe')
     .example('egaki subscribe')
     .example('# Non-interactive (for agents)')
     .example('egaki subscribe --email user@example.com --plan pro')
+    .example('# Non-interactive without email prefill')
+    .example('egaki subscribe --plan pro')
     .action(async (options) => {
     const isTTY = process.stdout.isTTY && process.stdin.isTTY;
     if (!isTTY || options.email || options.plan) {
@@ -216,6 +219,73 @@ cli
         });
     }
 });
+// ─── video command ───────────────────────────────────────────────────────────
+cli
+    .command('video <prompt>', dedent `
+      Generate videos from a text prompt (or image+text prompt for models that
+      support image-to-video). Uses AI SDK experimental_generateVideo under the hood.
+
+      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('-o, --output [path]', z
+    .string()
+    .default('egaki-output.mp4')
+    .describe('Output file path (index suffix added when generating multiple)'))
+    .option('-n, --count [n]', z.number().default(1).describe('Number of videos to generate'))
+    .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)'))
+    .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)'))
+    .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')
+    .example('egaki video "A paper airplane gliding through clouds" -o airplane.mp4')
+    .example('# Generate with Veo model + duration')
+    .example('egaki video "cinematic rainy street at night" -m veo-3.1-fast-generate-001 --duration 6')
+    .example('# Image-to-video (model support required)')
+    .example('egaki video "animate subtle camera pan" --model luma-ray-2 --input frame.png -o animated.mp4')
+    .example('# Generate multiple videos')
+    .example('egaki video "waves crashing on cliffs" -n 2 -o waves.mp4')
+    .action(async (prompt, options) => {
+    injectCredentialsToEnv();
+    const model = options.model;
+    const outputPath = options.output;
+    const config = getModelConfig(model);
+    if (config.strategy !== 'video') {
+        console.error(pc.red(`Model ${model} is not a video model`));
+        process.exit(1);
+    }
+    if (!options.stdout) {
+        console.error(pc.dim(`Model: ${model}`));
+        console.error(pc.dim(`Prompt: ${prompt}`));
+        console.error(pc.dim('Mode: Video API (experimental_generateVideo)'));
+    }
+    const inputImage = options.input
+        ? await readInputSource(options.input)
+        : undefined;
+    await generateWithVideoModel({
+        prompt,
+        model,
+        outputPath,
+        count: options.count,
+        aspectRatio: options.aspectRatio,
+        resolution: options.resolution,
+        duration: options.duration,
+        fps: options.fps,
+        seed: options.seed,
+        inputImage,
+        json: options.json || false,
+        stdout: options.stdout || false,
+    });
+});
 // ─── models command ──────────────────────────────────────────────────────────
 cli
     .command('models', dedent `
@@ -223,11 +293,19 @@ cli
       and provider info. Output is YAML for easy reading and piping.
     `)
     .option('-p, --provider [provider]', z.string().describe('Filter models by provider name (e.g. google, openai, replicate, fal)'))
+    .option('--type [type]', z
+    .enum(['all', 'image', 'video'])
+    .default('all')
+    .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');
-    let models = CATALOG;
+    let models = options.type === 'video'
+        ? VIDEO_CATALOG
+        : options.type === 'image'
+            ? CATALOG
+            : [...CATALOG, ...VIDEO_CATALOG];
     if (options.provider) {
         models = models.filter((m) => m.provider === options.provider);
         if (models.length === 0) {
@@ -242,17 +320,28 @@ cli
         provider: m.provider,
         strategy: m.strategy,
         released: m.released,
-        cost: m.cost.type === 'per-image'
-            ? `$${m.cost.perImage}/image`
-            : `$${m.cost.inputPerM}/M input, $${m.cost.outputPerM}/M output`,
-        features: {
-            editing: m.features.editing,
-            inpainting: m.features.inpainting,
-            seed: m.features.seed,
-            multipleImages: m.features.multipleImages,
-            aspectRatios: m.features.aspectRatios.join(', ') || 'none',
-            ...(m.features.sizes ? { sizes: m.features.sizes.join(', ') } : {}),
-        },
+        cost: formatCatalogCost(m.cost),
+        features: m.strategy === 'video'
+            ? {
+                textToVideo: m.features.textToVideo,
+                imageToVideo: m.features.imageToVideo,
+                capabilities: m.features.capabilities.join(', ') || 'none',
+                seed: m.features.seed,
+                multipleVideos: m.features.multipleVideos,
+                aspectRatios: m.features.aspectRatios?.join(', ') || 'none',
+                resolutions: m.features.resolutions?.join(', ') || 'unknown',
+                durationRangeSec: m.features.durationRangeSec
+                    ? `${m.features.durationRangeSec.min}-${m.features.durationRangeSec.max}`
+                    : 'unknown',
+            }
+            : {
+                editing: m.features.editing,
+                inpainting: m.features.inpainting,
+                seed: m.features.seed,
+                multipleImages: m.features.multipleImages,
+                aspectRatios: m.features.aspectRatios.join(', ') || 'none',
+                ...(m.features.sizes ? { sizes: m.features.sizes.join(', ') } : {}),
+            },
     }));
     if (options.json) {
         console.log(JSON.stringify(output, null, 2));
@@ -432,16 +521,107 @@ async function generateWithTextModel({ prompt, model, outputPath, inputImages, i
         console.log(JSON.stringify(output, null, 2));
     }
 }
+// Generate using experimental_generateVideo (video models)
+async function generateWithVideoModel({ prompt, model, outputPath, count, aspectRatio, resolution, duration, fps, seed, inputImage, json, stdout, }) {
+    const videoModel = await createVideoModel(model);
+    if (!stdout) {
+        console.error(pc.cyan('Generating...'));
+    }
+    const result = await aiGenerateVideo({
+        model: videoModel,
+        prompt: inputImage
+            ? { image: inputImage, text: prompt }
+            : prompt,
+        n: count,
+        ...(aspectRatio ? { aspectRatio: aspectRatio } : {}),
+        ...(resolution ? { resolution: resolution } : {}),
+        ...(duration != null ? { duration } : {}),
+        ...(fps != null ? { fps } : {}),
+        ...(seed != null ? { seed } : {}),
+    });
+    if (stdout) {
+        const video = result.videos[0];
+        if (video) {
+            process.stdout.write(Buffer.from(video.uint8Array));
+        }
+        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 cost = calculateCost(config.cost, {
+        videosGenerated: result.videos.length,
+        durationSeconds: duration,
+        resolution,
+    }, result.videos.length);
+    if (cost != null) {
+        console.error(pc.dim(`Cost: ${formatCost(cost)}`));
+    }
+    if (json) {
+        const output = {
+            model,
+            files: savedFiles,
+            count: result.videos.length,
+            cost,
+            warnings: result.warnings,
+            responses: result.responses,
+        };
+        console.log(JSON.stringify(output, null, 2));
+    }
+}
 // ─── cost helpers ────────────────────────────────────────────────────────────
-function calculateCost(cost, usage, imageCount) {
+function calculateCost(cost, usage, count = 1) {
     if (cost.type === 'per-image') {
-        return cost.perImage * imageCount;
+        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 tier = cost.tiers.find((t) => normalizeResolutionKey(t.resolution) === resolution) ??
+            cost.tiers[0];
+        if (!tier) {
+            return null;
+        }
+        return tier.costPerSecond * durationSec * count;
+    }
     return null;
 }
+function formatCatalogCost(cost) {
+    if (cost.type === 'per-image') {
+        return `$${cost.perImage}/image`;
+    }
+    if (cost.type === 'per-token') {
+        return `$${cost.inputPerM}/M input, $${cost.outputPerM}/M output`;
+    }
+    if (cost.type === 'per-video-second') {
+        const tierText = cost.tiers
+            .map((t) => {
+            const parts = [
+                t.resolution,
+                t.mode ? `mode=${t.mode}` : undefined,
+                t.audio != null ? `audio=${t.audio}` : undefined,
+            ].filter(Boolean);
+            return parts.length > 0
+                ? `$${t.costPerSecond}/s (${parts.join(', ')})`
+                : `$${t.costPerSecond}/s`;
+        })
+            .join('; ');
+        return `${tierText} (default duration ${cost.defaultDurationSec}s)`;
+    }
+    return 'unknown';
+}
 function formatCost(dollars) {
     if (dollars < 0.01) {
         return `$${dollars.toFixed(4)}`;
@@ -454,8 +634,23 @@ function extensionFromMediaType(mediaType) {
         'image/jpeg': '.jpg',
         'image/webp': '.webp',
         'image/gif': '.gif',
+        'video/mp4': '.mp4',
+        'video/webm': '.webm',
+        'video/quicktime': '.mov',
     };
-    return map[mediaType] || '.png';
+    return map[mediaType] || (mediaType.startsWith('video/') ? '.mp4' : '.png');
+}
+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;
 }
 function ensureExtension(filePath, ext) {
     const parsed = path.parse(filePath);

package/dist/credentials.d.ts

@@ -3,7 +3,7 @@ export declare const PROVIDERS: Record<string, {
     label: string;
     hint: string;
 }>;
-export declare const EGAKI_GATEWAY_URL = "https://egaki.org/v1/ai";
+export declare const EGAKI_GATEWAY_URL = "https://egaki.org/v3/ai";
 export type Credentials = Record<string, string>;
 export declare function readCredentials(): Credentials;
 export declare function writeCredentials(creds: Credentials): void;

package/dist/credentials.js

@@ -34,7 +34,7 @@ export const PROVIDERS = {
         hint: 'Get your key at https://fal.ai/dashboard/keys',
     },
 };
-export const EGAKI_GATEWAY_URL = 'https://egaki.org/v1/ai';
+export const EGAKI_GATEWAY_URL = 'https://egaki.org/v3/ai';
 function getConfigDir() {
     // XDG_CONFIG_HOME or ~/.config/egaki
     const xdg = process.env['XDG_CONFIG_HOME'];

package/dist/gateway-model-candidates.generated.d.ts

@@ -0,0 +1,11 @@
+export type GatewayModelCandidate = {
+    fullId: string;
+    provider: string;
+    modelId: string;
+    type: string;
+    tags: string[];
+    reason: 'type-image' | 'tag-image-generation';
+};
+export declare const GATEWAY_MODEL_CANDIDATES: GatewayModelCandidate[];
+export declare const GATEWAY_MODEL_CANDIDATE_PROVIDERS: string[];
+//# sourceMappingURL=gateway-model-candidates.generated.d.ts.map

package/dist/gateway-model-candidates.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-model-candidates.generated.d.ts","sourceRoot":"","sources":["../src/gateway-model-candidates.generated.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,MAAM,EAAE,YAAY,GAAG,sBAAsB,CAAA;CAC9C,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,qBAAqB,EAwD3D,CAAA;AAED,eAAO,MAAM,iCAAiC,UAG7C,CAAA"}