openllmprovider 0.1.0

package/src/provider/bundled.ts

@@ -0,0 +1,59 @@
+import type { LanguageModelV3 } from '@ai-sdk/provider'
+import { createLogger } from '../logger.js'
+
+const log = createLogger('provider:bundled')
+
+export interface ProviderInstance {
+  languageModel(modelId: string): LanguageModelV3
+}
+
+export type ProviderFactory = (options: Record<string, unknown>) => ProviderInstance
+
+const PROVIDER_LOADERS: Record<string, () => Promise<ProviderFactory>> = {
+  '@ai-sdk/anthropic': () => import('@ai-sdk/anthropic').then((m) => m.createAnthropic as unknown as ProviderFactory),
+  '@ai-sdk/openai': () => import('@ai-sdk/openai').then((m) => m.createOpenAI as unknown as ProviderFactory),
+  '@ai-sdk/google': () =>
+    import('@ai-sdk/google').then((m) => m.createGoogleGenerativeAI as unknown as ProviderFactory),
+  '@ai-sdk/google-vertex': () =>
+    import('@ai-sdk/google-vertex').then((m) => m.createVertex as unknown as ProviderFactory),
+  '@ai-sdk/amazon-bedrock': () =>
+    import('@ai-sdk/amazon-bedrock').then((m) => m.createAmazonBedrock as unknown as ProviderFactory),
+  '@ai-sdk/azure': () => import('@ai-sdk/azure').then((m) => m.createAzure as unknown as ProviderFactory),
+  '@ai-sdk/openai-compatible': () =>
+    import('@ai-sdk/openai-compatible').then((m) => m.createOpenAICompatible as unknown as ProviderFactory),
+  '@ai-sdk/xai': () => import('@ai-sdk/xai').then((m) => m.createXai as unknown as ProviderFactory),
+  '@ai-sdk/mistral': () => import('@ai-sdk/mistral').then((m) => m.createMistral as unknown as ProviderFactory),
+  '@ai-sdk/groq': () => import('@ai-sdk/groq').then((m) => m.createGroq as unknown as ProviderFactory),
+  '@openrouter/ai-sdk-provider': () =>
+    import('@openrouter/ai-sdk-provider').then((m) => m.createOpenRouter as unknown as ProviderFactory),
+}
+
+const loadedProviders = new Map<string, ProviderFactory>()
+const unavailableProviders = new Set<string>()
+
+export async function loadProvider(packageName: string): Promise<ProviderFactory | undefined> {
+  if (loadedProviders.has(packageName)) return loadedProviders.get(packageName)
+  if (unavailableProviders.has(packageName)) return undefined
+
+  const loader = PROVIDER_LOADERS[packageName]
+  if (loader === undefined) return undefined
+
+  try {
+    const factory = await loader()
+    loadedProviders.set(packageName, factory)
+    log('loaded provider package: %s', packageName)
+    return factory
+  } catch {
+    unavailableProviders.add(packageName)
+    log('provider package not available: %s (not installed)', packageName)
+    return undefined
+  }
+}
+
+export async function isProviderInstalled(packageName: string): Promise<boolean> {
+  return (await loadProvider(packageName)) !== undefined
+}
+
+export function getAllProviderPackages(): string[] {
+  return Object.keys(PROVIDER_LOADERS)
+}

package/src/provider/index.ts

