openllmprovider 0.1.0

package/src/auth/store.ts

@@ -0,0 +1,357 @@
+import { createLogger } from '../logger.js'
+import { type StorageAdapter, createDefaultStorage } from '../storage/index.js'
+import type { AuthCredential } from '../types/plugin.js'
+import type { DiskScanResult, DiskScanner, ScanContext } from './scanners.js'
+import { DEFAULT_SCANNERS, createNodeScanContext, runDiskScanners } from './scanners.js'
+
+const log = createLogger('auth')
+
+export interface DiscoveredCredential {
+  providerId: string
+  source: 'env' | 'disk' | 'auth'
+  key?: string
+  credential?: AuthCredential
+  location?: string
+}
+
+export interface DiscoverOptions {
+  scanners?: DiskScanner[]
+  scanContext?: ScanContext
+  skipDiskScan?: boolean
+  skipEnvScan?: boolean
+  persist?: boolean
+}
+
+export interface AuthStoreOptions {
+  storage?: StorageAdapter
+  data?: Record<string, AuthCredential>
+}
+
+export interface AuthStore {
+  all(): Promise<Record<string, AuthCredential>>
+  get(providerId: string): Promise<AuthCredential | null>
+  set(providerId: string, credential: AuthCredential): Promise<void>
+  remove(providerId: string): Promise<void>
+  discover(options?: DiscoverOptions): Promise<DiscoveredCredential[]>
+  getPreferred?(providerId: string, prefer: 'api' | 'oauth'): Promise<AuthCredential | null>
+}
+
+function pickBestCredential(creds: AuthCredential[], prefer: 'api' | 'oauth' = 'api'): AuthCredential | undefined {
+  if (creds.length === 0) return undefined
+  const preferred = creds.find((c) => c.type === prefer && c.key !== undefined)
+  if (preferred !== undefined) return preferred
+  const withKey = creds.find((c) => c.key !== undefined)
+  if (withKey !== undefined) return withKey
+  return creds[0]
+}
+
+export function createAuthStore(options?: AuthStoreOptions): AuthStore {
+  const externalData = options?.data
+  let storagePromise: Promise<StorageAdapter> | undefined
+  const discoveredCredentials = new Map<string, AuthCredential[]>()
+
+  log('auth store created, external=%s', externalData !== undefined)
+
+  function getStorage(): Promise<StorageAdapter> {
+    if (storagePromise === undefined) {
+      storagePromise = options?.storage ? Promise.resolve(options.storage) : createDefaultStorage()
+    }
+    return storagePromise
+  }
+
+  async function readAuthState(): Promise<Record<string, AuthCredential>> {
+    if (externalData !== undefined) {
+      log('using external data, skipping file read')
+      return { ...externalData }
+    }
+
+    const storage = await getStorage()
+    const raw = await storage.get(AUTH_STORE_KEY)
+    if (raw === null) {
+      log('auth store not found, returning empty store')
+      return {}
+    }
+
+    const parsed: unknown = JSON.parse(raw)
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+      log('auth store payload is malformed, returning empty store')
+      return {}
+    }
+
+    const normalized = normalizeAuthState(parsed as Record<string, unknown>)
+    log('read auth store with %d entries', Object.keys(normalized).length)
+    return normalized
+  }
+
+  async function writeAuthState(data: Record<string, AuthCredential>): Promise<void> {
+    if (externalData !== undefined) {
+      for (const [k, v] of Object.entries(data)) {
+        externalData[k] = v
+      }
+      for (const k of Object.keys(externalData)) {
+        if (!(k in data)) {
+          delete externalData[k]
+        }
+      }
+      log('updated external data, %d entries', Object.keys(externalData).length)
+      return
+    }
+
+    const content = JSON.stringify(data, null, 2)
+    const storage = await getStorage()
+    await storage.set(AUTH_STORE_KEY, content)
+
+    log('wrote auth store with %d entries', Object.keys(data).length)
+  }
+
+  function mergeWithDiscovered(fileData: Record<string, AuthCredential>): Record<string, AuthCredential> {
+    if (discoveredCredentials.size === 0) return fileData
+    const merged = { ...fileData }
+    for (const [pid, creds] of discoveredCredentials) {
+      if (merged[pid] === undefined || !merged[pid].key) {
+        const best = pickBestCredential(creds, 'api')
+        if (best !== undefined) {
+          merged[pid] = best
+        }
+      }
+    }
+    log(
+      'merged %d discovered credentials with %d file entries',
+      discoveredCredentials.size,
+      Object.keys(fileData).length
+    )
+    return merged
+  }
+
+  function pushDiscoveredCredential(providerId: string, credential: AuthCredential): void {
+    const arr = discoveredCredentials.get(providerId) ?? []
+    arr.push(credential)
+    discoveredCredentials.set(providerId, arr)
+  }
+
+  function pushDiscoveredResultOnce(
+    seen: Set<string>,
+    results: DiscoveredCredential[],
+    result: DiscoveredCredential
+  ): boolean {
+    if (seen.has(result.providerId)) return false
+    seen.add(result.providerId)
+    results.push(result)
+    return true
+  }
+
+  function buildCredentialFromEnv(envVar: string, key: string): AuthCredential {
+    return buildCredential({ type: 'api', key, location: `env:${envVar}` })
+  }
+
+  function buildCredentialFromDisk(result: DiskScanResult): AuthCredential | undefined {
+    if (result.key === undefined) return undefined
+    return buildCredential({
+      type: result.credentialType ?? 'api',
+      key: result.key,
+      location: result.source,
+      refresh: result.refresh,
+      accountId: result.accountId,
+      expires: result.expires,
+    })
+  }
+
+  return {
+    async all(): Promise<Record<string, AuthCredential>> {
+      return mergeWithDiscovered(await readAuthState())
+    },
+
+    async get(providerId: string): Promise<AuthCredential | null> {
+      const store = mergeWithDiscovered(await readAuthState())
+      const credential = store[providerId]
+      if (credential === undefined) {
+        log('get(%s): not found', providerId)
+        return null
+      }
+      log('get(%s): found type=%s', providerId, credential.type)
+      return credential
+    },
+
+    async set(providerId: string, credential: AuthCredential): Promise<void> {
+      const store = await readAuthState()
+      store[providerId] = credential
+      await writeAuthState(store)
+      log('set(%s): type=%s', providerId, credential.type)
+    },
+
+    async remove(providerId: string): Promise<void> {
+      const store = await readAuthState()
+      if (!(providerId in store)) {
+        log('remove(%s): not found, no-op', providerId)
+        return
+      }
+      delete store[providerId]
+      await writeAuthState(store)
+      log('remove(%s): done', providerId)
+    },
+
+    async discover(discoverOptions?: DiscoverOptions): Promise<DiscoveredCredential[]> {
+      const results: DiscoveredCredential[] = []
+      const seen = new Set<string>()
+
+      if (!discoverOptions?.skipEnvScan) {
+        for (const [envVar, providerId] of ENV_HINTS) {
+          const value = process.env[envVar]
+          if (value) {
+            pushDiscoveredCredential(providerId, buildCredentialFromEnv(envVar, value))
+            pushDiscoveredResultOnce(seen, results, { providerId, source: 'env', key: value })
+            log('discover: %s [api] from env:%s', providerId, envVar)
+          }
+        }
+      }
+
+      if (!discoverOptions?.skipDiskScan) {
+        const scanners = discoverOptions?.scanners ?? DEFAULT_SCANNERS
+        const ctx = discoverOptions?.scanContext ?? createNodeScanContext()
+        const diskResults = await runDiskScanners(scanners, ctx)
+
+        for (const disk of diskResults) {
+          const credType = disk.credentialType ?? 'api'
+          pushDiscoveredResultOnce(seen, results, {
+            providerId: disk.providerId,
+            source: 'disk',
+            key: disk.key,
+            location: disk.source,
+          })
+          const cred = buildCredentialFromDisk(disk)
+          if (cred !== undefined) {
+            pushDiscoveredCredential(disk.providerId, cred)
+            log('discover: %s [%s] from %s', disk.providerId, credType, disk.source)
+          }
+        }
+      }
+
+      if (discoverOptions?.persist === true) {
+        const persistedCount = await persistDiscoveredCredentials()
+        log('discover: persisted %d providers to auth store', persistedCount)
+      }
+
+      let authData: Record<string, AuthCredential>
+      try {
+        authData = await readAuthState()
+      } catch (err: unknown) {
+        log('discover: failed to read auth store: %s', err instanceof Error ? err.message : String(err))
+        authData = {}
+      }
+
+      for (const [providerId, credential] of Object.entries(authData)) {
+        const added = pushDiscoveredResultOnce(seen, results, { providerId, source: 'auth', credential })
+        if (added) log('discover: %s via auth store', providerId)
+      }
+
+      log('discover: complete, %d providers found', results.length)
+      return results
+    },
+
+    async getPreferred(providerId: string, prefer: 'api' | 'oauth'): Promise<AuthCredential | null> {
+      const creds = discoveredCredentials.get(providerId)
+      if (creds !== undefined && creds.length > 0) {
+        const best = pickBestCredential(creds, prefer)
+        if (best !== undefined) return best
+      }
+      const store = mergeWithDiscovered(await readAuthState())
+      const credential = store[providerId]
+      return credential ?? null
+    },
+  }
+
+  async function persistDiscoveredCredentials(): Promise<number> {
+    if (discoveredCredentials.size === 0) return 0
+
+    const store = await readAuthState()
+    let changed = 0
+
+    for (const [providerId, creds] of discoveredCredentials) {
+      const existing = store[providerId]
+      if (existing?.key) {
+        continue
+      }
+
+      const best = pickBestCredential(creds, 'api')
+      if (best === undefined) {
+        continue
+      }
+
+      store[providerId] = best
+      changed += 1
+    }
+
+    if (changed > 0) {
+      await writeAuthState(store)
+    }
+
+    return changed
+  }
+}
+
+const AUTH_STORE_KEY = 'auth:store'
+
+interface CredentialBuildInput {
+  type: 'api' | 'oauth' | 'wellknown'
+  key?: string
+  location?: string
+  refresh?: string
+  accountId?: string
+  expires?: number
+}
+
+function buildCredential(input: CredentialBuildInput): AuthCredential {
+  const credential: AuthCredential = {
+    type: input.type,
+    key: input.key,
+    location: input.location,
+  }
+
+  if (input.refresh !== undefined) credential.refresh = input.refresh
+  if (input.accountId !== undefined) credential.accountId = input.accountId
+  if (input.expires !== undefined) credential.expires = input.expires
+
+  return credential
+}
+
+function normalizeAuthState(input: Record<string, unknown>): Record<string, AuthCredential> {
+  const normalized: Record<string, AuthCredential> = {}
+
+  for (const [providerId, rawCredential] of Object.entries(input)) {
+    const credential = normalizeCredential(rawCredential)
+    if (credential !== undefined) {
+      normalized[providerId] = credential
+    }
+  }
+
+  return normalized
+}
+
+function normalizeCredential(rawCredential: unknown): AuthCredential | undefined {
+  if (typeof rawCredential !== 'object' || rawCredential === null || Array.isArray(rawCredential)) {
+    return undefined
+  }
+
+  const typed = rawCredential as Record<string, unknown>
+  const type =
+    typed.type === 'api' || typed.type === 'oauth' || typed.type === 'wellknown' ? typed.type : ('api' as const)
+
+  const key = typeof typed.key === 'string' && typed.key.length > 0 ? typed.key : undefined
+  return {
+    ...typed,
+    type,
+    key,
+  } as AuthCredential
+}
+
+const ENV_HINTS: Array<[string, string]> = [
+  ['ANTHROPIC_API_KEY', 'anthropic'],
+  ['OPENAI_API_KEY', 'openai'],
+  ['GOOGLE_GENERATIVE_AI_API_KEY', 'google'],
+  ['GOOGLE_API_KEY', 'google'],
+  ['AZURE_API_KEY', 'azure'],
+  ['XAI_API_KEY', 'xai'],
+  ['MISTRAL_API_KEY', 'mistral'],
+  ['GROQ_API_KEY', 'groq'],
+  ['OPENROUTER_API_KEY', 'openrouter'],
+]

