egaki 0.5.0 → 0.7.0

package/dist/{models.d.ts → cli/models.d.ts}

@@ -1,20 +1,27 @@
 import type { ImageModel, LanguageModel } from 'ai';
-import type { ModelEntry } from './model-catalog.js';
-import type { VideoModelEntry } from './video-model-catalog.js';
-export type AnyModelEntry = ModelEntry | VideoModelEntry;
-export type { ModelEntry, VideoModelEntry };
+import { type ImageModelEntry, type VideoModelEntry, type AnyModelEntry } from './model-catalog.js';
+export type { ImageModelEntry, VideoModelEntry, AnyModelEntry };
+/** @deprecated Use ImageModelEntry instead */
+export type ModelEntry = ImageModelEntry;
+/**
+ * Validation error for user-facing input issues (wrong model, missing key, etc.).
+ * CLI prints just the message; provider/runtime errors get full stack + details.
+ */
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}
 export declare const IMAGE_MODELS: [string, ...string[]];
 export declare const VIDEO_MODELS: [string, ...string[]];
 export declare const DEFAULT_MODEL = "nano-banana-pro-preview";
 export declare const DEFAULT_VIDEO_MODEL = "veo-3.1-fast-generate-001";
-export declare function getModelConfig(modelId: string): AnyModelEntry;
-export declare function ensureProviderKey(providerName: string): void;
+export declare function getModelConfig(modelId: string): Error | AnyModelEntry;
+export declare function ensureProviderKey(providerName: string): Error | undefined;
 /**
  * ChatGPT OAuth image generation goes through the Codex backend instead of the
  * OpenAI Image API, so OpenAI image models need the custom responses path.
  */
 export declare function shouldUseResponsesApi(modelId: string): boolean;
-export declare function createImageModel(modelId: string): Promise<ImageModel>;
-export declare function createTextModel(modelId: string): Promise<LanguageModel>;
-export declare function createVideoModel(modelId: string): Promise<any>;
+export declare function createImageModel(modelId: string): Promise<Error | ImageModel>;
+export declare function createTextModel(modelId: string): Promise<Error | LanguageModel>;
+export declare function createVideoModel(modelId: string): Promise<Error | any>;
 //# sourceMappingURL=models.d.ts.map

package/dist/cli/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/cli/models.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,IAAI,CAAA;AAWnD,OAAO,EAML,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAA;AAE3B,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,CAAA;AAC/D,8CAA8C;AAC9C,MAAM,MAAM,UAAU,GAAG,eAAe,CAAA;AAExC;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAI5B;AAED,eAAO,MAAM,YAAY,EAA+B,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAA;AAC7E,eAAO,MAAM,YAAY,EAAqC,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAA;AAYnF,eAAO,MAAM,aAAa,4BAA4B,CAAA;AACtD,eAAO,MAAM,mBAAmB,8BAA8B,CAAA;AAE9D,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,aAAa,CAMrE;AAyHD,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAsBzE;AAoCD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAI9D;AAgED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,UAAU,CAAC,CAyBnF;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,aAAa,CAAC,CA2BrF;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,GAAG,CAAC,CA6B5E"}

package/dist/cli/models.js

