openllmprovider 0.1.0

package/src/catalog/mapper.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod'
+import type { ModelDefinition } from '../types/model.js'
+
+const ModelsDevModelSchema = z
+  .object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+    family: z.string().optional(),
+
+    reasoning: z.boolean().optional(),
+    tool_call: z.boolean().optional(),
+    structured_output: z.boolean().optional(),
+    temperature: z.boolean().optional(),
+    attachment: z.boolean().optional(),
+    streaming: z.boolean().optional(),
+    system_message: z.boolean().optional(),
+
+    modalities: z
+      .object({
+        input: z.array(z.string()),
+        output: z.array(z.string()),
+      })
+      .passthrough(),
+
+    limit: z
+      .object({
+        context: z.number(),
+        output: z.number(),
+        input_images: z.number().optional(),
+      })
+      .passthrough(),
+
+    cost: z
+      .object({
+        input: z.number(),
+        output: z.number(),
+        cache_read: z.number().optional(),
+        cache_write: z.number().optional(),
+      })
+      .passthrough()
+      .optional(),
+
+    status: z.enum(['stable', 'beta', 'deprecated']).optional(),
+    knowledge: z.string().optional(),
+  })
+  .passthrough()
+
+const ModelsDevProviderSchema = z
+  .object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+    env: z.array(z.string()).optional(),
+    api: z.string().optional(),
+    npm: z.string().optional(),
+    doc: z.string().optional(),
+    models: z.record(z.string(), z.unknown()).optional(),
+  })
+  .passthrough()
+
+export function mapModelsDevToModelDefinition(
+  modelId: string,
+  raw: unknown,
+  provenance?: 'snapshot' | 'remote'
+): ModelDefinition | null {
+  const parsed = ModelsDevModelSchema.safeParse(raw)
+  if (!parsed.success) return null
+
+  const { id: _id, knowledge, ...rest } = parsed.data
+
+  const result: Record<string, unknown> = {
+    ...rest,
+    modelId,
+  }
+
+  if (knowledge !== undefined) {
+    result.knowledgeCutoff = knowledge
+  }
+
+  if (provenance !== undefined) {
+    result.provenance = provenance
+  }
+
+  return result as unknown as ModelDefinition
+}
+
+export function mapModelsDevProvider(
+  providerId: string,
+  raw: unknown,
+  provenance?: 'snapshot' | 'remote'
+): {
+  provider: { id: string; name: string; env?: string[]; api?: string; doc?: string }
+  models: ModelDefinition[]
+} {
+  const parsed = ModelsDevProviderSchema.safeParse(raw)
+  const name = parsed.success ? (parsed.data.name ?? providerId) : providerId
+  const rawModels = parsed.success ? (parsed.data.models ?? {}) : {}
+
+  const models: ModelDefinition[] = []
+  for (const [modelId, modelRaw] of Object.entries(rawModels)) {
+    const mapped = mapModelsDevToModelDefinition(modelId, modelRaw, provenance)
+    if (mapped) models.push(mapped)
+  }
+
+  return {
+    provider: {
+      id: providerId,
+      name,
+      ...(parsed.success && parsed.data.env !== undefined ? { env: parsed.data.env } : {}),
+      ...(parsed.success && parsed.data.api !== undefined ? { api: parsed.data.api } : {}),
+      ...(parsed.success && parsed.data.doc !== undefined ? { doc: parsed.data.doc } : {}),
+    },
+    models,
+  }
+}
+
+export function mapModelsDevProviderMetadata(
+  providerId: string,
+  raw: unknown
+): { id: string; name: string; env?: string[]; api?: string; doc?: string } {
+  const parsed = ModelsDevProviderSchema.safeParse(raw)
+
+  return {
+    id: providerId,
+    name: parsed.success ? (parsed.data.name ?? providerId) : providerId,
+    ...(parsed.success && parsed.data.env !== undefined ? { env: parsed.data.env } : {}),
+    ...(parsed.success && parsed.data.api !== undefined ? { api: parsed.data.api } : {}),
+    ...(parsed.success && parsed.data.doc !== undefined ? { doc: parsed.data.doc } : {}),
+  }
+}

package/src/catalog/merger.ts