package/src/catalog/catalog.ts

@@ -0,0 +1,302 @@
+import { createLogger } from '../logger.js'
+import type { ModelDefinition } from '../types/model.js'
+import { mapModelsDevProvider, mapModelsDevProviderMetadata } from './mapper.js'
+import { mergeCatalogData, mergeModelDefinitions } from './merger.js'
+
+const DEFAULT_REMOTE_URL = 'https://models.dev/api.json'
+const DEFAULT_TIMEOUT_MS = 10_000
+
+const log = createLogger('catalog')
+
+type CatalogDataSource = Record<string, unknown>
+type ProviderModelMap = Map<string, Map<string, ModelDefinition>>
+type FetchLike = (
+  url: string,
+  init?: { signal?: unknown }
+) => Promise<{ ok: boolean; status: number; json(): Promise<unknown> }>
+
+export interface CatalogProvider {
+  id: string
+  name: string
+  env?: string[]
+  api?: string
+  doc?: string
+  bundledProvider?: string
+  baseURL?: string
+  headers?: Record<string, string>
+  options?: Record<string, unknown>
+}
+
+export interface ExtendModelConfig {
+  name?: string
+  modalities?: {
+    input: Array<'text' | 'image' | 'audio' | 'video' | 'pdf'>
+    output: Array<'text' | 'image' | 'audio'>
+  }
+  limit?: { context: number; output: number }
+}
+
+export interface ExtendProviderConfig {
+  name: string
+  env?: string[]
+  bundledProvider?: string
+  baseURL?: string
+  headers?: Record<string, string>
+  options?: Record<string, unknown>
+  models?: Record<string, ExtendModelConfig>
+}
+
+export interface ExtendConfig {
+  providers?: Record<string, ExtendProviderConfig>
+}
+
+export interface CatalogOptions {
+  snapshot?: Record<string, unknown>
+  remote?: {
+    url?: string
+    timeoutMs?: number
+    fetch?: FetchLike
+  }
+}
+
+export interface RefreshResult {
+  success: boolean
+  updatedProviders: string[]
+  newModels: number
+  error?: Error
+}
+
+export class Catalog {
+  private readonly remoteOptions: {
+    readonly url: string
+    readonly timeoutMs: number
+    readonly fetch?: FetchLike
+  }
+
+  private readonly snapshotData: CatalogDataSource
+  private remoteData: CatalogDataSource = {}
+  private readonly providers = new Map<string, CatalogProvider>()
+  private modelsByProvider: ProviderModelMap = new Map()
+  private refreshInFlight: Promise<RefreshResult> | null = null
+  private readonly extendedProviders = new Map<string, CatalogProvider>()
+  private readonly extendedModels = new Map<string, Map<string, Partial<ModelDefinition>>>()
+
+  constructor(options: CatalogOptions = {}) {
+    this.snapshotData = options.snapshot ?? {}
+    this.remoteOptions = {
+      url: options.remote?.url ?? DEFAULT_REMOTE_URL,
+      timeoutMs: options.remote?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      fetch: options.remote?.fetch,
+    }
+    this.applyProviderMetadata(this.snapshotData, {})
+    log('initialized with %d providers from snapshot', this.providers.size)
+  }
+
+  getProvider(id: string): CatalogProvider | undefined {
+    return this.providers.get(id)
+  }
+
+  listProviders(): CatalogProvider[] {
+    return [...this.providers.values()]
+  }
+
+  getModel(providerId: string, modelId: string): ModelDefinition | undefined {
+    this.ensureProviderModelsLoaded(providerId)
+    return this.modelsByProvider.get(providerId)?.get(modelId)
+  }
+
+  listModels(providerId?: string): ModelDefinition[] {
+    if (providerId !== undefined) {
+      this.ensureProviderModelsLoaded(providerId)
+      return [...(this.modelsByProvider.get(providerId)?.values() ?? [])]
+    }
+
+    const results: ModelDefinition[] = []
+    for (const pid of this.providers.keys()) {
+      this.ensureProviderModelsLoaded(pid)
+      const models = this.modelsByProvider.get(pid)
+      if (models) {
+        results.push(...models.values())
+      }
+    }
+    return results
+  }
+
+  enrichModel(providerId: string, modelId: string, partial: Partial<ModelDefinition>): ModelDefinition {
+    const catalogModel = this.getModel(providerId, modelId)
+    const partialWithId = { ...partial, modelId }
+    if (!catalogModel) {
+      return partialWithId as ModelDefinition
+    }
+    return mergeModelDefinitions(catalogModel, partialWithId)
+  }
+
+  extend(config: ExtendConfig): void {
+    if (!config.providers) return
+
+    for (const [providerId, providerConfig] of Object.entries(config.providers)) {
+      const existingProvider = this.providers.get(providerId)
+      const provider: CatalogProvider = {
+        id: providerId,
+        name: providerConfig.name,
+        ...(providerConfig.env !== undefined ? { env: providerConfig.env } : {}),
+        ...(existingProvider?.api !== undefined ? { api: existingProvider.api } : {}),
+        ...(existingProvider?.doc !== undefined ? { doc: existingProvider.doc } : {}),
+        ...(providerConfig.bundledProvider !== undefined ? { bundledProvider: providerConfig.bundledProvider } : {}),
+        ...(providerConfig.baseURL !== undefined ? { baseURL: providerConfig.baseURL } : {}),
+        ...(providerConfig.headers !== undefined ? { headers: providerConfig.headers } : {}),
+        ...(providerConfig.options !== undefined ? { options: providerConfig.options } : {}),
+      }
+
+      this.extendedProviders.set(providerId, provider)
+      this.providers.set(providerId, provider)
+
+      if (providerConfig.models) {
+        const modelOverrides = this.extendedModels.get(providerId) ?? new Map<string, Partial<ModelDefinition>>()
+
+        for (const [modelId, modelConfig] of Object.entries(providerConfig.models)) {
+          const partial: Partial<ModelDefinition> = { modelId }
+          if (modelConfig.name !== undefined) partial.name = modelConfig.name
+          if (modelConfig.modalities !== undefined) partial.modalities = modelConfig.modalities
+          if (modelConfig.limit !== undefined) partial.limit = modelConfig.limit
+          modelOverrides.set(modelId, partial)
+        }
+
+        this.extendedModels.set(providerId, modelOverrides)
+      }
+
+      this.modelsByProvider.delete(providerId)
+    }
+  }
+
+  refresh(): Promise<RefreshResult> {
+    if (this.refreshInFlight) {
+      return this.refreshInFlight
+    }
+
+    const task = this.refreshInternal().finally(() => {
+      this.refreshInFlight = null
+    })
+
+    this.refreshInFlight = task
+    return task
+  }
+
+  private async refreshInternal(): Promise<RefreshResult> {
+    try {
+      log('refresh: fetching from %s', this.remoteOptions.url)
+      const remoteData = await this.fetchRemoteData()
+      this.remoteData = remoteData
+      const { updatedProviders } = this.applyProviderMetadata(this.snapshotData, this.remoteData)
+      this.modelsByProvider.clear()
+      log('refresh: updated %d providers', updatedProviders.length)
+      return { success: true, updatedProviders, newModels: 0 }
+    } catch (error) {
+      log('refresh: failed — %s', error instanceof Error ? error.message : String(error))
+      return {
+        success: false,
+        updatedProviders: [],
+        newModels: 0,
+        error: error instanceof Error ? error : new Error(String(error)),
+      }
+    }
+  }
+
+  private async fetchRemoteData(): Promise<CatalogDataSource> {
+    const fetchFn = this.remoteOptions.fetch ?? this.resolveGlobalFetch()
+    if (!fetchFn) throw new Error('No fetch implementation available')
+
+    const response = await fetchFn(this.remoteOptions.url)
+    if (!response.ok) throw new Error(`Failed to fetch remote catalog: HTTP ${response.status}`)
+
+    const payload = await response.json()
+    if (payload && typeof payload === 'object') return payload as CatalogDataSource
+    throw new Error('Invalid remote catalog payload')
+  }
+
+  private resolveGlobalFetch(): FetchLike | undefined {
+    const maybeFetch = (globalThis as Record<string, unknown>).fetch
+    return typeof maybeFetch === 'function' ? (maybeFetch as FetchLike) : undefined
+  }
+
+  private applyProviderMetadata(
+    snapshotRaw: CatalogDataSource,
+    remoteRaw: CatalogDataSource
+  ): { updatedProviders: string[] } {
+    const snapshotProviders = this.mapProviderMetadata(snapshotRaw)
+    const remoteProviders = this.mapProviderMetadata(remoteRaw)
+    const allProviderIds = new Set<string>([...snapshotProviders.keys(), ...remoteProviders.keys()])
+
+    this.providers.clear()
+    for (const providerId of allProviderIds) {
+      const provider = remoteProviders.get(providerId) ?? snapshotProviders.get(providerId)
+      if (provider) this.providers.set(providerId, provider)
+    }
+
+    for (const [providerId, provider] of this.extendedProviders.entries()) {
+      this.providers.set(providerId, provider)
+    }
+
+    return { updatedProviders: [...remoteProviders.keys()] }
+  }
+
+  private mapProviderMetadata(data: CatalogDataSource): Map<string, CatalogProvider> {
+    const result = new Map<string, CatalogProvider>()
+    for (const [providerId, rawProvider] of Object.entries(data)) {
+      if (providerId.startsWith('_')) continue
+      result.set(providerId, mapModelsDevProviderMetadata(providerId, rawProvider))
+    }
+    return result
+  }
+
+  private providerRaw(data: CatalogDataSource, providerId: string): unknown {
+    const value = data[providerId]
+    return value && typeof value === 'object' ? value : undefined
+  }
+
+  private mapProviderModelsFromRaw(
+    providerId: string,
+    raw: unknown,
+    provenance: 'snapshot' | 'remote'
+  ): Map<string, ModelDefinition> {
+    if (!raw || typeof raw !== 'object') return new Map<string, ModelDefinition>()
+    const mapped = mapModelsDevProvider(providerId, raw, provenance)
+    const byId = new Map<string, ModelDefinition>()
+    for (const model of mapped.models) {
+      byId.set(model.modelId, model)
+    }
+    return byId
+  }
+
+  private ensureProviderModelsLoaded(providerId: string): void {
+    if (this.modelsByProvider.has(providerId)) return
+
+    const snapshotModels = this.mapProviderModelsFromRaw(
+      providerId,
+      this.providerRaw(this.snapshotData, providerId),
+      'snapshot'
+    )
+    const remoteModels = this.mapProviderModelsFromRaw(
+      providerId,
+      this.providerRaw(this.remoteData, providerId),
+      'remote'
+    )
+    const extendedOverrides = this.extendedModels.get(providerId) ?? new Map<string, Partial<ModelDefinition>>()
+
+    const merged = mergeCatalogData(snapshotModels, remoteModels, extendedOverrides)
+
+    for (const [modelId, partial] of extendedOverrides.entries()) {
+      if (!merged.has(modelId)) {
+        const base: ModelDefinition = {
+          modelId,
+          modalities: { input: ['text'], output: ['text'] },
+          limit: { context: 0, output: 0 },
+          provenance: 'user-override',
+        }
+        merged.set(modelId, mergeModelDefinitions(base, partial))
+      }
+    }
+
+    this.modelsByProvider.set(providerId, merged)
+  }
+}

package/src/catalog/index.ts

@@ -0,0 +1,17 @@
+import type { CatalogOptions } from './catalog.js'
+import { Catalog } from './catalog.js'
+
+export type {
+  CatalogOptions,
+  CatalogProvider,
+  ExtendConfig,
+  ExtendModelConfig,
+  ExtendProviderConfig,
+  RefreshResult,
+} from './catalog.js'
+
+export { Catalog }
+
+export function createCatalog(options: CatalogOptions = {}): Catalog {
+  return new Catalog(options)
+}