@@ -0,0 +1,313 @@
+import pc from 'picocolors';
+import { PROVIDERS, EGAKI_GATEWAY_URL, shouldUseChatGptBackend, shouldUseXaiOAuth, getXaiAuth, saveXaiAuth, } from './credentials.js';
+import { getValidXaiAuth } from './xai-auth.js';
+import { CATALOG, VIDEO_CATALOG, findModel, findVideoModel, findAnyModel, } from './model-catalog.js';
+/**
+ * Validation error for user-facing input issues (wrong model, missing key, etc.).
+ * CLI prints just the message; provider/runtime errors get full stack + details.
+ */
+export class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ValidationError';
+    }
+}
+export const IMAGE_MODELS = CATALOG.map((m) => m.id);
+export const VIDEO_MODELS = VIDEO_CATALOG.map((m) => m.id);
+/**
+ * Strip provider prefix from a model ID (e.g. "vertex/imagen-4.0-generate-001" → "imagen-4.0-generate-001").
+ * Provider SDKs expect bare model IDs, but the catalog uses prefixed IDs for routing.
+ */
+function stripProviderPrefix(modelId) {
+    const slash = modelId.indexOf('/');
+    if (slash === -1)
+        return modelId;
+    return modelId.slice(slash + 1);
+}
+export const DEFAULT_MODEL = 'nano-banana-pro-preview';
+export const DEFAULT_VIDEO_MODEL = 'veo-3.1-fast-generate-001';
+export function getModelConfig(modelId) {
+    const entry = findAnyModel(modelId);
+    if (!entry) {
+        return new ValidationError(`Unknown model: ${modelId}`);
+    }
+    return entry;
+}
+// Vertex is the only provider that uses a prefix (vertex/model-id) in the catalog
+// but expects a bare model ID in its SDK. Replicate and fal use slashes as part
+// of the actual model name (e.g. fal-ai/flux/schnell, black-forest-labs/flux-1.1-pro).
+// stripProviderPrefix is called inside the Vertex lambdas only.
+const PROVIDER_SDKS = {
+    google: {
+        image: async (id) => (await import('@ai-sdk/google')).google.image(id),
+        text: async (id) => (await import('@ai-sdk/google')).google(id),
+        video: async (id) => (await import('@ai-sdk/google')).google.video(id),
+    },
+    vertex: {
+        image: async (id) => (await import('@ai-sdk/google-vertex')).vertex.image(stripProviderPrefix(id)),
+        text: async (id) => (await import('@ai-sdk/google-vertex')).vertex(stripProviderPrefix(id)),
+        video: async (id) => (await import('@ai-sdk/google-vertex')).vertex.video(stripProviderPrefix(id)),
+    },
+    openai: {
+        image: async (id) => (await import('@ai-sdk/openai')).openai.image(id),
+    },
+    replicate: {
+        image: async (id) => (await import('@ai-sdk/replicate')).replicate.image(id),
+    },
+    fal: {
+        image: async (id) => (await import('@ai-sdk/fal')).fal.image(id),
+        video: async (id) => (await import('@ai-sdk/fal')).fal.video(id),
+    },
+    xai: {
+        image: async (id) => {
+            const xaiProvider = await getXaiProviderInstance();
+            if (xaiProvider instanceof Error)
+                return xaiProvider;
+            return xaiProvider.image(id);
+        },
+        video: async (id) => {
+            const xaiProvider = await getXaiProviderInstance();
+            if (xaiProvider instanceof Error)
+                return xaiProvider;
+            return xaiProvider.video(id);
+        },
+    },
+    // Providers routed exclusively through the egaki gateway (no direct SDK).
+    // They only need catalog entries and gateway routing, no local SDK factory.
+    // bfl, recraft, klingai, alibaba — all handled by the gateway fallback.
+};
+// ─── xAI provider instance ───────────────────────────────────────────────────
+// Creates an @ai-sdk/xai provider instance with either a direct API key or
+// OAuth tokens from the Grok Build subscription. OAuth tokens are injected via
+// a custom fetch that replaces the Authorization header on every request.
+async function getXaiProviderInstance() {
+    const { createXai } = await import('@ai-sdk/xai');
+    // Direct API key path (env or stored)
+    if (!shouldUseXaiOAuth()) {
+        return createXai({
+            apiKey: process.env['XAI_API_KEY'],
+        });
+    }
+    // OAuth path: inject bearer token via custom fetch
+    const storedAuth = getXaiAuth();
+    if (!storedAuth) {
+        return new ValidationError('Missing xAI OAuth tokens. Please run `egaki login` and select xAI Grok Build.');
+    }
+    const auth = await getValidXaiAuth(storedAuth, saveXaiAuth);
+    if (auth instanceof Error) {
+        return auth;
+    }
+    return createXai({
+        // Dummy key to satisfy the SDK's apiKey requirement; the custom fetch
+        // overrides the Authorization header with the real OAuth token.
+        apiKey: 'xai-oauth-placeholder',
+        fetch: async (input, init) => {
+            const headers = new Headers(input instanceof Request ? input.headers : undefined);
+            if (init?.headers) {
+                const initHeaders = new Headers(init.headers);
+                initHeaders.forEach((value, key) => headers.set(key, value));
+            }
+            headers.set('authorization', `Bearer ${auth.access}`);
+            return fetch(input, { ...init, headers });
+        },
+    });
+}
+// ─── key checking ────────────────────────────────────────────────────────────
+function hasEgakiKey() {
+    const info = PROVIDERS['egaki'];
+    if (!info)
+        return false;
+    return Boolean(process.env[info.envVar]);
+}
+function hasDirectProviderKey(providerName) {
+    const info = PROVIDERS[providerName];
+    if (!info)
+        return false;
+    if (Boolean(process.env[info.envVar]))
+        return true;
+    // xAI OAuth counts as having a direct provider key since we use @ai-sdk/xai directly
+    if (providerName === 'xai' && shouldUseXaiOAuth())
+        return true;
+    return false;
+}
+// Check that the provider's API key or OAuth login is available before making API calls.
+// Returns an Error with a user-friendly message if no key is found.
+export function ensureProviderKey(providerName) {
+    if (hasDirectProviderKey(providerName))
+        return undefined;
+    // Vertex models require a direct key — the upstream Vercel AI Gateway
+    // does not support vertex/ routing, so egaki gateway can't proxy them.
+    if (providerName === 'vertex') {
+        return new ValidationError('Vertex models require a direct Google Cloud API key. ' +
+            'Run: egaki login --provider vertex --key <key>. ' +
+            'Get a key at https://console.cloud.google.com/apis/credentials');
+    }
+    if (hasEgakiKey())
+        return undefined;
+    const info = PROVIDERS[providerName];
+    const label = info?.label || providerName;
+    return new ValidationError(`Missing API key for ${label}. ` +
+        'Use an Egaki subscription (egaki subscribe) or configure a provider key directly (egaki login).' +
+        (info ? ` ${info.hint}` : ''));
+}
+// ─── gateway model factories ─────────────────────────────────────────────────
+async function createGatewayImageModel(modelId, provider) {
+    const { createGateway } = await import('ai');
+    const gateway = createGateway({
+        apiKey: process.env['EGAKI_API_KEY'],
+        baseURL: EGAKI_GATEWAY_URL,
+    });
+    const bareId = stripProviderPrefix(modelId);
+    return gateway.image(`${provider}/${bareId}`);
+}
+async function createGatewayTextModel(modelId, provider) {
+    const { createGateway } = await import('ai');
+    const gateway = createGateway({
+        apiKey: process.env['EGAKI_API_KEY'],
+        baseURL: EGAKI_GATEWAY_URL,
+    });
+    const bareId = stripProviderPrefix(modelId);
+    return gateway(`${provider}/${bareId}`);
+}
+async function createGatewayVideoModel(modelId, provider) {
+    const { createGateway } = await import('ai');
+    const gateway = createGateway({
+        apiKey: process.env['EGAKI_API_KEY'],
+        baseURL: EGAKI_GATEWAY_URL,
+    });
+    const bareId = stripProviderPrefix(modelId);
+    return gateway.video(`${provider}/${bareId}`);
+}
+// ─── ChatGPT OAuth routing ───────────────────────────────────────────────────
+/**
+ * ChatGPT OAuth image generation goes through the Codex backend instead of the
+ * OpenAI Image API, so OpenAI image models need the custom responses path.
+ */
+export function shouldUseResponsesApi(modelId) {
+    const config = findModel(modelId);
+    if (!config)
+        return false;
+    return config.provider === 'openai' && config.strategy === 'image' && shouldUseChatGptBackend();
+}
+/**
+ * Determine which auth source will be used for a given provider.
+ * Returns the auth type for logging. Does NOT check if the key is valid.
+ */
+function resolveAuthSource(providerName) {
+    const info = PROVIDERS[providerName];
+    // xAI has special OAuth handling
+    if (providerName === 'xai') {
+        if (process.env['XAI_API_KEY'] && !shouldUseXaiOAuth()) {
+            return { type: 'api-key', label: 'XAI_API_KEY' };
+        }
+        if (shouldUseXaiOAuth()) {
+            return { type: 'oauth', label: 'xAI Grok Build OAuth' };
+        }
+    }
+    // ChatGPT OAuth
+    if (providerName === 'openai' && shouldUseChatGptBackend()) {
+        return { type: 'oauth', label: 'ChatGPT OAuth' };
+    }
+    // Direct provider env var
+    if (info && process.env[info.envVar]) {
+        return { type: 'api-key', label: info.envVar };
+    }
+    // Egaki gateway
+    if (hasEgakiKey()) {
+        return { type: 'egaki-gateway' };
+    }
+    // Should not reach here if ensureProviderKey passed
+    return { type: 'api-key', label: 'unknown' };
+}
+function logAuthSource(source) {
+    switch (source.type) {
+        case 'api-key':
+            console.error(pc.dim(`Auth: ${source.label}`));
+            break;
+        case 'oauth':
+            console.error(pc.dim(`Auth: ${source.label}`));
+            break;
+        case 'egaki-gateway':
+            console.error(pc.dim('Auth: Egaki subscription (gateway)'));
+            break;
+    }
+}
+// ─── public model factories ──────────────────────────────────────────────────
+// Priority for xAI: explicit XAI_API_KEY > xai-oauth tokens > egaki gateway > error.
+// Priority for others: direct provider key > egaki gateway > error.
+// Uses PROVIDER_SDKS map for direct provider creation, eliminating switch blocks.
+export async function createImageModel(modelId) {
+    const config = getModelConfig(modelId);
+    if (config instanceof Error)
+        return config;
+    const keyError = ensureProviderKey(config.provider);
+    if (keyError)
+        return keyError;
+    const authSource = resolveAuthSource(config.provider);
+    logAuthSource(authSource);
+    if (hasDirectProviderKey(config.provider)) {
+        const factory = PROVIDER_SDKS[config.provider]?.image;
+        if (factory) {
+            const result = await factory(modelId);
+            if (result instanceof Error)
+                return result;
+            return result;
+        }
+        return new ValidationError(`Direct image generation is not supported for provider: ${config.provider}.`);
+    }
+    if (hasEgakiKey()) {
+        return createGatewayImageModel(modelId, config.provider);
+    }
+    return new ValidationError(`No API key available for provider: ${config.provider}`);
+}
+export async function createTextModel(modelId) {
+    const config = getModelConfig(modelId);
+    if (config instanceof Error)
+        return config;
+    if (config.strategy !== 'text') {
+        return new ValidationError(`Model ${modelId} is not a text model`);
+    }
+    const keyError = ensureProviderKey(config.provider);
+    if (keyError)
+        return keyError;
+    const authSource = resolveAuthSource(config.provider);
+    logAuthSource(authSource);
+    if (hasDirectProviderKey(config.provider)) {
+        const factory = PROVIDER_SDKS[config.provider]?.text;
+        if (factory) {
+            return factory(modelId);
+        }
+        return new ValidationError(`Text+image generation is not supported for provider: ${config.provider}`);
+    }
+    if (hasEgakiKey()) {
+        return createGatewayTextModel(modelId, config.provider);
+    }
+    return new ValidationError(`No API key available for provider: ${config.provider}`);
+}
+export async function createVideoModel(modelId) {
+    const config = getModelConfig(modelId);
+    if (config instanceof Error)
+        return config;
+    if (config.strategy !== 'video') {
+        return new ValidationError(`Model ${modelId} is not a video model`);
+    }
+    const keyError = ensureProviderKey(config.provider);
+    if (keyError)
+        return keyError;
+    const authSource = resolveAuthSource(config.provider);
+    logAuthSource(authSource);
+    if (hasDirectProviderKey(config.provider)) {
+        const factory = PROVIDER_SDKS[config.provider]?.video;
+        if (factory) {
+            const result = await factory(modelId);
+            if (result instanceof Error)
+                return result;
+            return result;
+        }
+        return new ValidationError(`Direct video generation is not supported for provider: ${config.provider}. Use an egaki subscription instead.`);
+    }
+    if (hasEgakiKey()) {
+        return createGatewayVideoModel(modelId, config.provider);
+    }
+    return new ValidationError(`No API key available for provider: ${config.provider}`);
+}

