ethagent 3.3.3 → 4.0.0

package/src/models/catalog.ts

@@ -1,327 +0,0 @@
-import { defaultModelFor, type EthagentConfig, type ProviderId } from '../storage/config.js'
-import { getKey } from '../storage/secrets.js'
-import { loadLocalHfModels } from './huggingface.js'
-import { hasOpenAIOAuthCredentials } from '../auth/openaiOAuth/credentials.js'
-import { providerDisplayName } from './providerDisplay.js'
-
-const OPENAI_OAUTH_MODEL_IDS = ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.2'] as const
-
-export const OPENAI_OAUTH_DEFAULT_MODEL = 'gpt-5.4'
-
-export function isOpenAIOAuthAllowedModel(model: string): boolean {
-  return (OPENAI_OAUTH_MODEL_IDS as readonly string[]).includes(model)
-}
-
-export type ModelCatalogSource = 'installed' | 'discovered' | 'fallback'
-
-export type ModelCatalogEntry = {
-  provider: ProviderId
-  id: string
-  label: string
-  description?: string
-  source: ModelCatalogSource
-}
-
-export type ModelCatalogResult = {
-  provider: ProviderId
-  entries: ModelCatalogEntry[]
-  status: 'ok' | 'fallback'
-  error?: string
-}
-
-type DiscoverDeps = {
-  fetchImpl?: typeof fetch
-  loadKey?: (provider: ProviderId) => Promise<string | null>
-  listHfLocal?: () => Promise<Array<{ id: string; displayName: string }>>
-  now?: () => number
-}
-
-const OPENAI_DEFAULT_BASE_URL = 'https://api.openai.com/v1'
-const ANTHROPIC_VERSION = '2023-06-01'
-const CACHE_TTL_MS = 60_000
-
-type CacheValue = {
-  expiresAt: number
-  entries: ModelCatalogEntry[]
-}
-
-const cache = new Map<string, CacheValue>()
-
-export function openAIBaseUrlFor(config: Pick<EthagentConfig, 'provider' | 'baseUrl'>): string {
-  return config.provider === 'openai' && config.baseUrl
-    ? config.baseUrl
-    : OPENAI_DEFAULT_BASE_URL
-}
-
-export function clearModelCatalogCache(): void {
-  cache.clear()
-}
-
-export async function discoverProviderModels(
-  config: EthagentConfig,
-  deps: DiscoverDeps = {},
-): Promise<ModelCatalogResult> {
-  const provider = config.provider
-  if (provider === 'llamacpp') {
-    try {
-      const installed = await (deps.listHfLocal ?? (() => loadLocalHfModels()))()
-      return {
-        provider,
-        status: 'ok',
-        entries: dedupeEntries(installed.map(model => ({
-          provider,
-          id: model.id,
-          label: model.displayName,
-          source: 'installed' as const,
-        }))),
-      }
-    } catch (err: unknown) {
-      return fallbackResult(config, (err as Error).message)
-    }
-  }
-
-  const loadKey = deps.loadKey ?? getKey
-  const apiKey = await loadKey(provider)
-  if (!apiKey) {
-    if (provider === 'openai' && await hasOpenAIOAuthCredentials()) {
-      return openAIOAuthCatalog()
-    }
-    return fallbackResult(config, `missing ${providerDisplayName(provider)} API key`)
-  }
-
-  const baseUrl = provider === 'openai' ? openAIBaseUrlFor(config) : ''
-  const key = cacheKey(provider, baseUrl, true)
-  const now = deps.now?.() ?? Date.now()
-  const cached = cache.get(key)
-  if (cached && cached.expiresAt > now) {
-    return { provider, status: 'ok', entries: cached.entries }
-  }
-
-  try {
-    const fetchImpl = deps.fetchImpl ?? fetch
-    const entries =
-      provider === 'openai'
-        ? await discoverOpenAIModels(fetchImpl, provider, baseUrl, apiKey, isDefaultOpenAIBaseUrl(baseUrl))
-        : provider === 'anthropic'
-          ? await discoverAnthropicModels(fetchImpl, apiKey)
-          : await discoverGeminiModels(fetchImpl, apiKey)
-    const deduped = dedupeEntries(entries)
-    cache.set(key, { expiresAt: now + CACHE_TTL_MS, entries: deduped })
-    return { provider, status: 'ok', entries: deduped }
-  } catch (err: unknown) {
-    return fallbackResult(config, (err as Error).message)
-  }
-}
-
-function openAIOAuthCatalog(): ModelCatalogResult {
-  return {
-    provider: 'openai',
-    status: 'ok',
-    entries: OPENAI_OAUTH_MODEL_IDS.map(id => ({
-      provider: 'openai' as ProviderId,
-      id,
-      label: id,
-      source: 'discovered' as const,
-    })),
-  }
-}
-
-function fallbackResult(config: EthagentConfig, error?: string): ModelCatalogResult {
-  const provider = config.provider
-  return {
-    provider,
-    status: 'fallback',
-    error,
-    entries: dedupeEntries([
-      {
-        provider,
-        id: config.model,
-        label: config.model,
-        source: 'fallback',
-      },
-      {
-        provider,
-        id: defaultModelFor(provider),
-        label: defaultModelFor(provider),
-        source: 'fallback',
-      },
-    ]),
-  }
-}
-
-const OPENAI_CHAT_PREFIXES = ['gpt-', 'chatgpt-', 'o1', 'o3', 'o4']
-const OPENAI_NON_CHAT_PATTERNS: RegExp[] = [
-  /-instruct(?:$|-)/,
-  /-realtime(?:$|-)/,
-  /-audio(?:$|-)/,
-  /-transcribe(?:$|-)/,
-  /-tts(?:$|-)/,
-  /-search-preview(?:$|-)/,
-  /-image(?:$|-)/,
-]
-const OPENAI_NON_CHAT_FAMILIES = [
-  'text-embedding-',
-  'text-similarity-',
-  'text-search-',
-  'whisper-',
-  'tts-',
-  'dall-e-',
-  'gpt-image-',
-  'omni-moderation-',
-  'text-moderation-',
-  'babbage-',
-  'davinci-',
-  'computer-use-',
-]
-const OPENAI_NON_CHAT_EXACT = new Set(['davinci', 'babbage', 'ada', 'curie'])
-
-function isChatCapableOpenAIModel(id: string): boolean {
-  if (OPENAI_NON_CHAT_EXACT.has(id)) return false
-  if (OPENAI_NON_CHAT_FAMILIES.some(prefix => id.startsWith(prefix))) return false
-  if (OPENAI_NON_CHAT_PATTERNS.some(re => re.test(id))) return false
-  return OPENAI_CHAT_PREFIXES.some(prefix => id.startsWith(prefix))
-}
-
-function isDefaultOpenAIBaseUrl(baseUrl: string): boolean {
-  return baseUrl.replace(/\/+$/, '') === OPENAI_DEFAULT_BASE_URL
-}
-
-async function discoverOpenAIModels(
-  fetchImpl: typeof fetch,
-  provider: ProviderId,
-  baseUrl: string,
-  apiKey: string,
-  applyChatFilter: boolean,
-): Promise<ModelCatalogEntry[]> {
-  const urls = openAIModelUrls(baseUrl)
-  let lastError: Error | undefined
-  for (const url of urls) {
-    try {
-      const response = await fetchImpl(url, {
-        method: 'GET',
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          Accept: 'application/json',
-        },
-      })
-      if (!response.ok) {
-        lastError = new Error(`HTTP ${response.status}`)
-        continue
-      }
-      const data = await response.json() as { data?: Array<{ id?: unknown }> }
-      return (data.data ?? [])
-        .filter(item => typeof item.id === 'string' && item.id.length > 0)
-        .filter(item => !applyChatFilter || isChatCapableOpenAIModel(item.id as string))
-        .map(item => ({
-          provider,
-          id: item.id as string,
-          label: item.id as string,
-          source: 'discovered' as const,
-        }))
-    } catch (err: unknown) {
-      lastError = err as Error
-    }
-  }
-  throw lastError ?? new Error('no OpenAI model endpoint responded')
-}
-
-function openAIModelUrls(baseUrl: string): string[] {
-  const normalized = baseUrl.replace(/\/+$/, '')
-  const fallback = normalized.endsWith('/v1')
-    ? `${normalized.slice(0, -3)}/models`
-    : `${normalized}/v1/models`
-  return dedupeStrings([`${normalized}/models`, fallback])
-}
-
-async function discoverAnthropicModels(
-  fetchImpl: typeof fetch,
-  apiKey: string,
-): Promise<ModelCatalogEntry[]> {
-  const response = await fetchImpl('https://api.anthropic.com/v1/models', {
-    method: 'GET',
-    headers: {
-      'x-api-key': apiKey,
-      'anthropic-version': ANTHROPIC_VERSION,
-      Accept: 'application/json',
-    },
-  })
-  if (!response.ok) throw new Error(`HTTP ${response.status}`)
-  const data = await response.json() as { data?: Array<{ id?: unknown; display_name?: unknown }> }
-  return (data.data ?? [])
-    .filter(item => typeof item.id === 'string' && item.id.length > 0)
-    .map(item => ({
-      provider: 'anthropic',
-      id: item.id as string,
-      label: typeof item.display_name === 'string' && item.display_name.length > 0
-        ? item.display_name
-        : item.id as string,
-      source: 'discovered' as const,
-    }))
-}
-
-async function discoverGeminiModels(
-  fetchImpl: typeof fetch,
-  apiKey: string,
-): Promise<ModelCatalogEntry[]> {
-  const response = await fetchImpl(
-    'https://generativelanguage.googleapis.com/v1beta/models',
-    {
-      method: 'GET',
-      headers: {
-        Accept: 'application/json',
-        'x-goog-api-key': apiKey.trim(),
-      },
-    },
-  )
-  if (!response.ok) throw new Error(`HTTP ${response.status}`)
-  const data = await response.json() as {
-    models?: Array<{
-      name?: unknown
-      displayName?: unknown
-      description?: unknown
-      supportedGenerationMethods?: unknown
-    }>
-  }
-  return (data.models ?? [])
-    .filter(item => typeof item.name === 'string' && item.name.length > 0)
-    .filter(item => Array.isArray(item.supportedGenerationMethods)
-      && item.supportedGenerationMethods.includes('generateContent'))
-    .map(item => {
-      const id = (item.name as string).replace(/^models\//, '')
-      return {
-        provider: 'gemini' as const,
-        id,
-        label: typeof item.displayName === 'string' && item.displayName.length > 0
-          ? item.displayName
-          : id,
-        description: typeof item.description === 'string' ? item.description : undefined,
-        source: 'discovered' as const,
-      }
-    })
-}
-
-function cacheKey(provider: ProviderId, baseUrl: string, hasKey: boolean): string {
-  return `${provider}\0${baseUrl}\0${hasKey ? 'key' : 'no-key'}`
-}
-
-function dedupeEntries(entries: ModelCatalogEntry[]): ModelCatalogEntry[] {
-  const seen = new Set<string>()
-  const out: ModelCatalogEntry[] = []
-  for (const entry of entries) {
-    if (seen.has(entry.id)) continue
-    seen.add(entry.id)
-    out.push(entry)
-  }
-  return out
-}
-
-function dedupeStrings(values: string[]): string[] {
-  const seen = new Set<string>()
-  const out: string[] = []
-  for (const value of values) {
-    if (seen.has(value)) continue
-    seen.add(value)
-    out.push(value)
-  }
-  return out
-}