@@ -0,0 +1,249 @@
+import type { LanguageModelV3 } from '@ai-sdk/provider'
+import type { AuthStore } from '../auth/store.js'
+import { createAuthStore } from '../auth/store.js'
+import type { CatalogProvider, ExtendConfig } from '../catalog/catalog.js'
+import { Catalog } from '../catalog/catalog.js'
+import { createLogger } from '../logger.js'
+import { anthropicPlugin } from '../plugin/anthropic.js'
+import { codexPlugin } from '../plugin/codex.js'
+import { copilotPlugin } from '../plugin/copilot.js'
+import { googlePlugin } from '../plugin/google.js'
+import { registerPlugin } from '../plugin/index.js'
+import type { ModelDefinition } from '../types/model.js'
+import type { ProviderUserConfig } from '../types/provider.js'
+import { isProviderInstalled, loadProvider } from './bundled.js'
+import { buildProviderState } from './state.js'
+
+export type { ProviderInstance, ProviderFactory } from './bundled.js'
+export { loadProvider, isProviderInstalled, getAllProviderPackages } from './bundled.js'
+
+const log = createLogger('provider')
+
+const DEFAULT_PROVIDERS: Record<string, { name: string; env: string[]; bundledProvider: string }> = {
+  anthropic: { name: 'Anthropic', env: ['ANTHROPIC_API_KEY'], bundledProvider: '@ai-sdk/anthropic' },
+  openai: { name: 'OpenAI', env: ['OPENAI_API_KEY'], bundledProvider: '@ai-sdk/openai' },
+  google: {
+    name: 'Google AI',
+    env: ['GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_API_KEY'],
+    bundledProvider: '@ai-sdk/google',
+  },
+  'google-vertex': { name: 'Google Vertex AI', env: [], bundledProvider: '@ai-sdk/google-vertex' },
+  'amazon-bedrock': { name: 'Amazon Bedrock', env: [], bundledProvider: '@ai-sdk/amazon-bedrock' },
+  azure: { name: 'Azure OpenAI', env: ['AZURE_API_KEY'], bundledProvider: '@ai-sdk/azure' },
+  xai: { name: 'xAI', env: ['XAI_API_KEY'], bundledProvider: '@ai-sdk/xai' },
+  mistral: { name: 'Mistral', env: ['MISTRAL_API_KEY'], bundledProvider: '@ai-sdk/mistral' },
+  groq: { name: 'Groq', env: ['GROQ_API_KEY'], bundledProvider: '@ai-sdk/groq' },
+  openrouter: { name: 'OpenRouter', env: ['OPENROUTER_API_KEY'], bundledProvider: '@openrouter/ai-sdk-provider' },
+  'github-copilot': { name: 'GitHub Copilot', env: [], bundledProvider: '@ai-sdk/openai-compatible' },
+}
+
+function resolveBundledProviderKey(providerId: string, catalogProvider?: CatalogProvider): string | undefined {
+  if (catalogProvider?.bundledProvider !== undefined) return catalogProvider.bundledProvider
+  return DEFAULT_PROVIDERS[providerId]?.bundledProvider
+}
+
+export interface ProviderStoreConfig {
+  userConfig?: Record<string, ProviderUserConfig>
+}
+
+export interface ProviderListOptions {
+  includeUnavailable?: boolean
+}
+
+export interface ModelListOptions {
+  includeUnavailable?: boolean
+}
+
+export interface GetModelOptions {
+  includeUnavailable?: boolean
+}
+
+export interface ProviderStore {
+  getLanguageModel(providerId: string, modelId: string): Promise<LanguageModelV3>
+  extend(config: ExtendConfig): void
+  listProviders(options?: ProviderListOptions): Promise<CatalogProvider[]>
+  listModels(providerId?: string, options?: ModelListOptions): Promise<ModelDefinition[]>
+  getModel(providerId: string, modelId: string, options?: GetModelOptions): Promise<ModelDefinition | undefined>
+}
+
+export function createProviderStore(authStore: AuthStore, config?: ProviderStoreConfig): ProviderStore {
+  const catalog = new Catalog()
+  registerPlugin(copilotPlugin)
+  registerPlugin(codexPlugin)
+  registerPlugin(googlePlugin)
+  registerPlugin(anthropicPlugin)
+  catalog.extend({
+    providers: Object.fromEntries(
+      Object.entries(DEFAULT_PROVIDERS).map(([id, p]) => [
+        id,
+        { name: p.name, env: p.env, bundledProvider: p.bundledProvider },
+      ])
+    ),
+  })
+  const userConfig = config?.userConfig
+  let stateCache: Promise<Record<string, import('./state.js').ProviderState>> | null = null
+  let catalogRefreshTask: Promise<void> | null = null
+
+  function invalidateState() {
+    stateCache = null
+  }
+
+  function getState() {
+    if (stateCache === null) {
+      log('initializing provider state')
+      stateCache = buildProviderState({ catalog, authStore, userConfig })
+    }
+    return stateCache
+  }
+
+  async function ensureCatalogEnriched(): Promise<void> {
+    if (catalogRefreshTask === null) {
+      catalogRefreshTask = (async () => {
+        const result = await catalog.refresh()
+        if (!result.success) {
+          log('catalog refresh failed: %s', result.error?.message ?? 'unknown error')
+          return
+        }
+        log('catalog refreshed with %d providers', result.updatedProviders.length)
+        invalidateState()
+      })()
+    }
+    await catalogRefreshTask
+  }
+
+  function hasProviderAuth(state: Record<string, import('./state.js').ProviderState>, providerId: string): boolean {
+    const providerState = state[providerId]
+    return providerState !== undefined && providerState.source !== 'none'
+  }
+
+  async function checkProviderUsable(providerId: string): Promise<boolean> {
+    const catalogProvider = catalog.getProvider(providerId)
+    const bundledKey = resolveBundledProviderKey(providerId, catalogProvider)
+    if (bundledKey === undefined) return false
+    return isProviderInstalled(bundledKey)
+  }
+
+  return {
+    async getLanguageModel(providerId: string, modelId: string): Promise<LanguageModelV3> {
+      await ensureCatalogEnriched()
+      const state = await getState()
+      const providerState = state[providerId]
+
+      log(
+        'getLanguageModel(%s, %s) — auth: source=%s, location=%s',
+        providerId,
+        modelId,
+        providerState?.source ?? 'none',
+        providerState?.location ?? 'unknown'
+      )
+      if (providerState === undefined) {
+        throw new Error(`Provider not found in catalog: ${providerId}`)
+      }
+
+      const catalogProvider = catalog.getProvider(providerId)
+      const bundledKey = resolveBundledProviderKey(providerId, catalogProvider)
+
+      if (bundledKey === undefined) {
+        throw new Error(
+          `No bundled provider mapping found for: ${providerId}. Set bundledProvider in catalog extend() config.`
+        )
+      }
+
+      const factory = await loadProvider(bundledKey)
+
+      if (factory === undefined) {
+        throw new Error(`Provider package not available: ${bundledKey}. Install it with: npm install ${bundledKey}`)
+      }
+
+      log('creating SDK for %s using %s', providerId, bundledKey)
+
+      const sdkOptions = { ...providerState.options }
+      if (providerState.key !== undefined) {
+        sdkOptions.apiKey = providerState.key
+      }
+      // authToken and apiKey must not coexist (e.g. @ai-sdk/anthropic rejects both)
+      if (sdkOptions.authToken !== undefined) {
+        sdkOptions.apiKey = undefined
+      }
+
+      const sdk = factory(sdkOptions)
+      log('calling sdk.languageModel(%s)', modelId)
+      return sdk.languageModel(modelId)
+    },
+
+    extend(extendConfig: ExtendConfig): void {
+      catalog.extend(extendConfig)
+      invalidateState()
+    },
+
+    async listProviders(options?: ProviderListOptions): Promise<CatalogProvider[]> {
+      await ensureCatalogEnriched()
+      const allProviders = catalog.listProviders()
+
+      const usabilityChecks = await Promise.all(
+        allProviders.map(async (p) => ({ provider: p, usable: await checkProviderUsable(p.id) }))
+      )
+      const installedProviders = usabilityChecks.filter((r) => r.usable).map((r) => r.provider)
+
+      if (options?.includeUnavailable === true) {
+        return installedProviders
+      }
+      const state = await getState()
+      return installedProviders.filter((provider) => hasProviderAuth(state, provider.id))
+    },
+
+    async listModels(providerId?: string, options?: ModelListOptions): Promise<ModelDefinition[]> {
+      await ensureCatalogEnriched()
+      if (options?.includeUnavailable === true) {
+        return catalog.listModels(providerId)
+      }
+
+      const state = await getState()
+      if (providerId !== undefined) {
+        if (!hasProviderAuth(state, providerId)) {
+          return []
+        }
+        return catalog.listModels(providerId)
+      }
+
+      const allProviders = catalog.listProviders()
+      const usabilityChecks = await Promise.all(
+        allProviders.map(async (p) => ({
+          provider: p,
+          usable: (await checkProviderUsable(p.id)) && hasProviderAuth(state, p.id),
+        }))
+      )
+
+      const results: ModelDefinition[] = []
+      for (const { provider, usable } of usabilityChecks) {
+        if (usable) {
+          results.push(...catalog.listModels(provider.id))
+        }
+      }
+      return results
+    },
+
+    async getModel(
+      providerId: string,
+      modelId: string,
+      options?: GetModelOptions
+    ): Promise<ModelDefinition | undefined> {
+      await ensureCatalogEnriched()
+      if (options?.includeUnavailable !== true) {
+        const state = await getState()
+        if (!hasProviderAuth(state, providerId)) {
+          return undefined
+        }
+      }
+      return catalog.getModel(providerId, modelId)
+    },
+  }
+}
+
+export function getLanguageModel(
+  providerId: string,
+  modelId: string,
+  config?: ProviderStoreConfig
+): Promise<LanguageModelV3> {
+  return createProviderStore(createAuthStore(), config).getLanguageModel(providerId, modelId)
+}