package/dist/cli/open-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-browser.d.ts","sourceRoot":"","sources":["../../src/cli/open-browser.ts"],"names":[],"mappings":"AAyBA,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAsBrD"}

package/dist/cli/openai-speech-provider.d.ts

@@ -0,0 +1,3 @@
+import type { SpeechProvider } from './speech-generate.js';
+export declare function createOpenAISpeechProvider(): SpeechProvider;
+//# sourceMappingURL=openai-speech-provider.d.ts.map

package/dist/cli/openai-speech-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-speech-provider.d.ts","sourceRoot":"","sources":["../../src/cli/openai-speech-provider.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAA+C,MAAM,sBAAsB,CAAA;AAEvG,wBAAgB,0BAA0B,IAAI,cAAc,CAyB3D"}

package/dist/cli/openai-speech-provider.js

@@ -0,0 +1,28 @@
+// OpenAI speech provider for egaki.
+// Wraps the Vercel AI SDK @ai-sdk/openai since OpenAI TTS has no
+// timestamp support. Returns audio only, timestamps are always undefined.
+import { experimental_generateSpeech as aiGenerateSpeech, } from 'ai';
+export function createOpenAISpeechProvider() {
+    return {
+        async generate(options) {
+            const { openai } = await import('@ai-sdk/openai');
+            const model = openai.speech(options.modelId);
+            const result = await aiGenerateSpeech({
+                model,
+                text: options.text,
+                ...(options.voice ? { voice: options.voice } : {}),
+                ...(options.outputFormat ? { outputFormat: options.outputFormat } : {}),
+                ...(options.instructions ? { instructions: options.instructions } : {}),
+                ...(options.speed != null ? { speed: options.speed } : {}),
+                ...(options.language ? { language: options.language } : {}),
+                ...(options.abortSignal ? { abortSignal: options.abortSignal } : {}),
+            });
+            return {
+                audio: result.audio.uint8Array,
+                mediaType: result.audio.mediaType || 'audio/mpeg',
+                // OpenAI TTS does not support word timestamps
+                timestamps: undefined,
+            };
+        },
+    };
+}