@@ -0,0 +1,99 @@
+import type { ModelDefinition } from '../types/model.js'
+
+type NestedObject = Record<string, unknown>
+
+const FIELD_LEVEL_MERGE_KEYS: ReadonlySet<string> = new Set(['limit', 'cost'])
+const REPLACE_KEYS: ReadonlySet<string> = new Set(['modalities'])
+
+function mergeNestedObject(
+  base: NestedObject | undefined,
+  overlay: NestedObject | undefined
+): NestedObject | undefined {
+  if (!overlay) return base ? { ...base } : undefined
+  if (!base) return { ...overlay }
+  const result = { ...base }
+  for (const key of Object.keys(overlay)) {
+    if (overlay[key] !== undefined) {
+      result[key] = overlay[key]
+    }
+  }
+  return result
+}
+
+export function mergeModelDefinitions(base: ModelDefinition, overlay: Partial<ModelDefinition>): ModelDefinition {
+  const result = { ...base }
+
+  for (const key of Object.keys(overlay) as Array<keyof ModelDefinition>) {
+    if (key === 'modelId') continue
+
+    const overlayValue = overlay[key]
+    if (overlayValue === undefined) continue
+
+    if (FIELD_LEVEL_MERGE_KEYS.has(key)) {
+      const merged = mergeNestedObject(base[key] as NestedObject | undefined, overlayValue as NestedObject)
+      if (merged !== undefined) {
+        ;(result as Record<string, unknown>)[key] = merged
+      }
+      continue
+    }
+
+    if (REPLACE_KEYS.has(key)) {
+      ;(result as Record<string, unknown>)[key] = overlayValue
+      continue
+    }
+    ;(result as Record<string, unknown>)[key] = overlayValue
+  }
+
+  return result
+}
+
+export function mergeCatalogData(
+  snapshot: Map<string, ModelDefinition>,
+  remote: Map<string, ModelDefinition>,
+  overrides: Map<string, Partial<ModelDefinition>>
+): Map<string, ModelDefinition> {
+  const allModelIds = new Set([...snapshot.keys(), ...remote.keys()])
+  const result = new Map<string, ModelDefinition>()
+
+  for (const modelId of allModelIds) {
+    const snap = snapshot.get(modelId)
+    const rem = remote.get(modelId)
+    const override = overrides.get(modelId)
+
+    const inSnapshot = snap !== undefined
+    const inRemote = rem !== undefined
+    const hasOverride = override !== undefined
+
+    let merged: ModelDefinition
+
+    if (inSnapshot && inRemote) {
+      merged = mergeModelDefinitions(snap, rem)
+    } else if (inRemote) {
+      merged = { ...rem }
+    } else if (snap) {
+      merged = { ...snap }
+    } else {
+      continue
+    }
+
+    if (hasOverride) {
+      merged = mergeModelDefinitions(merged, override)
+    }
+
+    if (hasOverride) {
+      merged.provenance = 'user-override'
+    } else if (inRemote) {
+      merged.provenance = 'remote'
+    } else {
+      merged.provenance = 'snapshot'
+    }
+
+    if (inSnapshot && !inRemote) {
+      merged.status = 'deprecated'
+    }
+
+    result.set(modelId, merged)
+  }
+
+  return result
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+export {
+  createProviderStore,
+  getLanguageModel,
+  loadProvider,
+  isProviderInstalled,
+  getAllProviderPackages,
+} from './provider/index.js'
+export type {
+  ProviderStore,
+  ProviderStoreConfig,
+  ProviderListOptions,
+  ModelListOptions,
+  GetModelOptions,
+} from './provider/index.js'
+
+export { createAuthStore } from './auth/index.js'
+export type { AuthStore, AuthStoreOptions, DiscoveredCredential, DiscoverOptions } from './auth/index.js'
+export { DEFAULT_SCANNERS } from './auth/index.js'
+export type { DiskScanner, DiskScanResult, ScanContext } from './auth/index.js'
+
+export { registerPlugin, getPlugins, getPluginForProvider } from './plugin/index.js'
+export { copilotPlugin } from './plugin/copilot.js'
+export { codexPlugin } from './plugin/codex.js'
+export { googlePlugin } from './plugin/google.js'
+export { anthropicPlugin } from './plugin/anthropic.js'
+
+export { MemoryStorage, FileStorage, createDefaultStorage } from './storage/index.js'
+export type { StorageAdapter } from './storage/index.js'
+
+export type { LanguageModel, LanguageModelV3 } from './types/index.js'
+export type { ExtendConfig, ExtendProviderConfig, ExtendModelConfig, CatalogProvider } from './catalog/catalog.js'
+export type { ModelDefinition } from './types/index.js'
+export type { AuthHook, AuthMethod, AuthCredential, ProviderInfo } from './types/index.js'
+export type { SecretRef, SecretResolver } from './types/index.js'
+export type { ProviderUserConfig } from './types/index.js'
+
+export { createLogger } from './logger.js'

package/src/logger.ts

@@ -0,0 +1,7 @@
+import createDebug from 'debug'
+
+export function createLogger(namespace: string) {
+  return createDebug(`openllmprovider:${namespace}`)
+}
+
+export const log = createDebug('openllmprovider')