egaki 0.5.0 → 0.7.0

package/src/cli/models.ts

@@ -0,0 +1,408 @@
+// Model registry for egaki.
+// Maps model IDs to their provider and generation strategy. The enum of
+// supported models is derived from this registry so there's a single source
+// of truth for both CLI validation and runtime provider resolution.
+//
+// Provider SDK factories are stored in a descriptor map (PROVIDER_SDKS) so
+// adding a new provider is one map entry instead of touching 3 switch blocks.
+//
+// Provider resolution priority:
+//   1. Provider-specific auth (API key, or xAI/ChatGPT OAuth) → direct/custom backend
+//   2. Egaki API key (EGAKI_API_KEY) → route through egaki gateway
+//   3. No key → error with subscription recommendation
+import type { ImageModel, LanguageModel } from 'ai'
+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,
+  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 class ValidationError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'ValidationError'
+  }
+}
+
+export const IMAGE_MODELS = CATALOG.map((m) => m.id) as [string, ...string[]]
+export const VIDEO_MODELS = VIDEO_CATALOG.map((m) => m.id) as [string, ...string[]]
+
+/**
+ * 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: string): string {
+  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: string): Error | AnyModelEntry {
+  const entry = findAnyModel(modelId)
+  if (!entry) {
+    return new ValidationError(`Unknown model: ${modelId}`)
+  }
+  return entry
+}
+
+// ─── provider SDK descriptor map ─────────────────────────────────────────────
+// Each provider declares which model factories it supports. Lazy imports keep
+// unused provider SDKs out of the startup path.
+//
+// To add a new provider:
+//   1. Add an entry here with the relevant factory functions.
+//   2. Add models to CATALOG/VIDEO_CATALOG in model-catalog.ts.
+//   3. Add a PROVIDERS entry in credentials.ts for the env var / login hint.
+// That's it — no switch statements to touch.
+
+type ProviderSdk = {
+  image?: (modelId: string) => Promise<Error | ImageModel>
+  text?: (modelId: string) => Promise<Error | LanguageModel>
+  video?: (modelId: string) => Promise<Error | any>
+}
+
+// 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: Record<string, ProviderSdk> = {
+  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(): Promise<Error | ReturnType<Awaited<typeof import('@ai-sdk/xai')>['createXai']>> {
+  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(): boolean {
+  const info = PROVIDERS['egaki']
+  if (!info) return false
+  return Boolean(process.env[info.envVar])
+}
+
+function hasDirectProviderKey(providerName: string): boolean {
+  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: string): Error | undefined {
+  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: string, provider: string): Promise<ImageModel> {
+  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: string, provider: string): Promise<LanguageModel> {
+  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: string, provider: string) {
+  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: string): boolean {
+  const config = findModel(modelId)
+  if (!config) return false
+  return config.provider === 'openai' && config.strategy === 'image' && shouldUseChatGptBackend()
+}
+
+// ─── auth source detection ───────────────────────────────────────────────────
+
+type AuthSource =
+  | { type: 'api-key'; label: string }
+  | { type: 'oauth'; label: string }
+  | { type: 'egaki-gateway' }
+
+/**
+ * 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: string): AuthSource {
+  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: AuthSource): void {
+  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: string): Promise<Error | ImageModel> {
+  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: string): Promise<Error | LanguageModel> {
+  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: string): Promise<Error | any> {
+  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/src/cli/openai-speech-provider.ts

@@ -0,0 +1,34 @@
+// 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'
+import type { SpeechProvider, SpeechProviderOptions, SpeechProviderResult } from './speech-generate.js'
+
+export function createOpenAISpeechProvider(): SpeechProvider {
+  return {
+    async generate(options: SpeechProviderOptions): Promise<SpeechProviderResult> {
+      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/src/cli/separation-generate.ts

@@ -0,0 +1,187 @@
+// 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'
+
+// ─── types ──────────────────────────────────────────────────────────────────
+
+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
+}
+
+// ─── validation ─────────────────────────────────────────────────────────────
+
+const ALL_STEMS: StemName[] = ['vocals', 'drums', 'bass', 'other', 'guitar', 'piano']
+const FOUR_STEM_MODELS: DemucsModel[] = ['htdemucs', 'htdemucs_ft', 'hdemucs_mmi', 'mdx', 'mdx_extra', 'mdx_q', 'mdx_extra_q']
+const SIX_STEM_ONLY: StemName[] = ['guitar', 'piano']
+
+export function validateStems(stems: StemName[], model: DemucsModel): Error | void {
+  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: SeparateAudioOptions,
+): Promise<Error | SeparateAudioResult> {
+  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: DemucsModel = opts.model ?? 'htdemucs_6s'
+  const stems: StemName[] = 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: string
+  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...')
+
+  // Call the Demucs API
+  type DemucsOutput = Record<string, { url: string; content_type: string }>
+  let result: { data: DemucsOutput }
+  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 as typeof update & { logs?: Array<{ message: string }> }
+          if (u.logs) {
+            for (const log of u.logs) {
+              opts.onProgress?.(log.message)
+            }
+          }
+        }
+      },
+    }) as any
+  } catch (err) {
+    return new Error(`Separation failed: ${err instanceof Error ? err.message : String(err)}`)
+  }
+
+  // Extract the requested stems from the result
+  const resultStems: StemResult[] = []
+  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: string): Promise<Error | Uint8Array> {
+  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)}`)
+  }
+}