package/src/provider/state.ts

@@ -0,0 +1,163 @@
+import type { AuthStore } from '../auth/store.js'
+import type { Catalog } from '../catalog/catalog.js'
+import { createLogger } from '../logger.js'
+import { loadPluginOptions } from '../plugin/index.js'
+import type { SecretRef } from '../types/auth.js'
+import type { ProviderUserConfig } from '../types/provider.js'
+
+const log = createLogger('provider:state')
+
+export interface ProviderState {
+  id: string
+  key?: string
+  options: Record<string, unknown>
+  source: 'env' | 'disk' | 'auth' | 'plugin' | 'config' | 'none'
+  location?: string
+}
+
+async function resolveSecretRef(ref: SecretRef): Promise<string | undefined> {
+  if (typeof ref === 'string') return ref
+  if (ref.type === 'plain') return ref.value
+  if (ref.type === 'env') return process.env[ref.name]
+  return undefined
+}
+
+const GOOGLE_PROVIDERS = new Set(['@ai-sdk/google', '@ai-sdk/google-vertex'])
+function normalizeProviderBaseURL(providerId: string, baseURL: string): string {
+  if (providerId !== 'openai') return baseURL
+
+  try {
+    const parsed = new URL(baseURL)
+    const path = parsed.pathname.replace(/\/+$/, '')
+    if (path === '' || path === '/') {
+      parsed.pathname = '/v1'
+    }
+    return parsed.toString().replace(/\/$/, '')
+  } catch {
+    return baseURL
+  }
+}
+
+function resolveAuthBaseURL(authCred: Record<string, unknown> | undefined): string | undefined {
+  if (authCred === undefined) return undefined
+  if (typeof authCred.baseURL === 'string' && authCred.baseURL.trim().length > 0) return authCred.baseURL.trim()
+  if (typeof authCred.apiHost === 'string' && authCred.apiHost.trim().length > 0) return authCred.apiHost.trim()
+  if (typeof authCred.host === 'string' && authCred.host.trim().length > 0) return authCred.host.trim()
+  return undefined
+}
+
+export async function buildProviderState(config: {
+  catalog: Catalog
+  authStore: AuthStore
+  userConfig?: Record<string, ProviderUserConfig>
+}): Promise<Record<string, ProviderState>> {
+  const { catalog, authStore, userConfig } = config
+
+  log('building provider state')
+
+  const allProviders = catalog.listProviders()
+  const authCredentials = await authStore.all()
+
+  log('found %d catalog providers, %d auth entries', allProviders.length, Object.keys(authCredentials).length)
+
+  const result: Record<string, ProviderState> = {}
+
+  for (const catalogProvider of allProviders) {
+    const pid = catalogProvider.id
+    const options: Record<string, unknown> = {}
+    let key: string | undefined
+    let source: ProviderState['source'] = 'none'
+    let location: string | undefined
+    if (catalogProvider.baseURL !== undefined) {
+      options.baseURL = normalizeProviderBaseURL(pid, catalogProvider.baseURL)
+    }
+    if (catalogProvider.headers !== undefined) options.headers = { ...catalogProvider.headers }
+    if (catalogProvider.options !== undefined) Object.assign(options, catalogProvider.options)
+    if (catalogProvider.env !== undefined) {
+      for (const envVar of catalogProvider.env) {
+        const val = process.env[envVar]
+        if (val !== undefined) {
+          key = val
+          source = 'env'
+          location = `env:${envVar}`
+          break
+        }
+      }
+    }
+    const authCred = authCredentials[pid]
+    const authBaseURL = resolveAuthBaseURL(authCred as Record<string, unknown> | undefined)
+    if (authBaseURL !== undefined) {
+      options.baseURL = normalizeProviderBaseURL(pid, authBaseURL)
+    }
+    if (authCred?.key !== undefined) {
+      key = authCred.key
+      source = 'auth'
+      location = authCred.location
+      const bp = catalogProvider.bundledProvider
+      if (authCred.type === 'oauth' && bp !== undefined) {
+        if (GOOGLE_PROVIDERS.has(bp)) {
+          const token = authCred.key
+          options.fetch = (url: string | URL | Request, init?: RequestInit) => {
+            const h = new Headers(init?.headers)
+            h.delete('x-goog-api-key')
+            h.set('Authorization', `Bearer ${token}`)
+            return globalThis.fetch(url, { ...init, headers: h })
+          }
+        }
+      }
+    }
+
+    const getAuth = async () => {
+      const preferred = await authStore.getPreferred?.(pid, 'oauth')
+      return preferred ?? authCred ?? { type: 'api' as const }
+    }
+    const setAuth = async (credential: Parameters<AuthStore['set']>[1]) => {
+      await authStore.set(pid, credential)
+    }
+    const pluginOpts = await loadPluginOptions(pid, getAuth, { id: pid, name: catalogProvider.name }, setAuth)
+    if (pluginOpts !== undefined) {
+      Object.assign(options, pluginOpts)
+      const pluginKey = pluginOpts.apiKey
+      if (typeof pluginKey === 'string') {
+        key = pluginKey
+        source = 'plugin'
+      }
+      // Resolve actual auth credential to track correct location
+      const resolvedAuth = await getAuth()
+      if (resolvedAuth.location) {
+        location = resolvedAuth.location
+      }
+    }
+
+    const userCfg = userConfig?.[pid]
+    if (userCfg !== undefined) {
+      if (userCfg.baseURL !== undefined) options.baseURL = normalizeProviderBaseURL(pid, userCfg.baseURL)
+      if (userCfg.headers !== undefined) {
+        const existingHeaders = options.headers
+        options.headers = {
+          ...(existingHeaders !== null && typeof existingHeaders === 'object' && !Array.isArray(existingHeaders)
+            ? (existingHeaders as Record<string, string>)
+            : {}),
+          ...userCfg.headers,
+        }
+      }
+      if (userCfg.options !== undefined) Object.assign(options, userCfg.options)
+      if (userCfg.apiKey !== undefined) {
+        const resolved = await resolveSecretRef(userCfg.apiKey)
+        if (resolved !== undefined) {
+          key = resolved
+          source = 'config'
+          log('%s: resolved key from user config', pid)
+        }
+      }
+    }
+
+    if (source !== 'none') {
+      log('%s: source=%s, location=%s', pid, source, location ?? 'n/a')
+    }
+    result[pid] = { id: pid, key, options, source, location }
+  }
+
+  log('provider state built for %d providers', Object.keys(result).length)
+  return result
+}

