core: expose v2 model listing API

AGENTS.md

@@ -73,6 +73,29 @@ function foo() {
 }
 ```
 
+### Complex Logic
+
+When a function has several validation branches or supporting details, make the main function read as the happy path and move supporting details into small helpers below it.
+
+```ts
+// Good
+export function loadThing(input: unknown) {
+  const config = requireConfig(input)
+  const metadata = readMetadata(input)
+  return createThing({ config, metadata })
+}
+
+function requireConfig(input: unknown) {
+  ...
+}
+```
+
+- Keep helpers close to the code they support, below the main export when that improves readability.
+- Do not over-abstract simple expressions into many single-use helpers; extract only when it names a real concept like `requireConfig` or `readMetadata`.
+- Do not return `Effect` from helpers unless they actually perform effectful work. Synchronous parsing, validation, and option building should stay synchronous.
+- Prefer Effect schema helpers such as `Schema.UnknownFromJsonString` and `Schema.decodeUnknownOption` over manual `JSON.parse` wrapped in `Effect.try` when parsing untrusted JSON strings.
+- Add comments for non-obvious constraints and surprising behavior, not for obvious assignments or control flow.
+
 ### Schema Definitions (Drizzle)
 
 Use snake_case for field names so column names don't need to be redefined as strings.

packages/core/package.json

@@ -26,6 +26,27 @@
     "@types/semver": "catalog:"
   },
   "dependencies": {
+    "@ai-sdk/alibaba": "1.0.17",
+    "@ai-sdk/amazon-bedrock": "4.0.96",
+    "@ai-sdk/anthropic": "3.0.71",
+    "@ai-sdk/azure": "3.0.49",
+    "@ai-sdk/cerebras": "2.0.41",
+    "@ai-sdk/cohere": "3.0.27",
+    "@ai-sdk/deepinfra": "2.0.41",
+    "@ai-sdk/gateway": "3.0.104",
+    "@ai-sdk/google": "3.0.63",
+    "@ai-sdk/google-vertex": "4.0.112",
+    "@ai-sdk/groq": "3.0.31",
+    "@ai-sdk/mistral": "3.0.27",
+    "@ai-sdk/openai": "3.0.53",
+    "@ai-sdk/openai-compatible": "2.0.41",
+    "@ai-sdk/perplexity": "3.0.26",
+    "@ai-sdk/provider": "3.0.8",
+    "@ai-sdk/provider-utils": "4.0.23",
+    "@ai-sdk/togetherai": "2.0.41",
+    "@ai-sdk/vercel": "2.0.39",
+    "@ai-sdk/xai": "3.0.82",
+    "@aws-sdk/credential-providers": "3.993.0",
     "@effect/opentelemetry": "catalog:",
     "@effect/platform-node": "catalog:",
     "@npmcli/arborist": "9.4.0",
@@ -34,14 +55,21 @@
     "@opentelemetry/context-async-hooks": "2.6.1",
     "@opentelemetry/exporter-trace-otlp-http": "0.214.0",
     "@opentelemetry/sdk-trace-base": "2.6.1",
-    "effect": "catalog:",
+    "@openrouter/ai-sdk-provider": "2.8.1",
+    "ai-gateway-provider": "3.1.2",
     "cross-spawn": "catalog:",
+    "effect": "catalog:",
+    "gitlab-ai-provider": "6.6.0",
     "glob": "13.0.5",
+    "google-auth-library": "10.5.0",
+    "immer": "11.1.4",
     "mime-types": "3.0.2",
     "minimatch": "10.2.5",
     "npm-package-arg": "13.0.2",
     "semver": "^7.6.3",
-    "xdg-basedir": "5.1.0"
+    "venice-ai-sdk-provider": "2.0.1",
+    "xdg-basedir": "5.1.0",
+    "zod": "catalog:"
   },
   "overrides": {
     "drizzle-orm": "catalog:"

packages/core/src/aisdk.ts

@@ -0,0 +1,172 @@
+export * as AISDK from "./aisdk"
+
+import type { LanguageModelV3 } from "@ai-sdk/provider"
+import { Cause, Context, Effect, Layer, Schema } from "effect"
+import { ModelV2 } from "./model"
+import { PluginV2 } from "./plugin"
+import { ProviderV2 } from "./provider"
+
+type SDK = any
+
+function wrapSSE(res: Response, ms: number, ctl: AbortController) {
+  if (typeof ms !== "number" || ms <= 0) return res
+  if (!res.body) return res
+  if (!res.headers.get("content-type")?.includes("text/event-stream")) return res
+
+  const reader = res.body.getReader()
+  const body = new ReadableStream<Uint8Array>({
+    async pull(ctrl) {
+      const part = await new Promise<Awaited<ReturnType<typeof reader.read>>>((resolve, reject) => {
+        const id = setTimeout(() => {
+          const err = new Error("SSE read timed out")
+          ctl.abort(err)
+          void reader.cancel(err)
+          reject(err)
+        }, ms)
+
+        reader.read().then(
+          (part) => {
+            clearTimeout(id)
+            resolve(part)
+          },
+          (err) => {
+            clearTimeout(id)
+            reject(err)
+          },
+        )
+      })
+
+      if (part.done) {
+        ctrl.close()
+        return
+      }
+
+      ctrl.enqueue(part.value)
+    },
+    async cancel(reason) {
+      ctl.abort(reason)
+      await reader.cancel(reason)
+    },
+  })
+
+  return new Response(body, {
+    headers: new Headers(res.headers),
+    status: res.status,
+    statusText: res.statusText,
+  })
+}
+
+function prepareOptions(model: ModelV2.Info, pkg: string) {
+  const options: Record<string, any> = { name: model.providerID, ...model.options.aisdk.provider }
+  if (model.endpoint.type === "aisdk" && model.endpoint.url) options.baseURL = model.endpoint.url
+
+  const customFetch = options.fetch
+  const chunkTimeout = options.chunkTimeout
+  delete options.chunkTimeout
+  options.fetch = async (input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+    const opts = { ...(init ?? {}) }
+    const signals = [
+      opts.signal,
+      typeof chunkTimeout === "number" && chunkTimeout > 0 ? new AbortController() : undefined,
+      options.timeout !== undefined && options.timeout !== null && options.timeout !== false
+        ? AbortSignal.timeout(options.timeout)
+        : undefined,
+    ].filter((item): item is AbortSignal | AbortController => Boolean(item))
+    const chunkAbortCtl = signals.find((item): item is AbortController => item instanceof AbortController)
+    const abortSignals = signals.map((item) => (item instanceof AbortController ? item.signal : item))
+    if (abortSignals.length === 1) opts.signal = abortSignals[0]
+    if (abortSignals.length > 1) opts.signal = AbortSignal.any(abortSignals)
+
+    if ((pkg === "@ai-sdk/openai" || pkg === "@ai-sdk/azure") && opts.body && opts.method === "POST") {
+      const body = JSON.parse(opts.body as string)
+      if (body.store !== true && Array.isArray(body.input)) {
+        for (const item of body.input) {
+          if ("id" in item) delete item.id
+        }
+        opts.body = JSON.stringify(body)
+      }
+    }
+
+    const res = await (typeof customFetch === "function" ? customFetch : fetch)(input, {
+      ...opts,
+      timeout: false,
+    })
+    if (!chunkAbortCtl || typeof chunkTimeout !== "number") return res
+    return wrapSSE(res, chunkTimeout, chunkAbortCtl)
+  }
+
+  return options
+}
+
+export class InitError extends Schema.TaggedErrorClass<InitError>()("AISDK.InitError", {
+  providerID: ProviderV2.ID,
+  cause: Schema.Defect,
+}) {}
+
+function initError(providerID: ProviderV2.ID) {
+  return Effect.catchCause((cause) => Effect.fail(new InitError({ providerID, cause: Cause.squash(cause) })))
+}
+
+export interface Interface {
+  readonly language: (model: ModelV2.Info) => Effect.Effect<LanguageModelV3, InitError>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/AISDK") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const plugin = yield* PluginV2.Service
+    const languages = new Map<string, LanguageModelV3>()
+    const sdks = new Map<string, SDK>()
+
+    return Service.of({
+      language: Effect.fn("AISDK.language")(function* (model) {
+        const key = `${model.providerID}/${model.id}/${model.options.variant ?? "default"}`
+        const existing = languages.get(key)
+        if (existing) return existing
+        if (model.endpoint.type !== "aisdk")
+          return yield* new InitError({
+            providerID: model.providerID,
+            cause: new Error(`Unsupported endpoint ${model.endpoint.type}`),
+          })
+
+        const options = prepareOptions(model, model.endpoint.package)
+        const sdkKey = JSON.stringify({
+          providerID: model.providerID,
+          endpoint: model.endpoint,
+          options,
+        })
+        const sdk =
+          sdks.get(sdkKey) ??
+          (yield* plugin
+            .trigger("aisdk.sdk", { model, package: model.endpoint.package, options }, {})
+            .pipe(initError(model.providerID))).sdk
+        if (!sdk)
+          return yield* new InitError({
+            providerID: model.providerID,
+            cause: new Error("No AISDK provider plugin returned an SDK"),
+          })
+        sdks.set(sdkKey, sdk)
+        const result = yield* plugin
+          .trigger(
+            "aisdk.language",
+            {
+              model,
+              sdk,
+              options,
+            },
+            {},
+          )
+          .pipe(initError(model.providerID))
+        const language = yield* Effect.sync(() => result.language ?? sdk.languageModel(model.apiID)).pipe(
+          initError(model.providerID),
+        )
+        languages.set(key, language)
+        return language
+      }),
+    })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(PluginV2.defaultLayer))

packages/opencode/src/v2/auth.ts → packages/core/src/auth.ts

@@ -1,9 +1,9 @@
 import path from "path"
 import { Effect, Layer, Option, Schema, Context, SynchronizedRef } from "effect"
-import { Identifier } from "@opencode-ai/core/util/identifier"
-import { NonNegativeInt, withStatics } from "@opencode-ai/core/schema"
-import { Global } from "@opencode-ai/core/global"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
+import { Identifier } from "./util/identifier"
+import { NonNegativeInt, withStatics } from "./schema"
+import { Global } from "./global"
+import { AppFileSystem } from "./filesystem"
 
 export const OAUTH_DUMMY_KEY = "opencode-oauth-dummy-key"
 
@@ -106,25 +106,43 @@ export const layer = Layer.effect(
     const fsys = yield* AppFileSystem.Service
     const global = yield* Global.Service
     const file = path.join(global.data, "auth-v2.json")
+    const legacyFile = path.join(global.data, "auth.json")
+
+    const writeMigrated = Effect.fnUntraced(function* (raw: Record<string, unknown>) {
+      const migrated = migrate(raw)
+      yield* fsys
+        .writeJson(file, migrated, 0o600)
+        .pipe(Effect.mapError((cause) => new AuthFileWriteError({ operation: "migrate", cause })))
+      return migrated
+    })
+
+    const parseAuthContent = () => {
+      try {
+        return JSON.parse(process.env.OPENCODE_AUTH_CONTENT ?? "")
+      } catch {}
+    }
 
     const load: () => Effect.Effect<Writable, AuthError> = Effect.fnUntraced(function* () {
       if (process.env.OPENCODE_AUTH_CONTENT) {
-        try {
-          return JSON.parse(process.env.OPENCODE_AUTH_CONTENT)
-        } catch {}
+        const raw = parseAuthContent()
+        if (raw && typeof raw === "object") {
+          if ("version" in raw && raw.version === 2) return raw as Writable
+          return yield* writeMigrated(raw as Record<string, unknown>)
+        }
+        return { version: 2, accounts: {}, active: {} }
       }
 
-      const raw = yield* fsys.readJson(file).pipe(Effect.orElseSucceed(() => null))
+      const legacy = yield* fsys.readJson(legacyFile).pipe(Effect.orElseSucceed(() => null))
+      if (legacy && typeof legacy === "object") return yield* writeMigrated(legacy as Record<string, unknown>)
 
-      if (!raw || typeof raw !== "object") return { version: 2, accounts: {}, active: {} }
+      const raw = yield* fsys.readJson(file).pipe(Effect.orElseSucceed(() => null))
 
-      if ("version" in raw && raw.version === 2) return raw as Writable
+      if (raw && typeof raw === "object") {
+        if ("version" in raw && raw.version === 2) return raw as Writable
+        return yield* writeMigrated(raw as Record<string, unknown>)
+      }
 
-      const migrated = migrate(raw as Record<string, unknown>)
-      yield* fsys
-        .writeJson(file, migrated, 0o600)
-        .pipe(Effect.mapError((cause) => new AuthFileWriteError({ operation: "migrate", cause })))
-      return migrated
+      return { version: 2, accounts: {}, active: {} }
     })
 
     const write = (data: Writable) =>