package/dist/cli/separation-generate.d.ts

@@ -0,0 +1,34 @@
+export type StemName = 'vocals' | 'drums' | 'bass' | 'other' | 'guitar' | 'piano';
+export type DemucsModel = 'htdemucs' | 'htdemucs_ft' | 'htdemucs_6s' | 'hdemucs_mmi' | 'mdx' | 'mdx_extra' | 'mdx_q' | 'mdx_extra_q';
+export interface SeparateAudioOptions {
+    /** Raw audio bytes to separate. */
+    audio: Uint8Array;
+    /** Which stems to extract. Default: ['vocals', 'other'] */
+    stems?: StemName[];
+    /** Demucs model variant. Default: 'htdemucs_6s' */
+    model?: DemucsModel;
+    /** Output format: 'mp3' or 'wav'. Default: 'mp3' */
+    outputFormat?: 'mp3' | 'wav';
+    /** Number of random shifts for quality (higher = better but slower). Default: 1 */
+    shifts?: number;
+    /** Segment overlap 0.0-1.0 (higher = better quality). Default: 0.25 */
+    overlap?: number;
+    /** Original filename for display/logging. */
+    filename?: string;
+    /** Progress callback for queue updates. */
+    onProgress?: (message: string) => void;
+}
+export interface StemResult {
+    name: StemName;
+    url: string;
+    contentType: string;
+}
+export interface SeparateAudioResult {
+    stems: StemResult[];
+    model: string;
+}
+export declare function validateStems(stems: StemName[], model: DemucsModel): Error | void;
+export declare function separateAudioUncached(opts: SeparateAudioOptions): Promise<Error | SeparateAudioResult>;
+/** Download a stem from its URL and return the bytes. */
+export declare function downloadStem(url: string): Promise<Error | Uint8Array>;
+//# sourceMappingURL=separation-generate.d.ts.map

