lazy load LLMs even harder

packages/opencode/src/provider/provider.ts

@@ -1,6 +1,16 @@
 import z from "zod"
+import { App } from "../app/app"
+import { Config } from "../config/config"
+import { PROVIDER_DATABASE } from "./database"
+import { NoSuchModelError, type LanguageModel, type Provider as SDK } from "ai"
+import { Log } from "../util/log"
+import path from "path"
+import { Global } from "../global"
+import { BunProc } from "../bun"
 
 export namespace Provider {
+  const log = Log.create({ service: "provider" })
+
   export const Model = z
     .object({
       id: z.string(),
@@ -32,4 +42,97 @@ export namespace Provider {
       ref: "Provider.Info",
     })
   export type Info = z.output<typeof Info>
+
+  const AUTODETECT: Record<string, string[]> = {
+    anthropic: ["ANTHROPIC_API_KEY"],
+    openai: ["OPENAI_API_KEY"],
+    google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GEMINI_API_KEY"],
+  }
+
+  const state = App.state("provider", async () => {
+    const config = await Config.get()
+    const providers = new Map<string, Info>()
+    const models = new Map<string, { info: Model; language: LanguageModel }>()
+    const sdk = new Map<string, SDK>()
+
+    for (const item of PROVIDER_DATABASE) {
+      if (!AUTODETECT[item.id].some((env) => process.env[env])) continue
+      providers.set(item.id, item)
+    }
+
+    for (const item of config.provider ?? []) {
+      providers.set(item.id, item)
+    }
+
+    return {
+      models,
+      providers,
+      sdk,
+    }
+  })
+
+  export async function active() {
+    return state().then((state) => state.providers)
+  }
+
+  async function getSDK(providerID: string) {
+    const s = await state()
+    if (s.sdk.has(providerID)) return s.sdk.get(providerID)!
+
+    const dir = path.join(Global.cache(), `node_modules`, `@ai-sdk`, providerID)
+    if (!(await Bun.file(path.join(dir, "package.json")).exists())) {
+      log.info("installing", {
+        providerID,
+      })
+      BunProc.run(["add", `@ai-sdk/${providerID}@alpha`], {
+        cwd: Global.cache(),
+      })
+    }
+    const mod = await import(path.join(dir))
+    const fn = mod[Object.keys(mod).find((key) => key.startsWith("create"))!]
+    const loaded = fn(s.providers.get(providerID)?.options)
+    s.sdk.set(providerID, loaded)
+    return loaded as SDK
+  }
+
+  export async function getModel(providerID: string, modelID: string) {
+    const key = `${providerID}/${modelID}`
+    const s = await state()
+    if (s.models.has(key)) return s.models.get(key)!
+
+    log.info("loading", {
+      providerID,
+      modelID,
+    })
+
+    const provider = s.providers.get(providerID)
+    if (!provider) throw new ModelNotFoundError(modelID)
+    const info = provider.models.find((m) => m.id === modelID)
+    if (!info) throw new ModelNotFoundError(modelID)
+
+    const sdk = await getSDK(providerID)
+    if (!sdk) throw new ModelNotFoundError(modelID)
+
+    try {
+      const language = sdk.languageModel(modelID)
+      log.info("found", { providerID, modelID })
+      s.models.set(key, {
+        info,
+        language,
+      })
+      return {
+        info,
+        language,
+      }
+    } catch (e) {
+      if (e instanceof NoSuchModelError) throw new ModelNotFoundError(modelID)
+      throw e
+    }
+  }
+
+  class ModelNotFoundError extends Error {
+    constructor(public readonly model: string) {
+      super()
+    }
+  }
 }