package/src/storage/auto.ts

@@ -0,0 +1,32 @@
+import { createLogger } from '../logger.js'
+import { MemoryStorage } from './memory.js'
+
+const log = createLogger('storage')
+
+function defaultNodeDir(): string {
+  const g = globalThis as { process?: { env?: Record<string, string | undefined> } }
+  const xdg = g.process?.env?.XDG_DATA_HOME
+  if (xdg) return `${xdg}/openllmprovider/storage`
+
+  const home = g.process?.env?.HOME
+  if (home) return `${home}/.openllmprovider/storage`
+
+  return '.openllmprovider/storage'
+}
+
+export interface DefaultStorageOptions {
+  directory?: string
+}
+
+export async function createDefaultStorage(options: DefaultStorageOptions = {}) {
+  const directory = options.directory ?? defaultNodeDir()
+  try {
+    const { FileStorage } = await import('./file.js')
+    const storage = new FileStorage({ directory })
+    log('using FileStorage at %s', directory)
+    return storage
+  } catch (err) {
+    log('FileStorage unavailable, falling back to MemoryStorage: %o', err)
+    return new MemoryStorage()
+  }
+}

package/src/storage/file.ts

@@ -0,0 +1,84 @@
+import type { StorageAdapter } from './index.js'
+
+interface FsLike {
+  readFile(path: string, encoding: string): Promise<string>
+  writeFile(path: string, data: string, encoding: string): Promise<void>
+  mkdir(path: string, options: { recursive: boolean }): Promise<string | undefined>
+  unlink(path: string): Promise<void>
+  readdir(path: string): Promise<string[]>
+}
+
+interface PathLike {
+  join(...paths: string[]): string
+}
+
+async function getFs(): Promise<FsLike> {
+  return (await import('node:fs/promises')) as unknown as FsLike
+}
+
+async function getPath(): Promise<PathLike> {
+  return await import('node:path')
+}
+
+const UNSAFE_CHARS = /[/\\:*?"<>|]/g
+
+function sanitizeKey(key: string): string {
+  return key.replace(UNSAFE_CHARS, '_')
+}
+
+export interface FileStorageOptions {
+  directory: string
+}
+
+export class FileStorage implements StorageAdapter {
+  private readonly directory: string
+
+  constructor(options: FileStorageOptions) {
+    this.directory = options.directory
+  }
+
+  private async filePath(key: string): Promise<string> {
+    const path = await getPath()
+    return path.join(this.directory, sanitizeKey(key))
+  }
+
+  async get(key: string): Promise<string | null> {
+    const fs = await getFs()
+    try {
+      return await fs.readFile(await this.filePath(key), 'utf-8')
+    } catch (err: unknown) {
+      if (isEnoent(err)) return null
+      throw err
+    }
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    const fs = await getFs()
+    await fs.mkdir(this.directory, { recursive: true })
+    await fs.writeFile(await this.filePath(key), value, 'utf-8')
+  }
+
+  async remove(key: string): Promise<void> {
+    const fs = await getFs()
+    try {
+      await fs.unlink(await this.filePath(key))
+    } catch (err: unknown) {
+      if (isEnoent(err)) return
+      throw err
+    }
+  }
+
+  async list(): Promise<string[]> {
+    const fs = await getFs()
+    try {
+      return await fs.readdir(this.directory)
+    } catch (err: unknown) {
+      if (isEnoent(err)) return []
+      throw err
+    }
+  }
+}
+
+function isEnoent(err: unknown): boolean {
+  return typeof err === 'object' && err !== null && (err as { code?: string }).code === 'ENOENT'
+}

package/src/storage/index.ts

@@ -0,0 +1,10 @@
+export interface StorageAdapter {
+  get(key: string): Promise<string | null>
+  set(key: string, value: string): Promise<void>
+  remove(key: string): Promise<void>
+  list(): Promise<string[]>
+}
+
+export { MemoryStorage } from './memory.js'
+export { FileStorage, type FileStorageOptions } from './file.js'
+export { createDefaultStorage, type DefaultStorageOptions } from './auto.js'

package/src/storage/memory.ts

@@ -0,0 +1,23 @@
+import type { StorageAdapter } from './index.js'
+
+export class MemoryStorage implements StorageAdapter {
+  private store: Map<string, string> = new Map()
+
+  get(key: string): Promise<string | null> {
+    return Promise.resolve(this.store.get(key) ?? null)
+  }
+
+  set(key: string, value: string): Promise<void> {
+    this.store.set(key, value)
+    return Promise.resolve()
+  }
+
+  remove(key: string): Promise<void> {
+    this.store.delete(key)
+    return Promise.resolve()
+  }
+
+  list(): Promise<string[]> {
+    return Promise.resolve([...this.store.keys()])
+  }
+}

package/src/types/auth.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod'
+
+export type SecretRef =
+  | { type: 'plain'; value: string }
+  | { type: 'env'; name: string }
+  | { type: 'storage'; key: string }
+  | string
+
+export interface SecretResolver {
+  resolve(ref: SecretRef): Promise<string>
+}
+
+export const SecretRefSchema: z.ZodType<SecretRef> = z.union([
+  z.object({ type: z.literal('plain'), value: z.string() }),
+  z.object({ type: z.literal('env'), name: z.string() }),
+  z.object({ type: z.literal('storage'), key: z.string() }),
+  z.string(),
+])