package/dist/cli/separation-generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"separation-generate.d.ts","sourceRoot":"","sources":["../../src/cli/separation-generate.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAA;AAEjF,MAAM,MAAM,WAAW,GACnB,UAAU,GACV,aAAa,GACb,aAAa,GACb,aAAa,GACb,KAAK,GACL,WAAW,GACX,OAAO,GACP,aAAa,CAAA;AAEjB,MAAM,WAAW,oBAAoB;IACnC,mCAAmC;IACnC,KAAK,EAAE,UAAU,CAAA;IACjB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAA;IAClB,mDAAmD;IACnD,KAAK,CAAC,EAAE,WAAW,CAAA;IACnB,oDAAoD;IACpD,YAAY,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;IAC5B,mFAAmF;IACnF,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,2CAA2C;IAC3C,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CACvC;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;CACd;AAQD,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,KAAK,GAAG,IAAI,CAejF;AAID,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC,KAAK,GAAG,mBAAmB,CAAC,CA0FtC;AAID,yDAAyD;AACzD,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,UAAU,CAAC,CAU3E"}

package/dist/cli/separation-generate.js

@@ -0,0 +1,117 @@
+// Audio separation using fal.ai's Demucs API.
+// Splits audio into stems (vocals, drums, bass, guitar, piano, other).
+// Returns Error | Result (errore style) instead of throwing.
+//
+// Uses @fal-ai/client directly since Demucs is a fal-specific API
+// with no Vercel AI SDK wrapper. Requires FAL_KEY env var or
+// egaki login --provider fal.
+import { fal } from '@fal-ai/client';
+import { injectCredentialsToEnv } from './credentials.js';
+// ─── validation ─────────────────────────────────────────────────────────────
+const ALL_STEMS = ['vocals', 'drums', 'bass', 'other', 'guitar', 'piano'];
+const FOUR_STEM_MODELS = ['htdemucs', 'htdemucs_ft', 'hdemucs_mmi', 'mdx', 'mdx_extra', 'mdx_q', 'mdx_extra_q'];
+const SIX_STEM_ONLY = ['guitar', 'piano'];
+export function validateStems(stems, model) {
+    for (const s of stems) {
+        if (!ALL_STEMS.includes(s)) {
+            return new Error(`Unknown stem: "${s}". Valid stems: ${ALL_STEMS.join(', ')}`);
+        }
+    }
+    if (FOUR_STEM_MODELS.includes(model)) {
+        const invalid = stems.filter((s) => SIX_STEM_ONLY.includes(s));
+        if (invalid.length > 0) {
+            return new Error(`Stems ${invalid.join(', ')} are only available with htdemucs_6s model. ` +
+                `Current model: ${model}`);
+        }
+    }
+}
+// ─── main function ──────────────────────────────────────────────────────────
+export async function separateAudioUncached(opts) {
+    injectCredentialsToEnv();
+    const falKey = process.env['FAL_KEY'];
+    if (!falKey) {
+        return new Error('FAL_KEY not found. Run: egaki login --provider fal\n' +
+            'Get your key at https://fal.ai/dashboard/keys');
+    }
+    fal.config({ credentials: falKey });
+    const model = opts.model ?? 'htdemucs_6s';
+    const stems = opts.stems ?? ['vocals', 'other'];
+    const outputFormat = opts.outputFormat ?? 'mp3';
+    const validationError = validateStems(stems, model);
+    if (validationError)
+        return validationError;
+    if (opts.audio.length === 0) {
+        return new Error('No audio data provided');
+    }
+    // Upload the audio file to fal storage so the API can access it
+    const file = new File([Buffer.from(opts.audio)], opts.filename ?? 'audio.mp3', { type: 'audio/mpeg' });
+    opts.onProgress?.('Uploading audio to fal.ai...');
+    let audioUrl;
+    try {
+        audioUrl = await fal.storage.upload(file);
+    }
+    catch (err) {
+        return new Error(`Failed to upload audio: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    opts.onProgress?.('Audio uploaded. Starting separation...');
+    let result;
+    try {
+        result = await fal.subscribe('fal-ai/demucs', {
+            input: {
+                audio_url: audioUrl,
+                model,
+                stems,
+                shifts: opts.shifts ?? 1,
+                overlap: opts.overlap ?? 0.25,
+                output_format: outputFormat,
+            },
+            logs: true,
+            onQueueUpdate: (update) => {
+                if (update.status === 'IN_PROGRESS') {
+                    const u = update;
+                    if (u.logs) {
+                        for (const log of u.logs) {
+                            opts.onProgress?.(log.message);
+                        }
+                    }
+                }
+            },
+        });
+    }
+    catch (err) {
+        return new Error(`Separation failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Extract the requested stems from the result
+    const resultStems = [];
+    for (const stemName of stems) {
+        const stemData = result.data[stemName];
+        if (stemData?.url) {
+            resultStems.push({
+                name: stemName,
+                url: stemData.url,
+                contentType: stemData.content_type ?? `audio/${outputFormat}`,
+            });
+        }
+    }
+    if (resultStems.length === 0) {
+        return new Error('No stems returned from the API. Check model and stem names.');
+    }
+    return {
+        stems: resultStems,
+        model,
+    };
+}
+// ─── download helper ────────────────────────────────────────────────────────
+/** Download a stem from its URL and return the bytes. */
+export async function downloadStem(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            return new Error(`Failed to download stem: HTTP ${response.status}`);
+        }
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    catch (err) {
+        return new Error(`Failed to download stem: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/cli/speech-catalog.d.ts

@@ -0,0 +1,35 @@
+import type { ProviderOption } from './model-catalog.js';
+export type PerCharacterCost = {
+    type: 'per-character';
+    /** USD per 1 million characters */
+    perMillionChars: number;
+};
+export type SpeechModelCost = PerCharacterCost;
+export type SpeechModelFeatures = {
+    /** Supported output audio formats */
+    outputFormats: string[];
+    /** Whether the model supports voice instructions / style prompts */
+    instructions: boolean;
+    /** Whether speed control is supported */
+    speed: boolean;
+    /** Whether language selection is supported */
+    language: boolean;
+    /** Max input characters per request (0 = unknown/unlimited) */
+    maxChars: number;
+    /** Built-in voice names (not exhaustive for providers with voice libraries) */
+    defaultVoices: string[];
+};
+export type SpeechModelEntry = {
+    id: string;
+    name: string;
+    description?: string;
+    provider: string;
+    strategy: 'speech';
+    released: string;
+    cost: SpeechModelCost;
+    features: SpeechModelFeatures;
+    providerOptions?: ProviderOption[];
+};
+export declare const SPEECH_CATALOG: SpeechModelEntry[];
+export declare function findSpeechModel(modelId: string): SpeechModelEntry | undefined;
+//# sourceMappingURL=speech-catalog.d.ts.map

package/dist/cli/speech-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"speech-catalog.d.ts","sourceRoot":"","sources":["../../src/cli/speech-catalog.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAIxD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,eAAe,CAAA;IACrB,mCAAmC;IACnC,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,gBAAgB,CAAA;AAI9C,MAAM,MAAM,mBAAmB,GAAG;IAChC,qCAAqC;IACrC,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,oEAAoE;IACpE,YAAY,EAAE,OAAO,CAAA;IACrB,yCAAyC;IACzC,KAAK,EAAE,OAAO,CAAA;IACd,8CAA8C;IAC9C,QAAQ,EAAE,OAAO,CAAA;IACjB,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAA;IAChB,+EAA+E;IAC/E,aAAa,EAAE,MAAM,EAAE,CAAA;CACxB,CAAA;AAID,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,QAAQ,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,eAAe,CAAA;IACrB,QAAQ,EAAE,mBAAmB,CAAA;IAC7B,eAAe,CAAC,EAAE,cAAc,EAAE,CAAA;CACnC,CAAA;AAqBD,eAAO,MAAM,cAAc,EAAE,gBAAgB,EA8K5C,CAAA;AAID,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAE7E"}