test(v2): simplify storage contract setup

bun.lock

@@ -429,12 +429,14 @@
         "@clack/prompts": "1.0.0-alpha.1",
         "@effect/opentelemetry": "catalog:",
         "@effect/platform-node": "catalog:",
+        "@effect/sql-sqlite-bun": "catalog:",
         "@gitlab/opencode-gitlab-auth": "1.3.3",
         "@lydell/node-pty": "catalog:",
         "@modelcontextprotocol/sdk": "1.27.1",
         "@octokit/graphql": "9.0.2",
         "@octokit/rest": "catalog:",
         "@openauthjs/openauth": "catalog:",
+        "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
         "@opencode-ai/llm": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
         "@opencode-ai/script": "workspace:*",

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-kCSAVPQgJROcvnnwf0Cn6PuYL25hYgTasJeBJlmnFgQ=",
-    "aarch64-linux": "sha256-prY27Ek2QhW+4OvBJ3bHHkUDoLTA4mD3KQmOQqSbAuo=",
-    "aarch64-darwin": "sha256-0yIqnnjreVHTgGZLrKFpT9Cc2B2LNfmYcRByaCu7tiU=",
-    "x86_64-darwin": "sha256-n+urvMRozB9nO5D3qyCweSa5HExFk1YGEzOt2445LEE="
+    "x86_64-linux": "sha256-1KQFagCMMfSdZJLPAr0b17V66Z2ITcaQis4Pa2jC1hE=",
+    "aarch64-linux": "sha256-DWhmkYpa9ArqzfPdmmNFkaiOw5+DllEBHESU54T/aQA=",
+    "aarch64-darwin": "sha256-egfIey1y2wVbvxueiI4S9IPl6IvfVpJvvj3h4B2nkxA=",
+    "x86_64-darwin": "sha256-22Rezk0MiDIeT4qeeT/iosDaEX1l2kn6B7/eNphT678="
   }
 }

packages/core/src/account.ts

@@ -1,319 +0,0 @@
-import path from "path"
-import { Effect, Layer, Option, Schema, Context, SynchronizedRef } from "effect"
-import { Identifier } from "./util/identifier"
-import { NonNegativeInt, withStatics } from "./schema"
-import { Global } from "./global"
-import { AppFileSystem } from "./filesystem"
-import { EventV2 } from "./event"
-
-export const ID = Schema.String.pipe(
-  Schema.brand("AccountV2.ID"),
-  withStatics((schema) => ({ create: () => schema.make("acc_" + Identifier.ascending()) })),
-)
-export type ID = typeof ID.Type
-
-export const ServiceID = Schema.String.pipe(Schema.brand("ServiceID"))
-export type ServiceID = typeof ServiceID.Type
-
-export class OAuthCredential extends Schema.Class<OAuthCredential>("AccountV2.OAuthCredential")({
-  type: Schema.Literal("oauth"),
-  refresh: Schema.String,
-  access: Schema.String,
-  expires: NonNegativeInt,
-}) {}
-
-export class ApiKeyCredential extends Schema.Class<ApiKeyCredential>("AccountV2.ApiKeyCredential")({
-  type: Schema.Literal("api"),
-  key: Schema.String,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-}) {}
-
-export const Credential = Schema.Union([OAuthCredential, ApiKeyCredential])
-  .pipe(Schema.toTaggedUnion("type"))
-  .annotate({
-    identifier: "AccountV2.Credential",
-  })
-export type Credential = Schema.Schema.Type<typeof Credential>
-
-export class Info extends Schema.Class<Info>("AccountV2.Info")({
-  id: ID,
-  serviceID: ServiceID,
-  description: Schema.String,
-  credential: Credential,
-}) {}
-
-export class FileWriteError extends Schema.TaggedErrorClass<FileWriteError>()("AccountV2.FileWriteError", {
-  operation: Schema.Union([Schema.Literal("migrate"), Schema.Literal("write")]),
-  cause: Schema.Defect,
-}) {}
-
-export type Error = FileWriteError
-
-export const Event = {
-  Added: EventV2.define({
-    type: "account.added",
-    schema: {
-      account: Info,
-    },
-  }),
-  Removed: EventV2.define({
-    type: "account.removed",
-    schema: {
-      account: Info,
-    },
-  }),
-  Switched: EventV2.define({
-    type: "account.switched",
-    schema: {
-      serviceID: ServiceID,
-      from: Schema.optional(ID),
-      to: Schema.optional(ID),
-    },
-  }),
-}
-
-interface Writable {
-  version: 2
-  accounts: Record<string, Info>
-  active: Record<string, ID>
-}
-
-const decodeV1 = Schema.decodeUnknownOption(Schema.Record(Schema.String, Credential))
-
-function migrate(old: Record<string, unknown>): Writable {
-  const accounts: Record<string, Info> = {}
-  const active: Record<string, ID> = {}
-  for (const [serviceID, value] of Object.entries(old)) {
-    const decoded = Option.getOrElse(decodeV1({ [serviceID]: value }), () => ({}))
-    const parsed = (decoded as Record<string, Credential>)[serviceID]
-    if (!parsed) continue
-    const id = Identifier.ascending()
-    const account = ID.make(id)
-    const brandedServiceID = ServiceID.make(serviceID)
-    accounts[id] = new Info({
-      id: account,
-      serviceID: brandedServiceID,
-      description: "default",
-      credential: parsed,
-    })
-    active[brandedServiceID] = account
-  }
-  return { version: 2, accounts, active }
-}
-
-export interface Interface {
-  readonly get: (id: ID) => Effect.Effect<Info | undefined, Error>
-  readonly all: () => Effect.Effect<Info[], Error>
-  readonly create: (input: {
-    serviceID: ServiceID
-    credential: Credential
-    description?: string
-  }) => Effect.Effect<Info | undefined, Error>
-  readonly update: (id: ID, updates: Partial<Pick<Info, "description" | "credential">>) => Effect.Effect<void, Error>
-  readonly remove: (id: ID) => Effect.Effect<void, Error>
-  readonly activate: (id: ID) => Effect.Effect<void, Error>
-  readonly active: (serviceID: ServiceID) => Effect.Effect<Info | undefined, Error>
-  readonly forService: (serviceID: ServiceID) => Effect.Effect<Info[], Error>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Account") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fsys = yield* AppFileSystem.Service
-    const global = yield* Global.Service
-    const events = yield* EventV2.Service
-    const file = path.join(global.data, "account.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 FileWriteError({ operation: "migrate", cause })))
-      return migrated
-    })
-
-    const parseAuthContent = () => {
-      try {
-        return JSON.parse(process.env.OPENCODE_AUTH_CONTENT ?? "")
-      } catch {}
-    }
-
-    const load: () => Effect.Effect<Writable, Error> = Effect.fnUntraced(function* () {
-      if (process.env.OPENCODE_AUTH_CONTENT) {
-        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 legacy = yield* fsys.readJson(legacyFile).pipe(Effect.orElseSucceed(() => null))
-      if (legacy && typeof legacy === "object") return yield* writeMigrated(legacy as Record<string, unknown>)
-
-      const raw = yield* fsys.readJson(file).pipe(Effect.orElseSucceed(() => null))
-
-      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 write = (data: Writable) =>
-      fsys
-        .writeJson(file, data, 0o600)
-        .pipe(Effect.mapError((cause) => new FileWriteError({ operation: "write", cause })))
-
-    const state = SynchronizedRef.makeUnsafe(
-      yield* load().pipe(Effect.orElseSucceed((): Writable => ({ version: 2, accounts: {}, active: {} }))),
-    )
-
-    const activate = Effect.fn("AccountV2.activate")(function* (id: ID) {
-      const data = yield* SynchronizedRef.get(state)
-      const account = data.accounts[id]
-      if (!account) return
-      const activated = yield* SynchronizedRef.modifyEffect(
-        state,
-        Effect.fnUntraced(function* (data) {
-          const nextAccount = data.accounts[id]
-          if (!nextAccount) return [undefined, data] as const
-
-          const next = { ...data, active: { ...data.active, [nextAccount.serviceID]: id } }
-          yield* write(next)
-          return [{ serviceID: nextAccount.serviceID, from: data.active[nextAccount.serviceID], to: id }, next] as const
-        }),
-      )
-      if (activated) yield* events.publish(Event.Switched, activated)
-    })
-
-    const result: Interface = {
-      get: Effect.fn("AccountV2.get")(function* (id) {
-        return (yield* SynchronizedRef.get(state)).accounts[id]
-      }),
-
-      all: Effect.fn("AccountV2.all")(function* () {
-        return Object.values((yield* SynchronizedRef.get(state)).accounts)
-      }),
-
-      active: Effect.fn("AccountV2.active")(function* (serviceID) {
-        const data = yield* SynchronizedRef.get(state)
-        return (
-          data.accounts[data.active[serviceID]] ?? Object.values(data.accounts).find((a) => a.serviceID === serviceID)
-        )
-      }),
-
-      forService: Effect.fn("AccountV2.list")(function* (serviceID) {
-        return Object.values((yield* SynchronizedRef.get(state)).accounts).filter((a) => a.serviceID === serviceID)
-      }),
-
-      create: Effect.fn("AccountV2.add")(function* (input) {
-        const id = ID.make(Identifier.ascending())
-        const account = new Info({
-          id,
-          serviceID: input.serviceID,
-          description: input.description ?? "default",
-          credential: input.credential,
-        })
-        const added = yield* SynchronizedRef.modifyEffect(
-          state,
-          Effect.fnUntraced(function* (data) {
-            const next = {
-              ...data,
-              accounts: { ...data.accounts, [account.id]: account },
-              active: { ...data.active, [account.serviceID]: account.id },
-            }
-
-            yield* write(next)
-            return [
-              {
-                account,
-                switched: { serviceID: account.serviceID, from: data.active[account.serviceID], to: account.id },
-              },
-              next,
-            ] as const
-          }),
-        )
-        yield* events.publish(Event.Added, { account: added.account })
-        yield* events.publish(Event.Switched, added.switched)
-        return added.account
-      }),
-
-      update: Effect.fn("AccountV2.update")(function* (id, updates) {
-        const existing = (yield* SynchronizedRef.get(state)).accounts[id]
-        if (!existing) return
-        yield* SynchronizedRef.modifyEffect(
-          state,
-          Effect.fnUntraced(function* (data) {
-            if (!data.accounts[id]) return [undefined, data] as const
-
-            const next = {
-              ...data,
-              accounts: {
-                ...data.accounts,
-                [id]: new Info({
-                  id,
-                  serviceID: existing.serviceID,
-                  description: updates.description ?? existing.description,
-                  credential: updates.credential ?? existing.credential,
-                }),
-              },
-            }
-
-            yield* write(next)
-            return [undefined, next] as const
-          }),
-        )
-      }),
-
-      remove: Effect.fn("AccountV2.remove")(function* (id) {
-        const removed = yield* SynchronizedRef.modifyEffect(
-          state,
-          Effect.fnUntraced(function* (data) {
-            const accounts = { ...data.accounts }
-            const active = { ...data.active }
-            const removed = accounts[id]
-            if (!removed) return [undefined, data] as const
-            const wasActive = active[removed.serviceID] === id
-            delete accounts[id]
-            const replacement = Object.values(accounts).find((account) => account.serviceID === removed.serviceID)
-            if (wasActive) {
-              if (replacement) active[removed.serviceID] = replacement.id
-              else delete active[removed.serviceID]
-            }
-
-            const next = { ...data, accounts, active }
-            yield* write(next)
-            return [
-              {
-                account: removed,
-                switched: wasActive ? { serviceID: removed.serviceID, from: id, to: replacement?.id } : undefined,
-              },
-              next,
-            ] as const
-          }),
-        )
-        if (removed) {
-          yield* events.publish(Event.Removed, { account: removed.account })
-          if (removed.switched) yield* events.publish(Event.Switched, removed.switched)
-        }
-      }),
-
-      activate,
-    }
-
-    return Service.of(result)
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(Global.defaultLayer),
-  Layer.provide(EventV2.defaultLayer),
-)
-
-export * as AccountV2 from "./account"

packages/core/src/agent.ts

@@ -1,147 +0,0 @@
-export * as AgentV2 from "./agent"
-
-import { Context, Effect, HashMap, Layer, Option, Order, pipe, Schema, Array } from "effect"
-import { produce, type Draft } from "immer"
-import { ModelV2 } from "./model"
-import { PermissionV2 } from "./permission"
-import { PluginV2 } from "./plugin"
-import { ProviderV2 } from "./provider"
-
-export const ID = Schema.String.pipe(Schema.brand("AgentV2.ID"))
-export type ID = typeof ID.Type
-
-export const Mode = Schema.Literals(["subagent", "primary", "all"]).annotate({ identifier: "AgentV2.Mode" })
-export type Mode = typeof Mode.Type
-
-export const Info = Schema.Struct({
-  name: ID,
-  description: Schema.optional(Schema.String),
-  mode: Mode,
-  hidden: Schema.Boolean.pipe(Schema.optional),
-  color: Schema.String.pipe(Schema.optional),
-  permission: PermissionV2.Ruleset,
-  model: ModelV2.Ref.pipe(Schema.optional),
-  system: Schema.String.pipe(Schema.optional),
-  options: ProviderV2.Options.pipe(Schema.optional),
-  steps: Schema.Int.pipe(Schema.optional),
-}).annotate({ identifier: "AgentV2.Info" })
-export type Info = typeof Info.Type
-
-export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("AgentV2.NotFound", {
-  agent: ID,
-}) {}
-
-export class InvalidDefaultError extends Schema.TaggedErrorClass<InvalidDefaultError>()("AgentV2.InvalidDefault", {
-  agent: ID,
-  reason: Schema.Literals(["missing", "subagent", "hidden"]),
-}) {}
-
-export class NoDefaultError extends Schema.TaggedErrorClass<NoDefaultError>()("AgentV2.NoDefault", {}) {}
-
-export interface Interface {
-  readonly get: (agent: ID) => Effect.Effect<Info, NotFoundError>
-  readonly list: () => Effect.Effect<Info[]>
-  readonly update: (agent: ID, fn: (agent: Draft<Info>) => void) => Effect.Effect<void>
-  readonly remove: (agent: ID) => Effect.Effect<void>
-  readonly defaultInfo: () => Effect.Effect<Info, InvalidDefaultError | NoDefaultError>
-  readonly defaultAgent: () => Effect.Effect<ID, InvalidDefaultError | NoDefaultError>
-  readonly setDefault: (agent: ID) => Effect.Effect<void, NotFoundError>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Agent") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const plugin = yield* PluginV2.Service
-    let agents = HashMap.empty<ID, Info>()
-    let defaultAgent: ID | undefined
-
-    const result: Interface = {
-      get: Effect.fn("AgentV2.get")(function* (agent) {
-        const match = HashMap.get(agents, agent)
-        if (!match.valueOrUndefined) return yield* new NotFoundError({ agent })
-        return match.value
-      }),
-
-      list: Effect.fn("AgentV2.list")(function* () {
-        return pipe(
-          HashMap.toValues(agents),
-          Array.sortWith((agent) => agent.name, Order.String),
-        )
-      }),
-
-      update: Effect.fnUntraced(function* (agent, fn) {
-        const next = produce(
-          HashMap.get(agents, agent).pipe(
-            Option.getOrElse(
-              () =>
-                ({
-                  name: agent,
-                  mode: "all",
-                  permission: [],
-                  options: {
-                    headers: {},
-                    body: {},
-                    aisdk: {
-                      provider: {},
-                      request: {},
-                    },
-                  },
-                }) satisfies Info,
-            ),
-          ),
-          fn,
-        )
-        const updated = yield* plugin.trigger("agent.update", {}, { agent: next, cancel: false })
-        if (updated.cancel) return
-        agents = HashMap.set(agents, agent, { ...updated.agent, name: agent })
-      }),
-
-      remove: Effect.fn("AgentV2.remove")(function* (agent) {
-        const existing = Option.getOrUndefined(HashMap.get(agents, agent))
-        if (!existing) return
-        if ((yield* plugin.trigger("agent.remove", { agent: existing }, { cancel: false })).cancel) return
-        agents = HashMap.remove(agents, agent)
-        if (defaultAgent === agent) defaultAgent = undefined
-      }),
-
-      defaultInfo: Effect.fn("AgentV2.defaultInfo")(function* () {
-        const updated = yield* plugin.trigger("agent.default", {}, { agent: defaultAgent })
-        const selected = updated.agent
-        if (selected) {
-          const agent = yield* result
-            .get(selected)
-            .pipe(
-              Effect.catchTag("AgentV2.NotFound", () =>
-                Effect.fail(new InvalidDefaultError({ agent: selected, reason: "missing" })),
-              ),
-            )
-          if (agent.mode === "subagent") return yield* new InvalidDefaultError({ agent: selected, reason: "subagent" })
-          if (agent.hidden === true) return yield* new InvalidDefaultError({ agent: selected, reason: "hidden" })
-          return agent
-        }
-
-        const visible = pipe(
-          yield* result.list(),
-          Array.findFirst((agent) => agent.mode !== "subagent" && agent.hidden !== true),
-        )
-        if (Option.isSome(visible)) return visible.value
-        return yield* new NoDefaultError()
-      }),
-
-      defaultAgent: Effect.fn("AgentV2.defaultAgent")(function* () {
-        return (yield* result.defaultInfo()).name
-      }),
-
-      setDefault: Effect.fn("AgentV2.setDefault")(function* (agent) {
-        yield* result.get(agent)
-        defaultAgent = agent
-      }),
-    }
-
-    return Service.of(result)
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(PluginV2.defaultLayer))

packages/core/src/auth.ts

@@ -0,0 +1,264 @@
+import path from "path"
+import { Effect, Layer, Option, Schema, Context, SynchronizedRef } from "effect"
+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"
+
+const AccountID = Schema.String.pipe(
+  Schema.brand("AccountID"),
+  withStatics((schema) => ({ create: () => schema.make("acc_" + Identifier.ascending()) })),
+)
+export type AccountID = typeof AccountID.Type
+
+export const ServiceID = Schema.String.pipe(Schema.brand("ServiceID"))
+export type ServiceID = typeof ServiceID.Type
+
+export class OAuthCredential extends Schema.Class<OAuthCredential>("AuthV2.OAuthCredential")({
+  type: Schema.Literal("oauth"),
+  refresh: Schema.String,
+  access: Schema.String,
+  expires: NonNegativeInt,
+}) {}
+
+export class ApiKeyCredential extends Schema.Class<ApiKeyCredential>("AuthV2.ApiKeyCredential")({
+  type: Schema.Literal("api"),
+  key: Schema.String,
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+}) {}
+
+export const Credential = Schema.Union([OAuthCredential, ApiKeyCredential])
+  .pipe(Schema.toTaggedUnion("type"))
+  .annotate({
+    identifier: "AuthV2.Credential",
+  })
+export type Credential = Schema.Schema.Type<typeof Credential>
+
+export class Account extends Schema.Class<Account>("AuthV2.Account")({
+  id: AccountID,
+  serviceID: ServiceID,
+  description: Schema.String,
+  credential: Credential,
+}) {}
+
+export class AuthFileWriteError extends Schema.TaggedErrorClass<AuthFileWriteError>()("AuthV2.FileWriteError", {
+  operation: Schema.Union([Schema.Literal("migrate"), Schema.Literal("write")]),
+  cause: Schema.Defect,
+}) {}
+
+export type AuthError = AuthFileWriteError
+
+interface Writable {
+  version: 2
+  accounts: Record<string, Account>
+  active: Record<string, AccountID>
+}
+
+const decodeV1 = Schema.decodeUnknownOption(Schema.Record(Schema.String, Credential))
+
+function migrate(old: Record<string, unknown>): Writable {
+  const accounts: Record<string, Account> = {}
+  const active: Record<string, AccountID> = {}
+  for (const [serviceID, value] of Object.entries(old)) {
+    const decoded = Option.getOrElse(decodeV1({ [serviceID]: value }), () => ({}))
+    const parsed = (decoded as Record<string, Credential>)[serviceID]
+    if (!parsed) continue
+    const id = Identifier.ascending()
+    const accountID = AccountID.make(id)
+    const brandedServiceID = ServiceID.make(serviceID)
+    accounts[id] = new Account({
+      id: accountID,
+      serviceID: brandedServiceID,
+      description: "default",
+      credential: parsed,
+    })
+    active[brandedServiceID] = accountID
+  }
+  return { version: 2, accounts, active }
+}
+
+export interface Interface {
+  readonly get: (accountID: AccountID) => Effect.Effect<Account | undefined, AuthError>
+  readonly all: () => Effect.Effect<Account[], AuthError>
+  readonly create: (input: {
+    serviceID: ServiceID
+    credential: Credential
+    description?: string
+    active?: boolean
+  }) => Effect.Effect<Account, AuthError>
+  readonly update: (
+    accountID: AccountID,
+    updates: Partial<Pick<Account, "description" | "credential">>,
+  ) => Effect.Effect<void, AuthError>
+  readonly remove: (accountID: AccountID) => Effect.Effect<void, AuthError>
+  readonly activate: (accountID: AccountID) => Effect.Effect<void, AuthError>
+  readonly active: (serviceID: ServiceID) => Effect.Effect<Account | undefined, AuthError>
+  readonly forService: (serviceID: ServiceID) => Effect.Effect<Account[], AuthError>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Auth") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    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) {
+        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 legacy = yield* fsys.readJson(legacyFile).pipe(Effect.orElseSucceed(() => null))
+      if (legacy && typeof legacy === "object") return yield* writeMigrated(legacy as Record<string, unknown>)
+
+      const raw = yield* fsys.readJson(file).pipe(Effect.orElseSucceed(() => null))
+
+      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 write = (data: Writable) =>
+      fsys
+        .writeJson(file, data, 0o600)
+        .pipe(Effect.mapError((cause) => new AuthFileWriteError({ operation: "write", cause })))
+
+    const state = SynchronizedRef.makeUnsafe(yield* load())
+
+    const result: Interface = {
+      get: Effect.fn("AuthV2.get")(function* (accountID) {
+        return (yield* SynchronizedRef.get(state)).accounts[accountID]
+      }),
+
+      all: Effect.fn("AuthV2.all")(function* () {
+        return Object.values((yield* SynchronizedRef.get(state)).accounts)
+      }),
+
+      active: Effect.fn("AuthV2.active")(function* (serviceID) {
+        const data = yield* SynchronizedRef.get(state)
+        return (
+          data.accounts[data.active[serviceID]] ?? Object.values(data.accounts).find((a) => a.serviceID === serviceID)
+        )
+      }),
+
+      forService: Effect.fn("AuthV2.list")(function* (serviceID) {
+        return Object.values((yield* SynchronizedRef.get(state)).accounts).filter((a) => a.serviceID === serviceID)
+      }),
+
+      create: Effect.fn("AuthV2.add")(function* (input) {
+        return yield* SynchronizedRef.modifyEffect(
+          state,
+          Effect.fnUntraced(function* (data) {
+            const account = new Account({
+              id: AccountID.make(Identifier.ascending()),
+              serviceID: input.serviceID,
+              description: input.description ?? "default",
+              credential: input.credential,
+            })
+            const next = {
+              ...data,
+              accounts: { ...data.accounts, [account.id]: account },
+              active:
+                (input.active ?? Object.values(data.accounts).every((a) => a.serviceID !== input.serviceID))
+                  ? { ...data.active, [input.serviceID]: account.id }
+                  : data.active,
+            }
+
+            yield* write(next)
+            return [account, next] as const
+          }),
+        )
+      }),
+
+      update: Effect.fn("AuthV2.update")(function* (accountID, updates) {
+        yield* SynchronizedRef.modifyEffect(
+          state,
+          Effect.fnUntraced(function* (data) {
+            const existing = data.accounts[accountID]
+            if (!existing) return [undefined, data] as const
+
+            const next = {
+              ...data,
+              accounts: {
+                ...data.accounts,
+                [accountID]: new Account({
+                  id: accountID,
+                  serviceID: existing.serviceID,
+                  description: updates.description ?? existing.description,
+                  credential: updates.credential ?? existing.credential,
+                }),
+              },
+            }
+
+            yield* write(next)
+            return [undefined, next] as const
+          }),
+        )
+      }),
+
+      remove: Effect.fn("AuthV2.remove")(function* (accountID) {
+        yield* SynchronizedRef.modifyEffect(
+          state,
+          Effect.fnUntraced(function* (data) {
+            const accounts = { ...data.accounts }
+            const active = { ...data.active }
+            if (accounts[accountID] && active[accounts[accountID].serviceID] === accountID)
+              delete active[accounts[accountID].serviceID]
+            delete accounts[accountID]
+
+            const next = { ...data, accounts, active }
+            yield* write(next)
+            return [undefined, next] as const
+          }),
+        )
+      }),
+
+      activate: Effect.fn("AuthV2.activate")(function* (accountID) {
+        yield* SynchronizedRef.modifyEffect(
+          state,
+          Effect.fnUntraced(function* (data) {
+            const account = data.accounts[accountID]
+            if (!account) return [undefined, data] as const
+
+            const next = { ...data, active: { ...data.active, [account.serviceID]: accountID } }
+            yield* write(next)
+            return [undefined, next] as const
+          }),
+        )
+      }),
+    }
+
+    return Service.of(result)
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(Global.defaultLayer))
+
+export * as AuthV2 from "./auth"

packages/core/src/catalog.ts

@@ -1,6 +1,6 @@
 export * as Catalog from "./catalog"
 
-import { Context, Effect, HashMap, Layer, Option, Order, pipe, Schema, Array, Scope, Stream } from "effect"
+import { Context, Effect, HashMap, Layer, Option, Order, pipe, Schema, Array } from "effect"
 import { produce, type Draft } from "immer"
 import { ModelV2 } from "./model"
 import { PluginV2 } from "./plugin"
@@ -8,9 +8,9 @@ import { ProviderV2 } from "./provider"
 import { Location } from "./location"
 import { EventV2 } from "./event"
 
-export type ProviderRecord = {
+type ProviderRecord = {
   provider: ProviderV2.Info
-  models: Map<ModelV2.ID, ModelV2.Info>
+  models: HashMap.HashMap<ModelV2.ID, ModelV2.Info>
 }
 
 export class ProviderNotFoundError extends Schema.TaggedErrorClass<ProviderNotFoundError>()(
@@ -34,26 +34,10 @@ export const Event = {
   }),
 }
 
-export type Context = {
-  data: readonly ProviderRecord[]
-  updateProvider: (providerID: ProviderV2.ID, fn: (provider: Draft<ProviderV2.Info>) => void) => void
-  updateModel: (providerID: ProviderV2.ID, modelID: ModelV2.ID, fn: (model: Draft<ModelV2.Info>) => void) => void
-  provider: {
-    update: (providerID: ProviderV2.ID, fn: (provider: Draft<ProviderV2.Info>) => void) => void
-    remove: (providerID: ProviderV2.ID) => void
-  }
-  model: {
-    update: (providerID: ProviderV2.ID, modelID: ModelV2.ID, fn: (model: Draft<ModelV2.Info>) => void) => void
-    remove: (providerID: ProviderV2.ID, modelID: ModelV2.ID) => void
-  }
-}
-
-export type Loader = (update: (ctx: Context) => void) => Effect.Effect<void>
-
 export interface Interface {
-  readonly loader: () => Effect.Effect<Loader, never, Scope.Scope>
   readonly provider: {
     readonly get: (providerID: ProviderV2.ID) => Effect.Effect<ProviderV2.Info, ProviderNotFoundError>
+    readonly update: (providerID: ProviderV2.ID, fn: (provider: Draft<ProviderV2.Info>) => void) => Effect.Effect<void>
     readonly all: () => Effect.Effect<ProviderV2.Info[]>
     readonly available: () => Effect.Effect<ProviderV2.Info[]>
   }
@@ -62,6 +46,11 @@ export interface Interface {
       providerID: ProviderV2.ID,
       modelID: ModelV2.ID,
     ) => Effect.Effect<ModelV2.Info, ProviderNotFoundError | ModelNotFoundError>
+    readonly update: (
+      providerID: ProviderV2.ID,
+      modelID: ModelV2.ID,
+      fn: (model: Draft<ModelV2.Info>) => void,
+    ) => Effect.Effect<void, ProviderNotFoundError>
     readonly all: () => Effect.Effect<ModelV2.Info[]>
     readonly available: () => Effect.Effect<ModelV2.Info[]>
     readonly default: () => Effect.Effect<Option.Option<ModelV2.Info>>
@@ -80,11 +69,9 @@ export const layer = Layer.effect(
   Effect.gen(function* () {
     yield* Location.Service
     let records = HashMap.empty<ProviderV2.ID, ProviderRecord>()
-    let loaders: { update: (ctx: Context) => void }[] = []
     let defaultModel: { providerID: ProviderV2.ID; modelID: ModelV2.ID } | undefined
     const plugin = yield* PluginV2.Service
     const events = yield* EventV2.Service
-    const scope = yield* Scope.Scope
 
     const resolve = (model: ModelV2.Info) => {
       const provider = Option.getOrThrow(HashMap.get(records, model.providerID)).provider
@@ -125,127 +112,29 @@ export const layer = Layer.effect(
       return match.value
     }
 
-    const normalizeEndpoint = (item: Draft<ProviderV2.Info> | Draft<ModelV2.Info>) => {
-      if (item.endpoint.type !== "aisdk" || typeof item.options.aisdk.provider.baseURL !== "string") return
-      item.endpoint.url = item.options.aisdk.provider.baseURL
-      delete item.options.aisdk.provider.baseURL
-    }
-
-    const clone = (input: HashMap.HashMap<ProviderV2.ID, ProviderRecord>) =>
-      HashMap.fromIterable(
-        HashMap.toEntries(input).map(([key, value]) => [key, { ...value, models: new Map(value.models) }] as const),
-      )
-
-    const context = (draft: {
-      records: HashMap.HashMap<ProviderV2.ID, ProviderRecord>
-      data: ProviderRecord[]
-    }): Context => {
-      const result: Context = {
-        data: draft.data,
-        updateProvider: (providerID, fn) => result.provider.update(providerID, fn),
-        updateModel: (providerID, modelID, fn) => result.model.update(providerID, modelID, fn),
-        provider: {
-          update: (providerID, fn) => {
-            const current = Option.getOrUndefined(HashMap.get(draft.records, providerID))
-            const provider = produce(current?.provider ?? ProviderV2.Info.empty(providerID), (draft) => {
-              fn(draft)
-              normalizeEndpoint(draft)
-            })
-            const next = {
-              provider,
-              models: current?.models ?? new Map<ModelV2.ID, ModelV2.Info>(),
-            }
-            draft.records = HashMap.set(draft.records, providerID, next)
-            const index = draft.data.findIndex((item) => item.provider.id === providerID)
-            if (index === -1) draft.data.push(next)
-            else draft.data[index] = next
-          },
-          remove: (providerID) => {
-            draft.records = HashMap.remove(draft.records, providerID)
-            const index = draft.data.findIndex((item) => item.provider.id === providerID)
-            if (index !== -1) draft.data.splice(index, 1)
-          },
-        },
-        model: {
-          update: (providerID, modelID, fn) => {
-            const current = Option.getOrThrow(HashMap.get(draft.records, providerID))
-            const model = produce(current.models.get(modelID) ?? ModelV2.Info.empty(providerID, modelID), (draft) => {
-              fn(draft)
-              normalizeEndpoint(draft)
-            })
-            const next = {
-              provider: current.provider,
-              models: new Map(current.models).set(modelID, new ModelV2.Info({ ...model, id: modelID, providerID })),
-            }
-            draft.records = HashMap.set(draft.records, providerID, next)
-            const index = draft.data.findIndex((item) => item.provider.id === providerID)
-            if (index === -1) draft.data.push(next)
-            else draft.data[index] = next
-          },
-          remove: (providerID, modelID) => {
-            const current = Option.getOrUndefined(HashMap.get(draft.records, providerID))
-            if (!current) return
-            const next = {
-              provider: current.provider,
-              models: new Map(current.models),
-            }
-            next.models.delete(modelID)
-            draft.records = HashMap.set(draft.records, providerID, next)
-            const index = draft.data.findIndex((item) => item.provider.id === providerID)
-            if (index !== -1) draft.data[index] = next
-          },
-        },
-      }
-      return result
-    }
-
-    const transform = Effect.fn("CatalogV2.transform")(function* () {
-      const draft = { records: clone(records), data: HashMap.toValues(records) }
-      yield* plugin.trigger("catalog.transform", context(draft), {})
-      records = draft.records
-    })
-
-    const rebuild = Effect.fn("CatalogV2.rebuild")(function* () {
-      const draft = { records: HashMap.empty<ProviderV2.ID, ProviderRecord>(), data: [] as ProviderRecord[] }
-      for (const loader of loaders) loader.update(context(draft))
-      yield* plugin.trigger("catalog.transform", context(draft), {})
-      records = draft.records
-    })
-
-    yield* plugin.added().pipe(
-      Stream.runForEach((id) =>
-        Effect.gen(function* () {
-          const draft = { records: clone(records), data: HashMap.toValues(records) }
-          yield* plugin.triggerFor(id, "catalog.transform", context(draft), {})
-          records = draft.records
-        }),
-      ),
-      Effect.forkIn(scope, { startImmediately: true }),
-    )
-
     const result: Interface = {
-      loader: Effect.fn("CatalogV2.loader")(function* () {
-        const loader = { update: (_ctx: Context) => {} }
-        loaders = [...loaders, loader]
-        const scope = yield* Scope.Scope
-        yield* Scope.addFinalizer(
-          scope,
-          Effect.sync(() => {
-            loaders = loaders.filter((item) => item !== loader)
-          }).pipe(Effect.andThen(rebuild())),
-        )
-        return Effect.fnUntraced(function* (update) {
-          loader.update = update
-          yield* rebuild()
-        })
-      }),
-
       provider: {
         get: Effect.fn("CatalogV2.provider.get")(function* (providerID) {
           const record = yield* getRecord(providerID)
           return record.provider
         }),
 
+        update: Effect.fnUntraced(function* (providerID, fn) {
+          const current = Option.getOrUndefined(HashMap.get(records, providerID))
+          const provider = produce(current?.provider ?? ProviderV2.Info.empty(providerID), (draft) => {
+            fn(draft)
+            if (draft.endpoint.type === "aisdk" && typeof draft.options.aisdk.provider.baseURL === "string") {
+              draft.endpoint.url = draft.options.aisdk.provider.baseURL
+              delete draft.options.aisdk.provider.baseURL
+            }
+          })
+          const updated = yield* plugin.trigger("provider.update", {}, { provider, cancel: false })
+          records = HashMap.set(records, providerID, {
+            provider: updated.provider,
+            models: current?.models ?? HashMap.empty<ModelV2.ID, ModelV2.Info>(),
+          })
+        }),
+
         all: Effect.fn("CatalogV2.provider.all")(function* () {
           return globalThis.Array.from(HashMap.values(records)).map((record) => record.provider)
         }),
@@ -260,16 +149,39 @@ export const layer = Layer.effect(
       model: {
         get: Effect.fn("CatalogV2.model.get")(function* (providerID, modelID) {
           const record = yield* getRecord(providerID)
-          const model = record.models.get(modelID)
+          const model = Option.getOrUndefined(HashMap.get(record.models, modelID))
           if (!model) return yield* new ModelNotFoundError({ providerID, modelID })
           return resolve(model)
         }),
 
+        update: Effect.fnUntraced(function* (providerID, modelID, fn) {
+          const record = yield* getRecord(providerID)
+          const model = produce(
+            HashMap.get(record.models, modelID).pipe(Option.getOrElse(() => ModelV2.Info.empty(providerID, modelID))),
+            (draft) => {
+              fn(draft)
+              if (draft.endpoint.type === "aisdk" && typeof draft.options.aisdk.provider.baseURL === "string") {
+                draft.endpoint.url = draft.options.aisdk.provider.baseURL
+                delete draft.options.aisdk.provider.baseURL
+              }
+            },
+          )
+          const updated = yield* plugin.trigger("model.update", {}, { model, cancel: false })
+          if (updated.cancel) return
+          const next = new ModelV2.Info({ ...updated.model, id: modelID, providerID })
+          records = HashMap.set(records, providerID, {
+            provider: record.provider,
+            models: HashMap.set(record.models, modelID, next),
+          })
+          yield* events.publish(Event.ModelUpdated, { model: resolve(next) })
+          return
+        }),
+
         all: Effect.fn("CatalogV2.model.all")(function* () {
           return pipe(
             records,
             HashMap.toValues,
-            Array.flatMap((record) => globalThis.Array.from(record.models.values())),
+            Array.flatMap((record) => HashMap.toValues(record.models)),
             Array.map(resolve),
             Array.sortWith((item) => item.time.released.epochMilliseconds, Order.flip(Order.Number)),
           )
@@ -305,12 +217,12 @@ export const layer = Layer.effect(
           if (!record) return Option.none<ModelV2.Info>()
 
           if (providerID === ProviderV2.ID.opencode) {
-            const gpt5Nano = record.models.get(ModelV2.ID.make("gpt-5-nano"))
+            const gpt5Nano = Option.getOrUndefined(HashMap.get(record.models, ModelV2.ID.make("gpt-5-nano")))
             if (gpt5Nano?.enabled && gpt5Nano.status === "active") return Option.some(resolve(gpt5Nano))
           }
 
           const candidates = pipe(
-            globalThis.Array.from(record.models.values()),
+            HashMap.toValues(record.models),
             Array.filter(
               (model) =>
                 model.providerID === providerID &&
@@ -354,4 +266,4 @@ export const layer = Layer.effect(
 
 const SMALL_MODEL_RE = /\b(nano|flash|lite|mini|haiku|small|fast)\b/
 
-export const defaultLayer = layer.pipe(Layer.provide(EventV2.defaultLayer), Layer.provide(PluginV2.defaultLayer))
+export const defaultLayer = layer.pipe(Layer.provideMerge(EventV2.defaultLayer), Layer.provide(PluginV2.defaultLayer))

packages/core/src/event.ts

@@ -1,5 +1,3 @@
-export * as EventV2 from "./event"
-
 import { Context, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
 import { Location } from "./location"
 import { withStatics } from "./schema"
@@ -155,3 +153,5 @@ export const layer = Layer.effect(
 )
 
 export const defaultLayer = layer
+
+export * as EventV2 from "./event"

packages/core/src/location-layer.ts

@@ -4,10 +4,9 @@ import { Catalog } from "./catalog"
 import { PluginBoot } from "./plugin/boot"
 
 export class LocationServiceMap extends LayerMap.Service<LocationServiceMap>()("@opencode/example/LocationServiceMap", {
-  lookup: (ref: Location.Ref) =>
-    Layer.mergeAll(Catalog.defaultLayer, PluginBoot.defaultLayer).pipe(
-      Layer.provide([Layer.succeed(Location.Service, Location.Service.of(ref))]),
-    ),
+  lookup: (ref: Location.Ref) => {
+    const location = Layer.succeed(Location.Service, Location.Service.of(ref))
+    return Layer.mergeAll(Catalog.defaultLayer, PluginBoot.defaultLayer).pipe(Layer.provide(location))
+  },
   idleTimeToLive: "5 minutes",
-  dependencies: [],
 }) {}

packages/core/src/models-dev.ts

@@ -7,7 +7,6 @@ import { Flock } from "./util/flock"
 import { Hash } from "./util/hash"
 import { AppFileSystem } from "./filesystem"
 import { InstallationChannel, InstallationVersion } from "./installation/version"
-import { EventV2 } from "./event"
 
 export const CatalogModelStatus = Schema.Literals(["alpha", "beta", "deprecated"])
 export type CatalogModelStatus = typeof CatalogModelStatus.Type
@@ -106,13 +105,6 @@ export const Provider = Schema.Struct({
 
 export type Provider = Schema.Schema.Type<typeof Provider>
 
-export const Event = {
-  Refreshed: EventV2.define({
-    type: "models-dev.refreshed",
-    schema: {},
-  }),
-}
-
 declare const OPENCODE_MODELS_DEV: Record<string, Provider> | undefined
 
 export interface Interface {
@@ -126,7 +118,6 @@ export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const fs = yield* AppFileSystem.Service
-    const events = yield* EventV2.Service
     const http = HttpClient.filterStatusOk(
       (yield* HttpClient.HttpClient).pipe(
         HttpClient.retryTransient({
@@ -206,7 +197,6 @@ export const layer = Layer.effect(
           if (!force && (yield* fresh())) return
           yield* fetchAndWrite()
           yield* invalidate
-          yield* events.publish(Event.Refreshed, {})
         }),
       ).pipe(
         Effect.tapCause((cause) =>
@@ -225,10 +215,9 @@ export const layer = Layer.effect(
   }),
 )
 
-export const defaultLayer = layer.pipe(
+export const defaultLayer: Layer.Layer<Service> = layer.pipe(
   Layer.provide(FetchHttpClient.layer),
   Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(EventV2.defaultLayer),
 )
 
 export * as ModelsDev from "./models-dev"

packages/core/src/permission.ts

@@ -1,45 +0,0 @@
-export * as PermissionV2 from "./permission"
-
-import { Schema } from "effect"
-import { Wildcard } from "./util/wildcard"
-
-export const Action = Schema.Literals(["allow", "deny", "ask"]).annotate({ identifier: "PermissionV2.Action" })
-export type Action = typeof Action.Type
-
-export const Rule = Schema.Struct({
-  permission: Schema.String,
-  pattern: Schema.String,
-  action: Action,
-}).annotate({ identifier: "PermissionV2.Rule" })
-export type Rule = typeof Rule.Type
-
-export const Ruleset = Schema.Array(Rule).annotate({ identifier: "PermissionV2.Ruleset" })
-export type Ruleset = typeof Ruleset.Type
-
-const EDIT_TOOLS = ["edit", "write", "apply_patch"]
-
-export function evaluate(permission: string, pattern: string, ...rulesets: Ruleset[]): Rule {
-  return (
-    rulesets
-      .flat()
-      .findLast((rule) => Wildcard.match(permission, rule.permission) && Wildcard.match(pattern, rule.pattern)) ?? {
-      action: "ask",
-      permission,
-      pattern: "*",
-    }
-  )
-}
-
-export function merge(...rulesets: Ruleset[]): Ruleset {
-  return rulesets.flat()
-}
-
-export function disabled(tools: string[], ruleset: Ruleset): Set<string> {
-  return new Set(
-    tools.filter((tool) => {
-      const permission = EDIT_TOOLS.includes(tool) ? "edit" : tool
-      const rule = ruleset.findLast((rule) => Wildcard.match(permission, rule.permission))
-      return rule?.pattern === "*" && rule.action === "deny"
-    }),
-  )
-}

packages/core/src/plugin.ts

@@ -2,26 +2,27 @@ export * as PluginV2 from "./plugin"
 
 import { createDraft, finishDraft, type Draft } from "immer"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
-import { Context, Effect, Exit, Layer, PubSub, Schema, Scope, Stream } from "effect"
+import { type ProviderV2 } from "./provider"
+import { Context, Effect, Layer, Schema } from "effect"
 import type { ModelV2 } from "./model"
-import type { AgentV2 } from "./agent"
-import type { Catalog } from "./catalog"
 
 export const ID = Schema.String.pipe(Schema.brand("Plugin.ID"))
 export type ID = typeof ID.Type
 
 type HookSpec = {
-  "catalog.transform": {
-    input: Catalog.Context
-    output: {}
-  }
-  "account.switched": {
-    input: {
-      serviceID: import("./account").AccountV2.ServiceID
-      from?: import("./account").AccountV2.ID
-      to?: import("./account").AccountV2.ID
+  "provider.update": {
+    input: {}
+    output: {
+      provider: ProviderV2.Info
+      cancel: boolean
+    }
+  }
+  "model.update": {
+    input: {}
+    output: {
+      model: ModelV2.Info
+      cancel: boolean
     }
-    output: {}
   }
   "aisdk.language": {
     input: {
@@ -43,27 +44,6 @@ type HookSpec = {
       sdk?: any
     }
   }
-  "agent.update": {
-    input: {}
-    output: {
-      agent: AgentV2.Info
-      cancel: boolean
-    }
-  }
-  "agent.remove": {
-    input: {
-      agent: AgentV2.Info
-    }
-    output: {
-      cancel: boolean
-    }
-  }
-  "agent.default": {
-    input: {}
-    output: {
-      agent?: AgentV2.ID
-    }
-  }
 }
 
 export type Hooks = {
@@ -81,25 +61,15 @@ export type HookFunctions = {
 export type HookInput<Name extends keyof Hooks> = HookSpec[Name]["input"]
 export type HookOutput<Name extends keyof Hooks> = HookSpec[Name]["output"]
 
-export type Effect<R = never> = Effect.Effect<HookFunctions | void, never, R | Scope.Scope>
+export type Effect = Effect.Effect<HookFunctions | void, never, never>
 
 export function define<R>(input: { id: ID; effect: Effect.Effect<HookFunctions | void, never, R> }) {
   return input
 }
 
 export interface Interface {
-  readonly add: (input: {
-    id: ID
-    effect: Effect.Effect<void | HookFunctions, never, Scope.Scope>
-  }) => Effect.Effect<void, never, never>
+  readonly add: (input: { id: ID; effect: Effect }) => Effect.Effect<void>
   readonly remove: (id: ID) => Effect.Effect<void>
-  readonly added: () => Stream.Stream<ID>
-  readonly triggerFor: <Name extends keyof Hooks>(
-    id: ID,
-    name: Name,
-    input: HookInput<Name>,
-    output: HookOutput<Name>,
-  ) => Effect.Effect<HookInput<Name> & HookOutput<Name>>
   readonly trigger: <Name extends keyof Hooks>(
     name: Name,
     input: HookInput<Name>,
@@ -115,33 +85,21 @@ export const layer = Layer.effect(
     let hooks: {
       id: ID
       hooks: HookFunctions
-      scope: Scope.Closeable
     }[] = []
-    const added = yield* PubSub.unbounded<ID>()
-
-    yield* Effect.addFinalizer(() => PubSub.shutdown(added))
 
     const svc = Service.of({
       add: Effect.fn("Plugin.add")(function* (input) {
-        const existing = hooks.find((item) => item.id === input.id)
-        if (existing) yield* Scope.close(existing.scope, Exit.void).pipe(Effect.ignore)
-        const scope = yield* Scope.make()
-        const result = yield* input.effect.pipe(Scope.provide(scope))
+        const result = yield* input.effect
+        if (!result) return
         hooks = [
           ...hooks.filter((item) => item.id !== input.id),
           {
             id: input.id,
-            hooks: result ?? {},
-            scope,
+            hooks: result,
           },
         ]
-        yield* PubSub.publish(added, input.id)
       }),
-      added: () => Stream.fromPubSub(added),
       trigger: Effect.fn("Plugin.trigger")(function* (name, input, output) {
-        return yield* svc.triggerFor(ID.make("*"), name, input, output)
-      }),
-      triggerFor: Effect.fn("Plugin.triggerFor")(function* (id, name, input, output) {
         const draftEntries = new Map<string, ReturnType<typeof createDraft>>()
         const event = {
           ...input,
@@ -156,7 +114,6 @@ export const layer = Layer.effect(
         }
 
         for (const item of hooks) {
-          if (id !== ID.make("*") && item.id !== id) continue
           const match = item.hooks[name]
           if (!match) continue
           yield* match(event as any).pipe(
@@ -176,9 +133,7 @@ export const layer = Layer.effect(
         return event as any
       }),
       remove: Effect.fn("Plugin.remove")(function* (id) {
-        const existing = hooks.find((item) => item.id === id)
         hooks = hooks.filter((item) => item.id !== id)
-        if (existing) yield* Scope.close(existing.scope, Exit.void).pipe(Effect.ignore)
       }),
     })
     return svc

packages/core/src/plugin/account.ts

@@ -1,41 +0,0 @@
-import { Effect, Scope, Stream } from "effect"
-import { AccountV2 } from "../account"
-import { EventV2 } from "../event"
-import { PluginV2 } from "../plugin"
-
-export const AccountPlugin = PluginV2.define({
-  id: PluginV2.ID.make("account"),
-  effect: Effect.gen(function* () {
-    const accounts = yield* AccountV2.Service
-    const events = yield* EventV2.Service
-    const scope = yield* Scope.Scope
-
-    yield* events.subscribe(AccountV2.Event.Switched).pipe(
-      Stream.runForEach((event) =>
-        PluginV2.Service.use((plugin) => plugin.trigger("account.switched", event.data, {})).pipe(Effect.asVoid),
-      ),
-      Effect.forkIn(scope, { startImmediately: true }),
-    )
-
-    return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          const account = yield* accounts.active(AccountV2.ServiceID.make(item.provider.id)).pipe(Effect.orDie)
-          if (!account) continue
-          evt.provider.update(item.provider.id, (provider) => {
-            provider.enabled = {
-              via: "account",
-              service: account.serviceID,
-            }
-            if (account.credential.type === "api") {
-              provider.options.aisdk.provider.apiKey = account.credential.key
-              Object.assign(provider.options.aisdk.provider, account.credential.metadata ?? {})
-            }
-            if (account.credential.type === "oauth") provider.options.aisdk.provider.apiKey = account.credential.access
-          })
-        }
-      }),
-      "account.switched": Effect.fn(function* () {}),
-    }
-  }),
-})

packages/core/src/plugin/auth.ts

@@ -0,0 +1,27 @@
+import { Effect } from "effect"
+import { AuthV2 } from "../auth"
+import { PluginV2 } from "../plugin"
+
+export const AuthPlugin = PluginV2.define({
+  id: PluginV2.ID.make("auth"),
+  effect: Effect.gen(function* () {
+    const auth = yield* AuthV2.Service
+    return {
+      "provider.update": Effect.fn(function* (evt) {
+        const account = yield* auth.active(AuthV2.ServiceID.make(evt.provider.id)).pipe(Effect.orDie)
+        if (!account) return
+        evt.provider.enabled = {
+          via: "auth",
+          service: account.serviceID,
+        }
+        if (account.credential.type === "api") {
+          evt.provider.options.aisdk.provider.apiKey = account.credential.key
+          Object.assign(evt.provider.options.aisdk.provider, account.credential.metadata ?? {})
+        }
+        if (account.credential.type === "oauth") {
+          evt.provider.options.aisdk.provider.apiKey = account.credential.access
+        }
+      }),
+    }
+  }),
+})

packages/core/src/plugin/boot.ts

@@ -1,22 +1,18 @@
 export * as PluginBoot from "./boot"
 
-import { Context, Deferred, Effect, Layer, Scope } from "effect"
-import { AccountV2 } from "../account"
-import { AgentV2 } from "../agent"
+import { Context, Deferred, Effect, Layer } from "effect"
+import { AuthV2 } from "../auth"
 import { Catalog } from "../catalog"
-import { EventV2 } from "../event"
 import { Npm } from "../npm"
 import { PluginV2 } from "../plugin"
-import { AccountPlugin } from "./account"
+import { AuthPlugin } from "./auth"
 import { EnvPlugin } from "./env"
 import { ModelsDevPlugin } from "./models-dev"
 import { ProviderPlugins } from "./provider"
 
 type Plugin = {
   id: PluginV2.ID
-  effect: PluginV2.Effect<
-    Catalog.Service | AgentV2.Service | AccountV2.Service | Npm.Service | EventV2.Service | PluginV2.Service
-  >
+  effect: Effect.Effect<PluginV2.HookFunctions | void, never, Catalog.Service | AuthV2.Service | Npm.Service>
 }
 
 export interface Interface {
@@ -25,57 +21,51 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/PluginBoot") {}
 
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const agent = yield* AgentV2.Service
-    const catalog = yield* Catalog.Service
-    const plugin = yield* PluginV2.Service
-    const accounts = yield* AccountV2.Service
-    const npm = yield* Npm.Service
-    const events = yield* EventV2.Service
-    const done = yield* Deferred.make<void>()
+export const layer: Layer.Layer<Service, never, Catalog.Service | PluginV2.Service | AuthV2.Service | Npm.Service> =
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      const plugin = yield* PluginV2.Service
+      const auth = yield* AuthV2.Service
+      const npm = yield* Npm.Service
+      const done = yield* Deferred.make<void>()
 
-    const add = Effect.fn("PluginBoot.add")(function* (input: Plugin) {
-      yield* plugin.add({
-        id: input.id,
-        effect: input.effect.pipe(
-          Effect.provideService(Catalog.Service, catalog),
-          Effect.provideService(AgentV2.Service, agent),
-          Effect.provideService(AccountV2.Service, accounts),
-          Effect.provideService(Npm.Service, npm),
-          Effect.provideService(EventV2.Service, events),
-          Effect.provideService(PluginV2.Service, plugin),
-        ),
+      const add = Effect.fn("PluginBoot.add")(function* (input: Plugin) {
+        yield* plugin.add({
+          id: input.id,
+          effect: input.effect.pipe(
+            Effect.provideService(Catalog.Service, catalog),
+            Effect.provideService(AuthV2.Service, auth),
+            Effect.provideService(Npm.Service, npm),
+          ),
+        })
       })
-    })
 
-    const boot = Effect.gen(function* () {
-      yield* add(EnvPlugin)
-      yield* add(AccountPlugin)
-      for (const item of ProviderPlugins) {
-        yield* add(item)
-      }
-      yield* add(ModelsDevPlugin)
-    }).pipe(Effect.withSpan("PluginBoot.boot"))
+      const boot = Effect.gen(function* () {
+        yield* add(EnvPlugin)
+        yield* add(AuthPlugin)
+        for (const item of ProviderPlugins) {
+          yield* add(item)
+        }
+        yield* add(ModelsDevPlugin)
+      }).pipe(Effect.withSpan("PluginBoot.boot"))
 
-    yield* boot.pipe(
-      Effect.exit,
-      Effect.flatMap((exit) => Deferred.done(done, exit)),
-      Effect.forkScoped,
-    )
+      yield* boot.pipe(
+        Effect.exit,
+        Effect.flatMap((exit) => Deferred.done(done, exit)),
+        Effect.forkScoped,
+      )
 
-    return Service.of({
-      wait: () => Deferred.await(done),
-    })
-  }),
-)
+      return Service.of({
+        wait: () => Deferred.await(done),
+      })
+    }),
+  )
 
 export const defaultLayer = layer.pipe(
-  Layer.provide(AgentV2.defaultLayer),
   Layer.provide(Catalog.defaultLayer),
-  Layer.provide(EventV2.defaultLayer),
   Layer.provide(PluginV2.defaultLayer),
-  Layer.provide(AccountV2.defaultLayer),
+  Layer.provide(Layer.orDie(AuthV2.defaultLayer)),
   Layer.provide(Npm.defaultLayer),
 )

packages/core/src/plugin/env.ts

@@ -5,16 +5,12 @@ export const EnvPlugin = PluginV2.define({
   id: PluginV2.ID.make("env"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          const key = item.provider.env.find((env) => process.env[env])
-          if (!key) continue
-          evt.provider.update(item.provider.id, (provider) => {
-            provider.enabled = {
-              via: "env",
-              name: key,
-            }
-          })
+      "provider.update": Effect.fn(function* (evt) {
+        const key = evt.provider.env.find((item) => process.env[item])
+        if (!key) return
+        evt.provider.enabled = {
+          via: "env",
+          name: key,
         }
       }),
     }

packages/core/src/plugin/models-dev.ts

@@ -1,6 +1,5 @@
-import { DateTime, Effect, Scope, Stream } from "effect"
+import { DateTime, Effect } from "effect"
 import { Catalog } from "../catalog"
-import { EventV2 } from "../event"
 import { ModelV2 } from "../model"
 import { ModelsDev } from "../models-dev"
 import { PluginV2 } from "../plugin"
@@ -55,66 +54,55 @@ export const ModelsDevPlugin = PluginV2.define({
   effect: Effect.gen(function* () {
     const catalog = yield* Catalog.Service
     const modelsDev = yield* ModelsDev.Service
-    const events = yield* EventV2.Service
-    const scope = yield* Scope.Scope
-    const load = yield* catalog.loader()
-    const refresh = Effect.fn("ModelsDevPlugin.refresh")(function* () {
-      const data = yield* modelsDev.get()
-      yield* load((catalog) => {
-        for (const item of Object.values(data)) {
-          const providerID = ProviderV2.ID.make(item.id)
-          catalog.provider.update(providerID, (provider) => {
-            provider.name = item.name
-            provider.env = [...item.env]
-            provider.endpoint = item.npm
+    for (const item of Object.values(yield* modelsDev.get())) {
+      const providerID = ProviderV2.ID.make(item.id)
+      yield* catalog.provider.update(providerID, (provider) => {
+        provider.name = item.name
+        provider.env = [...item.env]
+        provider.endpoint = item.npm
+          ? {
+              type: "aisdk",
+              package: item.npm,
+              url: item.api,
+            }
+          : {
+              type: "unknown",
+            }
+      })
+
+      for (const model of Object.values(item.models)) {
+        const modelID = ModelV2.ID.make(model.id)
+        yield* catalog.model
+          .update(providerID, modelID, (draft) => {
+            draft.name = model.name
+            draft.family = model.family ? ModelV2.Family.make(model.family) : undefined
+            draft.endpoint = model.provider?.npm
               ? {
                   type: "aisdk",
-                  package: item.npm,
-                  url: item.api,
+                  package: model.provider?.npm,
+                  url: model.provider.api,
                 }
               : {
                   type: "unknown",
                 }
+            draft.capabilities = {
+              tools: model.tool_call,
+              input: [...(model.modalities?.input ?? [])],
+              output: [...(model.modalities?.output ?? [])],
+            }
+            draft.variants = variants(model)
+            draft.time.released = released(model.release_date)
+            draft.cost = cost(model.cost)
+            draft.status = model.status ?? "active"
+            draft.enabled = true
+            draft.limit = {
+              context: model.limit.context,
+              input: model.limit.input,
+              output: model.limit.output,
+            }
           })
-
-          for (const model of Object.values(item.models)) {
-            const modelID = ModelV2.ID.make(model.id)
-            catalog.model.update(providerID, modelID, (draft) => {
-              draft.name = model.name
-              draft.family = model.family ? ModelV2.Family.make(model.family) : undefined
-              draft.endpoint = model.provider?.npm
-                ? {
-                    type: "aisdk",
-                    package: model.provider?.npm,
-                    url: model.provider.api,
-                  }
-                : {
-                    type: "unknown",
-                  }
-              draft.capabilities = {
-                tools: model.tool_call,
-                input: [...(model.modalities?.input ?? [])],
-                output: [...(model.modalities?.output ?? [])],
-              }
-              draft.variants = variants(model)
-              draft.time.released = released(model.release_date)
-              draft.cost = cost(model.cost)
-              draft.status = model.status ?? "active"
-              draft.enabled = true
-              draft.limit = {
-                context: model.limit.context,
-                input: model.limit.input,
-                output: model.limit.output,
-              }
-            })
-          }
-        }
-      })
-    })
-    yield* refresh()
-    yield* events.subscribe(ModelsDev.Event.Refreshed).pipe(
-      Stream.runForEach(() => refresh()),
-      Effect.forkIn(scope, { startImmediately: true }),
-    )
+          .pipe(Effect.orDie)
+      }
+    }
   }).pipe(Effect.provide(ModelsDev.defaultLayer)),
 })

packages/core/src/plugin/provider/amazon-bedrock.ts

@@ -50,19 +50,14 @@ export const AmazonBedrockPlugin = PluginV2.define({
   id: PluginV2.ID.make("amazon-bedrock"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/amazon-bedrock") continue
-          evt.provider.update(item.provider.id, (provider) => {
-            if (provider.endpoint.type !== "aisdk") return
-            if (typeof provider.options.aisdk.provider.endpoint !== "string") return
-            // The AI SDK expects a base URL, but users configure Bedrock private/VPC
-            // endpoints as `endpoint`; move it into the catalog endpoint URL once.
-            provider.endpoint.url = provider.options.aisdk.provider.endpoint
-            delete provider.options.aisdk.provider.endpoint
-          })
-        }
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.amazonBedrock) return
+        if (evt.provider.endpoint.type !== "aisdk") return
+        if (typeof evt.provider.options.aisdk.provider.endpoint !== "string") return
+        // The AI SDK expects a base URL, but users configure Bedrock private/VPC
+        // endpoints as `endpoint`; move it into the catalog endpoint URL once.
+        evt.provider.endpoint.url = evt.provider.options.aisdk.provider.endpoint
+        delete evt.provider.options.aisdk.provider.endpoint
       }),
       "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/amazon-bedrock") return

packages/core/src/plugin/provider/anthropic.ts

@@ -1,19 +1,15 @@
 import { Effect } from "effect"
 import { PluginV2 } from "../../plugin"
+import { ProviderV2 } from "../../provider"
 
 export const AnthropicPlugin = PluginV2.define({
   id: PluginV2.ID.make("anthropic"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/anthropic") continue
-          evt.provider.update(item.provider.id, (provider) => {
-            provider.options.headers["anthropic-beta"] =
-              "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14"
-          })
-        }
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.anthropic) return
+        evt.provider.options.headers["anthropic-beta"] =
+          "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14"
       }),
       "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/anthropic") return

packages/core/src/plugin/provider/azure.ts

@@ -14,18 +14,12 @@ export const AzurePlugin = PluginV2.define({
   id: PluginV2.ID.make("azure"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/azure") continue
-          const configured = item.provider.options.aisdk.provider.resourceName
-          const resourceName =
-            typeof configured === "string" && configured.trim() !== "" ? configured : process.env.AZURE_RESOURCE_NAME
-          if (!resourceName) continue
-          evt.provider.update(item.provider.id, (provider) => {
-            provider.options.aisdk.provider.resourceName = resourceName
-          })
-        }
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.azure) return
+        const configured = evt.provider.options.aisdk.provider.resourceName
+        const resourceName =
+          typeof configured === "string" && configured.trim() !== "" ? configured : process.env.AZURE_RESOURCE_NAME
+        if (resourceName) evt.provider.options.aisdk.provider.resourceName = resourceName
       }),
       "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/azure") return
@@ -55,17 +49,11 @@ export const AzureCognitiveServicesPlugin = PluginV2.define({
   id: PluginV2.ID.make("azure-cognitive-services"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.make("azure-cognitive-services")) return
         const resourceName = process.env.AZURE_COGNITIVE_SERVICES_RESOURCE_NAME
-        if (!resourceName) return
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/openai-compatible") continue
-          if (!item.provider.id.includes("azure-cognitive-services")) continue
-          evt.provider.update(item.provider.id, (provider) => {
-            provider.options.aisdk.provider.baseURL = `https://${resourceName}.cognitiveservices.azure.com/openai`
-          })
-        }
+        if (resourceName)
+          evt.provider.options.aisdk.provider.baseURL = `https://${resourceName}.cognitiveservices.azure.com/openai`
       }),
       "aisdk.language": Effect.fn(function* (evt) {
         if (evt.model.providerID !== ProviderV2.ID.make("azure-cognitive-services")) return

packages/core/src/plugin/provider/cerebras.ts

@@ -1,18 +1,14 @@
 import { Effect } from "effect"
 import { PluginV2 } from "../../plugin"
+import { ProviderV2 } from "../../provider"
 
 export const CerebrasPlugin = PluginV2.define({
   id: PluginV2.ID.make("cerebras"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (ctx) {
-        for (const item of ctx.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/cerebras") continue
-          ctx.provider.update(item.provider.id, (provider) => {
-            provider.options.headers["X-Cerebras-3rd-Party-Integration"] = "opencode"
-          })
-        }
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.make("cerebras")) return
+        evt.provider.options.headers["X-Cerebras-3rd-Party-Integration"] = "opencode"
       }),
       "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/cerebras") return

packages/core/src/plugin/provider/cloudflare-ai-gateway.ts

@@ -45,7 +45,7 @@ const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
 
 function gatewayConfig(options: Record<string, unknown>): GatewayConfig | undefined {
   const accountId = process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId")
-  // AccountPlugin copies CLI prompt metadata into options. The prompt stores the
+  // AuthPlugin copies CLI prompt metadata into options. The prompt stores the
   // gateway as gatewayId, while older config examples may use gateway.
   const gatewayId =
     process.env.CLOUDFLARE_GATEWAY_ID ?? stringOption(options, "gatewayId") ?? stringOption(options, "gateway")

packages/core/src/plugin/provider/cloudflare-workers-ai.ts

@@ -10,15 +10,13 @@ export const CloudflareWorkersAIPlugin = PluginV2.define({
   id: PluginV2.ID.make("cloudflare-workers-ai"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        const item = evt.data.find((record) => record.provider.id === providerID)
-        if (!item) return
-        evt.provider.update(item.provider.id, (provider) => {
-          if (provider.endpoint.type !== "aisdk") return
-          if (provider.endpoint.url) return
-          const accountId = resolveAccountId(provider.options.aisdk.provider)
-          if (accountId) provider.endpoint.url = workersEndpoint(accountId)
-        })
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== providerID) return
+        if (evt.provider.endpoint.type !== "aisdk") return
+        if (evt.provider.endpoint.url) return
+
+        const accountId = resolveAccountId(evt.provider.options.aisdk.provider)
+        if (accountId) evt.provider.endpoint.url = workersEndpoint(accountId)
       }),
       "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.model.providerID !== providerID) return

packages/core/src/plugin/provider/github-copilot.ts

@@ -15,6 +15,9 @@ export const GithubCopilotPlugin = PluginV2.define({
   id: PluginV2.ID.make("github-copilot"),
   effect: Effect.gen(function* () {
     return {
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.githubCopilot) return
+      }),
       "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/github-copilot") return
         const mod = yield* Effect.promise(() => import("../../github-copilot/copilot-provider"))
@@ -30,14 +33,11 @@ export const GithubCopilotPlugin = PluginV2.define({
           ? evt.sdk.responses(evt.model.apiID)
           : evt.sdk.chat(evt.model.apiID)
       }),
-      "catalog.transform": Effect.fn(function* (evt) {
-        const item = evt.data.find((record) => record.provider.id === ProviderV2.ID.githubCopilot)
-        if (!item || !item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) return
-        evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
-          // This chat-only alias conflicts with the Copilot GPT-5 Responses route,
-          // so hide it only for Copilot rather than for every provider catalog.
-          model.enabled = false
-        })
+      "model.update": Effect.fn(function* (evt) {
+        if (evt.model.providerID !== ProviderV2.ID.githubCopilot) return
+        // This chat-only alias conflicts with the Copilot GPT-5 Responses route,
+        // so hide it only for Copilot rather than for every provider catalog.
+        if (evt.model.id === ModelV2.ID.make("gpt-5-chat-latest")) evt.cancel = true
       }),
     }
   }),

packages/core/src/plugin/provider/google-vertex.ts

@@ -57,26 +57,20 @@ export const GoogleVertexPlugin = PluginV2.define({
   id: PluginV2.ID.make("google-vertex"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (
-            item.provider.endpoint.package !== "@ai-sdk/google-vertex" &&
-            !item.provider.endpoint.package.includes("@ai-sdk/openai-compatible")
-          )
-            continue
-          const project = resolveProject(item.provider.options.aisdk.provider)
-          const location = String(resolveLocation(item.provider.options.aisdk.provider))
-          evt.provider.update(item.provider.id, (provider) => {
-            if (project) provider.options.aisdk.provider.project = project
-            provider.options.aisdk.provider.location = location
-            if (provider.endpoint.type === "aisdk" && provider.endpoint.url) {
-              provider.endpoint.url = replaceVertexVars(provider.endpoint.url, project, location)
-            }
-            if (provider.endpoint.type === "aisdk" && provider.endpoint.package.includes("@ai-sdk/openai-compatible")) {
-              provider.options.aisdk.provider.fetch = authFetch(provider.options.aisdk.provider.fetch)
-            }
-          })
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.googleVertex) return
+        const project = resolveProject(evt.provider.options.aisdk.provider)
+        const location = String(resolveLocation(evt.provider.options.aisdk.provider))
+        if (project) evt.provider.options.aisdk.provider.project = project
+        evt.provider.options.aisdk.provider.location = location
+        if (evt.provider.endpoint.type === "aisdk" && evt.provider.endpoint.url) {
+          evt.provider.endpoint.url = replaceVertexVars(evt.provider.endpoint.url, project, location)
+        }
+        if (
+          evt.provider.endpoint.type === "aisdk" &&
+          evt.provider.endpoint.package.includes("@ai-sdk/openai-compatible")
+        ) {
+          evt.provider.options.aisdk.provider.fetch = authFetch(evt.provider.options.aisdk.provider.fetch)
         }
       }),
       "aisdk.sdk": Effect.fn(function* (evt) {
@@ -108,25 +102,20 @@ export const GoogleVertexAnthropicPlugin = PluginV2.define({
   id: PluginV2.ID.make("google-vertex-anthropic"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/google-vertex/anthropic") continue
-          const project =
-            item.provider.options.aisdk.provider.project ??
-            process.env.GOOGLE_CLOUD_PROJECT ??
-            process.env.GCP_PROJECT ??
-            process.env.GCLOUD_PROJECT
-          const location =
-            item.provider.options.aisdk.provider.location ??
-            process.env.GOOGLE_CLOUD_LOCATION ??
-            process.env.VERTEX_LOCATION ??
-            "global"
-          evt.provider.update(item.provider.id, (provider) => {
-            if (project) provider.options.aisdk.provider.project = project
-            provider.options.aisdk.provider.location = location
-          })
-        }
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.make("google-vertex-anthropic")) return
+        const project =
+          evt.provider.options.aisdk.provider.project ??
+          process.env.GOOGLE_CLOUD_PROJECT ??
+          process.env.GCP_PROJECT ??
+          process.env.GCLOUD_PROJECT
+        const location =
+          evt.provider.options.aisdk.provider.location ??
+          process.env.GOOGLE_CLOUD_LOCATION ??
+          process.env.VERTEX_LOCATION ??
+          "global"
+        if (project) evt.provider.options.aisdk.provider.project = project
+        evt.provider.options.aisdk.provider.location = location
       }),
       "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/google-vertex/anthropic") return

packages/core/src/plugin/provider/kilo.ts

@@ -1,20 +1,15 @@
 import { Effect } from "effect"
 import { PluginV2 } from "../../plugin"
+import { ProviderV2 } from "../../provider"
 
 export const KiloPlugin = PluginV2.define({
   id: PluginV2.ID.make("kilo"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/openai-compatible") continue
-          if (item.provider.endpoint.url !== "https://api.kilo.ai/api/gateway") continue
-          evt.provider.update(item.provider.id, (provider) => {
-            provider.options.headers["HTTP-Referer"] = "https://opencode.ai/"
-            provider.options.headers["X-Title"] = "opencode"
-          })
-        }
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.make("kilo")) return
+        evt.provider.options.headers["HTTP-Referer"] = "https://opencode.ai/"
+        evt.provider.options.headers["X-Title"] = "opencode"
       }),
     }
   }),

packages/core/src/plugin/provider/llmgateway.ts

@@ -1,22 +1,17 @@
 import { Effect } from "effect"
 import { PluginV2 } from "../../plugin"
+import { ProviderV2 } from "../../provider"
 
 export const LLMGatewayPlugin = PluginV2.define({
   id: PluginV2.ID.make("llmgateway"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.enabled === false) continue
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/openai-compatible") continue
-          if (item.provider.endpoint.url !== "https://api.llmgateway.io/v1") continue
-          evt.provider.update(item.provider.id, (provider) => {
-            provider.options.headers["HTTP-Referer"] = "https://opencode.ai/"
-            provider.options.headers["X-Title"] = "opencode"
-            provider.options.headers["X-Source"] = "opencode"
-          })
-        }
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.make("llmgateway")) return
+        if (evt.provider.enabled === false) return
+        evt.provider.options.headers["HTTP-Referer"] = "https://opencode.ai/"
+        evt.provider.options.headers["X-Title"] = "opencode"
+        evt.provider.options.headers["X-Source"] = "opencode"
       }),
     }
   }),

packages/core/src/plugin/provider/nvidia.ts

@@ -1,21 +1,16 @@
 import { Effect } from "effect"
 import { PluginV2 } from "../../plugin"
+import { ProviderV2 } from "../../provider"
 
 export const NvidiaPlugin = PluginV2.define({
   id: PluginV2.ID.make("nvidia"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/openai-compatible") continue
-          if (item.provider.endpoint.url !== "https://integrate.api.nvidia.com/v1") continue
-          evt.provider.update(item.provider.id, (provider) => {
-            provider.options.headers["HTTP-Referer"] = "https://opencode.ai/"
-            provider.options.headers["X-Title"] = "opencode"
-            provider.options.headers["X-BILLING-INVOKE-ORIGIN"] ??= "OpenCode"
-          })
-        }
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.make("nvidia")) return
+        evt.provider.options.headers["HTTP-Referer"] = "https://opencode.ai/"
+        evt.provider.options.headers["X-Title"] = "opencode"
+        evt.provider.options.headers["X-BILLING-INVOKE-ORIGIN"] ??= "OpenCode"
       }),
     }
   }),

packages/core/src/plugin/provider/openai.ts

@@ -16,17 +16,11 @@ export const OpenAIPlugin = PluginV2.define({
         if (evt.model.providerID !== ProviderV2.ID.openai) return
         evt.language = evt.sdk.responses(evt.model.apiID)
       }),
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/openai") continue
-          if (!item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) continue
-          evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
-            // OpenAIPlugin sends OpenAI models through Responses; this alias is a
-            // chat-completions-only model, so hide it only from OpenAI's catalog.
-            model.enabled = false
-          })
-        }
+      "model.update": Effect.fn(function* (evt) {
+        if (evt.model.providerID !== ProviderV2.ID.openai) return
+        // OpenAIPlugin sends OpenAI models through Responses; this alias is a
+        // chat-completions-only model, so remove it only from OpenAI's catalog.
+        if (evt.model.id === ModelV2.ID.make("gpt-5-chat-latest")) evt.cancel = true
       }),
     }
   }),

packages/core/src/plugin/provider/opencode.ts

@@ -7,25 +7,20 @@ export const OpencodePlugin = PluginV2.define({
   effect: Effect.gen(function* () {
     let hasKey = false
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        const item = evt.data.find((record) => record.provider.id === ProviderV2.ID.opencode)
-        if (!item) return
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.opencode) return
         hasKey = Boolean(
           process.env.OPENCODE_API_KEY ||
-            item.provider.env.some((env) => process.env[env]) ||
-            item.provider.options.aisdk.provider.apiKey ||
-            (item.provider.enabled && item.provider.enabled.via === "account"),
+            evt.provider.env.some((item) => process.env[item]) ||
+            evt.provider.options.aisdk.provider.apiKey ||
+            (evt.provider.enabled && evt.provider.enabled.via === "auth"),
         )
-        evt.provider.update(item.provider.id, (provider) => {
-          if (!hasKey) provider.options.aisdk.provider.apiKey = "public"
-        })
+        if (!hasKey) evt.provider.options.aisdk.provider.apiKey = "public"
+      }),
+      "model.update": Effect.fn(function* (evt) {
+        if (evt.model.providerID !== ProviderV2.ID.opencode) return
         if (hasKey) return
-        for (const model of item.models.values()) {
-          if (!model.cost.some((cost) => cost.input > 0)) continue
-          evt.model.update(item.provider.id, model.id, (draft) => {
-            draft.enabled = false
-          })
-        }
+        if (evt.model.cost.some((item) => item.input > 0)) evt.cancel = true
       }),
     }
   }),

packages/core/src/plugin/provider/openrouter.ts

@@ -1,34 +1,29 @@
 import { Effect } from "effect"
 import { ModelV2 } from "../../model"
 import { PluginV2 } from "../../plugin"
+import { ProviderV2 } from "../../provider"
 
 export const OpenRouterPlugin = PluginV2.define({
   id: PluginV2.ID.make("openrouter"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@openrouter/ai-sdk-provider") continue
-          evt.provider.update(item.provider.id, (provider) => {
-            provider.options.headers["HTTP-Referer"] = "https://opencode.ai/"
-            provider.options.headers["X-Title"] = "opencode"
-          })
-          for (const modelID of [ModelV2.ID.make("gpt-5-chat-latest"), ModelV2.ID.make("openai/gpt-5-chat")]) {
-            if (!item.models.has(modelID)) continue
-            evt.model.update(item.provider.id, modelID, (model) => {
-              // These are OpenRouter-specific OpenAI chat aliases that do not work
-              // on the generic path. Keep custom providers with matching IDs untouched.
-              model.enabled = false
-            })
-          }
-        }
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.openrouter) return
+        evt.provider.options.headers["HTTP-Referer"] = "https://opencode.ai/"
+        evt.provider.options.headers["X-Title"] = "opencode"
       }),
       "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@openrouter/ai-sdk-provider") return
         const mod = yield* Effect.promise(() => import("@openrouter/ai-sdk-provider"))
         evt.sdk = mod.createOpenRouter(evt.options)
       }),
+      "model.update": Effect.fn(function* (evt) {
+        if (evt.model.providerID !== ProviderV2.ID.openrouter) return
+        // These are OpenRouter-specific OpenAI chat aliases that do not work on
+        // the generic path. Keep custom providers with matching IDs untouched.
+        if (evt.model.id === ModelV2.ID.make("gpt-5-chat-latest")) evt.cancel = true
+        if (evt.model.id === ModelV2.ID.make("openai/gpt-5-chat")) evt.cancel = true
+      }),
     }
   }),
 })

packages/core/src/plugin/provider/vercel.ts

@@ -6,15 +6,10 @@ export const VercelPlugin = PluginV2.define({
   id: PluginV2.ID.make("vercel"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/vercel") continue
-          evt.provider.update(item.provider.id, (provider) => {
-            provider.options.headers["http-referer"] = "https://opencode.ai/"
-            provider.options.headers["x-title"] = "opencode"
-          })
-        }
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.make("vercel")) return
+        evt.provider.options.headers["http-referer"] = "https://opencode.ai/"
+        evt.provider.options.headers["x-title"] = "opencode"
       }),
       "aisdk.sdk": Effect.fn(function* (evt) {
         if (evt.package !== "@ai-sdk/vercel") return

packages/core/src/plugin/provider/zenmux.ts

@@ -1,20 +1,15 @@
 import { Effect } from "effect"
 import { PluginV2 } from "../../plugin"
+import { ProviderV2 } from "../../provider"
 
 export const ZenmuxPlugin = PluginV2.define({
   id: PluginV2.ID.make("zenmux"),
   effect: Effect.gen(function* () {
     return {
-      "catalog.transform": Effect.fn(function* (evt) {
-        for (const item of evt.data) {
-          if (item.provider.endpoint.type !== "aisdk") continue
-          if (item.provider.endpoint.package !== "@ai-sdk/openai-compatible") continue
-          if (item.provider.endpoint.url !== "https://zenmux.ai/api/v1") continue
-          evt.provider.update(item.provider.id, (provider) => {
-            provider.options.headers["HTTP-Referer"] ??= "https://opencode.ai/"
-            provider.options.headers["X-Title"] ??= "opencode"
-          })
-        }
+      "provider.update": Effect.fn(function* (evt) {
+        if (evt.provider.id !== ProviderV2.ID.make("zenmux")) return
+        evt.provider.options.headers["HTTP-Referer"] ??= "https://opencode.ai/"
+        evt.provider.options.headers["X-Title"] ??= "opencode"
       }),
     }
   }),

packages/core/src/provider.ts

@@ -86,7 +86,7 @@ export class Info extends Schema.Class<Info>("ProviderV2.Info")({
       name: Schema.String,
     }),
     Schema.Struct({
-      via: Schema.Literal("account"),
+      via: Schema.Literal("auth"),
       service: Schema.String,
     }),
     Schema.Struct({

packages/core/src/util/wildcard.ts

@@ -1,14 +0,0 @@
-export * as Wildcard from "./wildcard"
-
-export function match(input: string, pattern: string) {
-  const normalized = input.replaceAll("\\", "/")
-  let escaped = pattern
-    .replaceAll("\\", "/")
-    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
-    .replace(/\*/g, ".*")
-    .replace(/\?/g, ".")
-
-  if (escaped.endsWith(" .*")) escaped = escaped.slice(0, -3) + "( .*)?"
-
-  return new RegExp("^" + escaped + "$", process.platform === "win32" ? "si" : "s").test(normalized)
-}

packages/core/test/account.test.ts

@@ -1,284 +0,0 @@
-import path from "path"
-import { describe, expect } from "bun:test"
-import { produce } from "immer"
-import { Effect, Fiber, Layer, Option, Stream } from "effect"
-import { AccountV2 } from "@opencode-ai/core/account"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { EventV2 } from "@opencode-ai/core/event"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { Global } from "@opencode-ai/core/global"
-import { PluginV2 } from "@opencode-ai/core/plugin"
-import { AccountPlugin } from "@opencode-ai/core/plugin/account"
-import { ModelV2 } from "@opencode-ai/core/model"
-import { ProviderV2 } from "@opencode-ai/core/provider"
-import { tmpdir } from "./fixture/tmpdir"
-import { testEffect } from "./lib/effect"
-
-const it = testEffect(PluginV2.defaultLayer)
-
-function context(
-  records: { provider: ProviderV2.Info; models: Map<ModelV2.ID, ModelV2.Info> }[],
-  updates: Array<{ id: ProviderV2.ID; enabled: ProviderV2.Info["enabled"]; apiKey?: string }>,
-): Catalog.Context {
-  return {
-    data: records,
-    updateProvider: (providerID, fn) => context(records, updates).provider.update(providerID, fn),
-    updateModel: (providerID, modelID, fn) => context(records, updates).model.update(providerID, modelID, fn),
-    provider: {
-      update: (providerID, fn) => {
-        const record = records.find((item) => item.provider.id === providerID)
-        const provider = produce(record?.provider ?? ProviderV2.Info.empty(providerID), fn)
-        if (record) record.provider = provider
-        else records.push({ provider, models: new Map<ModelV2.ID, ModelV2.Info>() })
-        updates.push({
-          id: providerID,
-          enabled: provider.enabled,
-          apiKey:
-            typeof provider.options.aisdk.provider.apiKey === "string"
-              ? provider.options.aisdk.provider.apiKey
-              : undefined,
-        })
-      },
-      remove: (providerID) => {
-        const index = records.findIndex((item) => item.provider.id === providerID)
-        if (index !== -1) records.splice(index, 1)
-      },
-    },
-    model: {
-      update: () => {},
-      remove: () => {},
-    },
-  }
-}
-
-function testLayer(dir: string) {
-  return AccountV2.layer.pipe(
-    Layer.provide(AppFileSystem.defaultLayer),
-    Layer.provideMerge(EventV2.defaultLayer),
-    Layer.provide(
-      Global.layerWith({
-        data: dir,
-        cache: path.join(dir, "cache"),
-        config: path.join(dir, "config"),
-        state: path.join(dir, "state"),
-        tmp: path.join(dir, "tmp"),
-        bin: path.join(dir, "bin"),
-        log: path.join(dir, "log"),
-        repos: path.join(dir, "repos"),
-      }),
-    ),
-  )
-}
-
-describe("AccountV2", () => {
-  it.live("emits account lifecycle events", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const accounts = yield* AccountV2.Service
-          const eventSvc = yield* EventV2.Service
-          const addedFiber = yield* eventSvc
-            .subscribe(AccountV2.Event.Added)
-            .pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped)
-          const switchedFiber = yield* eventSvc
-            .subscribe(AccountV2.Event.Switched)
-            .pipe(Stream.take(3), Stream.runCollect, Effect.forkScoped)
-          const removedFiber = yield* eventSvc
-            .subscribe(AccountV2.Event.Removed)
-            .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
-
-          yield* Effect.yieldNow
-
-          const first = yield* accounts.create({
-            serviceID: AccountV2.ServiceID.make("provider"),
-            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "raw-key" }),
-          })
-          expect(first).toBeDefined()
-          if (!first) return
-          expect(first.description).toBe("default")
-          expect(first.credential.type).toBe("api")
-          if (first.credential.type === "api") expect(first.credential.key).toBe("raw-key")
-
-          yield* accounts.update(first.id, { description: "keep" })
-          const updated = yield* accounts.get(first.id)
-          expect(updated?.description).toBe("keep")
-          expect(updated?.credential.type).toBe("api")
-          if (updated?.credential.type === "api") expect(updated.credential.key).toBe("raw-key")
-
-          const second = yield* accounts.create({
-            serviceID: AccountV2.ServiceID.make("provider"),
-            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "second-key" }),
-          })
-          expect(second).toBeDefined()
-          if (!second) return
-
-          yield* accounts.remove(second.id)
-          const added = Array.from(yield* Fiber.join(addedFiber))
-          const switched = Array.from(yield* Fiber.join(switchedFiber))
-          const removed = Array.from(yield* Fiber.join(removedFiber))
-          expect(added.map((event) => event.data.account.id)).toEqual([first.id, second.id])
-          expect(switched.map((event) => event.data)).toEqual([
-            { serviceID: AccountV2.ServiceID.make("provider"), from: undefined, to: first.id },
-            { serviceID: AccountV2.ServiceID.make("provider"), from: first.id, to: second.id },
-            { serviceID: AccountV2.ServiceID.make("provider"), from: second.id, to: first.id },
-          ])
-          expect(removed[0]?.data.account.id).toBe(second.id)
-        }).pipe(Effect.provide(testLayer(tmp.path))),
-      ),
-    ),
-  )
-
-  it.live("always switches to newly created accounts", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const accounts = yield* AccountV2.Service
-          const eventSvc = yield* EventV2.Service
-          const switchedFiber = yield* eventSvc
-            .subscribe(AccountV2.Event.Switched)
-            .pipe(Stream.take(3), Stream.runCollect, Effect.forkScoped)
-
-          yield* Effect.yieldNow
-
-          const first = yield* accounts.create({
-            serviceID: AccountV2.ServiceID.make("provider"),
-            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "first-key" }),
-          })
-          const second = yield* accounts.create({
-            serviceID: AccountV2.ServiceID.make("provider"),
-            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "second-key" }),
-          })
-          const third = yield* accounts.create({
-            serviceID: AccountV2.ServiceID.make("provider"),
-            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "third-key" }),
-          })
-
-          expect(first).toBeDefined()
-          expect(second).toBeDefined()
-          expect(third).toBeDefined()
-          if (!first || !second || !third) return
-
-          expect((yield* accounts.active(AccountV2.ServiceID.make("provider")))?.id).toBe(third.id)
-          expect(Array.from(yield* Fiber.join(switchedFiber)).map((event) => event.data)).toEqual([
-            { serviceID: AccountV2.ServiceID.make("provider"), from: undefined, to: first.id },
-            { serviceID: AccountV2.ServiceID.make("provider"), from: first.id, to: second.id },
-            { serviceID: AccountV2.ServiceID.make("provider"), from: second.id, to: third.id },
-          ])
-        }).pipe(Effect.provide(testLayer(tmp.path))),
-      ),
-    ),
-  )
-
-  it.live("account plugin refreshes providers on account lifecycle events", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const accounts = yield* AccountV2.Service
-          const plugin = yield* PluginV2.Service
-          const records = [
-            {
-              provider: ProviderV2.Info.empty(ProviderV2.ID.make("provider")),
-              models: new Map<ModelV2.ID, ModelV2.Info>(),
-            },
-          ]
-          const updates: Array<{ id: ProviderV2.ID; enabled: ProviderV2.Info["enabled"]; apiKey?: string }> = []
-          const catalog = Catalog.Service.of({
-            loader: () => Effect.die("unexpected catalog.loader"),
-            provider: {
-              get: () => Effect.die("unexpected provider.get"),
-              all: () => Effect.succeed([]),
-              available: () => Effect.succeed([]),
-            },
-            model: {
-              get: () => Effect.die("unexpected model.get"),
-              all: () => Effect.succeed([]),
-              available: () => Effect.succeed([]),
-              default: () => Effect.succeed(Option.none<ModelV2.Info>()),
-              setDefault: () => Effect.die("unexpected model.setDefault"),
-              small: () => Effect.succeed(Option.none<ModelV2.Info>()),
-            },
-          })
-
-          const eventSvc = yield* EventV2.Service
-          yield* plugin.add({
-            ...AccountPlugin,
-            effect: AccountPlugin.effect.pipe(
-              Effect.provideService(AccountV2.Service, accounts),
-              Effect.provideService(Catalog.Service, catalog),
-              Effect.provideService(EventV2.Service, eventSvc),
-              Effect.provideService(PluginV2.Service, plugin),
-            ),
-          })
-          yield* Effect.yieldNow
-
-          const first = yield* accounts.create({
-            serviceID: AccountV2.ServiceID.make("provider"),
-            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "first-key" }),
-          })
-          expect(first).toBeDefined()
-          if (!first) return
-          yield* plugin.trigger("catalog.transform", context(records, updates), {})
-          expect(updates).toEqual([
-            {
-              id: ProviderV2.ID.make("provider"),
-              enabled: { via: "account", service: AccountV2.ServiceID.make("provider") },
-              apiKey: "first-key",
-            },
-          ])
-
-          updates.length = 0
-          const second = yield* accounts.create({
-            serviceID: AccountV2.ServiceID.make("provider"),
-            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "second-key" }),
-          })
-          expect(second).toBeDefined()
-          if (!second) return
-          yield* plugin.trigger("catalog.transform", context(records, updates), {})
-          expect(updates).toEqual([
-            {
-              id: ProviderV2.ID.make("provider"),
-              enabled: { via: "account", service: AccountV2.ServiceID.make("provider") },
-              apiKey: "second-key",
-            },
-          ])
-
-          updates.length = 0
-          yield* accounts.activate(first.id)
-          yield* plugin.trigger("catalog.transform", context(records, updates), {})
-          expect(updates).toEqual([
-            {
-              id: ProviderV2.ID.make("provider"),
-              enabled: { via: "account", service: AccountV2.ServiceID.make("provider") },
-              apiKey: "first-key",
-            },
-          ])
-
-          updates.length = 0
-          yield* accounts.remove(first.id)
-          yield* plugin.trigger("catalog.transform", context(records, updates), {})
-          expect(updates).toEqual([
-            {
-              id: ProviderV2.ID.make("provider"),
-              enabled: { via: "account", service: AccountV2.ServiceID.make("provider") },
-              apiKey: "second-key",
-            },
-          ])
-
-          updates.length = 0
-          yield* accounts.remove(second.id)
-          yield* plugin.trigger("catalog.transform", context(records, updates), {})
-          expect(updates).toEqual([])
-        }).pipe(Effect.provide(testLayer(tmp.path))),
-      ),
-    ),
-  )
-})

packages/core/test/catalog.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect } from "bun:test"
-import { DateTime, Effect, Layer, Option } from "effect"
+import { DateTime, Effect, Fiber, Layer, Option, Stream } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Location } from "@opencode-ai/core/location"
@@ -22,24 +22,24 @@ describe("CatalogV2", () => {
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
-      const load = yield* catalog.loader()
 
-      yield* load((catalog) =>
-        catalog.provider.update(providerID, (provider) => {
-          provider.endpoint = {
-            type: "aisdk",
-            package: "@ai-sdk/openai-compatible",
-            url: "https://default.example.com",
-          }
-          provider.options.aisdk.provider.baseURL = "https://override.example.com"
-        }),
-      )
+      yield* catalog.provider.update(providerID, (provider) => {
+        provider.endpoint = {
+          type: "aisdk",
+          package: "@ai-sdk/openai-compatible",
+          url: "https://default.example.com",
+        }
+        provider.options.aisdk.provider.baseURL = "https://override.example.com"
+      })
 
-      expect((yield* catalog.provider.get(providerID)).endpoint).toEqual({
+      const provider = yield* catalog.provider.get(providerID)
+
+      expect(provider.endpoint).toEqual({
         type: "aisdk",
         package: "@ai-sdk/openai-compatible",
         url: "https://override.example.com",
       })
+      expect(provider.options.aisdk.provider.baseURL).toBeUndefined()
     }),
   )
 
@@ -48,27 +48,56 @@ describe("CatalogV2", () => {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
       const modelID = ModelV2.ID.make("model")
-      const load = yield* catalog.loader()
 
-      yield* load((catalog) => {
-        catalog.provider.update(providerID, (provider) => {
-          provider.endpoint = {
-            type: "aisdk",
-            package: "@ai-sdk/openai-compatible",
-            url: "https://provider.example.com",
-          }
-        })
-        catalog.model.update(providerID, modelID, (model) => {
-          model.endpoint = { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://model.example.com" }
-          model.options.aisdk.provider.baseURL = "https://override.example.com"
-        })
+      yield* catalog.provider.update(providerID, (provider) => {
+        provider.endpoint = {
+          type: "aisdk",
+          package: "@ai-sdk/openai-compatible",
+          url: "https://provider.example.com",
+        }
+      })
+      yield* catalog.model.update(providerID, modelID, (model) => {
+        model.endpoint = {
+          type: "aisdk",
+          package: "@ai-sdk/openai-compatible",
+          url: "https://model.example.com",
+        }
+        model.options.aisdk.provider.baseURL = "https://override.example.com"
       })
 
-      expect((yield* catalog.model.get(providerID, modelID)).endpoint).toEqual({
+      const model = yield* catalog.model.get(providerID, modelID)
+
+      expect(model.endpoint).toEqual({
         type: "aisdk",
         package: "@ai-sdk/openai-compatible",
         url: "https://override.example.com",
       })
+      expect(model.options.aisdk.provider.baseURL).toBeUndefined()
+    }),
+  )
+
+  it.effect("publishes model updated events", () =>
+    Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      const events = yield* EventV2.Service
+      const providerID = ProviderV2.ID.make("test")
+      const modelID = ModelV2.ID.make("model")
+      const fiber = yield* events
+        .subscribe(Catalog.Event.ModelUpdated)
+        .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
+
+      yield* Effect.yieldNow
+      yield* catalog.provider.update(providerID, () => {})
+      yield* catalog.model.update(providerID, modelID, (model) => {
+        model.name = "Updated Model"
+      })
+      const event = Array.from(yield* Fiber.join(fiber))[0]
+
+      expect(event?.type).toBe("catalog.model.updated")
+      expect(event?.data.model.providerID).toBe(providerID)
+      expect(event?.data.model.id).toBe(modelID)
+      expect(event?.data.model.name).toBe("Updated Model")
+      expect(event?.location).toEqual({ directory: "test" })
     }),
   )
 
@@ -77,20 +106,19 @@ describe("CatalogV2", () => {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
       const modelID = ModelV2.ID.make("model")
-      const load = yield* catalog.loader()
 
-      yield* load((catalog) => {
-        catalog.provider.update(providerID, (provider) => {
-          provider.endpoint = {
-            type: "aisdk",
-            package: "@ai-sdk/openai-compatible",
-            url: "https://provider.example.com",
-          }
-        })
-        catalog.model.update(providerID, modelID, () => {})
+      yield* catalog.provider.update(providerID, (provider) => {
+        provider.endpoint = {
+          type: "aisdk",
+          package: "@ai-sdk/openai-compatible",
+          url: "https://provider.example.com",
+        }
       })
+      yield* catalog.model.update(providerID, modelID, () => {})
 
-      expect((yield* catalog.model.get(providerID, modelID)).endpoint).toEqual({
+      const model = yield* catalog.model.get(providerID, modelID)
+
+      expect(model.endpoint).toEqual({
         type: "aisdk",
         package: "@ai-sdk/openai-compatible",
         url: "https://provider.example.com",
@@ -98,91 +126,58 @@ describe("CatalogV2", () => {
     }),
   )
 
-  it.effect("runs catalog transform hooks after baseURL is normalized", () =>
+  it.effect("runs provider hooks after baseURL is normalized", () =>
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       const plugin = yield* PluginV2.Service
       const providerID = ProviderV2.ID.make("test")
       const seen: unknown[] = []
-      const load = yield* catalog.loader()
 
       yield* plugin.add({
         id: PluginV2.ID.make("test"),
         effect: Effect.succeed({
-          "catalog.transform": (evt) =>
+          "provider.update": (evt) =>
             Effect.sync(() => {
-              const item = evt.data.find((record) => record.provider.id === providerID)
-              if (!item) return
-              seen.push(item.provider.endpoint.type)
-              if (item?.provider.endpoint.type === "aisdk") seen.push(item.provider.endpoint.url)
-              seen.push(item?.provider.options.aisdk.provider.baseURL)
+              seen.push(evt.provider.endpoint.type)
+              if (evt.provider.endpoint.type === "aisdk") seen.push(evt.provider.endpoint.url)
+              seen.push(evt.provider.options.aisdk.provider.baseURL)
             }),
         }),
       })
-      yield* load((catalog) =>
-        catalog.provider.update(providerID, (provider) => {
-          provider.endpoint = { type: "aisdk", package: "@ai-sdk/openai-compatible" }
-          provider.options.aisdk.provider.baseURL = "https://provider.example.com"
-        }),
-      )
+      yield* catalog.provider.update(providerID, (provider) => {
+        provider.endpoint = {
+          type: "aisdk",
+          package: "@ai-sdk/openai-compatible",
+        }
+        provider.options.aisdk.provider.baseURL = "https://provider.example.com"
+      })
 
       expect(seen).toEqual(["aisdk", "https://provider.example.com", undefined])
     }),
   )
 
-  it.effect("runs catalog transform when a plugin is added", () =>
-    Effect.gen(function* () {
-      const catalog = yield* Catalog.Service
-      const plugin = yield* PluginV2.Service
-      const providerID = ProviderV2.ID.make("test")
-      const load = yield* catalog.loader()
-
-      yield* load((catalog) =>
-        catalog.provider.update(providerID, (provider) => {
-          provider.name = "Before"
-        }),
-      )
-      yield* plugin.add({
-        id: PluginV2.ID.make("test-transform"),
-        effect: Effect.succeed({
-          "catalog.transform": (evt) =>
-            Effect.sync(() =>
-              evt.provider.update(providerID, (provider) => {
-                provider.name = "After"
-              }),
-            ),
-        }),
-      })
-      yield* Effect.yieldNow
-
-      expect((yield* catalog.provider.get(providerID)).name).toBe("After")
-    }),
-  )
-
   it.effect("resolves provider and model option merges", () =>
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
       const modelID = ModelV2.ID.make("model")
-      const load = yield* catalog.loader()
 
-      yield* load((catalog) => {
-        catalog.provider.update(providerID, (provider) => {
-          provider.options.headers.provider = "provider"
-          provider.options.headers.shared = "provider"
-          provider.options.body.provider = true
-          provider.options.aisdk.provider.provider = true
-        })
-        catalog.model.update(providerID, modelID, (model) => {
-          model.options.headers.model = "model"
-          model.options.headers.shared = "model"
-          model.options.body.model = true
-          model.options.aisdk.provider.model = true
-          model.options.aisdk.request.request = true
-        })
+      yield* catalog.provider.update(providerID, (provider) => {
+        provider.options.headers.provider = "provider"
+        provider.options.headers.shared = "provider"
+        provider.options.body.provider = true
+        provider.options.aisdk.provider.provider = true
+      })
+      yield* catalog.model.update(providerID, modelID, (model) => {
+        model.options.headers.model = "model"
+        model.options.headers.shared = "model"
+        model.options.body.model = true
+        model.options.aisdk.provider.model = true
+        model.options.aisdk.request.request = true
       })
 
       const model = yield* catalog.model.get(providerID, modelID)
+
       expect(model.options.headers).toEqual({ provider: "provider", shared: "model", model: "model" })
       expect(model.options.body).toEqual({ provider: true, model: true })
       expect(model.options.aisdk.provider).toEqual({ provider: true, model: true })
@@ -194,21 +189,20 @@ describe("CatalogV2", () => {
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
-      const load = yield* catalog.loader()
 
-      yield* load((catalog) => {
-        catalog.provider.update(providerID, (provider) => {
-          provider.enabled = { via: "custom", data: {} }
-        })
-        catalog.model.update(providerID, ModelV2.ID.make("old"), (model) => {
-          model.time.released = DateTime.makeUnsafe(1000)
-        })
-        catalog.model.update(providerID, ModelV2.ID.make("new"), (model) => {
-          model.time.released = DateTime.makeUnsafe(2000)
-        })
+      yield* catalog.provider.update(providerID, (provider) => {
+        provider.enabled = { via: "custom", data: {} }
+      })
+      yield* catalog.model.update(providerID, ModelV2.ID.make("old"), (model) => {
+        model.time.released = DateTime.makeUnsafe(1000)
+      })
+      yield* catalog.model.update(providerID, ModelV2.ID.make("new"), (model) => {
+        model.time.released = DateTime.makeUnsafe(2000)
       })
 
-      expect(Option.getOrUndefined(yield* catalog.model.default())?.id).toMatch("new")
+      const model = yield* catalog.model.default()
+
+      expect(Option.getOrUndefined(model)?.id).toMatch("new")
     }),
   )
 
@@ -216,25 +210,24 @@ describe("CatalogV2", () => {
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.make("test")
-      const load = yield* catalog.loader()
 
-      yield* load((catalog) => {
-        catalog.provider.update(providerID, () => {})
-        catalog.model.update(providerID, ModelV2.ID.make("cheap-large"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [{ input: 1, output: 1, cache: { read: 0, write: 0 } }]
-          model.time.released = DateTime.makeUnsafe(Date.now())
-        })
-        catalog.model.update(providerID, ModelV2.ID.make("expensive-mini"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [{ input: 10, output: 10, cache: { read: 0, write: 0 } }]
-          model.time.released = DateTime.makeUnsafe(Date.now())
-        })
+      yield* catalog.provider.update(providerID, () => {})
+      yield* catalog.model.update(providerID, ModelV2.ID.make("cheap-large"), (model) => {
+        model.capabilities.input = ["text"]
+        model.capabilities.output = ["text"]
+        model.cost = [{ input: 1, output: 1, cache: { read: 0, write: 0 } }]
+        model.time.released = DateTime.makeUnsafe(Date.now())
+      })
+      yield* catalog.model.update(providerID, ModelV2.ID.make("expensive-mini"), (model) => {
+        model.capabilities.input = ["text"]
+        model.capabilities.output = ["text"]
+        model.cost = [{ input: 10, output: 10, cache: { read: 0, write: 0 } }]
+        model.time.released = DateTime.makeUnsafe(Date.now())
       })
 
-      expect(Option.getOrUndefined(yield* catalog.model.small(providerID))?.id).toMatch("expensive-mini")
+      const model = yield* catalog.model.small(providerID)
+
+      expect(Option.getOrUndefined(model)?.id).toMatch("expensive-mini")
     }),
   )
 })

packages/core/test/models.test.ts

@@ -5,7 +5,6 @@ import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { Global } from "@opencode-ai/core/global"
 import { ModelsDev } from "@opencode-ai/core/models-dev"
-import { EventV2 } from "@opencode-ai/core/event"
 import { it } from "./lib/effect"
 import { rm, writeFile, utimes, mkdir } from "fs/promises"
 import path from "path"
@@ -93,7 +92,6 @@ const buildLayer = (state: Ref.Ref<MockState>) =>
   Layer.fresh(ModelsDev.layer).pipe(
     Layer.provide(Layer.succeed(HttpClient.HttpClient, makeMockClient(state))),
     Layer.provide(AppFileSystem.defaultLayer),
-    Layer.provide(EventV2.defaultLayer),
   )
 
 const writeCache = (data: object, mtimeMs?: number) =>

packages/core/test/plugin/provider-amazon-bedrock.test.ts

@@ -1,9 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { AmazonBedrockPlugin } from "@opencode-ai/core/plugin/provider/amazon-bedrock"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { fakeSelectorSdk, it, model, provider, withEnv } from "./provider-helper"
 
 function bedrockBaseURL(sdk: unknown, modelID = "anthropic.claude-sonnet-4-5") {
@@ -22,30 +20,27 @@ describe("AmazonBedrockPlugin", () => {
   it.effect("moves endpoint option to endpoint URL", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(AmazonBedrockPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const bedrock = provider("amazon-bedrock", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/amazon-bedrock" },
-          options: {
-            headers: {},
-            body: {},
-            aisdk: { provider: { endpoint: "https://bedrock.example" }, request: {} },
-          },
-        })
-        catalog.provider.update(bedrock.id, (item) => {
-          item.endpoint = bedrock.endpoint
-          item.options = bedrock.options
-        })
-      })
-      const result = yield* catalog.provider.get(ProviderV2.ID.amazonBedrock)
-      expect(result.endpoint).toEqual({
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("amazon-bedrock", {
+            options: {
+              headers: {},
+              body: {},
+              aisdk: { provider: { endpoint: "https://bedrock.example" }, request: {} },
+            },
+          }),
+          cancel: false,
+        },
+      )
+      expect(result.provider.endpoint).toEqual({
         type: "aisdk",
-        package: "@ai-sdk/amazon-bedrock",
+        package: "test-provider",
         url: "https://bedrock.example",
       })
-      expect(result.options.aisdk.provider.endpoint).toBeUndefined()
+      expect(result.provider.options.aisdk.provider.endpoint).toBeUndefined()
     }),
   )
 

packages/core/test/plugin/provider-anthropic.test.ts

@@ -1,43 +1,37 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { AnthropicPlugin } from "@opencode-ai/core/plugin/provider/anthropic"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { it, model, provider } from "./provider-helper"
 
 describe("AnthropicPlugin", () => {
   it.effect("applies legacy beta headers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(AnthropicPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("anthropic", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/anthropic" },
-          options: { headers: { Existing: "1" }, body: {}, aisdk: { provider: {}, request: {} } },
-        })
-        catalog.provider.update(item.id, (draft) => {
-          draft.endpoint = item.endpoint
-          draft.options = item.options
-        })
-      })
-      expect((yield* catalog.provider.get(ProviderV2.ID.anthropic)).options.headers["anthropic-beta"]).toBe(
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("anthropic", {
+            options: { headers: { Existing: "1" }, body: {}, aisdk: { provider: {}, request: {} } },
+          }),
+          cancel: false,
+        },
+      )
+      expect(result.provider.options.headers["anthropic-beta"]).toBe(
         "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14",
       )
-      expect((yield* catalog.provider.get(ProviderV2.ID.anthropic)).options.headers.Existing).toBe("1")
+      expect(result.provider.options.headers.Existing).toBe("1")
     }),
   )
 
   it.effect("ignores non-Anthropic providers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(AnthropicPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => catalog.provider.update(provider("openai").id, () => {}))
-      expect((yield* catalog.provider.get(ProviderV2.ID.openai)).options.headers["anthropic-beta"]).toBeUndefined()
+      const result = yield* plugin.trigger("provider.update", {}, { provider: provider("openai"), cancel: false })
+      expect(result.provider.options.headers["anthropic-beta"]).toBeUndefined()
     }),
   )
 

packages/core/test/plugin/provider-azure-cognitive-services.test.ts

@@ -1,9 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { AzureCognitiveServicesPlugin } from "@opencode-ai/core/plugin/provider/azure"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { fakeSelectorSdk, it, model, provider, withEnv } from "./provider-helper"
 
 describe("AzureCognitiveServicesPlugin", () => {
@@ -11,22 +9,20 @@ describe("AzureCognitiveServicesPlugin", () => {
     withEnv({ AZURE_COGNITIVE_SERVICES_RESOURCE_NAME: "cognitive" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(AzureCognitiveServicesPlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          catalog.provider.update(ProviderV2.ID.make("azure-cognitive-services"), (item) => {
-            item.endpoint = { type: "aisdk", package: "@ai-sdk/openai-compatible" }
-          })
-        })
-        const result = yield* catalog.provider.get(ProviderV2.ID.make("azure-cognitive-services"))
-        expect(result.endpoint).toEqual({
+        const result = yield* plugin.trigger(
+          "provider.update",
+          {},
+          { provider: provider("azure-cognitive-services"), cancel: false },
+        )
+        expect(result.provider.endpoint).toEqual({
           type: "aisdk",
-          package: "@ai-sdk/openai-compatible",
-          url: "https://cognitive.cognitiveservices.azure.com/openai",
+          package: "test-provider",
         })
-        expect(result.options.aisdk.provider.baseURL).toBeUndefined()
-        expect(result.options.aisdk.provider.resourceName).toBeUndefined()
+        expect(result.provider.options.aisdk.provider.baseURL).toBe(
+          "https://cognitive.cognitiveservices.azure.com/openai",
+        )
+        expect(result.provider.options.aisdk.provider.resourceName).toBeUndefined()
       }),
     ),
   )
@@ -35,27 +31,17 @@ describe("AzureCognitiveServicesPlugin", () => {
     withEnv({ AZURE_COGNITIVE_SERVICES_RESOURCE_NAME: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(AzureCognitiveServicesPlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const azure = provider("azure-cognitive-services", {
-            endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible" },
-          })
-          const openai = provider("openai")
-          catalog.provider.update(azure.id, (item) => {
-            item.endpoint = azure.endpoint
-          })
-          catalog.provider.update(openai.id, (item) => {
-            item.endpoint = openai.endpoint
-          })
-        })
-        const azure = yield* catalog.provider.get(ProviderV2.ID.make("azure-cognitive-services"))
-        const openai = yield* catalog.provider.get(ProviderV2.ID.openai)
-        expect(azure.options.aisdk.provider.baseURL).toBeUndefined()
-        expect(azure.endpoint).toEqual({ type: "aisdk", package: "@ai-sdk/openai-compatible" })
-        expect(openai.options.aisdk.provider.baseURL).toBeUndefined()
-        expect(openai.endpoint).toEqual({ type: "aisdk", package: "test-provider" })
+        const azure = yield* plugin.trigger(
+          "provider.update",
+          {},
+          { provider: provider("azure-cognitive-services"), cancel: false },
+        )
+        const other = yield* plugin.trigger("provider.update", {}, { provider: provider("openai"), cancel: false })
+        expect(azure.provider.options.aisdk.provider.baseURL).toBeUndefined()
+        expect(azure.provider.endpoint).toEqual({ type: "aisdk", package: "test-provider" })
+        expect(other.provider.options.aisdk.provider.baseURL).toBeUndefined()
+        expect(other.provider.endpoint).toEqual({ type: "aisdk", package: "test-provider" })
       }),
     ),
   )

packages/core/test/plugin/provider-azure.test.ts

@@ -1,40 +1,22 @@
 import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
-import { AccountV2 } from "@opencode-ai/core/account"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { EventV2 } from "@opencode-ai/core/event"
-import { Location } from "@opencode-ai/core/location"
+import { AuthV2 } from "@opencode-ai/core/auth"
 import { PluginV2 } from "@opencode-ai/core/plugin"
-import { AccountPlugin } from "@opencode-ai/core/plugin/account"
+import { AuthPlugin } from "@opencode-ai/core/plugin/auth"
 import { AzurePlugin } from "@opencode-ai/core/plugin/provider/azure"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { testEffect } from "../lib/effect"
 import { fakeSelectorSdk, it, model, npmLayer, provider, withEnv } from "./provider-helper"
 
-const itWithAccount = testEffect(
-  Catalog.layer.pipe(
-    Layer.provideMerge(PluginV2.defaultLayer),
-    Layer.provideMerge(AccountV2.defaultLayer),
-    Layer.provideMerge(EventV2.defaultLayer),
-    Layer.provideMerge(Layer.succeed(Location.Service, Location.Service.of({ directory: "test" }))),
-    Layer.provideMerge(npmLayer),
-  ),
-)
+const itWithAuth = testEffect(Layer.mergeAll(PluginV2.defaultLayer, AuthV2.defaultLayer, npmLayer))
 
 describe("AzurePlugin", () => {
   it.effect("resolves resourceName from env", () =>
     withEnv({ AZURE_RESOURCE_NAME: "from-env" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(AzurePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          catalog.provider.update(ProviderV2.ID.azure, (item) => {
-            item.endpoint = { type: "aisdk", package: "@ai-sdk/azure" }
-          })
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.azure)).options.aisdk.provider.resourceName).toBe("from-env")
+        const result = yield* plugin.trigger("provider.update", {}, { provider: provider("azure"), cancel: false })
+        expect(result.provider.options.aisdk.provider.resourceName).toBe("from-env")
       }),
     ),
   )
@@ -43,29 +25,25 @@ describe("AzurePlugin", () => {
     withEnv({ AZURE_RESOURCE_NAME: "from-env" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(AzurePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const azure = provider("azure", {
-            endpoint: { type: "aisdk", package: "@ai-sdk/azure" },
-            options: { headers: {}, body: {}, aisdk: { provider: { resourceName: "from-config" }, request: {} } },
-          })
-          catalog.provider.update(azure.id, (item) => {
-            item.endpoint = azure.endpoint
-            item.options = azure.options
-          })
-          catalog.provider.update(ProviderV2.ID.openai, () => {})
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.azure)).options.aisdk.provider.resourceName).toBe(
-          "from-config",
+        const azure = yield* plugin.trigger(
+          "provider.update",
+          {},
+          {
+            provider: provider("azure", {
+              options: { headers: {}, body: {}, aisdk: { provider: { resourceName: "from-config" }, request: {} } },
+            }),
+            cancel: false,
+          },
         )
-        expect((yield* catalog.provider.get(ProviderV2.ID.openai)).options.aisdk.provider.resourceName).toBeUndefined()
+        const other = yield* plugin.trigger("provider.update", {}, { provider: provider("openai"), cancel: false })
+        expect(azure.provider.options.aisdk.provider.resourceName).toBe("from-config")
+        expect(other.provider.options.aisdk.provider.resourceName).toBeUndefined()
       }),
     ),
   )
 
-  itWithAccount.effect("prefers account resourceName over env", () =>
+  itWithAuth.effect("prefers auth resourceName over env", () =>
     withEnv(
       {
         AZURE_RESOURCE_NAME: "from-env",
@@ -73,36 +51,23 @@ describe("AzurePlugin", () => {
       () =>
         Effect.gen(function* () {
           const plugin = yield* PluginV2.Service
-          const accounts = yield* AccountV2.Service
-          const catalog = yield* Catalog.Service
-          const events = yield* EventV2.Service
-          yield* accounts.create({
-            serviceID: AccountV2.ServiceID.make("azure"),
-            credential: new AccountV2.ApiKeyCredential({
+          const auth = yield* AuthV2.Service
+          yield* auth.create({
+            serviceID: AuthV2.ServiceID.make("azure"),
+            credential: new AuthV2.ApiKeyCredential({
               type: "api",
               key: "key",
-              metadata: { resourceName: "from-account" },
+              metadata: { resourceName: "from-auth" },
             }),
+            active: true,
           })
           yield* plugin.add({
-            ...AccountPlugin,
-            effect: AccountPlugin.effect.pipe(
-              Effect.provideService(AccountV2.Service, accounts),
-              Effect.provideService(Catalog.Service, catalog),
-              Effect.provideService(EventV2.Service, events),
-              Effect.provideService(PluginV2.Service, plugin),
-            ),
+            ...AuthPlugin,
+            effect: AuthPlugin.effect.pipe(Effect.provideService(AuthV2.Service, auth)),
           })
           yield* plugin.add(AzurePlugin)
-          const load = yield* catalog.loader()
-          yield* load((catalog) => {
-            catalog.provider.update(ProviderV2.ID.azure, (item) => {
-              item.endpoint = { type: "aisdk", package: "@ai-sdk/azure" }
-            })
-          })
-          expect((yield* catalog.provider.get(ProviderV2.ID.azure)).options.aisdk.provider.resourceName).toBe(
-            "from-account",
-          )
+          const result = yield* plugin.trigger("provider.update", {}, { provider: provider("azure"), cancel: false })
+          expect(result.provider.options.aisdk.provider.resourceName).toBe("from-auth")
         }),
     ),
   )
@@ -111,20 +76,18 @@ describe("AzurePlugin", () => {
     withEnv({ AZURE_RESOURCE_NAME: "from-env" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(AzurePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const azure = provider("azure", {
-            endpoint: { type: "aisdk", package: "@ai-sdk/azure" },
-            options: { headers: {}, body: {}, aisdk: { provider: { resourceName: "" }, request: {} } },
-          })
-          catalog.provider.update(azure.id, (item) => {
-            item.endpoint = azure.endpoint
-            item.options = azure.options
-          })
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.azure)).options.aisdk.provider.resourceName).toBe("from-env")
+        const result = yield* plugin.trigger(
+          "provider.update",
+          {},
+          {
+            provider: provider("azure", {
+              options: { headers: {}, body: {}, aisdk: { provider: { resourceName: "" }, request: {} } },
+            }),
+            cancel: false,
+          },
+        )
+        expect(result.provider.options.aisdk.provider.resourceName).toBe("from-env")
       }),
     ),
   )
@@ -133,20 +96,18 @@ describe("AzurePlugin", () => {
     withEnv({ AZURE_RESOURCE_NAME: "from-env" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(AzurePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const azure = provider("azure", {
-            endpoint: { type: "aisdk", package: "@ai-sdk/azure" },
-            options: { headers: {}, body: {}, aisdk: { provider: { resourceName: "   " }, request: {} } },
-          })
-          catalog.provider.update(azure.id, (item) => {
-            item.endpoint = azure.endpoint
-            item.options = azure.options
-          })
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.azure)).options.aisdk.provider.resourceName).toBe("from-env")
+        const result = yield* plugin.trigger(
+          "provider.update",
+          {},
+          {
+            provider: provider("azure", {
+              options: { headers: {}, body: {}, aisdk: { provider: { resourceName: "   " }, request: {} } },
+            }),
+            cancel: false,
+          },
+        )
+        expect(result.provider.options.aisdk.provider.resourceName).toBe("from-env")
       }),
     ),
   )

packages/core/test/plugin/provider-cerebras.test.ts

@@ -1,9 +1,7 @@
 import { describe, expect, mock } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { CerebrasPlugin } from "@opencode-ai/core/plugin/provider/cerebras"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { it, model, provider } from "./provider-helper"
 
 const cerebrasOptions: Record<string, unknown>[] = []
@@ -22,30 +20,27 @@ describe("CerebrasPlugin", () => {
   it.effect("applies the legacy integration header", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(CerebrasPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        catalog.provider.update(ProviderV2.ID.make("cerebras"), (item) => {
-          item.endpoint = { type: "aisdk", package: "@ai-sdk/cerebras" }
-          item.options.headers.Existing = "1"
-        })
-      })
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("cerebras"))).options.headers).toEqual({
-        Existing: "1",
-        "X-Cerebras-3rd-Party-Integration": "opencode",
-      })
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("cerebras", {
+            options: { headers: { Existing: "1" }, body: {}, aisdk: { provider: {}, request: {} } },
+          }),
+          cancel: false,
+        },
+      )
+      expect(result.provider.options.headers).toEqual({ Existing: "1", "X-Cerebras-3rd-Party-Integration": "opencode" })
     }),
   )
 
   it.effect("ignores non-Cerebras providers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(CerebrasPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => catalog.provider.update(ProviderV2.ID.make("groq"), () => {}))
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("groq"))).options.headers).toEqual({})
+      const result = yield* plugin.trigger("provider.update", {}, { provider: provider("groq"), cancel: false })
+      expect(result.provider.options.headers).toEqual({})
     }),
   )
 

packages/core/test/plugin/provider-cloudflare-workers-ai.test.ts

@@ -1,26 +1,14 @@
 import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
-import { AccountV2 } from "@opencode-ai/core/account"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { Location } from "@opencode-ai/core/location"
-import { EventV2 } from "@opencode-ai/core/event"
+import { AuthV2 } from "@opencode-ai/core/auth"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
-import { AccountPlugin } from "@opencode-ai/core/plugin/account"
+import { AuthPlugin } from "@opencode-ai/core/plugin/auth"
 import { CloudflareWorkersAIPlugin } from "@opencode-ai/core/plugin/provider/cloudflare-workers-ai"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { testEffect } from "../lib/effect"
-import { fakeSelectorSdk, it, model, npmLayer, withEnv } from "./provider-helper"
+import { fakeSelectorSdk, it, model, npmLayer, provider, withEnv } from "./provider-helper"
 
-const itWithAccount = testEffect(
-  Catalog.layer.pipe(
-    Layer.provideMerge(PluginV2.defaultLayer),
-    Layer.provideMerge(AccountV2.defaultLayer),
-    Layer.provideMerge(EventV2.defaultLayer),
-    Layer.provideMerge(Layer.succeed(Location.Service, Location.Service.of({ directory: "test" }))),
-    Layer.provideMerge(npmLayer),
-  ),
-)
+const itWithAuth = testEffect(Layer.mergeAll(PluginV2.defaultLayer, AuthV2.defaultLayer, npmLayer))
 
 function cloudflareLanguage(sdk: unknown, modelID = "@cf/model") {
   return (sdk as { languageModel: (id: string) => { config: CloudflareConfig; provider: string } }).languageModel(
@@ -46,25 +34,22 @@ describe("CloudflareWorkersAIPlugin", () => {
     withEnv({ CLOUDFLARE_ACCOUNT_ID: "acct", CLOUDFLARE_API_KEY: "key" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(CloudflareWorkersAIPlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) =>
-          catalog.provider.update(ProviderV2.ID.make("cloudflare-workers-ai"), (provider) => {
-            provider.endpoint = { type: "aisdk", package: "test-provider" }
-          }),
+        const updated = yield* plugin.trigger(
+          "provider.update",
+          {},
+          { provider: provider("cloudflare-workers-ai"), cancel: false },
         )
-        const provider = yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai"))
         const sdk = yield* plugin.trigger(
           "aisdk.sdk",
           {
-            model: model("cloudflare-workers-ai", "@cf/model", { endpoint: provider.endpoint }),
+            model: model("cloudflare-workers-ai", "@cf/model", { endpoint: updated.provider.endpoint }),
             package: "@ai-sdk/openai-compatible",
             options: { name: "cloudflare-workers-ai", headers: { custom: "header" } },
           },
           {},
         )
-        expect(provider.endpoint).toEqual({
+        expect(updated.provider.endpoint).toEqual({
           type: "aisdk",
           package: "test-provider",
           url: "https://api.cloudflare.com/client/v4/accounts/acct/ai/v1",
@@ -78,15 +63,18 @@ describe("CloudflareWorkersAIPlugin", () => {
     withEnv({ CLOUDFLARE_ACCOUNT_ID: "acct" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(CloudflareWorkersAIPlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) =>
-          catalog.provider.update(ProviderV2.ID.make("cloudflare-workers-ai"), (provider) => {
-            provider.endpoint = { type: "aisdk", package: "test-provider", url: "https://proxy.example/v1" }
-          }),
+        const result = yield* plugin.trigger(
+          "provider.update",
+          {},
+          {
+            provider: provider("cloudflare-workers-ai", {
+              endpoint: { type: "aisdk", package: "test-provider", url: "https://proxy.example/v1" },
+            }),
+            cancel: false,
+          },
         )
-        expect((yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai"))).endpoint).toEqual({
+        expect(result.provider.endpoint).toEqual({
           type: "aisdk",
           package: "test-provider",
           url: "https://proxy.example/v1",
@@ -116,7 +104,7 @@ describe("CloudflareWorkersAIPlugin", () => {
     ),
   )
 
-  itWithAccount.effect("falls back to account metadata when account env is absent", () =>
+  itWithAuth.effect("falls back to auth account metadata when account env is absent", () =>
     withEnv(
       {
         CLOUDFLARE_ACCOUNT_ID: undefined,
@@ -125,37 +113,30 @@ describe("CloudflareWorkersAIPlugin", () => {
       () =>
         Effect.gen(function* () {
           const plugin = yield* PluginV2.Service
-          const accounts = yield* AccountV2.Service
-          const catalog = yield* Catalog.Service
-          const events = yield* EventV2.Service
-          yield* accounts.create({
-            serviceID: AccountV2.ServiceID.make("cloudflare-workers-ai"),
-            credential: new AccountV2.ApiKeyCredential({
+          const auth = yield* AuthV2.Service
+          yield* auth.create({
+            serviceID: AuthV2.ServiceID.make("cloudflare-workers-ai"),
+            credential: new AuthV2.ApiKeyCredential({
               type: "api",
-              key: "account-key",
-              metadata: { accountId: "account-acct" },
+              key: "auth-key",
+              metadata: { accountId: "auth-acct" },
             }),
+            active: true,
           })
           yield* plugin.add({
-            ...AccountPlugin,
-            effect: AccountPlugin.effect.pipe(
-              Effect.provideService(AccountV2.Service, accounts),
-              Effect.provideService(Catalog.Service, catalog),
-              Effect.provideService(EventV2.Service, events),
-              Effect.provideService(PluginV2.Service, plugin),
-            ),
+            ...AuthPlugin,
+            effect: AuthPlugin.effect.pipe(Effect.provideService(AuthV2.Service, auth)),
           })
           yield* plugin.add(CloudflareWorkersAIPlugin)
-          const load = yield* catalog.loader()
-          yield* load((catalog) =>
-            catalog.provider.update(ProviderV2.ID.make("cloudflare-workers-ai"), (provider) => {
-              provider.endpoint = { type: "aisdk", package: "test-provider" }
-            }),
+          const updated = yield* plugin.trigger(
+            "provider.update",
+            {},
+            { provider: provider("cloudflare-workers-ai"), cancel: false },
           )
-          expect((yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai"))).endpoint).toEqual({
+          expect(updated.provider.endpoint).toEqual({
             type: "aisdk",
             package: "test-provider",
-            url: "https://api.cloudflare.com/client/v4/accounts/account-acct/ai/v1",
+            url: "https://api.cloudflare.com/client/v4/accounts/auth-acct/ai/v1",
           })
         }),
     ),
@@ -165,16 +146,18 @@ describe("CloudflareWorkersAIPlugin", () => {
     withEnv({ CLOUDFLARE_ACCOUNT_ID: "env-acct" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(CloudflareWorkersAIPlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) =>
-          catalog.provider.update(ProviderV2.ID.make("cloudflare-workers-ai"), (provider) => {
-            provider.endpoint = { type: "aisdk", package: "test-provider" }
-            provider.options.aisdk.provider.accountId = "configured-acct"
-          }),
+        const result = yield* plugin.trigger(
+          "provider.update",
+          {},
+          {
+            provider: provider("cloudflare-workers-ai", {
+              options: { headers: {}, body: {}, aisdk: { provider: { accountId: "configured-acct" }, request: {} } },
+            }),
+            cancel: false,
+          },
         )
-        expect((yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai"))).endpoint).toEqual({
+        expect(result.provider.endpoint).toEqual({
           type: "aisdk",
           package: "test-provider",
           url: "https://api.cloudflare.com/client/v4/accounts/env-acct/ai/v1",

packages/core/test/plugin/provider-github-copilot.test.ts

@@ -1,10 +1,8 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { GithubCopilotPlugin } from "@opencode-ai/core/plugin/provider/github-copilot"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { fakeSelectorSdk, it, model } from "./provider-helper"
 
 describe("GithubCopilotPlugin", () => {
@@ -147,35 +145,29 @@ describe("GithubCopilotPlugin", () => {
     }),
   )
 
-  it.effect("disables gpt-5-chat-latest before Copilot language selection", () =>
+  it.effect("filters gpt-5-chat-latest before Copilot language selection", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(GithubCopilotPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        catalog.provider.update(ProviderV2.ID.make("github-copilot"), () => {})
-        catalog.model.update(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5-chat-latest"), () => {})
-      })
-      expect(
-        (yield* catalog.model.get(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5-chat-latest"))).enabled,
-      ).toBe(false)
+      const result = yield* plugin.trigger(
+        "model.update",
+        {},
+        { model: model("github-copilot", "gpt-5-chat-latest"), cancel: false },
+      )
+      expect(result.cancel).toBe(true)
     }),
   )
 
-  it.effect("does not disable gpt-5-chat-latest for non-Copilot providers", () =>
+  it.effect("does not filter gpt-5-chat-latest for non-Copilot providers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(GithubCopilotPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        catalog.provider.update(ProviderV2.ID.make("custom-copilot"), () => {})
-        catalog.model.update(ProviderV2.ID.make("custom-copilot"), ModelV2.ID.make("gpt-5-chat-latest"), () => {})
-      })
-      expect(
-        (yield* catalog.model.get(ProviderV2.ID.make("custom-copilot"), ModelV2.ID.make("gpt-5-chat-latest"))).enabled,
-      ).toBe(true)
+      const result = yield* plugin.trigger(
+        "model.update",
+        {},
+        { model: model("custom-copilot", "gpt-5-chat-latest"), cancel: false },
+      )
+      expect(result.cancel).toBe(false)
     }),
   )
 

packages/core/test/plugin/provider-gitlab.test.ts

@@ -1,15 +1,11 @@
 import { describe, expect, mock } from "bun:test"
 import { Effect, Layer } from "effect"
-import { AccountV2 } from "@opencode-ai/core/account"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { EventV2 } from "@opencode-ai/core/event"
-import { Location } from "@opencode-ai/core/location"
+import { AuthV2 } from "@opencode-ai/core/auth"
 import { PluginV2 } from "@opencode-ai/core/plugin"
-import { AccountPlugin } from "@opencode-ai/core/plugin/account"
+import { AuthPlugin } from "@opencode-ai/core/plugin/auth"
 import { GitLabPlugin } from "@opencode-ai/core/plugin/provider/gitlab"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { testEffect } from "../lib/effect"
-import { it, model, npmLayer, withEnv } from "./provider-helper"
+import { it, model, npmLayer, provider, withEnv } from "./provider-helper"
 
 const gitlabSDKOptions: Record<string, unknown>[] = []
 
@@ -26,15 +22,7 @@ void mock.module("gitlab-ai-provider", () => ({
   isWorkflowModel: (id: string) => id === "duo-workflow" || id === "duo-workflow-exact",
 }))
 
-const itWithAccount = testEffect(
-  Catalog.layer.pipe(
-    Layer.provideMerge(PluginV2.defaultLayer),
-    Layer.provideMerge(AccountV2.defaultLayer),
-    Layer.provideMerge(EventV2.defaultLayer),
-    Layer.provideMerge(Layer.succeed(Location.Service, Location.Service.of({ directory: "test" }))),
-    Layer.provideMerge(npmLayer),
-  ),
-)
+const itWithAuth = testEffect(Layer.mergeAll(PluginV2.defaultLayer, AuthV2.defaultLayer, npmLayer))
 
 describe("GitLabPlugin", () => {
   it.effect("creates SDKs with legacy default instance URL, token env, headers, and feature flags", () =>
@@ -153,7 +141,7 @@ describe("GitLabPlugin", () => {
     }),
   )
 
-  itWithAccount.effect("uses active account API token over GITLAB_TOKEN", () =>
+  itWithAuth.effect("uses active API auth token over GITLAB_TOKEN", () =>
     withEnv(
       {
         GITLAB_TOKEN: "env-token",
@@ -162,41 +150,33 @@ describe("GitLabPlugin", () => {
         Effect.gen(function* () {
           gitlabSDKOptions.length = 0
           const plugin = yield* PluginV2.Service
-          const accounts = yield* AccountV2.Service
-          const catalog = yield* Catalog.Service
-          const events = yield* EventV2.Service
-          yield* accounts.create({
-            serviceID: AccountV2.ServiceID.make("gitlab"),
-            credential: new AccountV2.ApiKeyCredential({ type: "api", key: "account-token" }),
+          const auth = yield* AuthV2.Service
+          yield* auth.create({
+            serviceID: AuthV2.ServiceID.make("gitlab"),
+            credential: new AuthV2.ApiKeyCredential({ type: "api", key: "auth-token" }),
+            active: true,
           })
           yield* plugin.add({
-            ...AccountPlugin,
-            effect: AccountPlugin.effect.pipe(
-              Effect.provideService(AccountV2.Service, accounts),
-              Effect.provideService(Catalog.Service, catalog),
-              Effect.provideService(EventV2.Service, events),
-              Effect.provideService(PluginV2.Service, plugin),
-            ),
+            ...AuthPlugin,
+            effect: AuthPlugin.effect.pipe(Effect.provideService(AuthV2.Service, auth)),
           })
           yield* plugin.add(GitLabPlugin)
-          const load = yield* catalog.loader()
-          yield* load((catalog) => catalog.provider.update(ProviderV2.ID.make("gitlab"), () => {}))
-          const provider = yield* catalog.provider.get(ProviderV2.ID.make("gitlab"))
+          const updated = yield* plugin.trigger("provider.update", {}, { provider: provider("gitlab"), cancel: false })
           yield* plugin.trigger(
             "aisdk.sdk",
             {
               model: model("gitlab", "claude"),
               package: "gitlab-ai-provider",
-              options: provider.options.aisdk.provider,
+              options: updated.provider.options.aisdk.provider,
             },
             {},
           )
-          expect(gitlabSDKOptions[0].apiKey).toBe("account-token")
+          expect(gitlabSDKOptions[0].apiKey).toBe("auth-token")
         }),
     ),
   )
 
-  itWithAccount.effect("uses active account OAuth access token when no API token exists", () =>
+  itWithAuth.effect("uses active OAuth access token when no API auth exists", () =>
     withEnv(
       {
         GITLAB_TOKEN: undefined,
@@ -205,41 +185,33 @@ describe("GitLabPlugin", () => {
         Effect.gen(function* () {
           gitlabSDKOptions.length = 0
           const plugin = yield* PluginV2.Service
-          const accounts = yield* AccountV2.Service
-          const catalog = yield* Catalog.Service
-          const events = yield* EventV2.Service
-          yield* accounts.create({
-            serviceID: AccountV2.ServiceID.make("gitlab"),
-            credential: new AccountV2.OAuthCredential({
+          const auth = yield* AuthV2.Service
+          yield* auth.create({
+            serviceID: AuthV2.ServiceID.make("gitlab"),
+            credential: new AuthV2.OAuthCredential({
               type: "oauth",
               refresh: "refresh-token",
-              access: "account-oauth-token",
+              access: "oauth-token",
               expires: 9999999999999,
             }),
+            active: true,
           })
           yield* plugin.add({
-            ...AccountPlugin,
-            effect: AccountPlugin.effect.pipe(
-              Effect.provideService(AccountV2.Service, accounts),
-              Effect.provideService(Catalog.Service, catalog),
-              Effect.provideService(EventV2.Service, events),
-              Effect.provideService(PluginV2.Service, plugin),
-            ),
+            ...AuthPlugin,
+            effect: AuthPlugin.effect.pipe(Effect.provideService(AuthV2.Service, auth)),
           })
           yield* plugin.add(GitLabPlugin)
-          const load = yield* catalog.loader()
-          yield* load((catalog) => catalog.provider.update(ProviderV2.ID.make("gitlab"), () => {}))
-          const provider = yield* catalog.provider.get(ProviderV2.ID.make("gitlab"))
+          const updated = yield* plugin.trigger("provider.update", {}, { provider: provider("gitlab"), cancel: false })
           yield* plugin.trigger(
             "aisdk.sdk",
             {
               model: model("gitlab", "claude"),
               package: "gitlab-ai-provider",
-              options: provider.options.aisdk.provider,
+              options: updated.provider.options.aisdk.provider,
             },
             {},
           )
-          expect(gitlabSDKOptions[0].apiKey).toBe("account-oauth-token")
+          expect(gitlabSDKOptions[0].apiKey).toBe("oauth-token")
         }),
     ),
   )

packages/core/test/plugin/provider-google-vertex-anthropic.test.ts

@@ -1,10 +1,8 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { GoogleVertexAnthropicPlugin } from "@opencode-ai/core/plugin/provider/google-vertex"
-import { ProviderV2 } from "@opencode-ai/core/provider"
-import { fakeSelectorSdk, it, model, withEnv } from "./provider-helper"
+import { fakeSelectorSdk, it, model, provider, withEnv } from "./provider-helper"
 
 describe("GoogleVertexAnthropicPlugin", () => {
   it.effect("resolves legacy project and location env on provider update", () =>
@@ -20,17 +18,14 @@ describe("GoogleVertexAnthropicPlugin", () => {
       () =>
         Effect.gen(function* () {
           const plugin = yield* PluginV2.Service
-          const catalog = yield* Catalog.Service
           yield* plugin.add(GoogleVertexAnthropicPlugin)
-          const load = yield* catalog.loader()
-          yield* load((catalog) =>
-            catalog.provider.update(ProviderV2.ID.make("google-vertex-anthropic"), (provider) => {
-              provider.endpoint = { type: "aisdk", package: "@ai-sdk/google-vertex/anthropic" }
-            }),
+          const result = yield* plugin.trigger(
+            "provider.update",
+            {},
+            { provider: provider("google-vertex-anthropic"), cancel: false },
           )
-          const provider = yield* catalog.provider.get(ProviderV2.ID.make("google-vertex-anthropic"))
-          expect(provider.options.aisdk.provider.project).toBe("cloud-project")
-          expect(provider.options.aisdk.provider.location).toBe("cloud-location")
+          expect(result.provider.options.aisdk.provider.project).toBe("cloud-project")
+          expect(result.provider.options.aisdk.provider.location).toBe("cloud-location")
         }),
     ),
   )
@@ -39,19 +34,23 @@ describe("GoogleVertexAnthropicPlugin", () => {
     withEnv({ GOOGLE_CLOUD_PROJECT: "env-project", GOOGLE_CLOUD_LOCATION: "env-location" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(GoogleVertexAnthropicPlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) =>
-          catalog.provider.update(ProviderV2.ID.make("google-vertex-anthropic"), (provider) => {
-            provider.endpoint = { type: "aisdk", package: "@ai-sdk/google-vertex/anthropic" }
-            provider.options.aisdk.provider.project = "configured-project"
-            provider.options.aisdk.provider.location = "configured-location"
-          }),
+        const result = yield* plugin.trigger(
+          "provider.update",
+          {},
+          {
+            provider: provider("google-vertex-anthropic", {
+              options: {
+                headers: {},
+                body: {},
+                aisdk: { provider: { project: "configured-project", location: "configured-location" }, request: {} },
+              },
+            }),
+            cancel: false,
+          },
         )
-        const provider = yield* catalog.provider.get(ProviderV2.ID.make("google-vertex-anthropic"))
-        expect(provider.options.aisdk.provider.project).toBe("configured-project")
-        expect(provider.options.aisdk.provider.location).toBe("configured-location")
+        expect(result.provider.options.aisdk.provider.project).toBe("configured-project")
+        expect(result.provider.options.aisdk.provider.location).toBe("configured-location")
       }),
     ),
   )

packages/core/test/plugin/provider-google-vertex.test.ts

@@ -1,10 +1,8 @@
 import { describe, expect, mock } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { GoogleVertexPlugin } from "@opencode-ai/core/plugin/provider/google-vertex"
-import { ProviderV2 } from "@opencode-ai/core/provider"
-import { fakeSelectorSdk, it, model, withEnv } from "./provider-helper"
+import { fakeSelectorSdk, it, model, provider, withEnv } from "./provider-helper"
 
 const vertexOptions: Record<string, any>[] = []
 
@@ -45,22 +43,24 @@ describe("GoogleVertexPlugin", () => {
       () =>
         Effect.gen(function* () {
           const plugin = yield* PluginV2.Service
-          const catalog = yield* Catalog.Service
           yield* plugin.add(GoogleVertexPlugin)
-          const load = yield* catalog.loader()
-          yield* load((catalog) =>
-            catalog.provider.update(ProviderV2.ID.make("google-vertex"), (provider) => {
-              provider.endpoint = {
-                type: "aisdk",
-                package: "@ai-sdk/openai-compatible",
-                url: "https://${GOOGLE_VERTEX_ENDPOINT}/v1/projects/${GOOGLE_VERTEX_PROJECT}/locations/${GOOGLE_VERTEX_LOCATION}",
-              }
-            }),
+          const result = yield* plugin.trigger(
+            "provider.update",
+            {},
+            {
+              provider: provider("google-vertex", {
+                endpoint: {
+                  type: "aisdk",
+                  package: "@ai-sdk/openai-compatible",
+                  url: "https://${GOOGLE_VERTEX_ENDPOINT}/v1/projects/${GOOGLE_VERTEX_PROJECT}/locations/${GOOGLE_VERTEX_LOCATION}",
+                },
+              }),
+              cancel: false,
+            },
           )
-          const provider = yield* catalog.provider.get(ProviderV2.ID.make("google-vertex"))
-          expect(provider.options.aisdk.provider.project).toBe("google-cloud-project")
-          expect(provider.options.aisdk.provider.location).toBe("google-vertex-location")
-          expect(provider.endpoint).toEqual({
+          expect(result.provider.options.aisdk.provider.project).toBe("google-cloud-project")
+          expect(result.provider.options.aisdk.provider.location).toBe("google-vertex-location")
+          expect(result.provider.endpoint).toEqual({
             type: "aisdk",
             package: "@ai-sdk/openai-compatible",
             url: "https://google-vertex-location-aiplatform.googleapis.com/v1/projects/google-cloud-project/locations/google-vertex-location",
@@ -84,19 +84,21 @@ describe("GoogleVertexPlugin", () => {
         Effect.gen(function* () {
           vertexOptions.length = 0
           const plugin = yield* PluginV2.Service
-          const catalog = yield* Catalog.Service
           yield* plugin.add(GoogleVertexPlugin)
-          const load = yield* catalog.loader()
-          yield* load((catalog) =>
-            catalog.provider.update(ProviderV2.ID.make("google-vertex"), (provider) => {
-              provider.endpoint = {
-                type: "aisdk",
-                package: "@ai-sdk/openai-compatible",
-                url: "https://${GOOGLE_VERTEX_ENDPOINT}/v1/projects/${GOOGLE_VERTEX_PROJECT}/locations/${GOOGLE_VERTEX_LOCATION}",
-              }
-            }),
+          const updated = yield* plugin.trigger(
+            "provider.update",
+            {},
+            {
+              provider: provider("google-vertex", {
+                endpoint: {
+                  type: "aisdk",
+                  package: "@ai-sdk/openai-compatible",
+                  url: "https://${GOOGLE_VERTEX_ENDPOINT}/v1/projects/${GOOGLE_VERTEX_PROJECT}/locations/${GOOGLE_VERTEX_LOCATION}",
+                },
+              }),
+              cancel: false,
+            },
           )
-          const provider = yield* catalog.provider.get(ProviderV2.ID.make("google-vertex"))
           yield* plugin.trigger(
             "aisdk.sdk",
             {
@@ -109,8 +111,8 @@ describe("GoogleVertexPlugin", () => {
             {},
           )
 
-          expect(provider.options.aisdk.provider.project).toBe("vertex-project")
-          expect(provider.endpoint).toEqual({
+          expect(updated.provider.options.aisdk.provider.project).toBe("vertex-project")
+          expect(updated.provider.endpoint).toEqual({
             type: "aisdk",
             package: "@ai-sdk/openai-compatible",
             url: "https://europe-west4-aiplatform.googleapis.com/v1/projects/vertex-project/locations/europe-west4",
@@ -134,24 +136,29 @@ describe("GoogleVertexPlugin", () => {
       () =>
         Effect.gen(function* () {
           const plugin = yield* PluginV2.Service
-          const catalog = yield* Catalog.Service
           yield* plugin.add(GoogleVertexPlugin)
-          const load = yield* catalog.loader()
-          yield* load((catalog) =>
-            catalog.provider.update(ProviderV2.ID.make("google-vertex"), (provider) => {
-              provider.endpoint = {
-                type: "aisdk",
-                package: "@ai-sdk/openai-compatible",
-                url: "https://${GOOGLE_VERTEX_ENDPOINT}/v1/projects/${GOOGLE_VERTEX_PROJECT}/locations/${GOOGLE_VERTEX_LOCATION}",
-              }
-              provider.options.aisdk.provider.project = "config-project"
-              provider.options.aisdk.provider.location = "global"
-            }),
+          const result = yield* plugin.trigger(
+            "provider.update",
+            {},
+            {
+              provider: provider("google-vertex", {
+                endpoint: {
+                  type: "aisdk",
+                  package: "@ai-sdk/openai-compatible",
+                  url: "https://${GOOGLE_VERTEX_ENDPOINT}/v1/projects/${GOOGLE_VERTEX_PROJECT}/locations/${GOOGLE_VERTEX_LOCATION}",
+                },
+                options: {
+                  headers: {},
+                  body: {},
+                  aisdk: { provider: { project: "config-project", location: "global" }, request: {} },
+                },
+              }),
+              cancel: false,
+            },
           )
-          const provider = yield* catalog.provider.get(ProviderV2.ID.make("google-vertex"))
-          expect(provider.options.aisdk.provider.project).toBe("config-project")
-          expect(provider.options.aisdk.provider.location).toBe("global")
-          expect(provider.endpoint).toEqual({
+          expect(result.provider.options.aisdk.provider.project).toBe("config-project")
+          expect(result.provider.options.aisdk.provider.location).toBe("global")
+          expect(result.provider.endpoint).toEqual({
             type: "aisdk",
             package: "@ai-sdk/openai-compatible",
             url: "https://aiplatform.googleapis.com/v1/projects/config-project/locations/global",
@@ -173,18 +180,19 @@ describe("GoogleVertexPlugin", () => {
       () =>
         Effect.gen(function* () {
           const plugin = yield* PluginV2.Service
-          const catalog = yield* Catalog.Service
           yield* plugin.add(GoogleVertexPlugin)
-          const load = yield* catalog.loader()
-          yield* load((catalog) =>
-            catalog.provider.update(ProviderV2.ID.make("google-vertex"), (provider) => {
-              provider.endpoint = { type: "aisdk", package: "@ai-sdk/google-vertex" }
-              provider.options.aisdk.provider.project = "config-project"
-            }),
+          const result = yield* plugin.trigger(
+            "provider.update",
+            {},
+            {
+              provider: provider("google-vertex", {
+                options: { headers: {}, body: {}, aisdk: { provider: { project: "config-project" }, request: {} } },
+              }),
+              cancel: false,
+            },
           )
-          const provider = yield* catalog.provider.get(ProviderV2.ID.make("google-vertex"))
-          expect(provider.options.aisdk.provider.project).toBe("config-project")
-          expect(provider.options.aisdk.provider.location).toBe("us-central1")
+          expect(result.provider.options.aisdk.provider.project).toBe("config-project")
+          expect(result.provider.options.aisdk.provider.location).toBe("us-central1")
         }),
     ),
   )

packages/core/test/plugin/provider-helper.ts

@@ -2,16 +2,12 @@ import { Npm } from "@opencode-ai/core/npm"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { expect } from "bun:test"
 import { Effect, Layer, Option } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { EventV2 } from "@opencode-ai/core/event"
-import { Location } from "@opencode-ai/core/location"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { testEffect } from "../lib/effect"
 
 export const fixtureProvider = new URL("./fixtures/provider-factory.ts", import.meta.url).href
-const locationLayer = Layer.succeed(Location.Service, Location.Service.of({ directory: "test" }))
 
 export const npmLayer = Layer.succeed(
   Npm.Service,
@@ -22,34 +18,7 @@ export const npmLayer = Layer.succeed(
   }),
 )
 
-export const catalogLayer = Layer.succeed(
-  Catalog.Service,
-  Catalog.Service.of({
-    loader: () => Effect.die("unexpected catalog.loader"),
-    provider: {
-      get: () => Effect.die("unexpected provider.get"),
-      all: () => Effect.succeed([]),
-      available: () => Effect.succeed([]),
-    },
-    model: {
-      get: () => Effect.die("unexpected model.get"),
-      all: () => Effect.succeed([]),
-      available: () => Effect.succeed([]),
-      default: () => Effect.succeed(Option.none<ModelV2.Info>()),
-      setDefault: () => Effect.die("unexpected model.setDefault"),
-      small: () => Effect.succeed(Option.none<ModelV2.Info>()),
-    },
-  }),
-)
-
-export const it = testEffect(
-  Catalog.layer.pipe(
-    Layer.provideMerge(PluginV2.defaultLayer),
-    Layer.provideMerge(EventV2.defaultLayer),
-    Layer.provideMerge(locationLayer),
-    Layer.provideMerge(npmLayer),
-  ),
-)
+export const it = testEffect(Layer.mergeAll(PluginV2.defaultLayer, npmLayer))
 
 export function provider(providerID: string, options?: Partial<ProviderV2.Info>) {
   return new ProviderV2.Info({

packages/core/test/plugin/provider-kilo.test.ts

@@ -1,10 +1,8 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
 import { KiloPlugin } from "@opencode-ai/core/plugin/provider/kilo"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { expectPluginRegistered, it, provider } from "./provider-helper"
 
 describe("KiloPlugin", () => {
@@ -20,81 +18,73 @@ describe("KiloPlugin", () => {
   it.effect("applies legacy referer headers only to kilo", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(KiloPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const kilo = provider("kilo", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://api.kilo.ai/api/gateway" },
-          options: { headers: { Existing: "value" }, body: {}, aisdk: { provider: {}, request: {} } },
-        })
-        catalog.provider.update(kilo.id, (draft) => {
-          draft.endpoint = kilo.endpoint
-          draft.options = kilo.options
-        })
-        catalog.provider.update(provider("openrouter").id, () => {})
-      })
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("kilo"))).options.headers).toEqual({
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("kilo", {
+            options: { headers: { Existing: "value" }, body: {}, aisdk: { provider: {}, request: {} } },
+          }),
+          cancel: false,
+        },
+      )
+      const ignored = yield* plugin.trigger("provider.update", {}, { provider: provider("openrouter"), cancel: false })
+      expect(result.provider.options.headers).toEqual({
         Existing: "value",
         "HTTP-Referer": "https://opencode.ai/",
         "X-Title": "opencode",
       })
-      expect((yield* catalog.provider.get(ProviderV2.ID.openrouter)).options.headers).toEqual({})
+      expect(ignored.provider.options.headers).toEqual({})
     }),
   )
 
   it.effect("uses the exact legacy Kilo header casing and set", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(KiloPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("kilo", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://api.kilo.ai/api/gateway" },
-        })
-        catalog.provider.update(item.id, (draft) => {
-          draft.endpoint = item.endpoint
-        })
-      })
+      const result = yield* plugin.trigger("provider.update", {}, { provider: provider("kilo"), cancel: false })
 
-      const result = yield* catalog.provider.get(ProviderV2.ID.make("kilo"))
-      expect(result.options.headers).toEqual({
+      expect(result.provider.options.headers).toEqual({
         "HTTP-Referer": "https://opencode.ai/",
         "X-Title": "opencode",
       })
-      expect(result.options.headers).not.toHaveProperty("http-referer")
-      expect(result.options.headers).not.toHaveProperty("x-title")
-      expect(result.options.headers).not.toHaveProperty("X-Source")
+      expect(result.provider.options.headers).not.toHaveProperty("http-referer")
+      expect(result.provider.options.headers).not.toHaveProperty("x-title")
+      expect(result.provider.options.headers).not.toHaveProperty("X-Source")
     }),
   )
 
   it.effect("uses the legacy provider-id guard instead of endpoint package matching", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(KiloPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const kilo = provider("kilo", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://api.kilo.ai/api/gateway" },
-        })
-        catalog.provider.update(kilo.id, (draft) => {
-          draft.endpoint = kilo.endpoint
-        })
-        const custom = provider("custom-kilo", {
-          endpoint: { type: "aisdk", package: "kilo" },
-        })
-        catalog.provider.update(custom.id, (draft) => {
-          draft.endpoint = custom.endpoint
-        })
-      })
+      const matchingID = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("kilo", {
+            endpoint: { type: "aisdk", package: "not-kilo" },
+          }),
+          cancel: false,
+        },
+      )
+      const matchingPackage = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("custom-kilo", {
+            endpoint: { type: "aisdk", package: "kilo" },
+          }),
+          cancel: false,
+        },
+      )
 
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("kilo"))).options.headers).toEqual({
+      expect(matchingID.provider.options.headers).toEqual({
         "HTTP-Referer": "https://opencode.ai/",
         "X-Title": "opencode",
       })
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("custom-kilo"))).options.headers).toEqual({})
+      expect(matchingPackage.provider.options.headers).toEqual({})
     }),
   )
 })

packages/core/test/plugin/provider-llmgateway.test.ts

@@ -1,10 +1,8 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
 import { LLMGatewayPlugin } from "@opencode-ai/core/plugin/provider/llmgateway"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { expectPluginRegistered, it, provider } from "./provider-helper"
 
 describe("LLMGatewayPlugin", () => {
@@ -20,54 +18,46 @@ describe("LLMGatewayPlugin", () => {
   it.effect("applies legacy referer headers only to enabled llmgateway", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(LLMGatewayPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const llmgateway = provider("llmgateway", {
-          enabled: { via: "env", name: "LLMGATEWAY_API_KEY" },
-          endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://api.llmgateway.io/v1" },
-          options: { headers: { Existing: "value" }, body: {}, aisdk: { provider: {}, request: {} } },
-        })
-        catalog.provider.update(llmgateway.id, (draft) => {
-          draft.enabled = llmgateway.enabled
-          draft.endpoint = llmgateway.endpoint
-          draft.options = llmgateway.options
-        })
-        const openrouter = provider("openrouter", {
-          enabled: { via: "env", name: "OPENROUTER_API_KEY" },
-        })
-        catalog.provider.update(openrouter.id, (draft) => {
-          draft.enabled = openrouter.enabled
-        })
-      })
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("llmgateway"))).options.headers).toEqual({
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("llmgateway", {
+            enabled: { via: "env", name: "LLMGATEWAY_API_KEY" },
+            options: { headers: { Existing: "value" }, body: {}, aisdk: { provider: {}, request: {} } },
+          }),
+          cancel: false,
+        },
+      )
+      const ignored = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("openrouter", {
+            enabled: { via: "env", name: "OPENROUTER_API_KEY" },
+          }),
+          cancel: false,
+        },
+      )
+      expect(result.provider.options.headers).toEqual({
         Existing: "value",
         "HTTP-Referer": "https://opencode.ai/",
         "X-Title": "opencode",
         "X-Source": "opencode",
       })
-      expect((yield* catalog.provider.get(ProviderV2.ID.openrouter)).options.headers).toEqual({})
+      expect(ignored.provider.options.headers).toEqual({})
     }),
   )
 
   it.effect("does not apply legacy headers to a disabled llmgateway provider", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(LLMGatewayPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("llmgateway", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://api.llmgateway.io/v1" },
-        })
-        catalog.provider.update(item.id, (draft) => {
-          draft.endpoint = item.endpoint
-        })
-      })
+      const result = yield* plugin.trigger("provider.update", {}, { provider: provider("llmgateway"), cancel: false })
 
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("llmgateway"))).enabled).toBe(false)
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("llmgateway"))).options.headers).toEqual({})
+      expect(result.provider.enabled).toBe(false)
+      expect(result.provider.options.headers).toEqual({})
     }),
   )
 })

packages/core/test/plugin/provider-nvidia.test.ts

@@ -1,10 +1,8 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
 import { NvidiaPlugin } from "@opencode-ai/core/plugin/provider/nvidia"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { expectPluginRegistered, it, provider } from "./provider-helper"
 
 describe("NvidiaPlugin", () => {
@@ -20,48 +18,45 @@ describe("NvidiaPlugin", () => {
   it.effect("applies NVIDIA tracking headers only to nvidia", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(NvidiaPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const nvidia = provider("nvidia", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://integrate.api.nvidia.com/v1" },
-          options: { headers: { Existing: "value" }, body: {}, aisdk: { provider: {}, request: {} } },
-        })
-        catalog.provider.update(nvidia.id, (draft) => {
-          draft.endpoint = nvidia.endpoint
-          draft.options = nvidia.options
-        })
-        catalog.provider.update(provider("openrouter").id, () => {})
-      })
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("nvidia"))).options.headers).toEqual({
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("nvidia", {
+            options: { headers: { Existing: "value" }, body: {}, aisdk: { provider: {}, request: {} } },
+          }),
+          cancel: false,
+        },
+      )
+      const ignored = yield* plugin.trigger("provider.update", {}, { provider: provider("openrouter"), cancel: false })
+      expect(result.provider.options.headers).toEqual({
         Existing: "value",
         "HTTP-Referer": "https://opencode.ai/",
         "X-Title": "opencode",
         "X-BILLING-INVOKE-ORIGIN": "OpenCode",
       })
-      expect((yield* catalog.provider.get(ProviderV2.ID.openrouter)).options.headers).toEqual({})
+      expect(ignored.provider.options.headers).toEqual({})
     }),
   )
 
   it.effect("adds billing origin for custom NVIDIA endpoints", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(NvidiaPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("nvidia", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://integrate.api.nvidia.com/v1" },
-          options: { headers: {}, body: {}, aisdk: { provider: {}, request: {} } },
-        })
-        catalog.provider.update(item.id, (draft) => {
-          draft.endpoint = item.endpoint
-          draft.options = item.options
-        })
-      })
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("nvidia", {
+            endpoint: { type: "aisdk", package: "test-provider", url: "http://localhost:8000/v1" },
+            options: { headers: {}, body: {}, aisdk: { provider: {}, request: {} } },
+          }),
+          cancel: false,
+        },
+      )
 
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("nvidia"))).options.headers).toEqual({
+      expect(result.provider.options.headers).toEqual({
         "HTTP-Referer": "https://opencode.ai/",
         "X-Title": "opencode",
         "X-BILLING-INVOKE-ORIGIN": "OpenCode",
@@ -72,25 +67,23 @@ describe("NvidiaPlugin", () => {
   it.effect("preserves an explicit NVIDIA billing origin header", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(NvidiaPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("nvidia", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://integrate.api.nvidia.com/v1" },
-          options: {
-            headers: { "X-BILLING-INVOKE-ORIGIN": "CustomOrigin" },
-            body: {},
-            aisdk: { provider: { baseURL: "https://integrate.api.nvidia.com/v1" }, request: {} },
-          },
-        })
-        catalog.provider.update(item.id, (draft) => {
-          draft.endpoint = item.endpoint
-          draft.options = item.options
-        })
-      })
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("nvidia", {
+            options: {
+              headers: { "X-BILLING-INVOKE-ORIGIN": "CustomOrigin" },
+              body: {},
+              aisdk: { provider: { baseURL: "https://integrate.api.nvidia.com/v1" }, request: {} },
+            },
+          }),
+          cancel: false,
+        },
+      )
 
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("nvidia"))).options.headers).toEqual({
+      expect(result.provider.options.headers).toEqual({
         "HTTP-Referer": "https://opencode.ai/",
         "X-Title": "opencode",
         "X-BILLING-INVOKE-ORIGIN": "CustomOrigin",

packages/core/test/plugin/provider-openai.test.ts

@@ -1,11 +1,9 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { OpenAIPlugin } from "@opencode-ai/core/plugin/provider/openai"
-import { ProviderV2 } from "@opencode-ai/core/provider"
-import { fakeSelectorSdk, it, model, provider } from "./provider-helper"
+import { fakeSelectorSdk, it, model } from "./provider-helper"
 
 describe("OpenAIPlugin", () => {
   it.effect("creates an OpenAI SDK for @ai-sdk/openai using the provider ID as SDK name", () =>
@@ -72,39 +70,31 @@ describe("OpenAIPlugin", () => {
     }),
   )
 
-  it.effect("disables gpt-5-chat-latest during catalog transforms", () =>
+  it.effect("cancels gpt-5-chat-latest during model updates", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(OpenAIPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("openai", { endpoint: { type: "aisdk", package: "@ai-sdk/openai" } })
-        catalog.provider.update(item.id, (draft) => {
-          draft.endpoint = item.endpoint
-        })
-        catalog.model.update(item.id, ModelV2.ID.make("gpt-5"), () => {})
-        catalog.model.update(item.id, ModelV2.ID.make("gpt-5-chat-latest"), () => {})
-      })
-      expect((yield* catalog.model.get(ProviderV2.ID.openai, ModelV2.ID.make("gpt-5"))).enabled).toBe(true)
-      expect((yield* catalog.model.get(ProviderV2.ID.openai, ModelV2.ID.make("gpt-5-chat-latest"))).enabled).toBe(false)
+      const normal = yield* plugin.trigger("model.update", {}, { model: model("openai", "gpt-5"), cancel: false })
+      const filtered = yield* plugin.trigger(
+        "model.update",
+        {},
+        { model: model("openai", "gpt-5-chat-latest"), cancel: false },
+      )
+      expect(normal.cancel).toBe(false)
+      expect(filtered.cancel).toBe(true)
     }),
   )
 
-  it.effect("does not disable gpt-5-chat-latest for non-OpenAI providers", () =>
+  it.effect("does not cancel gpt-5-chat-latest for non-OpenAI providers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(OpenAIPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("custom-openai")
-        catalog.provider.update(item.id, () => {})
-        catalog.model.update(item.id, ModelV2.ID.make("gpt-5-chat-latest"), () => {})
-      })
-      expect(
-        (yield* catalog.model.get(ProviderV2.ID.make("custom-openai"), ModelV2.ID.make("gpt-5-chat-latest"))).enabled,
-      ).toBe(true)
+      const result = yield* plugin.trigger(
+        "model.update",
+        {},
+        { model: model("custom-openai", "gpt-5-chat-latest"), cancel: false },
+      )
+      expect(result.cancel).toBe(false)
     }),
   )
 })

packages/core/test/plugin/provider-opencode.test.ts

@@ -12,23 +12,19 @@ const cost = (input: number, output = 0) => [{ input, output, cache: { read: 0,
 const locationLayer = Layer.succeed(Location.Service, Location.Service.of({ directory: "test" }))
 
 describe("OpencodePlugin", () => {
-  it.effect("uses a public key and disables paid models without credentials", () =>
+  it.effect("uses a public key and cancels paid models without credentials", () =>
     withEnv({ OPENCODE_API_KEY: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(OpencodePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const item = provider("opencode")
-          catalog.provider.update(item.id, () => {})
-          const paid = model("opencode", "paid", { cost: cost(1) })
-          catalog.model.update(item.id, paid.id, (draft) => {
-            draft.cost = [...paid.cost]
-          })
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.opencode)).options.aisdk.provider.apiKey).toBe("public")
-        expect((yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("paid"))).enabled).toBe(false)
+        const updated = yield* plugin.trigger("provider.update", {}, { provider: provider("opencode"), cancel: false })
+        const paid = yield* plugin.trigger(
+          "model.update",
+          {},
+          { model: model("opencode", "paid", { cost: cost(1) }), cancel: false },
+        )
+        expect(updated.provider.options.aisdk.provider.apiKey).toBe("public")
+        expect(paid.cancel).toBe(true)
       }),
     ),
   )
@@ -37,19 +33,14 @@ describe("OpencodePlugin", () => {
     withEnv({ OPENCODE_API_KEY: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(OpencodePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const item = provider("opencode")
-          catalog.provider.update(item.id, () => {})
-          const free = model("opencode", "free", { cost: cost(0) })
-          catalog.model.update(item.id, free.id, (draft) => {
-            draft.cost = [...free.cost]
-          })
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.opencode)).options.aisdk.provider.apiKey).toBe("public")
-        expect((yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("free"))).enabled).toBe(true)
+        yield* plugin.trigger("provider.update", {}, { provider: provider("opencode"), cancel: false })
+        const free = yield* plugin.trigger(
+          "model.update",
+          {},
+          { model: model("opencode", "free", { cost: cost(0) }), cancel: false },
+        )
+        expect(free.cancel).toBe(false)
       }),
     ),
   )
@@ -58,19 +49,14 @@ describe("OpencodePlugin", () => {
     withEnv({ OPENCODE_API_KEY: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(OpencodePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const item = provider("opencode")
-          catalog.provider.update(item.id, () => {})
-          const outputOnly = model("opencode", "output-only", { cost: cost(0, 1) })
-          catalog.model.update(item.id, outputOnly.id, (draft) => {
-            draft.cost = [...outputOnly.cost]
-          })
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.opencode)).options.aisdk.provider.apiKey).toBe("public")
-        expect((yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("output-only"))).enabled).toBe(true)
+        yield* plugin.trigger("provider.update", {}, { provider: provider("opencode"), cancel: false })
+        const outputOnly = yield* plugin.trigger(
+          "model.update",
+          {},
+          { model: model("opencode", "output-only", { cost: cost(0, 1) }), cancel: false },
+        )
+        expect(outputOnly.cancel).toBe(false)
       }),
     ),
   )
@@ -79,19 +65,15 @@ describe("OpencodePlugin", () => {
     withEnv({ OPENCODE_API_KEY: "secret" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(OpencodePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const item = provider("opencode")
-          catalog.provider.update(item.id, () => {})
-          const paid = model("opencode", "paid", { cost: cost(1) })
-          catalog.model.update(item.id, paid.id, (draft) => {
-            draft.cost = [...paid.cost]
-          })
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.opencode)).options.aisdk.provider.apiKey).toBeUndefined()
-        expect((yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("paid"))).enabled).toBe(true)
+        const updated = yield* plugin.trigger("provider.update", {}, { provider: provider("opencode"), cancel: false })
+        const paid = yield* plugin.trigger(
+          "model.update",
+          {},
+          { model: model("opencode", "paid", { cost: cost(1) }), cancel: false },
+        )
+        expect(updated.provider.options.aisdk.provider.apiKey).toBeUndefined()
+        expect(paid.cancel).toBe(false)
       }),
     ),
   )
@@ -100,21 +82,19 @@ describe("OpencodePlugin", () => {
     withEnv({ OPENCODE_API_KEY: undefined, CUSTOM_OPENCODE_API_KEY: "secret" }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(OpencodePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const item = provider("opencode", { env: ["CUSTOM_OPENCODE_API_KEY"] })
-          catalog.provider.update(item.id, (draft) => {
-            draft.env = [...item.env]
-          })
-          const paid = model("opencode", "paid", { cost: cost(1) })
-          catalog.model.update(item.id, paid.id, (draft) => {
-            draft.cost = [...paid.cost]
-          })
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.opencode)).options.aisdk.provider.apiKey).toBeUndefined()
-        expect((yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("paid"))).enabled).toBe(true)
+        const updated = yield* plugin.trigger(
+          "provider.update",
+          {},
+          { provider: provider("opencode", { env: ["CUSTOM_OPENCODE_API_KEY"] }), cancel: false },
+        )
+        const paid = yield* plugin.trigger(
+          "model.update",
+          {},
+          { model: model("opencode", "paid", { cost: cost(1) }), cancel: false },
+        )
+        expect(updated.provider.options.aisdk.provider.apiKey).toBeUndefined()
+        expect(paid.cancel).toBe(false)
       }),
     ),
   )
@@ -123,30 +103,31 @@ describe("OpencodePlugin", () => {
     withEnv({ OPENCODE_API_KEY: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(OpencodePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const item = provider("opencode", {
-            options: {
-              headers: {},
-              body: {},
-              aisdk: {
-                provider: { apiKey: "configured" },
-                request: {},
+        const updated = yield* plugin.trigger(
+          "provider.update",
+          {},
+          {
+            provider: provider("opencode", {
+              options: {
+                headers: {},
+                body: {},
+                aisdk: {
+                  provider: { apiKey: "configured" },
+                  request: {},
+                },
               },
-            },
-          })
-          catalog.provider.update(item.id, (draft) => {
-            draft.options = item.options
-          })
-          const paid = model("opencode", "paid", { cost: cost(1) })
-          catalog.model.update(item.id, paid.id, (draft) => {
-            draft.cost = [...paid.cost]
-          })
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.opencode)).options.aisdk.provider.apiKey).toBe("configured")
-        expect((yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("paid"))).enabled).toBe(true)
+            }),
+            cancel: false,
+          },
+        )
+        const paid = yield* plugin.trigger(
+          "model.update",
+          {},
+          { model: model("opencode", "paid", { cost: cost(1) }), cancel: false },
+        )
+        expect(updated.provider.options.aisdk.provider.apiKey).toBe("configured")
+        expect(paid.cancel).toBe(false)
       }),
     ),
   )
@@ -155,21 +136,19 @@ describe("OpencodePlugin", () => {
     withEnv({ OPENCODE_API_KEY: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(OpencodePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const item = provider("opencode", { enabled: { via: "account", service: "opencode" } })
-          catalog.provider.update(item.id, (draft) => {
-            draft.enabled = item.enabled
-          })
-          const paid = model("opencode", "paid", { cost: cost(1) })
-          catalog.model.update(item.id, paid.id, (draft) => {
-            draft.cost = [...paid.cost]
-          })
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.opencode)).options.aisdk.provider.apiKey).toBeUndefined()
-        expect((yield* catalog.model.get(ProviderV2.ID.opencode, ModelV2.ID.make("paid"))).enabled).toBe(true)
+        const updated = yield* plugin.trigger(
+          "provider.update",
+          {},
+          { provider: provider("opencode", { enabled: { via: "auth", service: "opencode" } }), cancel: false },
+        )
+        const paid = yield* plugin.trigger(
+          "model.update",
+          {},
+          { model: model("opencode", "paid", { cost: cost(1) }), cancel: false },
+        )
+        expect(updated.provider.options.aisdk.provider.apiKey).toBeUndefined()
+        expect(paid.cancel).toBe(false)
       }),
     ),
   )
@@ -178,19 +157,15 @@ describe("OpencodePlugin", () => {
     withEnv({ OPENCODE_API_KEY: undefined }, () =>
       Effect.gen(function* () {
         const plugin = yield* PluginV2.Service
-        const catalog = yield* Catalog.Service
         yield* plugin.add(OpencodePlugin)
-        const load = yield* catalog.loader()
-        yield* load((catalog) => {
-          const item = provider("openai")
-          catalog.provider.update(item.id, () => {})
-          const paid = model("openai", "paid", { cost: cost(1) })
-          catalog.model.update(item.id, paid.id, (draft) => {
-            draft.cost = [...paid.cost]
-          })
-        })
-        expect((yield* catalog.provider.get(ProviderV2.ID.openai)).options.aisdk.provider.apiKey).toBeUndefined()
-        expect((yield* catalog.model.get(ProviderV2.ID.openai, ModelV2.ID.make("paid"))).enabled).toBe(true)
+        const updated = yield* plugin.trigger("provider.update", {}, { provider: provider("openai"), cancel: false })
+        const paid = yield* plugin.trigger(
+          "model.update",
+          {},
+          { model: model("openai", "paid", { cost: cost(1) }), cancel: false },
+        )
+        expect(updated.provider.options.aisdk.provider.apiKey).toBeUndefined()
+        expect(paid.cancel).toBe(false)
       }),
     ),
   )
@@ -200,21 +175,18 @@ describe("OpencodePlugin", () => {
       const catalog = yield* Catalog.Service
       const providerID = ProviderV2.ID.opencode
 
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        catalog.provider.update(providerID, () => {})
-        catalog.model.update(providerID, ModelV2.ID.make("cheap-mini"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [...cost(1, 1)]
-          model.time.released = DateTime.makeUnsafe(Date.now())
-        })
-        catalog.model.update(providerID, ModelV2.ID.make("gpt-5-nano"), (model) => {
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.cost = [...cost(10, 10)]
-          model.time.released = DateTime.makeUnsafe(Date.now())
-        })
+      yield* catalog.provider.update(providerID, () => {})
+      yield* catalog.model.update(providerID, ModelV2.ID.make("cheap-mini"), (model) => {
+        model.capabilities.input = ["text"]
+        model.capabilities.output = ["text"]
+        model.cost = cost(1, 1)
+        model.time.released = DateTime.makeUnsafe(Date.now())
+      })
+      yield* catalog.model.update(providerID, ModelV2.ID.make("gpt-5-nano"), (model) => {
+        model.capabilities.input = ["text"]
+        model.capabilities.output = ["text"]
+        model.cost = cost(10, 10)
+        model.time.released = DateTime.makeUnsafe(Date.now())
       })
 
       const selected = yield* catalog.model.small(providerID)

packages/core/test/plugin/provider-openrouter.test.ts

@@ -1,11 +1,8 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { ModelV2 } from "@opencode-ai/core/model"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
 import { OpenRouterPlugin } from "@opencode-ai/core/plugin/provider/openrouter"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { expectPluginRegistered, it, model, provider } from "./provider-helper"
 
 describe("OpenRouterPlugin", () => {
@@ -21,27 +18,24 @@ describe("OpenRouterPlugin", () => {
   it.effect("applies legacy referer headers only to openrouter", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(OpenRouterPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const openrouter = provider("openrouter", {
-          endpoint: { type: "aisdk", package: "@openrouter/ai-sdk-provider" },
-          options: { headers: { Existing: "value" }, body: {}, aisdk: { provider: {}, request: {} } },
-        })
-        catalog.provider.update(openrouter.id, (item) => {
-          item.endpoint = openrouter.endpoint
-          item.options = openrouter.options
-        })
-        catalog.provider.update(ProviderV2.ID.make("nvidia"), () => {})
-      })
-
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("openrouter"))).options.headers).toEqual({
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("openrouter", {
+            options: { headers: { Existing: "value" }, body: {}, aisdk: { provider: {}, request: {} } },
+          }),
+          cancel: false,
+        },
+      )
+      const ignored = yield* plugin.trigger("provider.update", {}, { provider: provider("nvidia"), cancel: false })
+      expect(result.provider.options.headers).toEqual({
         Existing: "value",
         "HTTP-Referer": "https://opencode.ai/",
         "X-Title": "opencode",
       })
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("nvidia"))).options.headers).toEqual({})
+      expect(ignored.provider.options.headers).toEqual({})
     }),
   )
 
@@ -73,50 +67,39 @@ describe("OpenRouterPlugin", () => {
   it.effect("filters OpenRouter's gpt-5 chat alias", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(OpenRouterPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const openrouter = provider("openrouter", {
-          endpoint: { type: "aisdk", package: "@openrouter/ai-sdk-provider" },
-        })
-        catalog.provider.update(openrouter.id, (item) => {
-          item.endpoint = openrouter.endpoint
-        })
-        catalog.provider.update(ProviderV2.ID.openai, () => {})
-        for (const item of [
-          model("openrouter", "openai/gpt-5-chat"),
-          model("openrouter", "openai/gpt-5"),
-          model("openai", "openai/gpt-5-chat"),
-        ]) {
-          catalog.model.update(item.providerID, item.id, () => {})
-        }
-      })
+      const result = yield* plugin.trigger(
+        "model.update",
+        {},
+        { model: model("openrouter", "openai/gpt-5-chat"), cancel: false },
+      )
+      const regular = yield* plugin.trigger(
+        "model.update",
+        {},
+        { model: model("openrouter", "openai/gpt-5"), cancel: false },
+      )
+      const ignored = yield* plugin.trigger(
+        "model.update",
+        {},
+        { model: model("openai", "openai/gpt-5-chat"), cancel: false },
+      )
 
-      expect(
-        (yield* catalog.model.get(ProviderV2.ID.make("openrouter"), ModelV2.ID.make("openai/gpt-5-chat"))).enabled,
-      ).toBe(false)
-      expect(
-        (yield* catalog.model.get(ProviderV2.ID.make("openrouter"), ModelV2.ID.make("openai/gpt-5"))).enabled,
-      ).toBe(true)
-      expect((yield* catalog.model.get(ProviderV2.ID.openai, ModelV2.ID.make("openai/gpt-5-chat"))).enabled).toBe(true)
+      expect(result.cancel).toBe(true)
+      expect(regular.cancel).toBe(false)
+      expect(ignored.cancel).toBe(false)
     }),
   )
 
-  it.effect("does not disable gpt-5-chat-latest for non-OpenRouter providers", () =>
+  it.effect("does not filter gpt-5-chat-latest for non-OpenRouter providers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(OpenRouterPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        catalog.provider.update(ProviderV2.ID.make("custom-openrouter"), () => {})
-        catalog.model.update(ProviderV2.ID.make("custom-openrouter"), ModelV2.ID.make("gpt-5-chat-latest"), () => {})
-      })
-      expect(
-        (yield* catalog.model.get(ProviderV2.ID.make("custom-openrouter"), ModelV2.ID.make("gpt-5-chat-latest")))
-          .enabled,
-      ).toBe(true)
+      const result = yield* plugin.trigger(
+        "model.update",
+        {},
+        { model: model("custom-openrouter", "gpt-5-chat-latest"), cancel: false },
+      )
+      expect(result.cancel).toBe(false)
     }),
   )
 })

packages/core/test/plugin/provider-vercel.test.ts

@@ -1,29 +1,25 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { VercelPlugin } from "@opencode-ai/core/plugin/provider/vercel"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { it, model, provider } from "./provider-helper"
 
 describe("VercelPlugin", () => {
   it.effect("applies legacy lower-case referer headers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(VercelPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("vercel", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/vercel" },
-          options: { headers: { Existing: "1" }, body: {}, aisdk: { provider: {}, request: {} } },
-        })
-        catalog.provider.update(item.id, (draft) => {
-          draft.endpoint = item.endpoint
-          draft.options = item.options
-        })
-      })
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("vercel"))).options.headers).toEqual({
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("vercel", {
+            options: { headers: { Existing: "1" }, body: {}, aisdk: { provider: {}, request: {} } },
+          }),
+          cancel: false,
+        },
+      )
+      expect(result.provider.options.headers).toEqual({
         Existing: "1",
         "http-referer": "https://opencode.ai/",
         "x-title": "opencode",
@@ -34,19 +30,10 @@ describe("VercelPlugin", () => {
   it.effect("does not add legacy upper-case referer headers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(VercelPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("vercel", { endpoint: { type: "aisdk", package: "@ai-sdk/vercel" } })
-        catalog.provider.update(item.id, (draft) => {
-          draft.endpoint = item.endpoint
-        })
-      })
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("vercel"))).options.headers).not.toHaveProperty(
-        "HTTP-Referer",
-      )
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("vercel"))).options.headers).not.toHaveProperty("X-Title")
+      const result = yield* plugin.trigger("provider.update", {}, { provider: provider("vercel"), cancel: false })
+      expect(result.provider.options.headers).not.toHaveProperty("HTTP-Referer")
+      expect(result.provider.options.headers).not.toHaveProperty("X-Title")
     }),
   )
 
@@ -67,11 +54,9 @@ describe("VercelPlugin", () => {
   it.effect("ignores non-Vercel providers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(VercelPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => catalog.provider.update(provider("gateway").id, () => {}))
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("gateway"))).options.headers).toEqual({})
+      const result = yield* plugin.trigger("provider.update", {}, { provider: provider("gateway"), cancel: false })
+      expect(result.provider.options.headers).toEqual({})
     }),
   )
 })

packages/core/test/plugin/provider-zenmux.test.ts

@@ -1,10 +1,8 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
 import { ZenmuxPlugin } from "@opencode-ai/core/plugin/provider/zenmux"
-import { ProviderV2 } from "@opencode-ai/core/provider"
 import { expectPluginRegistered, it, provider } from "./provider-helper"
 
 describe("ZenmuxPlugin", () => {
@@ -20,41 +18,30 @@ describe("ZenmuxPlugin", () => {
   it.effect("applies the exact legacy Zenmux headers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(ZenmuxPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("zenmux", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://zenmux.ai/api/v1" },
-        })
-        catalog.provider.update(item.id, (draft) => {
-          draft.endpoint = item.endpoint
-        })
-      })
-      const result = yield* catalog.provider.get(ProviderV2.ID.make("zenmux"))
-      expect(result.options.headers).toEqual({ "HTTP-Referer": "https://opencode.ai/", "X-Title": "opencode" })
-      expect(Object.keys(result.options.headers).sort()).toEqual(["HTTP-Referer", "X-Title"])
+      const result = yield* plugin.trigger("provider.update", {}, { provider: provider("zenmux"), cancel: false })
+      expect(result.provider.options.headers).toEqual({ "HTTP-Referer": "https://opencode.ai/", "X-Title": "opencode" })
+      expect(Object.keys(result.provider.options.headers).sort()).toEqual(["HTTP-Referer", "X-Title"])
+      expect(result.cancel).toBe(false)
     }),
   )
 
   it.effect("merges legacy Zenmux headers with existing headers", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(ZenmuxPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("zenmux", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://zenmux.ai/api/v1" },
-          options: { headers: { Existing: "value" }, body: {}, aisdk: { provider: {}, request: {} } },
-        })
-        catalog.provider.update(item.id, (draft) => {
-          draft.endpoint = item.endpoint
-          draft.options = item.options
-        })
-      })
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("zenmux", {
+            options: { headers: { Existing: "value" }, body: {}, aisdk: { provider: {}, request: {} } },
+          }),
+          cancel: false,
+        },
+      )
 
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("zenmux"))).options.headers).toEqual({
+      expect(result.provider.options.headers).toEqual({
         Existing: "value",
         "HTTP-Referer": "https://opencode.ai/",
         "X-Title": "opencode",
@@ -65,25 +52,23 @@ describe("ZenmuxPlugin", () => {
   it.effect("lets configured Zenmux legacy headers override defaults", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(ZenmuxPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("zenmux", {
-          endpoint: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://zenmux.ai/api/v1" },
-          options: {
-            headers: { "HTTP-Referer": "https://example.com/", "X-Title": "custom-title" },
-            body: {},
-            aisdk: { provider: {}, request: {} },
-          },
-        })
-        catalog.provider.update(item.id, (draft) => {
-          draft.endpoint = item.endpoint
-          draft.options = item.options
-        })
-      })
+      const result = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("zenmux", {
+            options: {
+              headers: { "HTTP-Referer": "https://example.com/", "X-Title": "custom-title" },
+              body: {},
+              aisdk: { provider: {}, request: {} },
+            },
+          }),
+          cancel: false,
+        },
+      )
 
-      expect((yield* catalog.provider.get(ProviderV2.ID.make("zenmux"))).options.headers).toEqual({
+      expect(result.provider.options.headers).toEqual({
         "HTTP-Referer": "https://example.com/",
         "X-Title": "custom-title",
       })
@@ -93,23 +78,23 @@ describe("ZenmuxPlugin", () => {
   it.effect("guards legacy Zenmux headers to the exact zenmux provider id", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service
-      const catalog = yield* Catalog.Service
       yield* plugin.add(ZenmuxPlugin)
-      const load = yield* catalog.loader()
-      yield* load((catalog) => {
-        const item = provider("openrouter", {
-          options: {
-            headers: { "HTTP-Referer": "https://example.com/", "X-Title": "custom-title" },
-            body: {},
-            aisdk: { provider: {}, request: {} },
-          },
-        })
-        catalog.provider.update(item.id, (draft) => {
-          draft.options = item.options
-        })
-      })
+      const ignored = yield* plugin.trigger(
+        "provider.update",
+        {},
+        {
+          provider: provider("openrouter", {
+            options: {
+              headers: { "HTTP-Referer": "https://example.com/", "X-Title": "custom-title" },
+              body: {},
+              aisdk: { provider: {}, request: {} },
+            },
+          }),
+          cancel: false,
+        },
+      )
 
-      expect((yield* catalog.provider.get(ProviderV2.ID.openrouter)).options.headers).toEqual({
+      expect(ignored.provider.options.headers).toEqual({
         "HTTP-Referer": "https://example.com/",
         "X-Title": "custom-title",
       })

packages/llm/AGENTS.md

@@ -10,7 +10,7 @@
 
 ## Conventions
 
-Per-type constructors live on the type, not as top-level re-exports. Use `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `Model.make(...)`, `ToolDefinition.make(...)`, `ToolCallPart.make(...)`, `ToolResultPart.make(...)`, `ToolChoice.make(...)`, `ToolChoice.named(...)`, `SystemPart.make(...)`, and `GenerationOptions.make(...)` directly. The top-level `LLM` namespace is reserved for request-shaped call APIs: `LLM.request`, `LLM.generate`, `LLM.stream`, `LLM.updateRequest`, and `LLM.generateObject`. Two ways to construct the same thing is one too many.
+Per-type constructors live on the type's namespace, not as top-level re-exports. Use `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `ToolDefinition.make(...)`, `ToolCallPart.make(...)`, `ToolResultPart.make(...)`, `ToolChoice.make(...)`, `ToolChoice.named(...)`, `SystemPart.make(...)`, and `GenerationOptions.make(...)` directly. The top-level `LLM` namespace is reserved for the request-shaped call API: `LLM.request`, `LLM.generate`, `LLM.stream`, `LLM.model`, `LLM.updateRequest`, `LLM.generateObject`. Two ways to construct the same thing is one too many.
 
 ## Tests
 
@@ -21,22 +21,13 @@ Per-type constructors live on the type, not as top-level re-exports. Use `Messag
 
 This package is an Effect Schema-first LLM core. The Schema classes in `src/schema/` are the canonical runtime data model. Convenience functions in `src/llm.ts` are thin constructors that return those same Schema class instances; they should improve callsites without creating a second model.
 
-Primary in-repo integration point:
-
-- `packages/opencode/src/session/llm.ts` is the session-owned orchestration layer that decides whether a request uses AI SDK or this package's native route runtime.
-- `packages/opencode/src/session/llm/native-request.ts` is the lowering adapter from opencode's session/AI SDK-shaped data into this package's `LLMRequest` model.
-- `packages/opencode/src/session/llm/native-runtime.ts` is the execution adapter that calls `LLMClient.stream(...)` and bridges opencode tools into this package's tool runtime.
-- `packages/opencode/src/session/llm/ai-sdk.ts` keeps the default AI SDK path compatible by converting AI SDK stream parts into this package's shared `LLMEvent`s.
-
-Keep this package independent of session concerns. Session auth, permissions, plugins, telemetry headers, and runtime selection belong in `packages/opencode/src/session/llm.ts` and its local adapters.
-
 ### Request Flow
 
 The intended callsite is:
 
 ```ts
 const request = LLM.request({
-  model: OpenAI.configure({ apiKey }).responses("gpt-4o-mini"),
+  model: OpenAI.model("gpt-4o-mini", { apiKey }),
   system: "You are concise.",
   prompt: "Say hello.",
 })
@@ -44,7 +35,7 @@ const request = LLM.request({
 const response = yield * LLMClient.generate(request)
 ```
 
-`LLM.request(...)` builds an `LLMRequest`. `LLMClient.generate(...)` reads the executable route carried by `request.model.route`, builds the provider-native body, asks the route's transport for a real `HttpClientRequest.HttpClientRequest`, sends it through `RequestExecutor.Service`, parses the provider stream into common `LLMEvent`s, and finally returns an `LLMResponse`.
+`LLM.request(...)` builds an `LLMRequest`. `LLMClient.generate(...)` selects a registered route by `request.model.route`, builds the provider-native body, asks the route's transport for a real `HttpClientRequest.HttpClientRequest`, sends it through `RequestExecutor.Service`, parses the provider stream into common `LLMEvent`s, and finally returns an `LLMResponse`.
 
 Use `LLMClient.stream(request)` when callers want incremental `LLMEvent`s. Use `LLMClient.generate(request)` when callers want those same events collected into an `LLMResponse`. Use `LLMClient.prepare<Body>(request)` to compile a request through the route pipeline without sending it — the optional `Body` type argument narrows `.body` to the route's native shape (e.g. `prepare<OpenAIChatBody>(...)` returns a `PreparedRequestOf<OpenAIChatBody>`). The runtime body is identical; the generic is a type-level assertion.
 
@@ -55,8 +46,8 @@ Filter or narrow `LLMEvent` streams with `LLMEvent.is.*` (camelCase guards, e.g.
 A route is the registered, runnable composition of four orthogonal pieces:
 
 - **`Protocol`** (`src/route/protocol.ts`) — semantic API contract. Owns request body construction (`body.from`), the body schema (`body.schema`), the streaming-event schema (`stream.event`), and the event-to-`LLMEvent` state machine (`stream.step`). `Route.make(...)` validates and JSON-encodes the body from `body.schema` and decodes frames with `stream.event`. Examples: `OpenAIChat.protocol`, `OpenAIResponses.protocol`, `AnthropicMessages.protocol`, `Gemini.protocol`, `BedrockConverse.protocol`.
-- **`Endpoint`** (`src/route/endpoint.ts`) — URL construction. The host, path, and route query live on the endpoint. `Endpoint.path("/chat/completions", { baseURL })` is the common case; pass a function for paths that embed the model id or a body field (e.g. `Endpoint.path(({ body }) => `/model/${body.modelId}/converse-stream`)`).
-- **`Auth`** (`src/route/auth.ts`) — per-request transport authentication. Provider facades configure credentials onto the route before model selection, usually via `Auth.bearer(apiKey)` or `Auth.header(name, apiKey)`. Routes that need per-request signing (Bedrock SigV4, future Vertex IAM, Azure AAD) implement `Auth` as a function that signs the body and merges signed headers into the result.
+- **`Endpoint`** (`src/route/endpoint.ts`) — path construction. The host always lives on `model.baseURL`; the endpoint just supplies the path. `Endpoint.path("/chat/completions")` is the common case; pass a function for paths that embed the model id or a body field (e.g. `Endpoint.path(({ body }) => `/model/${body.modelId}/converse-stream`)`).
+- **`Auth`** (`src/route/auth.ts`) — per-request transport authentication. Routes read `model.apiKey` at request time via `Auth.bearer` (the default; sets `Authorization: Bearer <apiKey>`) or `Auth.apiKeyHeader(name)` for providers that use a custom header (Anthropic `x-api-key`, Gemini `x-goog-api-key`). Routes that need per-request signing (Bedrock SigV4, future Vertex IAM, Azure AAD) implement `Auth` as a function that signs the body and merges signed headers into the result.
 - **`Framing`** (`src/route/framing.ts`) — bytes → frames. SSE (`Framing.sse`) is shared; Bedrock keeps its AWS event-stream framing as a typed `Framing<object>` value alongside its protocol.
 
 Compose them via `Route.make(...)`:
@@ -66,52 +57,55 @@ export const route = Route.make({
   id: "openai-chat",
   provider: "openai",
   protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", {
-    baseURL: "https://api.openai.com/v1",
+  transport: HttpTransport.httpJson({
+    endpoint: Endpoint.path("/chat/completions"),
+    auth: Auth.bearer(),
+    framing: Framing.sse,
+    encodeBody,
   }),
-  auth: Auth.bearer(),
-  framing: Framing.sse,
+  defaults: {
+    baseURL: "https://api.openai.com/v1",
+    capabilities: capabilities({ tools: { calls: true, streamingInput: true } }),
+  },
 })
 ```
 
-Route defaults are request-shaping defaults such as `headers`, `limits`, `generation`, `providerOptions`, and `http`. Endpoint host/query belongs on the route endpoint. Selected `Model` values carry only model id, provider id, and the configured route value. Model capability/catalog metadata lives outside this package; protocol support is enforced by request lowering and typed `LLMError`s.
-
 The four-axis decomposition is the reason DeepSeek, TogetherAI, Cerebras, Baseten, Fireworks, and DeepInfra all reuse `OpenAIChat.protocol` verbatim — each provider deployment is a 5-15 line `Route.make(...)` call instead of a 300-400 line route clone. Bug fixes in one protocol propagate to every consumer of that protocol in a single commit.
 
-When a provider ships a non-HTTP transport (OpenAI's WebSocket Responses backend, hypothetical bidirectional streaming APIs), the seam is `Transport` — `WebSocketTransport.jsonTransport.with(...)` constructs an IO template whose `prepare` receives the route endpoint/auth at compile time, builds a WebSocket URL and message, and whose `frames` yields decoded text from the socket. Same protocol and endpoint source, different transport.
+When a provider ships a non-HTTP transport (OpenAI's WebSocket Responses backend, hypothetical bidirectional streaming APIs), the seam is `Transport` — `WebSocketTransport.json(...)` constructs a transport whose `prepare` builds a WebSocket URL and message and whose `frames` yields decoded text from the socket. Same protocol, different transport.
 
 ### URL Construction
 
-`Endpoint` owns `{ baseURL, path, query }`. Each protocol route includes a canonical endpoint when the provider has one (e.g. `https://api.openai.com/v1`); provider helpers override endpoint fields by configuring the route before selecting a model. Routes that have no canonical URL (OpenAI-compatible Chat, GitHub Copilot) require configuration before execution.
+`model.baseURL` is required; `Endpoint` only carries the path. Each protocol's `Route.make` includes a canonical URL in `defaults.baseURL` (e.g. `https://api.openai.com/v1`); provider helpers can override by passing `baseURL` in their input. Routes that have no canonical URL (OpenAI-compatible Chat, GitHub Copilot) set `baseURL: string` (required) on their input type so TypeScript catches a missing host at the call site.
 
-For providers where the URL is derived from typed inputs (Azure resource name, Bedrock region), the provider helper configures the route endpoint before calling `.model(...)`. Use `AtLeastOne<T>` from `route/auth-options.ts` for inputs that accept either of two derivation paths (Azure: `resourceName` or `baseURL`).
+For providers where the URL is derived from typed inputs (Azure resource name, Bedrock region), the provider helper computes `baseURL` at model construction time. Use `AtLeastOne<T>` from `route/auth-options.ts` for inputs that accept either of two derivation paths (Azure: `resourceName` or `baseURL`).
 
-### Provider Facades
+### Provider Definitions
 
-Provider-facing APIs are configured facades over route values. Endpoint/auth/resource/API-version setup happens before model selection, and model selectors accept only a model or deployment id:
+Provider-facing APIs are defined with `Provider.make(...)` from `src/provider.ts`:
 
 ```ts
-const openai = OpenAI.configure({ apiKey, baseURL })
-const model = openai.responses("gpt-4o-mini")
+export const provider = Provider.make({
+  id: ProviderID.make("openai"),
+  model: responses,
+  apis: { responses, chat },
+})
 
-const azure = Azure.configure({ resourceName, apiKey, apiVersion: "v1" })
-const deployment = azure.responses("my-deployment")
-
-const gateway = CloudflareAIGateway.configure({ accountId, gatewayId, gatewayApiKey, apiKey })
-const proxied = gateway.model("openai/gpt-4o-mini")
+export const model = provider.model
+export const apis = provider.apis
 ```
 
-Keep provider facades small and explicit:
+Keep provider definitions small and explicit:
 
+- Use only `id`, `model`, and optional `apis` in `Provider.make(...)`.
 - Use branded `ProviderID.make(...)` and `ModelID.make(...)` where ids are constructed directly.
-- Use `model` for the default API path and named methods for provider-native alternatives such as OpenAI `responses`, `responsesWebSocket`, and `chat`.
-- Put provider-specific setup on `.configure(...)`; do not add `model(id, overrides)` as a duplicate construction path.
+- Use `model` for the default API path and `apis` for named provider-native alternatives such as OpenAI `responses` versus `chat`.
+- Do not add author-facing `kind`, `version`, or `routes` fields.
 - Export lower-level `routes` arrays separately only when advanced internal wiring needs them.
 - Prefer `apiKey` as provider-specific sugar and `auth` as the explicit override; keep them mutually exclusive in provider option types with `ProviderAuthOption`.
 - Resolve `apiKey` → `Auth` with `AuthOptions.bearer(options, "<PROVIDER>_API_KEY")` (it honors an explicit `auth` override and falls back to `Auth.config(envVar)` so missing keys surface a typed `Authentication` error rather than a runtime crash).
-- Use separate top-level facades for products with different required setup, such as `CloudflareAIGateway` and `CloudflareWorkersAI`.
 
-`Provider.make(...)` remains available for simple static provider definitions, but new built-in providers should prefer plain configured facades unless a helper removes real duplication without adding runtime behavior.
+Built-in providers are namespace modules from `src/providers/index.ts`, so aliases like `OpenAI.model(...)`, `OpenAI.responses(...)`, and `OpenAI.apis.chat(...)` are fine. External provider packages should default-export the `Provider.make(...)` result and may add named aliases if useful.
 
 ### Folder layout
 
@@ -119,7 +113,7 @@ Keep provider facades small and explicit:
 packages/llm/src/
   schema/                   canonical Schema model, split by concern
     ids.ts                  branded IDs, literal types, ProviderMetadata
-    options.ts              Generation/Provider/Http options, Limits, Model, cache policy
+    options.ts              Generation/Provider/Http options, Capabilities, Limits, ModelRef
     messages.ts             content parts, Message, ToolDefinition, LLMRequest
     events.ts               Usage, individual events, LLMEvent, PreparedRequest, LLMResponse
     errors.ts               error reasons, LLMError, ToolFailure
@@ -151,12 +145,12 @@ packages/llm/src/
   providers/
     openai-compatible.ts    generic compatible helper + family model helpers
     openai-compatible-profile.ts family defaults (deepseek, togetherai, ...)
-    azure.ts / amazon-bedrock.ts / cloudflare.ts / github-copilot.ts / google.ts / xai.ts / openai.ts / anthropic.ts / openrouter.ts
+    azure.ts / amazon-bedrock.ts / github-copilot.ts / google.ts / xai.ts / openai.ts / anthropic.ts / openrouter.ts
   tool.ts                   typed tool() helper
   tool-runtime.ts           implementation helpers for LLMClient tool execution
 ```
 
-The dependency arrow points down: `providers/*.ts` files import protocol routes and auth-option utilities; protocol modules import `endpoint`, `auth`, `framing`, and transport pieces. Protocols do not import provider facades. Lower-level modules know nothing about provider catalog metadata.
+The dependency arrow points down: `providers/*.ts` files import `protocols`, `endpoint`, `auth`, and `framing`; protocols do not import provider metadata. Lower-level modules know nothing about specific providers.
 
 ### Shared protocol helpers
 
@@ -251,14 +245,14 @@ Use this order for every protocol module:
 5. Request body construction (`fromRequest`)
 6. Stream parsing (`step` and per-event handlers)
 7. Protocol and route
-8. Protocol route export
+8. Model helper
 
 ### Rules
 
 - Keep protocol files focused on the protocol. Move provider-specific projection, signing, media normalization, or other bulky transformations into `src/protocols/utils/*`.
 - Use `Effect.fn("Provider.fromRequest")` for request body construction entrypoints. Use `Effect.fn(...)` for event handlers that yield effects; keep purely synchronous handlers as plain functions returning a `StepResult` that the dispatcher lifts via `Effect.succeed(...)`.
-- Parser state owns terminal information. The state machine records finish reason, usage, and pending tool calls; emit one terminal `finish` event (or `provider-error`) for each completed response. If a provider splits reason and usage across events, merge them in parser state before flushing.
-- Emit exactly one terminal `finish` event for a completed response, normally after a matching `step-finish`. Use `stream.terminal` to stop reading when the provider has a completion sentinel; use `stream.onHalt` when the final event must be flushed after the framed stream ends.
+- Parser state owns terminal information. The state machine records finish reason, usage, and pending tool calls; emit one terminal `request-finish` (or `provider-error`) when a `terminal` event arrives. If a provider splits reason and usage across events, merge them in parser state before flushing.
+- Emit exactly one terminal `request-finish` event for a completed response. Use `stream.terminal` to signal the run is over and have `step` emit the final event.
 - Use shared helpers for repeated protocol policy such as text joining, usage totals, JSON parsing, and tool-call accumulation. `ToolStream` (`protocols/utils/tool-stream.ts`) accumulates streamed tool-call arguments uniformly.
 - Make intentional provider differences explicit in helper names or comments. If two protocol files differ visually, the reason should be obvious from the names.
 - Prefer dispatched per-event handlers (`onMessageStart`, `onContentBlockDelta`, ...) called from a small top-level `step` switch over a long if-chain. The dispatcher keeps the event surface visible at a glance.

packages/llm/README.md

@@ -7,7 +7,7 @@ import { Effect } from "effect"
 import { LLM, LLMClient } from "@opencode-ai/llm"
 import { OpenAI } from "@opencode-ai/llm/providers"
 
-const model = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).responses("gpt-4o-mini")
+const model = OpenAI.model("gpt-4o-mini", { apiKey: process.env.OPENAI_API_KEY })
 
 const request = LLM.request({
   model,
@@ -28,10 +28,10 @@ Run `LLMClient.stream(request)` instead of `generate` when you want incremental
 
 - **`LLM.request({...})`** — build a provider-neutral `LLMRequest`. Accepts ergonomic inputs (`system: string`, `prompt: string`) that normalize into the canonical Schema classes.
 - **`LLM.generate` / `LLM.stream`** — re-exported from `LLMClient` for one-import use.
-- **`Message.user(...)` / `Message.assistant(...)` / `Message.tool(...)`** — message constructors from the canonical schema model.
-- **`Model.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model.
+- **`LLM.user(...)` / `LLM.assistant(...)` / `LLM.toolMessage(...)`** — message constructors.
+- **`LLM.toolCall(...)` / `LLM.toolResult(...)` / `LLM.toolDefinition(...)`** — tool-related parts.
 - **`LLMClient.prepare(request)`** — compile a request through protocol body construction, validation, and HTTP preparation without sending. Useful for inspection and testing.
-- **`LLMEvent.is.*`** — typed guards (`is.textDelta`, `is.toolCall`, `is.finish`, …) for filtering streams.
+- **`LLMEvent.is.*`** — typed guards (`is.text`, `is.toolCall`, `is.requestFinish`, …) for filtering streams.
 
 ## Caching
 
@@ -92,19 +92,17 @@ Normalized cache usage is read back into `response.usage.cacheReadInputTokens` a
 
 ## Providers
 
-Provider facades configure endpoint/auth/deployment details first, then expose model selectors that take only a model or deployment id. The selected model carries the executable route value used at runtime.
+Each provider exports a `model(...)` helper that records identity, protocol, capabilities, auth, and defaults.
 
 ```ts
-import { OpenAI, CloudflareAIGateway } from "@opencode-ai/llm/providers"
+import { Anthropic } from "@opencode-ai/llm/providers"
 
-const openai = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).responses("gpt-4o-mini")
-const gateway = CloudflareAIGateway.configure({
-  accountId: process.env.CLOUDFLARE_ACCOUNT_ID,
-  gatewayApiKey: process.env.CLOUDFLARE_API_TOKEN,
-}).model("workers-ai/@cf/meta/llama-3.1-8b-instruct")
+const model = Anthropic.model("claude-sonnet-4-6", {
+  apiKey: process.env.ANTHROPIC_API_KEY,
+})
 ```
 
-Included providers: OpenAI, Anthropic, Google (Gemini), Amazon Bedrock, Azure OpenAI, Cloudflare AI Gateway, Cloudflare Workers AI, GitHub Copilot, OpenRouter, xAI, plus generic OpenAI-compatible helpers for DeepSeek, Cerebras, Groq, Fireworks, Together, etc.
+Included providers: OpenAI, Anthropic, Google (Gemini), Amazon Bedrock, Azure OpenAI, Cloudflare, GitHub Copilot, OpenRouter, xAI, plus generic OpenAI-compatible helpers for DeepSeek, Cerebras, Groq, Fireworks, Together, etc.
 
 ## Provider options & HTTP overlays
 
@@ -114,15 +112,15 @@ Three escape hatches in order of stability:
 2. **`providerOptions: { <provider>: {...} }`** — typed-at-the-facade provider-specific knobs (OpenAI `promptCacheKey`, Anthropic `thinking`, Gemini `thinkingConfig`, OpenRouter routing).
 3. **`http: { body, headers, query }`** — last-resort serializable overlays merged into the final HTTP request. Reach for this only when a stable typed path doesn't yet exist.
 
-Route/provider defaults are overridden by request-level values for each axis.
+Model-level defaults are overridden by request-level values for each axis.
 
 ## Routes
 
-Adding a new model or deployment is usually 5-15 lines using `Route.make({ protocol, endpoint, auth, framing, ... })`. The route owns endpoint/auth/framing and the protocol owns body construction plus stream parsing. Transports are reusable IO templates that receive route endpoint/auth at compile time. Capability/catalog metadata lives outside this low-level package; unsupported request shapes fail during protocol lowering. See `AGENTS.md` for the architectural detail.
+Adding a new model or deployment is usually 5–15 lines using `Route.make({ protocol, transport, ... })`. The four orthogonal pieces are protocol (body construction + stream parsing), transport (endpoint + auth + framing + encoding), defaults, and capabilities. See `AGENTS.md` for the architectural detail.
 
 ## Effect
 
-This package is built on Effect. Public methods return `Effect` or `Stream`; provide `LLMClient.layer` for runtime dispatch and import the provider/protocol modules for the routes you use. The example at `example/tutorial.ts` is a runnable walkthrough.
+This package is built on Effect. Public methods return `Effect` or `Stream`; provide `LLMClient.layer` (the default registers every shipped route) for runtime dispatch. The example at `example/tutorial.ts` is a runnable walkthrough.
 
 ## See also
 

packages/llm/example/call-sites.md

@@ -1,591 +0,0 @@
-# LLM Call Site Sketches
-
-Scratchpad for examples first, abstractions second. Current direction: routes
-execute, provider facades organize configured route sets, and models carry route
-values directly.
-
-## Conversation Summary
-
-Kit and Aidan want provider-specific LLM behavior to move out of opencode's AI
-SDK transform path and into `packages/llm` where possible. The goal is not a big
-generic transform layer; the goal is small composable route definitions backed by
-recorded golden tests.
-
-Things to keep testing against:
-
-- Cache placement: `cache: "auto"`, manual cache breakpoints, provider cache usage.
-- Images: golden image tests for providers/protocols that claim image support.
-- Reasoning: canonical reasoning parts/events versus provider-native knobs.
-- Auth: bearer, custom headers, multiple credentials, query auth, SigV4, OAuth, no auth.
-- OpenAI-compatible providers: DeepSeek, Together, Groq, Alibaba/DashScope, custom routers.
-- Provider switching: stale signatures, encrypted reasoning, provider metadata, incompatible parts.
-- Error quality: typed errors instead of generic SDK/server failures.
-
-## Final Guide: Routes Execute, Providers Organize
-
-Do not introduce a first-class `Deployment` abstraction unless it gains real
-semantics. Provider facades are ergonomic configured route groups, not execution
-registries. The executable/composable thing is still a route. Do not make route
-construction publish to a global registry; models should carry their route value
-directly.
-
-Keep durable identity separate from runtime capability:
-
-- Durable identity is small serializable data like `{ providerID, modelID }` for
-  config, sessions, logs, and catalogs.
-- Runtime capability is a `Model` with a route value, protocol, transport, auth,
-  and defaults. It is allowed to contain functions and schemas.
-- If persisted identity needs to become executable, resolve it through an app
-  boundary first. Do not make `LLMRequest` recover behavior from a global route
-  side table.
-
-Keep unconfigured behavior values as values, not factories. A transport like
-`HttpTransport.sseJson` should be a reusable immutable value. Use a function only
-when the caller supplies options or when construction needs fresh state.
-
-Use constants to remove repetition before inventing abstractions. Provider ids
-are branded once per provider facade and reused across routes; a plain exported
-object is enough for the provider-facing API unless a helper earns its keep by
-removing repeated route projection.
-
-Expose default configured provider instances, and put provider-specific setup on
-`.configure(...)`. Model selectors stay pure: `model(id)`, `responses(id)`,
-`chat(id)`, etc. Endpoint/auth/resource/api-version configuration happens before
-model selection, not as a second argument to model selection.
-
-Use provider/product facades consistently:
-
-- One coherent provider/product config surface gets one top-level facade.
-- APIs/model kinds that share that config are methods on the facade.
-- Different products with different required config get separate top-level
-  facades, not a shared namespace with unrelated children.
-- Default facades are exposed only when concrete defaults or lazy env/credential
-  defaults make the facade valid.
-
-Examples:
-
-```ts
-OpenAI.responses("gpt-4o")
-OpenAI.chat("gpt-4o")
-OpenAI.responsesWebSocket("gpt-4o")
-
-Azure.configure({ resourceName, apiKey }).responses("my-deployment")
-AmazonBedrock.configure({ region, credentials }).model("anthropic.claude-3-5-sonnet-20241022-v2:0")
-
-CloudflareAIGateway.configure({ accountId, gatewayId, gatewayApiKey, apiKey }).model("openai/gpt-4o")
-CloudflareWorkersAI.configure({ accountId, apiKey }).model("@cf/meta/llama-3.1-8b-instruct")
-
-OpenAICompatible.configure({
-  provider: "custom",
-  baseURL: "https://custom.example/v1",
-  auth: Auth.bearer(apiKey),
-}).model("custom-model")
-```
-
-Standardize the provider facade contract before abstracting construction. A
-plain object is enough at first; add a helper only if repeated route projection
-starts hiding the real provider-specific config.
-
-`Route.with(...)` patch semantics should be boring and explicit:
-
-- Omitted fields inherit from the original route.
-- `endpoint` patches merge with the existing endpoint, so overriding `baseURL`
-  keeps the existing `path`.
-- `endpoint.query` merges by default; later values win.
-- `auth` replaces.
-- `headers` merge by default; undefined values are omitted.
-- `id` is optional in patches. Route ids are diagnostic/provider API labels, not
-  global runtime registry keys.
-
-1. **Route**
-   - route id
-   - provider id
-   - protocol
-   - body schema
-   - body builder
-   - stream event schema
-   - parser/state machine
-   - transport
-     - method / IO shape
-     - framing
-     - request preparation
-     - constants when unconfigured; functions only when configured
-   - endpoint
-     - base URL
-     - static path
-     - body/model-derived path
-     - query params
-   - auth
-     - bearer
-     - custom header
-     - multiple credentials
-     - SigV4
-     - none
-   - defaults
-     - headers
-     - generation defaults
-     - provider options
-     - limits
-2. **Provider Facade**
-   - default configured provider instance
-   - provider-specific `.configure(...)`
-   - plain object/function facade over one or more routes
-   - top-level export only when it represents one coherent config surface
-   - no passive `Provider.make(...)` wrapper unless it gains runtime behavior
-3. **Model Selector**
-   - route/provider-owned selector
-   - accepts model id only
-   - returns executable models
-   - does not accept endpoint/auth/deployment overrides
-4. **Model**
-   - model id
-   - route value
-   - provider id
-   - configured route value at selection time
-5. **LLM Request**
-   - model
-   - messages/tools
-   - generation/cache/reasoning/response-format options
-   - request-level HTTP overlays for per-request headers/query/body additions,
-     not provider endpoint/auth reconfiguration
-6. **Compile**
-   - read route from model
-   - merge route defaults and request overrides
-   - build final URL from route endpoint
-   - apply auth from the configured route
-   - build body with protocol
-   - execute with transport and parse with protocol
-
-## Provider Facade Shape
-
-The provider abstraction is a facade over configured routes, not the runtime
-execution mechanism:
-
-```ts
-type ProviderFacade<APIs, Config> = {
-  readonly id: ProviderID
-  readonly model: (id: string) => Model
-  readonly configure: (input?: Config) => ProviderFacade<APIs, Config>
-} & APIs
-```
-
-Manual construction is fine and should be the default until duplication earns a
-helper:
-
-```ts
-export const OpenAI = {
-  id: openAIProvider,
-  model: openAIResponses.model,
-  responses: openAIResponses.model,
-  chat: openAIChat.model,
-  configure: configureOpenAI,
-} satisfies ProviderFacade<
-  {
-    responses: (id: string) => Model
-    chat: (id: string) => Model
-  },
-  OpenAIConfig
->
-```
-
-If several providers repeat the same projection from route values to model
-methods, the helper can stay deliberately tiny:
-
-```ts
-const configureOpenAI = (input: OpenAIConfig = {}) =>
-  Provider.define({
-    id: openAIProvider,
-    routes: {
-      responses: openAIResponses.with(openAIConfig(input)),
-      chat: openAIChat.with(openAIConfig(input)),
-    },
-    default: "responses",
-    configure: configureOpenAI,
-  })
-
-export const OpenAI = configureOpenAI()
-```
-
-`Provider.define(...)` would only project route methods and preserve types:
-
-```ts
-OpenAI.model("gpt-4o")
-OpenAI.responses("gpt-4o")
-OpenAI.chat("gpt-4o")
-OpenAI.configure({ apiKey }).responses("gpt-4o")
-```
-
-It must not register routes, select routes dynamically, or participate in
-execution. Execution still reads the route value carried by the model.
-
-## Ideal Call Sites
-
-Define concrete routes for a native provider, then project them through a
-provider facade:
-
-```ts
-const openAIProvider = ProviderID.make("openai")
-
-const openAIResponses = Route.make({
-  id: "openai-responses",
-  provider: openAIProvider,
-  protocol: OpenAIResponses.protocol,
-  transport: HttpTransport.sseJson,
-  endpoint: {
-    baseURL: "https://api.openai.com/v1",
-    path: "/responses",
-  },
-  auth: Auth.envBearer("OPENAI_API_KEY"),
-})
-
-const openAIChat = Route.make({
-  id: "openai-chat",
-  provider: openAIProvider,
-  protocol: OpenAIChat.protocol,
-  transport: HttpTransport.sseJson,
-  endpoint: {
-    baseURL: "https://api.openai.com/v1",
-    path: "/chat/completions",
-  },
-  auth: Auth.envBearer("OPENAI_API_KEY"),
-})
-
-const openAIResponsesWebSocket = openAIResponses.with({
-  id: "openai-responses-websocket",
-  transport: WebSocketTransport.json,
-})
-
-const openAIConfig = (input: OpenAIConfig) => ({
-  endpoint: input.endpoint,
-  auth: input.auth ?? (input.apiKey ? Auth.bearer(input.apiKey) : undefined),
-  headers: {
-    "OpenAI-Organization": input.organization,
-    "OpenAI-Project": input.project,
-  },
-})
-
-const configureOpenAI = (input: OpenAIConfig = {}) => {
-  const responses = openAIResponses.with(openAIConfig(input))
-  const responsesWebSocket = openAIResponsesWebSocket.with(openAIConfig(input))
-  const chat = openAIChat.with(openAIConfig(input))
-
-  return {
-    id: openAIProvider,
-    responses: responses.model,
-    responsesWebSocket: responsesWebSocket.model,
-    chat: chat.model,
-    model: responses.model,
-    configure: configureOpenAI,
-  }
-}
-
-export const OpenAI = configureOpenAI()
-```
-
-Specialize it functionally for concrete providers:
-
-```ts
-const deepSeekProvider = ProviderID.make("deepseek")
-
-const deepseekChat = openAIChat.with({
-  id: "deepseek-chat",
-  provider: deepSeekProvider,
-  endpoint: {
-    baseURL: "https://api.deepseek.com/v1",
-  },
-  auth: Auth.envBearer("DEEPSEEK_API_KEY"),
-})
-
-const configureDeepSeek = (input: OpenAICompatibleConfig = {}) => {
-  const route = deepseekChat.with({
-    endpoint: input.endpoint,
-    auth: input.auth ?? (input.apiKey ? Auth.bearer(input.apiKey) : undefined),
-  })
-
-  return {
-    id: deepSeekProvider,
-    model: route.model,
-    configure: configureDeepSeek,
-  }
-}
-
-export const DeepSeek = {
-  id: deepSeekProvider,
-  model: deepseekChat.model,
-  configure: configureDeepSeek,
-}
-```
-
-Provider-specific configuration happens before model selection:
-
-```ts
-const deepseek = DeepSeek.configure({
-  endpoint: {
-    baseURL: "https://proxy.example.com/v1",
-  },
-  auth: Auth.bearer(apiKey),
-})
-
-const model = deepseek.model("deepseek-chat")
-```
-
-Final request call site stays boring:
-
-```ts
-const response =
-  yield *
-  LLM.generate(
-    LLM.request({
-      model: DeepSeek.model("deepseek-chat"),
-      prompt: "Hello.",
-    }),
-  )
-```
-
-HTTP versus WebSocket is represented as named route selectors, not as model or
-request overrides. Same protocol, different transport, different route:
-
-```ts
-OpenAI.responses("gpt-4o")
-OpenAI.responsesWebSocket("gpt-4o")
-```
-
-The client should not require a different public layer just because a selected
-route uses WebSocket. Use one `LLMClient.layer` with HTTP and WebSocket runtime
-capabilities available; routes that do not need WebSocket simply never touch it.
-If a WebSocket route is selected in an environment without WebSocket support,
-fail with a typed transport configuration error.
-
-Azure is a route specialization with auth/path/default changes plus input
-mapping. The public API configures the Azure resource once, then selects
-deployment ids with pure model selectors:
-
-```ts
-const azureProvider = ProviderID.make("azure")
-
-const azureResponses = openAIResponses.with({
-  id: "azure-openai-responses",
-  provider: azureProvider,
-  auth: Auth.envHeader("api-key", "AZURE_OPENAI_API_KEY"),
-})
-
-const configureAzure = (input: AzureConfig = {}) => {
-  const route = azureResponses.with({
-    endpoint: {
-      baseURL:
-        input.baseURL ??
-        Endpoint.envBaseURL(
-          "AZURE_RESOURCE_NAME",
-          (resourceName) => `https://${resourceName}.openai.azure.com/openai/v1`,
-        ),
-      query: { "api-version": input.apiVersion ?? "v1" },
-    },
-    auth: input.apiKey ? Auth.header("api-key", input.apiKey) : Auth.envHeader("api-key", "AZURE_OPENAI_API_KEY"),
-  })
-
-  return {
-    id: azureProvider,
-    model: route.model,
-    responses: route.model,
-    configure: configureAzure,
-  }
-}
-
-export const Azure = configureAzure()
-
-const azure = Azure.configure({
-  resourceName: "my-resource",
-  apiVersion: "v1",
-})
-
-const model = azure.responses("my-deployment")
-```
-
-Default provider facades are only valid when required configuration has a lazy
-default source. `Azure.responses("my-deployment")` can be valid if endpoint
-resolution reads `AZURE_RESOURCE_NAME` lazily and fails with a typed
-configuration error when missing. If a provider has no sensible lazy default,
-do not expose a default model selector; expose only a configured entrypoint.
-
-Cloudflare AI Gateway and Workers AI are separate product facades because their
-configuration surfaces differ. Do not make a root `Cloudflare.configure(...)`
-pretend there is one coherent Cloudflare provider configuration:
-
-```ts
-const cloudflareProvider = ProviderID.make("cloudflare-ai-gateway")
-
-const cloudflareOpenAIChat = openAIChat.with({
-  id: "cloudflare-ai-gateway-openai-chat",
-  provider: cloudflareProvider,
-  auth: Auth.bearerHeader("cf-aig-authorization").andThen(Auth.bearer()),
-})
-
-const configureCloudflareAIGateway = (input: CloudflareAIGatewayConfig) => {
-  const route = cloudflareOpenAIChat.with({
-    endpoint: {
-      baseURL: `https://gateway.ai.cloudflare.com/v1/${input.accountId}/${input.gatewayId}/openai`,
-    },
-    auth: Auth.bearerHeader("cf-aig-authorization", input.gatewayApiKey).andThen(Auth.bearer(input.apiKey)),
-  })
-
-  return {
-    id: cloudflareProvider,
-    model: (modelID: string) => route.model({ id: modelID }),
-    configure: configureCloudflareAIGateway,
-  }
-}
-
-export const CloudflareAIGateway = {
-  id: cloudflareProvider,
-  configure: configureCloudflareAIGateway,
-}
-
-const gateway = CloudflareAIGateway.configure({
-  accountId: "account",
-  gatewayId: "gateway",
-  gatewayApiKey,
-  apiKey,
-})
-
-const model = gateway.model("openai/gpt-4o")
-```
-
-If a Cloudflare product gains a full lazy env default, it can expose a direct
-selector too. Until then, omitting `CloudflareAIGateway.model(...)` makes missing
-account/gateway configuration unrepresentable.
-
-opencode's dynamic runtime should construct executable models at its app
-boundary instead of exposing a giant unstructured public model constructor or a
-generic dynamic resolver:
-
-```ts
-const model =
-  providerID === "azure"
-    ? Azure.configure(resolvedAzureConfig).responses(apiModelID)
-    : endpoint.websocket
-      ? OpenAI.responsesWebSocket(apiModelID)
-      : OpenAI.responses(apiModelID)
-```
-
-That boundary can branch on durable config/catalog metadata and call typed
-provider APIs directly. Transport selection belongs there too: map metadata like
-`endpoint.websocket` to `OpenAI.responsesWebSocket(apiModelID)`; otherwise use
-the normal `OpenAI.responses(apiModelID)` route. The client runtime only executes
-the route carried by the model.
-
-## Competitive Shape
-
-This follows the strongest parts of adjacent libraries:
-
-- AI SDK: configured provider instances expose provider-specific model methods.
-- Effect AI: executable models carry provider requirements and can be resolved by
-  an app boundary.
-- LiteLLM/opencode config: dynamic `providerID/modelID` branching belongs at the
-  app boundary, not in the typed public provider API or a global runtime
-  resolver.
-- LangChain/LlamaIndex: constructor-style config plus model id is convenient,
-  but we avoid making model selection also configure endpoint/auth.
-
-The chosen split is:
-
-```txt
-Route = execution mechanics
-Provider facade = configured route group
-Model = selected executable model carrying route value
-App boundary = explicit durable-config -> typed-provider call
-```
-
-## What This Removes
-
-- No `Provider.make(...)` as a core abstraction.
-- No `Provider.make(...)` wrapper just to bind an id to model functions. Use a
-  branded provider id constant and a plain exported provider facade.
-- No `Deployment.define(...)` unless future examples force it.
-- No global route registry as the normal execution path.
-- No import side effects required before a model can execute.
-- No duplicate `provider.id` object when selected models already carry provider
-  id.
-- No `model(id, overrides)` escape hatch. Model selection takes the model id;
-  endpoint/auth/deployment customization happens by configuring the route first.
-- No transport override on model/request. HTTP SSE versus WebSocket is a named
-  route selector such as `responses` versus `responsesWebSocket`.
-- No separate public `LLMClient.layerWithWebSocket`. The runtime should expose one
-  client layer with the available transport capabilities.
-- No executable `ModelRef`. The executable handle is `Model`; durable model
-  identity stays separate and cannot execute on its own.
-
-## Implementation Todo
-
-- [x] Replace the current executable `ModelRef` with `Model`.
-- [x] Change `Model.route` to carry a route value, not a `RouteID` string.
-- [ ] Keep a separate durable model identity type for persisted/session/catalog
-      data, likely `{ providerID, modelID }`, and make it clear that it cannot
-      execute without resolver context.
-- [x] Change route model selectors so `route.model(id)` returns an executable
-      model with the route value attached, not a globally registered route id.
-- [x] Remove the standalone `Route.model(route, defaults, mapInput)` helper;
-      configured route instances own model selection.
-- [x] Remove endpoint/auth escape hatches from route model selection; callers must
-      configure endpoint/auth through `route.with(...)` or provider facades before
-      calling `.model(...)`.
-- [x] Remove request-shaping defaults from `Model`; selected models now carry only
-      id, provider, and configured route while defaults live on routes or requests.
-- [x] Rework `LLMClient.prepare` / `stream` / `generate` to read
-      `request.model.route` directly instead of calling `registeredRoute(...)`.
-- [x] Remove `Route.make(...)` global registration from the normal execution
-      path; keep route ids only as diagnostics/provider API labels.
-- [x] Model endpoint as `{ baseURL, path, query }` on routes, then remove the
-      current split where host/query live on the model and path lives in route
-      transport setup.
-- [x] Define `Route.with(...)` with explicit patch semantics for endpoint merge,
-      query merge, header merge, auth replacement, and optional diagnostic id.
-- [x] Make unconfigured transports reusable constants such as
-      `HttpTransport.sseJson`; keep transport functions only for configured/fresh
-      state construction.
-- [x] Collapse the public WebSocket runtime split so one `LLMClient.layer`
-      exposes available transport capabilities and selected routes fail with typed
-      transport config errors when a required capability is missing.
-- [x] Convert OpenAI provider APIs to provider-facade shape:
-      `OpenAI.configure(config).responses(id)`, `.chat(id)`, and
-      `.responsesWebSocket(id)`.
-- [x] Convert Azure to a configured facade where resource/base URL/api version
-      setup happens before selecting deployment ids.
-- [x] Split Cloudflare products into separate facades such as
-      `CloudflareAIGateway` and `CloudflareWorkersAI`; do not expose a shared root
-      config surface unless one product actually exists.
-- [x] Migrate remaining built-in provider facades one at a time so configuration
-      happens before model selection and selectors accept only ids:
-      xAI, GitHub Copilot, OpenRouter, OpenAI-compatible families, Anthropic,
-      Google/Gemini, and Amazon Bedrock now use configured facades such as
-      `Provider.configure(options).model(id)` with named selectors where needed.
-- [ ] Decide whether a tiny `Provider.define(...)` helper is warranted after two
-      or three provider conversions; start with plain objects if duplication is not
-      yet painful.
-- [x] Update `packages/opencode/src/session/llm/native-request.ts` to construct
-      executable models at the session boundary with explicit provider facade
-      calls, mapping catalog metadata such as `endpoint.websocket` to the correct
-      named route selector.
-- [ ] Update tests so direct route/provider tests assert route values are carried
-      by executable models, and opencode/native tests assert boundary-based route
-      selection.
-- [ ] Remove compatibility exports or stale docs only after internal call sites
-      are migrated; do not keep duplicate constructor paths without an external
-      compatibility need.
-
-## Open Questions
-
-- Default facades with required setup: should providers like Azure and Bedrock
-  expose default model selectors only when all required setup has lazy env or
-  credential-chain defaults? If not, omit the default selector so missing config
-  is impossible at the type/API level.
-- Lazy endpoint/auth values: should `Endpoint.envBaseURL(...)` and env-backed
-  auth produce typed configuration/authentication errors at compile/prepare time
-  or only when executing the transport?
-- `Route.with(...)` clearing semantics: endpoint/query/header patches merge by
-  default, but what is the explicit way to remove an inherited value?
-- Provider facade helper: keep plain objects until duplication hurts, or add a
-  tiny `Provider.define(...)` immediately to enforce shape and method projection?
-- Auth shape: should auth stay as today's composable `Auth`, or split into an
-  auth placement/strategy and credential sources?
-- Naming: is `baseURL` still the right endpoint field name, or should it be
-  `origin` / `urlPrefix` to clarify that route `path` is appended?

packages/llm/example/tutorial.ts

@@ -1,6 +1,6 @@
 import { Config, Effect, Formatter, Layer, Schema, Stream } from "effect"
-import { LLM, LLMClient, ProviderID, Tool } from "@opencode-ai/llm"
-import { Route, Auth, Endpoint, Framing, Protocol, RequestExecutor, WebSocketExecutor } from "@opencode-ai/llm/route"
+import { LLM, LLMClient, Provider, ProviderID, Tool, type ProviderModelOptions } from "@opencode-ai/llm"
+import { Route, Auth, Endpoint, Framing, Protocol, RequestExecutor } from "@opencode-ai/llm/route"
 import { OpenAI } from "@opencode-ai/llm/providers"
 
 /**
@@ -18,18 +18,18 @@ const apiKey = Config.redacted("OPENAI_API_KEY")
 
 // 1. Pick a model. The provider helper records provider identity, protocol
 // choice, capabilities, deployment options, authentication, and defaults.
-const model = OpenAI.configure({
+const model = OpenAI.model("gpt-4o-mini", {
   apiKey,
   generation: { maxTokens: 160 },
   providerOptions: {
     openai: { store: false },
   },
-}).model("gpt-4o-mini")
+})
 
 // 2. Build a provider-neutral request. This is useful when reusing one request
 // across generate and stream examples.
 //
-// Options can live on both the configured route/provider facade and the request:
+// Options can live on both the model and the request:
 //
 //   - `generation`: common controls such as max tokens, temperature, topP/topK,
 //     penalties, seed, and stop sequences.
@@ -39,7 +39,7 @@ const model = OpenAI.configure({
 //   - `http`: last-resort serializable overlays for final request body, headers,
 //     and query params. Prefer typed `providerOptions` when a field is stable.
 //
-// Route/provider options are defaults. Request options override them for this call.
+// Model options are defaults. Request options override them for this call.
 const request = LLM.request({
   model,
   system: "You are concise and practical.",
@@ -193,22 +193,19 @@ const FakeProtocol = Protocol.make<FakeBody, string, string, void>({
 // axes that the protocol deliberately does not know: URL, auth, and framing.
 const FakeAdapter = Route.make({
   id: "fake-echo",
-  provider: "fake-echo",
   protocol: FakeProtocol,
-  endpoint: Endpoint.path("/v1/echo", { baseURL: "https://fake.local" }),
+  endpoint: Endpoint.path("/v1/echo"),
   auth: Auth.passthrough,
   framing: Framing.sse,
 })
 
-// A provider module exports a configured facade. Configuration happens before
-// model selection; model selectors accept ids only.
-const FakeEcho = {
+// A provider module exports a Provider definition. The default `model` helper
+// sets provider identity, protocol id, and the route id resolved by the registry.
+const fakeEchoModel = Route.model(FakeAdapter, { provider: "fake-echo", baseURL: "https://fake.local" })
+const FakeEcho = Provider.make({
   id: ProviderID.make("fake-echo"),
-  configure: () => ({
-    id: ProviderID.make("fake-echo"),
-    model: (id: string) => FakeAdapter.model({ id }),
-  }),
-}
+  model: (id: string, options: ProviderModelOptions = {}) => fakeEchoModel({ id, ...options }),
+})
 
 // `LLMClient.prepare` is the lower-level inspection hook: it compiles through
 // body conversion, validation, endpoint, auth, and HTTP construction without
@@ -216,7 +213,7 @@ const FakeEcho = {
 const inspectFakeProvider = Effect.gen(function* () {
   const prepared = yield* LLMClient.prepare(
     LLM.request({
-      model: FakeEcho.configure().model("tiny-echo"),
+      model: FakeEcho.model("tiny-echo"),
       prompt: "Show me the provider pipeline.",
     }),
   )
@@ -230,8 +227,7 @@ const inspectFakeProvider = Effect.gen(function* () {
 // enabled at a time so the tutorial can demonstrate generate, prepare, stream,
 // or tool-loop behavior without spending tokens on every example.
 const requestExecutorLayer = RequestExecutor.defaultLayer
-const llmDeps = Layer.mergeAll(requestExecutorLayer, WebSocketExecutor.layer)
-const llmClientLayer = LLMClient.layer.pipe(Layer.provide(llmDeps))
+const llmClientLayer = LLMClient.layer.pipe(Layer.provide(requestExecutorLayer))
 
 const program = Effect.gen(function* () {
   // yield* generateOnce
@@ -241,6 +237,6 @@ const program = Effect.gen(function* () {
   // yield* generateStructuredObject
   // yield* generateDynamicObject.pipe(Effect.andThen((response) => Effect.sync(() => console.log(response.object))))
   yield* streamWithTools
-}).pipe(Effect.provide(Layer.mergeAll(llmDeps, llmClientLayer)))
+}).pipe(Effect.provide(Layer.mergeAll(requestExecutorLayer, llmClientLayer)))
 
 Effect.runPromise(program)

packages/llm/src/cache-policy.ts

@@ -97,7 +97,7 @@ const markMessages = (
 }
 
 export const applyCachePolicy = (request: LLMRequest): LLMRequest => {
-  if (!RESPECTS_INLINE_HINTS.has(request.model.route.id)) return request
+  if (!RESPECTS_INLINE_HINTS.has(request.model.route)) return request
   const policy = resolve(request.cache)
   if (!policy.tools && !policy.system && !policy.messages) return request
 

packages/llm/src/index.ts

@@ -1,4 +1,4 @@
-export { LLMClient } from "./route/client"
+export { LLMClient, modelLimits, modelRef } from "./route/client"
 export { Auth } from "./route/auth"
 export { Provider } from "./provider"
 export type {
@@ -6,6 +6,7 @@ export type {
   RouteRoutedModelInput,
   Interface as LLMClientShape,
   Service as LLMClientService,
+  ModelRefInput,
 } from "./route/client"
 export * from "./schema"
 export { Tool, ToolFailure, toDefinitions, tool } from "./tool"

packages/llm/src/llm.ts

@@ -1,5 +1,5 @@
 import { Effect, JsonSchema, Schema } from "effect"
-import { LLMClient } from "./route/client"
+import { LLMClient, modelLimits, modelRef, type ModelRefInput } from "./route/client"
 import {
   GenerationOptions,
   HttpOptions,
@@ -9,7 +9,6 @@ import {
   LLMRequest,
   LLMResponse,
   Message,
-  type ModelInput as SchemaModelInput,
   SystemPart,
   ToolChoice,
   ToolDefinition,
@@ -19,7 +18,7 @@ import {
 } from "./schema"
 import { make as makeTool, type ToolSchema } from "./tool"
 
-export type ModelInput = SchemaModelInput
+export type ModelInput = ModelRefInput
 
 export type MessageInput = Message.Input
 
@@ -43,6 +42,10 @@ export type RequestInput = Omit<
   readonly http?: HttpOptions.Input
 }
 
+export const limits = modelLimits
+
+export const model = modelRef
+
 export const generate = LLMClient.generate
 
 export const stream = LLMClient.stream

packages/llm/src/protocols/anthropic-messages.ts

@@ -386,7 +386,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     tools,
     tool_choice: toolChoice,
     stream: true as const,
-    max_tokens: generation?.maxTokens ?? request.model.route.defaults.limits?.output ?? 4096,
+    max_tokens: generation?.maxTokens ?? request.model.limits.output ?? 4096,
     temperature: generation?.temperature,
     top_p: generation?.topP,
     top_k: generation?.topK,
@@ -452,8 +452,8 @@ const mergeUsage = (left: Usage | undefined, right: Usage | undefined) => {
     totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
     providerMetadata: {
       anthropic: {
-        ...left.providerMetadata?.["anthropic"],
-        ...right.providerMetadata?.["anthropic"],
+        ...(left.providerMetadata?.["anthropic"] ?? {}),
+        ...(right.providerMetadata?.["anthropic"] ?? {}),
       },
     },
   })
@@ -673,12 +673,19 @@ export const protocol = Protocol.make({
 
 export const route = Route.make({
   id: ADAPTER,
-  provider: "anthropic",
   protocol,
-  endpoint: Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL }),
-  auth: Auth.none,
+  endpoint: Endpoint.path(PATH),
+  auth: Auth.apiKeyHeader("x-api-key"),
   framing: Framing.sse,
   headers: () => ({ "anthropic-version": "2023-06-01" }),
 })
 
+// =============================================================================
+// Model Helper
+// =============================================================================
+export const model = Route.model(route, {
+  provider: "anthropic",
+  baseURL: DEFAULT_BASE_URL,
+})
+
 export * as AnthropicMessages from "./anthropic-messages"

packages/llm/src/protocols/bedrock-converse.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect"
-import { Route } from "../route/client"
+import { Route, type RouteModelInput } from "../route/client"
 import { Endpoint } from "../route/endpoint"
 import { Protocol } from "../route/protocol"
 import {
@@ -14,7 +14,7 @@ import {
 } from "../schema"
 import { BedrockEventStream } from "./bedrock-event-stream"
 import { JsonObject, optionalArray, ProviderShared } from "./shared"
-import { BedrockAuth } from "./utils/bedrock-auth"
+import { BedrockAuth, type Credentials as BedrockCredentials } from "./utils/bedrock-auth"
 import { BedrockCache } from "./utils/bedrock-cache"
 import { BedrockMedia } from "./utils/bedrock-media"
 import { Lifecycle } from "./utils/lifecycle"
@@ -24,6 +24,23 @@ const ADAPTER = "bedrock-converse"
 
 export type { Credentials as BedrockCredentials } from "./utils/bedrock-auth"
 
+// =============================================================================
+// Public Model Input
+// =============================================================================
+export type BedrockConverseModelInput = RouteModelInput & {
+  /**
+   * Bearer API key (Bedrock's newer API key auth). Sets the `Authorization`
+   * header and bypasses SigV4 signing. Mutually exclusive with `credentials`.
+   */
+  readonly apiKey?: string
+  /**
+   * AWS credentials for SigV4 signing. The route signs each request at
+   * `toHttp` time using `aws4fetch`. Mutually exclusive with `apiKey`.
+   */
+  readonly credentials?: BedrockCredentials
+  readonly headers?: Record<string, string>
+}
+
 // =============================================================================
 // Request Body Schema
 // =============================================================================
@@ -44,7 +61,6 @@ type BedrockToolUseBlock = Schema.Schema.Type<typeof BedrockToolUseBlock>
 const BedrockToolResultContentItem = Schema.Union([
   Schema.Struct({ text: Schema.String }),
   Schema.Struct({ json: Schema.Unknown }),
-  BedrockMedia.ImageBlock,
 ])
 
 const BedrockToolResultBlock = Schema.Struct({
@@ -245,33 +261,15 @@ const lowerToolCall = (part: ToolCallPart): BedrockToolUseBlock => ({
   },
 })
 
-const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent")(function* (part: ToolResultPart) {
-  if (part.result.type === "text" || part.result.type === "error")
-    return [{ text: ProviderShared.toolResultText(part) }]
-  if (part.result.type === "json") return [{ json: part.result.value }]
-
-  const content: Array<Schema.Schema.Type<typeof BedrockToolResultContentItem>> = []
-  for (const item of part.result.value) {
-    if (item.type === "text") {
-      content.push({ text: item.text })
-      continue
-    }
-    const media = yield* BedrockMedia.lower(item)
-    if (!("image" in media))
-      return yield* ProviderShared.invalidRequest("Bedrock Converse only supports image media in tool results")
-    content.push(media)
-  }
-  return content
-})
-
-const lowerToolResult = Effect.fn("BedrockConverse.lowerToolResult")(function* (part: ToolResultPart) {
-  return {
-    toolResult: {
-      toolUseId: part.id,
-      content: yield* lowerToolResultContent(part),
-      status: part.result.type === "error" ? "error" : "success",
-    },
-  } satisfies BedrockToolResultBlock
+const lowerToolResult = (part: ToolResultPart): BedrockToolResultBlock => ({
+  toolResult: {
+    toolUseId: part.id,
+    content:
+      part.result.type === "text" || part.result.type === "error"
+        ? [{ text: ProviderShared.toolResultText(part) }]
+        : [{ json: part.result.value }],
+    status: part.result.type === "error" ? "error" : "success",
+  },
 })
 
 const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
@@ -333,7 +331,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
     for (const part of message.content) {
       if (!ProviderShared.supportsContent(part, ["tool-result"]))
         return yield* ProviderShared.unsupportedContent("Bedrock Converse", "tool", ["tool-result"])
-      content.push(yield* lowerToolResult(part))
+      content.push(lowerToolResult(part))
       const cachePoint = BedrockCache.block(breakpoints, part.cache)
       if (cachePoint) content.push(cachePoint)
     }
@@ -599,11 +597,11 @@ export const protocol = Protocol.make({
 
 export const route = Route.make({
   id: ADAPTER,
-  provider: "bedrock",
   protocol,
-  // Bedrock's URL embeds the region in the route endpoint host and the
-  // validated modelId in the path. We read the validated body so the URL
-  // matches the body that gets signed.
+  // Bedrock's URL embeds the region in the host (set on `model.baseURL` by
+  // the provider helper from credentials) and the validated modelId in the
+  // path. We read the validated body so the URL matches the body that gets
+  // signed.
   endpoint: Endpoint.path<BedrockConverseBody>(
     ({ body }) => `/model/${encodeURIComponent(body.modelId)}/converse-stream`,
   ),
@@ -611,6 +609,26 @@ export const route = Route.make({
   framing,
 })
 
-export const sigV4Auth = BedrockAuth.sigV4
+export const nativeCredentials = BedrockAuth.nativeCredentials
+
+const bedrockModel = Route.model(
+  route,
+  {
+    provider: "bedrock",
+  },
+  {
+    mapInput: (input: BedrockConverseModelInput) => {
+      const { credentials, ...rest } = input
+      const region = credentials?.region ?? "us-east-1"
+      return {
+        ...rest,
+        baseURL: rest.baseURL ?? `https://bedrock-runtime.${region}.amazonaws.com`,
+        native: nativeCredentials(input.native, credentials),
+      }
+    },
+  },
+)
+
+export const model = bedrockModel
 
 export * as BedrockConverse from "./bedrock-converse"

packages/llm/src/protocols/gemini.ts

@@ -404,14 +404,19 @@ export const protocol = Protocol.make({
 
 export const route = Route.make({
   id: ADAPTER,
-  provider: "google",
   protocol,
   // Gemini's path embeds the model id and pins SSE framing at the URL level.
-  endpoint: Endpoint.path(({ request }) => `/models/${request.model.id}:streamGenerateContent?alt=sse`, {
-    baseURL: DEFAULT_BASE_URL,
-  }),
-  auth: Auth.none,
+  endpoint: Endpoint.path(({ request }) => `/models/${request.model.id}:streamGenerateContent?alt=sse`),
+  auth: Auth.apiKeyHeader("x-goog-api-key"),
   framing: Framing.sse,
 })
 
+// =============================================================================
+// Model Helper
+// =============================================================================
+export const model = Route.model(route, {
+  provider: "google",
+  baseURL: DEFAULT_BASE_URL,
+})
+
 export * as Gemini from "./gemini"

packages/llm/src/protocols/openai-chat.ts

@@ -2,6 +2,7 @@ import { Array as Arr, Effect, Schema } from "effect"
 import { Route } from "../route/client"
 import { Auth } from "../route/auth"
 import { Endpoint } from "../route/endpoint"
+import { Framing } from "../route/framing"
 import { HttpTransport } from "../route/transport"
 import { Protocol } from "../route/protocol"
 import {
@@ -127,7 +128,6 @@ type OpenAIChatToolCallDelta = Schema.Schema.Type<typeof OpenAIChatToolCallDelta
 
 const OpenAIChatDelta = Schema.Struct({
   content: optionalNull(Schema.String),
-  reasoning_content: optionalNull(Schema.String),
   tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
 })
 
@@ -325,9 +325,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
 
     let lifecycle = state.lifecycle
 
-    if (delta?.reasoning_content)
-      lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", delta.reasoning_content)
-
     if (delta?.content) lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
 
     for (const tool of toolDeltas) {
@@ -396,15 +393,28 @@ export const protocol = Protocol.make({
   },
 })
 
-export const httpTransport = HttpTransport.sseJson.with<OpenAIChatBody>()
+const encodeBody = Schema.encodeSync(Schema.fromJsonString(OpenAIChatBody))
+
+export const httpTransport = HttpTransport.httpJson({
+  endpoint: Endpoint.path(PATH),
+  auth: Auth.bearer(),
+  framing: Framing.sse,
+  encodeBody,
+})
 
 export const route = Route.make({
   id: ADAPTER,
   provider: "openai",
   protocol,
-  endpoint: Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL }),
-  auth: Auth.none,
   transport: httpTransport,
+  defaults: {
+    baseURL: DEFAULT_BASE_URL,
+  },
 })
 
+// =============================================================================
+// Model Helper
+// =============================================================================
+export const model = route.model
+
 export * as OpenAIChat from "./openai-chat"

packages/llm/src/protocols/openai-compatible-chat.ts

@@ -5,14 +5,16 @@ import * as OpenAIChat from "./openai-chat"
 
 const ADAPTER = "openai-compatible-chat"
 
-export type OpenAICompatibleChatModelInput = RouteRoutedModelInput
+export type OpenAICompatibleChatModelInput = Omit<RouteRoutedModelInput, "baseURL"> & {
+  readonly baseURL: string
+}
 
 /**
  * Route for non-OpenAI providers that expose an OpenAI Chat-compatible
  * `/chat/completions` endpoint. Reuses `OpenAIChat.protocol` end-to-end and
  * overrides only the route id so providers can be resolved per-family without
- * colliding with native OpenAI. Provider helpers configure the route endpoint
- * before model selection.
+ * colliding with native OpenAI. The model carries the host on `baseURL`,
+ * supplied by whichever profile/provider helper builds it.
  */
 export const route = Route.make({
   id: ADAPTER,
@@ -21,4 +23,6 @@ export const route = Route.make({
   framing: Framing.sse,
 })
 
+export const model = Route.model<OpenAICompatibleChatModelInput>(route)
+
 export * as OpenAICompatibleChat from "./openai-compatible-chat"

packages/llm/src/protocols/openai-responses.ts

@@ -2,11 +2,11 @@ import { Effect, Schema } from "effect"
 import { Route } from "../route/client"
 import { Auth } from "../route/auth"
 import { Endpoint } from "../route/endpoint"
+import { Framing } from "../route/framing"
 import { HttpTransport, WebSocketTransport } from "../route/transport"
 import { Protocol } from "../route/protocol"
 import {
   LLMEvent,
-  type MediaPart,
   Usage,
   type FinishReason,
   type LLMRequest,
@@ -31,12 +31,6 @@ const OpenAIResponsesInputText = Schema.Struct({
   type: Schema.tag("input_text"),
   text: Schema.String,
 })
-const OpenAIResponsesInputImage = Schema.Struct({
-  type: Schema.tag("input_image"),
-  image_url: Schema.String,
-})
-const OpenAIResponsesInputContent = Schema.Union([OpenAIResponsesInputText, OpenAIResponsesInputImage])
-type OpenAIResponsesInputContent = Schema.Schema.Type<typeof OpenAIResponsesInputContent>
 
 const OpenAIResponsesOutputText = Schema.Struct({
   type: Schema.tag("output_text"),
@@ -45,7 +39,7 @@ const OpenAIResponsesOutputText = Schema.Struct({
 
 const OpenAIResponsesInputItem = Schema.Union([
   Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
-  Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenAIResponsesInputContent) }),
+  Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenAIResponsesInputText) }),
   Schema.Struct({ role: Schema.tag("assistant"), content: Schema.Array(OpenAIResponsesOutputText) }),
   Schema.Struct({
     type: Schema.tag("function_call"),
@@ -157,15 +151,12 @@ const OpenAIResponsesEvent = Schema.Struct({
   item_id: Schema.optional(Schema.String),
   item: Schema.optional(OpenAIResponsesStreamItem),
   response: Schema.optional(
-    Schema.StructWithRest(
-      Schema.Struct({
-        id: Schema.optional(Schema.String),
-        service_tier: optionalNull(Schema.String),
-        incomplete_details: optionalNull(Schema.Struct({ reason: Schema.String })),
-        usage: optionalNull(OpenAIResponsesUsage),
-      }),
-      [Schema.Record(Schema.String, Schema.Unknown)],
-    ),
+    Schema.Struct({
+      id: Schema.optional(Schema.String),
+      service_tier: Schema.optional(Schema.String),
+      incomplete_details: optionalNull(Schema.Struct({ reason: Schema.String })),
+      usage: optionalNull(OpenAIResponsesUsage),
+    }),
   ),
   code: Schema.optional(Schema.String),
   message: Schema.optional(Schema.String),
@@ -205,22 +196,6 @@ const lowerToolCall = (part: ToolCallPart): OpenAIResponsesInputItem => ({
   arguments: ProviderShared.encodeJson(part.input),
 })
 
-const imageUrl = (part: MediaPart) =>
-  typeof part.data === "string" && part.data.startsWith("data:")
-    ? part.data
-    : `data:${part.mediaType};base64,${ProviderShared.mediaBytes(part)}`
-
-const lowerUserContent = Effect.fn("OpenAIResponses.lowerUserContent")(function* (
-  part: LLMRequest["messages"][number]["content"][number],
-) {
-  if (part.type === "text") return { type: "input_text" as const, text: part.text }
-  if (part.type === "media" && part.mediaType.startsWith("image/")) {
-    return { type: "input_image" as const, image_url: imageUrl(part) }
-  }
-  if (part.type === "media") return yield* invalid("OpenAI Responses user media content only supports images")
-  return yield* ProviderShared.unsupportedContent("OpenAI Responses", "user", ["text", "media"])
-})
-
 const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (request: LLMRequest) {
   const system: OpenAIResponsesInputItem[] =
     request.system.length === 0 ? [] : [{ role: "system", content: ProviderShared.joinText(request.system) }]
@@ -228,7 +203,13 @@ const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (requ
 
   for (const message of request.messages) {
     if (message.role === "user") {
-      input.push({ role: "user", content: yield* Effect.forEach(message.content, lowerUserContent) })
+      const content: TextPart[] = []
+      for (const part of message.content) {
+        if (!ProviderShared.supportsContent(part, ["text"]))
+          return yield* ProviderShared.unsupportedContent("OpenAI Responses", "user", ["text"])
+        content.push(part)
+      }
+      input.push({ role: "user", content: content.map((part) => ({ type: "input_text", text: part.text })) })
       continue
     }
 
@@ -413,29 +394,6 @@ const onOutputTextDelta = (state: ParserState, event: OpenAIResponsesEvent): Ste
   ]
 }
 
-const onReasoningDelta = (state: ParserState, event: OpenAIResponsesEvent): StepResult => {
-  if (!event.delta) return [state, NO_EVENTS]
-  const events: LLMEvent[] = []
-  return [
-    {
-      ...state,
-      lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, event.item_id ?? "reasoning-0", event.delta),
-    },
-    events,
-  ]
-}
-
-const onReasoningDone = (state: ParserState, event: OpenAIResponsesEvent): StepResult => {
-  const events: LLMEvent[] = []
-  return [
-    {
-      ...state,
-      lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, event.item_id ?? "reasoning-0"),
-    },
-    events,
-  ]
-}
-
 const onOutputItemAdded = (state: ParserState, event: OpenAIResponsesEvent): StepResult => {
   const item = event.item
   if (item?.type !== "function_call" || !item.id) return [state, NO_EVENTS]
@@ -546,18 +504,6 @@ const onError = (state: ParserState, event: OpenAIResponsesEvent): StepResult =>
 
 const step = (state: ParserState, event: OpenAIResponsesEvent) => {
   if (event.type === "response.output_text.delta") return Effect.succeed(onOutputTextDelta(state, event))
-  if (
-    event.type === "response.reasoning_text.delta" ||
-    event.type === "response.reasoning_summary.delta" ||
-    event.type === "response.reasoning_summary_text.delta"
-  )
-    return Effect.succeed(onReasoningDelta(state, event))
-  if (
-    event.type === "response.reasoning_text.done" ||
-    event.type === "response.reasoning_summary.done" ||
-    event.type === "response.reasoning_summary_text.done"
-  )
-    return Effect.succeed(onReasoningDone(state, event))
   if (event.type === "response.output_item.added") return Effect.succeed(onOutputItemAdded(state, event))
   if (event.type === "response.function_call_arguments.delta") return onFunctionCallArgumentsDelta(state, event)
   if (event.type === "response.output_item.done") return onOutputItemDone(state, event)
@@ -590,18 +536,27 @@ export const protocol = Protocol.make({
   },
 })
 
-const endpoint = Endpoint.path<OpenAIResponsesBody>(PATH, { baseURL: DEFAULT_BASE_URL })
-const auth = Auth.none
+const encodeBody = Schema.encodeSync(Schema.fromJsonString(OpenAIResponsesBody))
+const transportBase = {
+  endpoint: Endpoint.path<OpenAIResponsesBody>(PATH),
+  auth: Auth.bearer(),
+  encodeBody,
+}
+const routeDefaults = {
+  baseURL: DEFAULT_BASE_URL,
+}
 
-export const httpTransport = HttpTransport.sseJson.with<OpenAIResponsesBody>()
+export const httpTransport = HttpTransport.httpJson({
+  ...transportBase,
+  framing: Framing.sse,
+})
 
 export const route = Route.make({
   id: ADAPTER,
   provider: "openai",
   protocol,
-  endpoint,
-  auth,
   transport: httpTransport,
+  defaults: routeDefaults,
 })
 
 const decodeWebSocketMessage = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIResponsesWebSocketMessage))
@@ -614,10 +569,8 @@ const webSocketMessage = (body: OpenAIResponsesBody | Record<string, unknown>) =
     return yield* decodeWebSocketMessage({ ...message, type: "response.create" })
   })
 
-export const webSocketTransport = WebSocketTransport.jsonTransport.with<
-  OpenAIResponsesBody,
-  OpenAIResponsesWebSocketMessage
->({
+export const webSocketTransport = WebSocketTransport.json({
+  ...transportBase,
   toMessage: webSocketMessage,
   encodeMessage: encodeWebSocketMessage,
 })
@@ -626,9 +579,15 @@ export const webSocketRoute = Route.make({
   id: `${ADAPTER}-websocket`,
   provider: "openai",
   protocol,
-  endpoint,
-  auth,
   transport: webSocketTransport,
+  defaults: routeDefaults,
 })
 
+// =============================================================================
+// Model Helper
+// =============================================================================
+export const model = route.model
+
+export const webSocketModel = webSocketRoute.model
+
 export * as OpenAIResponses from "./openai-responses"

packages/llm/src/protocols/shared.ts

@@ -11,7 +11,6 @@ import {
   type MediaPart,
   type ToolResultPart,
 } from "../schema"
-export { isRecord } from "../utils/record"
 
 export const Json = Schema.fromJsonString(Schema.Unknown)
 export const decodeJson = Schema.decodeUnknownSync(Json)
@@ -20,6 +19,13 @@ export const JsonObject = Schema.Record(Schema.String, Schema.Unknown)
 export const optionalArray = <const S extends Schema.Top>(schema: S) => Schema.optional(Schema.Array(schema))
 export const optionalNull = <const S extends Schema.Top>(schema: S) => Schema.optional(Schema.NullOr(schema))
 
+/**
+ * Plain-record narrowing. Excludes arrays so routes checking nested JSON
+ * Schema fragments don't accidentally treat a tuple as a key/value bag.
+ */
+export const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
 /**
  * Streaming tool-call accumulator. Adapters that build a tool call across
  * multiple `tool-input-delta` chunks store the partial JSON input string here
@@ -126,7 +132,6 @@ export const trimBaseUrl = (value: string) => value.replace(/\/+$/, "")
 
 export const toolResultText = (part: ToolResultPart) => {
   if (part.result.type === "text" || part.result.type === "error") return String(part.result.value)
-  if (part.result.type === "content") return encodeJson(part.result.value)
   return encodeJson(part.result.value)
 }
 

packages/llm/src/protocols/utils/bedrock-auth.ts

@@ -1,14 +1,15 @@
 import { AwsV4Signer } from "aws4fetch"
-import { Effect } from "effect"
+import { Effect, Option, Schema } from "effect"
 import { Headers } from "effect/unstable/http"
 import { Auth, type AuthInput } from "../../route/auth"
+import type { LLMRequest } from "../../schema"
 import { ProviderShared } from "../shared"
 
 /**
- * AWS credentials for SigV4 signing. Bedrock also supports Bearer API key auth,
- * which provider facades configure as route auth instead of SigV4. STS-vended
- * credentials should be refreshed by the consumer (rebuild the model) before
- * they expire; the route does not refresh.
+ * AWS credentials for SigV4 signing. Bedrock also supports Bearer API key auth
+ * via `model.apiKey`, which bypasses SigV4 signing. STS-vended credentials
+ * should be refreshed by the consumer (rebuild the model) before they expire;
+ * the route does not refresh.
  */
 export interface Credentials {
   readonly region: string
@@ -17,6 +18,32 @@ export interface Credentials {
   readonly sessionToken?: string
 }
 
+const NativeCredentials = Schema.Struct({
+  accessKeyId: Schema.String,
+  secretAccessKey: Schema.String,
+  region: Schema.optional(Schema.String),
+  sessionToken: Schema.optional(Schema.String),
+})
+
+const decodeNativeCredentials = Schema.decodeUnknownOption(NativeCredentials)
+
+export const region = (request: LLMRequest) => {
+  const fromNative = request.model.native?.aws_region
+  if (typeof fromNative === "string" && fromNative !== "") return fromNative
+  return (
+    decodeNativeCredentials(request.model.native?.aws_credentials).pipe(
+      Option.map((credentials) => credentials.region),
+      Option.getOrUndefined,
+    ) ?? "us-east-1"
+  )
+}
+
+const credentialsFromInput = (request: LLMRequest): Credentials | undefined =>
+  decodeNativeCredentials(request.model.native?.aws_credentials).pipe(
+    Option.map((creds) => ({ ...creds, region: creds.region ?? region(request) })),
+    Option.getOrUndefined,
+  )
+
 const signRequest = (input: {
   readonly url: string
   readonly body: string
@@ -44,27 +71,33 @@ const signRequest = (input: {
       ),
   })
 
-/** Sign the exact JSON bytes with SigV4 using credentials configured on the route. */
-export const sigV4 = (credentials: Credentials | undefined) =>
-  Auth.custom((input: AuthInput) => {
-    return Effect.gen(function* () {
-      if (!credentials) {
-        return yield* ProviderShared.invalidRequest(
-          "Bedrock Converse requires either route bearer auth or AWS credentials configured on the route",
-        )
-      }
-      const headersForSigning = Headers.set(input.headers, "content-type", "application/json")
-      const signed = yield* signRequest({
-        url: input.url,
-        body: input.body,
-        headers: headersForSigning,
-        credentials,
-      })
-      return Headers.setAll(headersForSigning, signed)
-    })
+/**
+ * Bedrock auth. `model.apiKey` (Bedrock's newer Bearer API key auth) wins if
+ * set; otherwise sign the exact JSON bytes with SigV4 using credentials from
+ * `model.native.aws_credentials`.
+ */
+export const auth = Auth.custom((input: AuthInput) => {
+  if (input.request.model.apiKey) return Auth.toEffect(Auth.bearer())(input)
+  return Effect.gen(function* () {
+    const credentials = credentialsFromInput(input.request)
+    if (!credentials) {
+      return yield* ProviderShared.invalidRequest(
+        "Bedrock Converse requires either model.apiKey or AWS credentials in model.native.aws_credentials",
+      )
+    }
+    const headersForSigning = Headers.set(input.headers, "content-type", "application/json")
+    const signed = yield* signRequest({ url: input.url, body: input.body, headers: headersForSigning, credentials })
+    return Headers.setAll(headersForSigning, signed)
   })
+})
 
-/** Bedrock route auth defaults to SigV4 and expects credentials from route configuration. */
-export const auth = sigV4(undefined)
+export const nativeCredentials = (native: Record<string, unknown> | undefined, credentials: Credentials | undefined) =>
+  credentials
+    ? {
+        ...native,
+        aws_credentials: credentials,
+        aws_region: credentials.region,
+      }
+    : native
 
 export * as BedrockAuth from "./bedrock-auth"

packages/llm/src/provider.ts

@@ -1,20 +1,14 @@
-import type { RouteDefaultsInput } from "./route/client"
-import type { Model, ModelID, ProviderID } from "./schema"
+import type { RouteModelInput } from "./route/client"
+import type { ModelID, ModelRef, ProviderID } from "./schema"
 
-export type ModelOptions = RouteDefaultsInput
+export type ModelOptions = Omit<RouteModelInput, "id">
 
-/**
- * Advanced structural provider definition helper. Built-in providers should
- * prefer explicit `configure(options).model(id)` facades so deployment config is
- * chosen before model selection. The optional `apis` map remains for external
- * structural providers that expose multiple route selectors behind one provider.
- */
 export type ModelFactory<Options extends ModelOptions = ModelOptions> = (
   id: string | ModelID,
   options?: Options,
-) => Model
+) => ModelRef
 
-type AnyModelFactory = (...args: never[]) => Model
+type AnyModelFactory = (...args: never[]) => ModelRef
 
 export interface Definition<Factory extends AnyModelFactory = ModelFactory> {
   readonly id: ProviderID
@@ -24,8 +18,8 @@ export interface Definition<Factory extends AnyModelFactory = ModelFactory> {
 
 type DefinitionShape = {
   readonly id: ProviderID
-  readonly model: (...args: never[]) => Model
-  readonly apis?: Record<string, (...args: never[]) => Model>
+  readonly model: (...args: never[]) => ModelRef
+  readonly apis?: Record<string, (...args: never[]) => ModelRef>
 }
 
 type NoExtraFields<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>

packages/llm/src/providers/amazon-bedrock.ts

@@ -1,12 +1,12 @@
-import type { RouteDefaultsInput } from "../route/client"
-import { Auth } from "../route/auth"
+import { Route, type RouteModelInput } from "../route/client"
+import { Provider } from "../provider"
 import { ProviderID, type ModelID } from "../schema"
 import * as BedrockConverse from "../protocols/bedrock-converse"
 import type { BedrockCredentials } from "../protocols/bedrock-converse"
 
 export const id = ProviderID.make("amazon-bedrock")
 
-export type Config = RouteDefaultsInput & {
+export type ModelOptions = Omit<RouteModelInput, "id" | "baseURL"> & {
   readonly apiKey?: string
   readonly headers?: Record<string, string>
   readonly credentials?: BedrockCredentials
@@ -15,29 +15,34 @@ export type Config = RouteDefaultsInput & {
   /** Override the computed `https://bedrock-runtime.<region>.amazonaws.com` URL. */
   readonly baseURL?: string
 }
+type ModelInput = ModelOptions & Pick<RouteModelInput, "id">
+
 export const routes = [BedrockConverse.route]
 
 const bedrockBaseURL = (region: string) => `https://bedrock-runtime.${region}.amazonaws.com`
 
-const configuredRoute = (input: Config) => {
-  const { apiKey, credentials, region, baseURL, ...rest } = input
-  const resolvedRegion = region ?? credentials?.region ?? "us-east-1"
-  return BedrockConverse.route.with({
-    ...rest,
-    provider: id,
-    endpoint: { baseURL: baseURL ?? bedrockBaseURL(resolvedRegion) },
-    auth: apiKey === undefined ? BedrockConverse.sigV4Auth(credentials) : Auth.bearer(apiKey),
-  })
-}
+const converseModel = Route.model<ModelInput>(
+  BedrockConverse.route,
+  {
+    provider: "amazon-bedrock",
+  },
+  {
+    mapInput: (input) => {
+      const { credentials, region, baseURL, ...rest } = input
+      const resolvedRegion = region ?? credentials?.region ?? "us-east-1"
+      return {
+        ...rest,
+        baseURL: baseURL ?? bedrockBaseURL(resolvedRegion),
+        native: BedrockConverse.nativeCredentials(input.native, credentials),
+      }
+    },
+  },
+)
 
-export const configure = (input: Config = {}) => {
-  const route = configuredRoute(input)
-  return {
-    id,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
-    configure,
-  }
-}
+export const model = (modelID: string | ModelID, options: ModelOptions = {}) =>
+  converseModel({ ...options, id: modelID })
 
-export const provider = configure()
-export const model = provider.model
+export const provider = Provider.make({
+  id,
+  model,
+})

packages/llm/src/providers/anthropic.ts

@@ -1,6 +1,5 @@
-import type { RouteDefaultsInput } from "../route/client"
-import { Auth } from "../route/auth"
-import type { ProviderAuthOption } from "../route/auth-options"
+import type { RouteModelInput } from "../route/client"
+import { Provider } from "../provider"
 import { ProviderID, type ModelID } from "../schema"
 import * as AnthropicMessages from "../protocols/anthropic-messages"
 
@@ -8,28 +7,12 @@ export const id = ProviderID.make("anthropic")
 
 export const routes = [AnthropicMessages.route]
 
-export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & { readonly baseURL?: string }
+export const model = (
+  id: string | ModelID,
+  options: Omit<RouteModelInput, "id" | "baseURL"> & { readonly baseURL?: string } = {},
+) => AnthropicMessages.model({ ...options, id })
 
-const auth = (options: ProviderAuthOption<"optional">) => {
-  if ("auth" in options && options.auth) return options.auth
-  return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
-    .orElse(Auth.config("ANTHROPIC_API_KEY"))
-    .pipe(Auth.header("x-api-key"))
-}
-
-const configuredRoute = (input: Config) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  return AnthropicMessages.route.with({ ...rest, endpoint: { baseURL }, auth: auth(input) })
-}
-
-export const configure = (input: Config = {}) => {
-  const route = configuredRoute(input)
-  return {
-    id,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = configure()
-export const model = provider.model
+export const provider = Provider.make({
+  id,
+  model,
+})

packages/llm/src/providers/azure.ts

@@ -1,110 +1,83 @@
 import { Auth } from "../route/auth"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options"
-import type { Route as RouteDef, RouteDefaultsInput } from "../route/client"
+import { Route } from "../route/client"
+import type { ModelInput } from "../llm"
+import { Provider } from "../provider"
 import { ProviderID, type ModelID } from "../schema"
 import * as OpenAIChat from "../protocols/openai-chat"
 import * as OpenAIResponses from "../protocols/openai-responses"
 import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options"
 
 export const id = ProviderID.make("azure")
-const routeAuth = Auth.remove("authorization")
+const routeAuth = Auth.remove("authorization").andThen(Auth.apiKeyHeader("api-key"))
 
 // Azure needs the customer's resource URL; supply either `resourceName`
 // (helper builds the URL) or `baseURL` directly.
 type AzureURL = AtLeastOne<{ readonly resourceName: string; readonly baseURL: string }>
 
 export type ModelOptions = AzureURL &
-  RouteDefaultsInput &
+  Omit<ModelInput, "id" | "provider" | "route" | "apiKey" | "auth" | "baseURL"> &
   ProviderAuthOption<"optional"> & {
     readonly apiVersion?: string
-    readonly queryParams?: Record<string, string>
     readonly useCompletionUrls?: boolean
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
-export type Config = ModelOptions
+type AzureModelInput = ModelOptions & Pick<ModelInput, "id">
 
 const resourceBaseURL = (resourceName: string) => `https://${resourceName.trim()}.openai.azure.com/openai/v1`
 
 const responsesRoute = OpenAIResponses.route.with({
   id: "azure-openai-responses",
   provider: id,
-  auth: routeAuth,
-  endpoint: {
-    query: { "api-version": "v1" },
-  },
+  transport: OpenAIResponses.httpTransport.with({ auth: routeAuth }),
 })
 
 const chatRoute = OpenAIChat.route.with({
   id: "azure-openai-chat",
   provider: id,
-  auth: routeAuth,
-  endpoint: {
-    query: { "api-version": "v1" },
-  },
+  transport: OpenAIChat.httpTransport.with({ auth: routeAuth }),
 })
 
 export const routes = [responsesRoute, chatRoute]
 
-const defaults = (input: Config) => {
-  const {
-    apiKey: _,
-    apiVersion: _apiVersion,
-    resourceName: _resourceName,
-    useCompletionUrls: _useCompletionUrls,
-    baseURL: _baseURL,
-    queryParams: _queryParams,
-    ...rest
-  } = input
-  if ("auth" in rest) {
-    const { auth: _, ...withoutAuth } = rest
-    return withoutAuth
-  }
-  return rest
-}
-
-const auth = (input: Config) => {
-  if ("auth" in input && input.auth) return input.auth
-  return Auth.remove("authorization").andThen(
-    Auth.optional("apiKey" in input ? input.apiKey : undefined, "apiKey")
-      .orElse(Auth.config("AZURE_OPENAI_API_KEY"))
-      .pipe(Auth.header("api-key")),
-  )
-}
-
-const configuredRoute = <Body, Prepared>(route: RouteDef<Body, Prepared>, input: Config) =>
-  route.with({
-    auth: auth(input),
-    endpoint: {
-      // AtLeastOne guarantees at least one is set; baseURL wins if both are.
-      baseURL: input.baseURL ?? resourceBaseURL(input.resourceName!),
-      query: {
-        ...(input.apiVersion ? { "api-version": input.apiVersion } : {}),
-        ...input.queryParams,
-      },
-    },
-  })
-
-export const configure = (input: Config) => {
-  const configuredResponsesRoute = configuredRoute(responsesRoute, input)
-  const configuredChatRoute = configuredRoute(chatRoute, input)
-  const modelDefaults = defaults(input)
-
-  const responses = (modelID: string | ModelID) =>
-    configuredResponsesRoute.with(withOpenAIOptions(modelID, modelDefaults)).model({ id: modelID })
-
-  const chat = (modelID: string | ModelID) =>
-    configuredChatRoute.with(withOpenAIOptions(modelID, modelDefaults)).model({ id: modelID })
-
+const mapInput = (input: AzureModelInput) => {
+  const { apiKey: _, apiVersion, resourceName, useCompletionUrls, ...rest } = input
   return {
-    id,
-    model: (modelID: string | ModelID) => (input.useCompletionUrls === true ? chat(modelID) : responses(modelID)),
-    responses,
-    chat,
-    configure,
+    ...withOpenAIOptions(input.id, rest),
+    auth:
+      "auth" in input && input.auth
+        ? input.auth
+        : Auth.remove("authorization").andThen(
+            Auth.optional("apiKey" in input ? input.apiKey : undefined, "apiKey")
+              .orElse(Auth.config("AZURE_OPENAI_API_KEY"))
+              .pipe(Auth.header("api-key")),
+          ),
+    // AtLeastOne guarantees at least one is set; baseURL wins if both are.
+    baseURL: rest.baseURL ?? resourceBaseURL(resourceName!),
+    queryParams: {
+      ...rest.queryParams,
+      "api-version": apiVersion ?? rest.queryParams?.["api-version"] ?? "v1",
+    },
   }
 }
 
-export const provider = {
-  id,
-  configure,
+const chatModel = Route.model<AzureModelInput>(chatRoute, {}, { mapInput })
+const responsesModel = Route.model<AzureModelInput>(responsesRoute, {}, { mapInput })
+
+export const responses = (modelID: string | ModelID, options: ModelOptions) =>
+  responsesModel({ ...options, id: modelID })
+
+export const chat = (modelID: string | ModelID, options: ModelOptions) => chatModel({ ...options, id: modelID })
+
+export const model = (modelID: string | ModelID, options: ModelOptions) => {
+  if (options.useCompletionUrls === true) return chat(modelID, options)
+  return responses(modelID, options)
 }
+
+export const provider = Provider.make({
+  id,
+  model,
+  apis: { responses, chat },
+})
+
+export const apis = provider.apis

packages/llm/src/providers/cloudflare.ts

@@ -1,16 +1,19 @@
 import type { Config, Redacted } from "effect"
+import { type ModelInput } from "../llm"
+import { Provider } from "../provider"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
 import { Auth } from "../route/auth"
 import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options"
-import type { RouteDefaultsInput } from "../route/client"
+import { Route } from "../route/client"
 import { ProviderID, type ModelID } from "../schema"
 
 export const aiGatewayID = ProviderID.make("cloudflare-ai-gateway")
 export const workersAIID = ProviderID.make("cloudflare-workers-ai")
+export const id = aiGatewayID
 export const aiGatewayAuthEnvVars = ["CLOUDFLARE_API_TOKEN", "CF_AIG_TOKEN"] as const
 export const workersAIAuthEnvVars = ["CLOUDFLARE_API_KEY", "CLOUDFLARE_WORKERS_AI_TOKEN"] as const
 
-type CloudflareSecret = string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>
+type CloudflareSecret = string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>>
 
 type GatewayURL = AtLeastOne<{
   readonly accountId: string
@@ -20,26 +23,32 @@ type GatewayURL = AtLeastOne<{
 }
 
 export type AIGatewayOptions = GatewayURL &
-  RouteDefaultsInput &
+  Omit<ModelInput, "id" | "provider" | "route" | "baseURL" | "apiKey" | "auth"> &
   ProviderAuthOption<"optional"> & {
     /** Cloudflare AI Gateway authentication token. Sent as `cf-aig-authorization`. */
     readonly gatewayApiKey?: CloudflareSecret
   }
 
+type AIGatewayInput = AIGatewayOptions & Pick<ModelInput, "id">
+
 type WorkersAIURL = AtLeastOne<{
   readonly accountId: string
   readonly baseURL: string
 }>
 
-export type WorkersAIOptions = WorkersAIURL & RouteDefaultsInput & ProviderAuthOption<"optional">
+export type WorkersAIOptions = WorkersAIURL &
+  Omit<ModelInput, "id" | "provider" | "route" | "baseURL" | "apiKey" | "auth"> &
+  ProviderAuthOption<"optional">
+
+type WorkersAIInput = WorkersAIOptions & Pick<ModelInput, "id">
 
 export const aiGatewayBaseURL = (input: GatewayURL) => {
   if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied")
+  if (!input.accountId) throw new Error("Cloudflare.aiGateway requires accountId unless baseURL is supplied")
   return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`
 }
 
-const aiGatewayAuth = (input: AIGatewayOptions) => {
+const aiGatewayAuth = (input: AIGatewayInput) => {
   if ("auth" in input && input.auth) return input.auth
   const gateway = Auth.optional(input.gatewayApiKey, "gatewayApiKey")
     .orElse(Auth.config("CLOUDFLARE_API_TOKEN"))
@@ -52,11 +61,11 @@ const aiGatewayAuth = (input: AIGatewayOptions) => {
 
 export const workersAIBaseURL = (input: WorkersAIURL) => {
   if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied")
+  if (!input.accountId) throw new Error("Cloudflare.workersAI requires accountId unless baseURL is supplied")
   return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(input.accountId)}/ai/v1`
 }
 
-const workersAIAuth = (input: WorkersAIOptions) => {
+const workersAIAuth = (input: WorkersAIInput) => {
   return AuthOptions.bearer(input, workersAIAuthEnvVars)
 }
 
@@ -72,56 +81,59 @@ export const workersAIRoute = OpenAICompatibleChat.route.with({
 
 export const routes = [aiGatewayRoute, workersAIRoute]
 
-const aiGatewayDefaults = (options: AIGatewayOptions) => {
-  const {
-    accountId: _accountId,
-    gatewayId: _gatewayId,
-    apiKey: _apiKey,
-    gatewayApiKey: _gatewayApiKey,
-    baseURL: _baseURL,
-    auth: _auth,
-    ...rest
-  } = options
-  return rest
-}
+const aiGatewayModel = Route.model<AIGatewayInput>(
+  aiGatewayRoute,
+  {
+    provider: id,
+  },
+  {
+    mapInput: (input) => {
+      const {
+        accountId: _accountId,
+        gatewayId: _gatewayId,
+        apiKey: _apiKey,
+        gatewayApiKey: _gatewayApiKey,
+        auth: _auth,
+        ...rest
+      } = input
+      return {
+        ...rest,
+        auth: aiGatewayAuth(input),
+        baseURL: aiGatewayBaseURL(input),
+      }
+    },
+  },
+)
 
-const workersAIDefaults = (options: WorkersAIOptions) => {
-  const { accountId: _accountId, apiKey: _apiKey, auth: _auth, baseURL: _baseURL, ...rest } = options
-  return rest
-}
+const workersAIModel = Route.model<WorkersAIInput>(
+  workersAIRoute,
+  {
+    provider: workersAIID,
+  },
+  {
+    mapInput: (input) => {
+      const { accountId: _accountId, apiKey: _apiKey, auth: _auth, ...rest } = input
+      return {
+        ...rest,
+        auth: workersAIAuth(input),
+        baseURL: workersAIBaseURL(input),
+      }
+    },
+  },
+)
 
-const configureAIGateway = (options: AIGatewayOptions) => {
-  const route = aiGatewayRoute.with({
-    ...aiGatewayDefaults(options),
-    endpoint: { baseURL: aiGatewayBaseURL(options) },
-    auth: aiGatewayAuth(options),
-  })
-  return {
-    id: aiGatewayID,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
-    configure: configureAIGateway,
-  }
-}
+export const aiGateway = (modelID: string | ModelID, options: AIGatewayOptions) =>
+  aiGatewayModel({ ...options, id: modelID })
 
-const configureWorkersAI = (options: WorkersAIOptions) => {
-  const route = workersAIRoute.with({
-    ...workersAIDefaults(options),
-    endpoint: { baseURL: workersAIBaseURL(options) },
-    auth: workersAIAuth(options),
-  })
-  return {
-    id: workersAIID,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
-    configure: configureWorkersAI,
-  }
-}
+export const workersAI = (modelID: string | ModelID, options: WorkersAIOptions) =>
+  workersAIModel({ ...options, id: modelID })
 
-export const CloudflareAIGateway = {
-  id: aiGatewayID,
-  configure: configureAIGateway,
-}
+export const model = aiGateway
 
-export const CloudflareWorkersAI = {
-  id: workersAIID,
-  configure: configureWorkersAI,
-}
+export const provider = Provider.make({
+  id,
+  model,
+  apis: { aiGateway, workersAI },
+})
+
+export const apis = provider.apis

packages/llm/src/providers/github-copilot.ts

@@ -1,5 +1,6 @@
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import type { RouteDefaultsInput } from "../route/client"
+import { Route } from "../route/client"
+import type { ModelInput } from "../llm"
+import { Provider } from "../provider"
 import { ProviderID, type ModelID } from "../schema"
 import * as OpenAIChat from "../protocols/openai-chat"
 import * as OpenAIResponses from "../protocols/openai-responses"
@@ -9,11 +10,10 @@ export const id = ProviderID.make("github-copilot")
 
 // GitHub Copilot has no canonical public URL — callers (opencode, etc.) must
 // supply `baseURL` explicitly.
-export type ModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
+export type ModelOptions = Omit<ModelInput, "id" | "provider" | "route"> & {
+  readonly providerOptions?: OpenAIProviderOptionsInput
+}
+type CopilotModelInput = ModelOptions & Pick<ModelInput, "id">
 
 export const shouldUseResponsesApi = (modelID: string | ModelID) => {
   const model = String(modelID)
@@ -24,43 +24,25 @@ export const shouldUseResponsesApi = (modelID: string | ModelID) => {
 
 export const routes = [OpenAIResponses.route, OpenAIChat.route]
 
-const chatRoute = OpenAIChat.route.with({ provider: id })
-const responsesRoute = OpenAIResponses.route.with({ provider: id })
+const mapInput = (input: CopilotModelInput) => withOpenAIOptions(input.id, input)
 
-const defaults = (options: ModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL: _baseURL, ...rest } = options
-  return rest
+const chatModel = Route.model<CopilotModelInput>(OpenAIChat.route, { provider: id }, { mapInput })
+const responsesModel = Route.model<CopilotModelInput>(OpenAIResponses.route, { provider: id }, { mapInput })
+
+export const responses = (modelID: string | ModelID, options: ModelOptions) =>
+  responsesModel({ ...options, id: modelID })
+
+export const chat = (modelID: string | ModelID, options: ModelOptions) => chatModel({ ...options, id: modelID })
+
+export const model = (modelID: string | ModelID, options: ModelOptions) => {
+  const create = shouldUseResponsesApi(modelID) ? responsesModel : chatModel
+  return create({ ...options, id: modelID })
 }
 
-const configuredResponsesRoute = (options: ModelOptions) =>
-  responsesRoute.with({
-    endpoint: { baseURL: options.baseURL },
-    auth: AuthOptions.bearer(options, []),
-  })
-
-const configuredChatRoute = (options: ModelOptions) =>
-  chatRoute.with({
-    endpoint: { baseURL: options.baseURL },
-    auth: AuthOptions.bearer(options, []),
-  })
-
-export const configure = (options: ModelOptions) => {
-  const responsesRoute = configuredResponsesRoute(options)
-  const chatRoute = configuredChatRoute(options)
-  const responses = (modelID: string | ModelID) =>
-    responsesRoute.with(withOpenAIOptions(modelID, defaults(options))).model({ id: modelID })
-  const chat = (modelID: string | ModelID) =>
-    chatRoute.with(withOpenAIOptions(modelID, defaults(options))).model({ id: modelID })
-  return {
-    id,
-    model: (modelID: string | ModelID) => (shouldUseResponsesApi(modelID) ? responses(modelID) : chat(modelID)),
-    responses,
-    chat,
-    configure,
-  }
-}
-
-export const provider = {
+export const provider = Provider.make({
   id,
-  configure,
-}
+  model,
+  apis: { responses, chat },
+})
+
+export const apis = provider.apis

packages/llm/src/providers/google.ts

@@ -1,6 +1,5 @@
-import type { RouteDefaultsInput } from "../route/client"
-import { Auth } from "../route/auth"
-import type { ProviderAuthOption } from "../route/auth-options"
+import type { RouteModelInput } from "../route/client"
+import { Provider } from "../provider"
 import { ProviderID, type ModelID } from "../schema"
 import * as Gemini from "../protocols/gemini"
 
@@ -8,28 +7,12 @@ export const id = ProviderID.make("google")
 
 export const routes = [Gemini.route]
 
-export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & { readonly baseURL?: string }
+export const model = (
+  id: string | ModelID,
+  options: Omit<RouteModelInput, "id" | "baseURL"> & { readonly baseURL?: string } = {},
+) => Gemini.model({ ...options, id })
 
-const auth = (options: ProviderAuthOption<"optional">) => {
-  if ("auth" in options && options.auth) return options.auth
-  return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
-    .orElse(Auth.config("GOOGLE_GENERATIVE_AI_API_KEY"))
-    .pipe(Auth.header("x-goog-api-key"))
-}
-
-const configuredRoute = (input: Config) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  return Gemini.route.with({ ...rest, endpoint: { baseURL }, auth: auth(input) })
-}
-
-export const configure = (input: Config = {}) => {
-  const route = configuredRoute(input)
-  return {
-    id,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = configure()
-export const model = provider.model
+export const provider = Provider.make({
+  id,
+  model,
+})

packages/llm/src/providers/index.ts

@@ -2,7 +2,6 @@ export * as Anthropic from "./anthropic"
 export * as AmazonBedrock from "./amazon-bedrock"
 export * as Azure from "./azure"
 export * as Cloudflare from "./cloudflare"
-export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare"
 export * as GitHubCopilot from "./github-copilot"
 export * as Google from "./google"
 export * as OpenAI from "./openai"

packages/llm/src/providers/openai-compatible.ts

@@ -1,60 +1,56 @@
+import { Provider } from "../provider"
 import { ProviderID, type ModelID } from "../schema"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
-import type { RouteDefaultsInput } from "../route/client"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
+import type { OpenAICompatibleChatModelInput } from "../protocols/openai-compatible-chat"
 import { profiles, type OpenAICompatibleProfile } from "./openai-compatible-profile"
 
 export const id = ProviderID.make("openai-compatible")
 
-type GenericModelOptions = RouteDefaultsInput &
-  ProviderAuthOption<"optional"> & {
-    readonly provider?: string
-    readonly baseURL: string
-  }
+export type ModelOptions = Omit<OpenAICompatibleChatModelInput, "id" | "provider"> & {
+  readonly provider: string
+}
 
-export type FamilyModelOptions = RouteDefaultsInput &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-  }
+type GenericModelOptions = Omit<ModelOptions, "provider"> & {
+  readonly provider?: string
+}
+
+export type FamilyModelOptions = Omit<OpenAICompatibleChatModelInput, "id" | "provider" | "baseURL"> & {
+  readonly baseURL?: string
+}
 
 export const routes = [OpenAICompatibleChat.route]
 
-export const configure = (input: GenericModelOptions) => {
-  const provider = input.provider ?? "openai-compatible"
-  const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
-  const route = OpenAICompatibleChat.route.with({
-    ...rest,
-    provider,
-    endpoint: { baseURL },
-    auth: AuthOptions.bearer(input, []),
+export const model = (id: string | ModelID, options: ModelOptions) => {
+  return OpenAICompatibleChat.model({
+    ...options,
+    id,
+    provider: ProviderID.make(options.provider),
   })
-  return {
-    id: ProviderID.make(provider),
-    model: (modelID: string | ModelID) => route.model({ id: modelID, provider: ProviderID.make(provider) }),
-    configure,
-  }
 }
 
-const define = (profile: OpenAICompatibleProfile) => {
-  const configureProfile = (input: FamilyModelOptions = {}) => {
-    const facade = configure({
-      ...input,
-      baseURL: input.baseURL ?? profile.baseURL,
-      provider: profile.provider,
-    })
-    return {
-      id: ProviderID.make(profile.provider),
-      model: facade.model,
-      configure: configureProfile,
-    }
-  }
-  return configureProfile()
-}
+export const profileModel = (
+  profile: OpenAICompatibleProfile,
+  id: string | ModelID,
+  options: FamilyModelOptions = {},
+) =>
+  OpenAICompatibleChat.model({
+    ...options,
+    id,
+    provider: profile.provider,
+    baseURL: options.baseURL ?? profile.baseURL,
+  })
 
-export const provider = {
+const define = (profile: OpenAICompatibleProfile) =>
+  Provider.make({
+    id: ProviderID.make(profile.provider),
+    model: (id: string | ModelID, options: FamilyModelOptions = {}) => profileModel(profile, id, options),
+  })
+
+export const provider = Provider.make({
   id,
-  configure,
-}
+  model: (id: string | ModelID, options: GenericModelOptions) =>
+    model(id, { ...options, provider: options.provider ?? "openai-compatible" }),
+})
 
 export const baseten = define(profiles.baseten)
 export const cerebras = define(profiles.cerebras)

packages/llm/src/providers/openai-options.ts

@@ -59,9 +59,10 @@ export const withOpenAIOptions = <Options extends { readonly providerOptions?: O
   modelID: string,
   options: Options,
   defaults: { readonly textVerbosity?: boolean } = {},
-): Omit<Options, "providerOptions"> & { readonly providerOptions?: ProviderOptions } => {
+): Options & { readonly id: string; readonly providerOptions?: ProviderOptions } => {
   return {
     ...options,
+    id: modelID,
     providerOptions: mergeProviderOptions(openAIDefaultOptions(modelID, defaults), options.providerOptions),
   }
 }

packages/llm/src/providers/openai.ts

@@ -1,5 +1,6 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import type { Route, RouteDefaultsInput } from "../route/client"
+import type { RouteModelInput } from "../route/client"
+import { Provider } from "../provider"
 import { ProviderID, type ModelID } from "../schema"
 import * as OpenAIChat from "../protocols/openai-chat"
 import * as OpenAIResponses from "../protocols/openai-responses"
@@ -14,50 +15,39 @@ export const routes = [OpenAIResponses.route, OpenAIResponses.webSocketRoute, Op
 // This provider facade wraps the lower-level Responses and Chat model factories
 // with OpenAI-specific conveniences: typed options, API-key sugar, env fallback,
 // and default option normalization.
-export type Config = RouteDefaultsInput &
+type OpenAIModelInput<ModelInput> = Omit<ModelInput, "apiKey" | "auth" | "baseURL"> &
   ProviderAuthOption<"optional"> & {
     readonly baseURL?: string
-    readonly queryParams?: Record<string, string>
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "OPENAI_API_KEY")
 
-const defaults = (input: Config) => {
-  const { apiKey: _, auth: _auth, baseURL: _baseURL, queryParams: _queryParams, ...rest } = input
-  return rest
+export const responses = (id: string | ModelID, options: OpenAIModelInput<Omit<RouteModelInput, "id">> = {}) => {
+  const { apiKey: _, ...rest } = options
+  return OpenAIResponses.model(withOpenAIOptions(id, { ...rest, auth: auth(options) }, { textVerbosity: true }))
 }
 
-const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Config) =>
-  route.with({
-    auth: auth(input),
-    endpoint: { baseURL: input.baseURL, query: input.queryParams },
-  })
-
-export const configure = (input: Config = {}) => {
-  const responsesRoute = configuredRoute(OpenAIResponses.route, input)
-  const responsesWebSocketRoute = configuredRoute(OpenAIResponses.webSocketRoute, input)
-  const chatRoute = configuredRoute(OpenAIChat.route, input)
-  const modelDefaults = defaults(input)
-  const responses = (id: string | ModelID) =>
-    responsesRoute.with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true })).model({ id })
-  const responsesWebSocket = (id: string | ModelID) =>
-    responsesWebSocketRoute.with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true })).model({ id })
-  const chat = (id: string | ModelID) => chatRoute.with(withOpenAIOptions(id, modelDefaults)).model({ id })
-
-  return {
-    id,
-    model: responses,
-    responses,
-    responsesWebSocket,
-    chat,
-    configure,
-  }
+export const responsesWebSocket = (
+  id: string | ModelID,
+  options: OpenAIModelInput<Omit<RouteModelInput, "id">> = {},
+) => {
+  const { apiKey: _, ...rest } = options
+  return OpenAIResponses.webSocketModel(
+    withOpenAIOptions(id, { ...rest, auth: auth(options) }, { textVerbosity: true }),
+  )
 }
 
-export const provider = configure()
+export const chat = (id: string | ModelID, options: OpenAIModelInput<Omit<RouteModelInput, "id">> = {}) => {
+  const { apiKey: _, ...rest } = options
+  return OpenAIChat.model(withOpenAIOptions(id, { ...rest, auth: auth(options) }))
+}
+
+export const provider = Provider.make({
+  id,
+  model: responses,
+  apis: { responses, responsesWebSocket, chat },
+})
 
 export const model = provider.model
-export const responses = provider.responses
-export const responsesWebSocket = provider.responsesWebSocket
-export const chat = provider.chat
+export const apis = provider.apis

packages/llm/src/providers/openrouter.ts

@@ -1,9 +1,9 @@
 import { Effect, Schema } from "effect"
-import { Route, type RouteDefaultsInput } from "../route/client"
+import { Route, type RouteModelInput } from "../route/client"
 import { Endpoint } from "../route/endpoint"
 import { Framing } from "../route/framing"
+import { Provider } from "../provider"
 import { Protocol } from "../route/protocol"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
 import { ProviderID, type ModelID, type ProviderOptions } from "../schema"
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile"
 import * as OpenAIChat from "../protocols/openai-chat"
@@ -24,11 +24,11 @@ export type OpenRouterProviderOptionsInput = ProviderOptions & {
   readonly openrouter?: OpenRouterOptions
 }
 
-export type ModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: OpenRouterProviderOptionsInput
-  }
+export type ModelOptions = Omit<RouteModelInput, "id" | "baseURL" | "providerOptions"> & {
+  readonly baseURL?: string
+  readonly providerOptions?: OpenRouterProviderOptionsInput
+}
+type ModelInput = ModelOptions & Pick<RouteModelInput, "id">
 
 const OpenRouterBody = Schema.StructWithRest(Schema.Struct(OpenAIChat.bodyFields), [
   Schema.Record(Schema.String, Schema.Any),
@@ -68,31 +68,21 @@ const bodyOptions = (input: unknown) => {
 
 export const route = Route.make({
   id: ADAPTER,
-  provider: profile.provider,
   protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: profile.baseURL }),
+  endpoint: Endpoint.path("/chat/completions"),
   framing: Framing.sse,
 })
 
 export const routes = [route]
 
-const configuredRoute = (input: ModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  return route.with({
-    ...rest,
-    endpoint: { baseURL: baseURL ?? profile.baseURL },
-    auth: AuthOptions.bearer(input, "OPENROUTER_API_KEY"),
-  })
-}
+const modelRef = Route.model<ModelInput>(route, {
+  provider: profile.provider,
+  baseURL: profile.baseURL,
+})
 
-export const configure = (input: ModelOptions = {}) => {
-  const route = configuredRoute(input)
-  return {
-    id,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
-    configure,
-  }
-}
+export const model = (id: string | ModelID, options: ModelOptions = {}) => modelRef({ ...options, id })
 
-export const provider = configure()
-export const model = provider.model
+export const provider = Provider.make({
+  id,
+  model,
+})

packages/llm/src/providers/xai.ts

@@ -1,5 +1,7 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import type { RouteDefaultsInput } from "../route/client"
+import { Route } from "../route/client"
+import type { RouteModelInput } from "../route/client"
+import { Provider } from "../provider"
 import { ProviderID, type ModelID } from "../schema"
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
@@ -7,50 +9,44 @@ import * as OpenAIResponses from "../protocols/openai-responses"
 
 export const id = ProviderID.make("xai")
 
-export type ModelOptions = RouteDefaultsInput &
+export type ModelOptions = Omit<RouteModelInput, "id" | "apiKey" | "auth" | "baseURL"> &
   ProviderAuthOption<"optional"> & {
     readonly baseURL?: string
   }
 
 export const routes = [OpenAIResponses.route, OpenAICompatibleChat.route]
 
+const responsesModel = Route.model(OpenAIResponses.route, { provider: id })
+const chatModel = OpenAICompatibleChat.model
+
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "XAI_API_KEY")
 
-const configuredResponsesRoute = (input: ModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  return OpenAIResponses.route.with({
+export const responses = (modelID: string | ModelID, options: ModelOptions = {}) => {
+  const { apiKey: _, ...rest } = options
+  return responsesModel({
     ...rest,
-    provider: id,
-    endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
-    auth: auth(input),
+    auth: auth(options),
+    id: modelID,
+    baseURL: options.baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL,
   })
 }
 
-const configuredChatRoute = (input: ModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
-  return OpenAICompatibleChat.route.with({
+export const chat = (modelID: string | ModelID, options: ModelOptions = {}) => {
+  const { apiKey: _, ...rest } = options
+  return chatModel({
     ...rest,
+    auth: auth(options),
+    id: modelID,
     provider: id,
-    endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
-    auth: auth(input),
+    baseURL: options.baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL,
   })
 }
 
-export const configure = (input: ModelOptions = {}) => {
-  const responsesRoute = configuredResponsesRoute(input)
-  const chatRoute = configuredChatRoute(input)
-  const responses = (modelID: string | ModelID) => responsesRoute.model({ id: modelID })
-  const chat = (modelID: string | ModelID) => chatRoute.model({ id: modelID })
-  return {
-    id,
-    model: responses,
-    responses,
-    chat,
-    configure,
-  }
-}
+export const provider = Provider.make({
+  id,
+  model: responses,
+  apis: { responses, chat },
+})
 
-export const provider = configure()
 export const model = provider.model
-export const responses = provider.responses
-export const chat = provider.chat
+export const apis = provider.apis

packages/llm/src/route/auth.ts

@@ -12,7 +12,6 @@ export class MissingCredentialError extends Error {
 
 export type CredentialError = MissingCredentialError | Config.ConfigError
 export type AuthError = CredentialError | LLMError
-type Secret = string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>
 
 export interface AuthInput {
   readonly request: LLMRequest
@@ -23,7 +22,7 @@ export interface AuthInput {
 }
 
 export interface Credential {
-  readonly load: Effect.Effect<Redacted.Redacted, CredentialError>
+  readonly load: Effect.Effect<Redacted.Redacted<string>, CredentialError>
   readonly orElse: (that: Credential) => Credential
   readonly bearer: () => Auth
   readonly header: (name: string) => Auth
@@ -40,7 +39,7 @@ export interface Auth {
 export const isAuth = (input: unknown): input is Auth =>
   typeof input === "object" && input !== null && "apply" in input && typeof input.apply === "function"
 
-const credential = (load: Effect.Effect<Redacted.Redacted, CredentialError>): Credential => {
+const credential = (load: Effect.Effect<Redacted.Redacted<string>, CredentialError>): Credential => {
   const self: Credential = {
     load,
     orElse: (that) => credential(load.pipe(Effect.catch(() => that.load))),
@@ -67,13 +66,16 @@ const fromCredential = (source: Credential, render: (secret: string) => Headers.
     source.load.pipe(Effect.map((secret) => Headers.setAll(input.headers, render(Redacted.value(secret))))),
   )
 
-const secretEffect = (secret: string | Redacted.Redacted, source: string) => {
+const secretEffect = (secret: string | Redacted.Redacted<string>, source: string) => {
   const redacted = typeof secret === "string" ? Redacted.make(secret) : secret
   if (Redacted.value(redacted) === "") return Effect.fail(new MissingCredentialError(source))
   return Effect.succeed(redacted)
 }
 
-const credentialFromSecret = (secret: Secret, source: string) => {
+const credentialFromSecret = (
+  secret: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>>,
+  source: string,
+) => {
   if (typeof secret === "string" || Redacted.isRedacted(secret)) return credential(secretEffect(secret, source))
   return credential(
     Effect.gen(function* () {
@@ -84,14 +86,17 @@ const credentialFromSecret = (secret: Secret, source: string) => {
 
 export const value = (secret: string, source = "value") => credentialFromSecret(secret, source)
 
-export const optional = (secret: Secret | undefined, source = "optional value") =>
+export const optional = (
+  secret: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | undefined,
+  source = "optional value",
+) =>
   secret === undefined
     ? credential(Effect.fail(new MissingCredentialError(source)))
     : credentialFromSecret(secret, source)
 
 export const config = (name: string) => credentialFromSecret(Config.redacted(name), name)
 
-export const effect = (load: Effect.Effect<Redacted.Redacted, CredentialError>) => credential(load)
+export const effect = (load: Effect.Effect<Redacted.Redacted<string>, CredentialError>) => credential(load)
 
 export const none = auth((input) => Effect.succeed(input.headers))
 
@@ -104,32 +109,68 @@ export const custom = (apply: (input: AuthInput) => Effect.Effect<Headers.Header
 
 export const passthrough = none
 
-const credentialInput = (source: Secret | Credential) =>
+const fromModelApiKey = (from: (apiKey: string) => Headers.Input) =>
+  auth(({ request, headers }) => {
+    const key = request.model.apiKey
+    if (!key) return Effect.succeed(headers)
+    return Effect.succeed(Headers.setAll(headers, from(key)))
+  })
+
+const credentialInput = (
+  source: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | Credential,
+) =>
   typeof source === "string" || Redacted.isRedacted(source) || Config.isConfig(source)
     ? credentialFromSecret(source, "value")
     : source
 
-export function bearer(source: Secret | Credential): Auth
-export function bearer(source: Secret | Credential) {
+export function bearer(): Auth
+export function bearer(
+  source: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | Credential,
+): Auth
+export function bearer(
+  source?: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | Credential,
+) {
+  if (source === undefined) return fromModelApiKey((key) => ({ authorization: `Bearer ${key}` }))
   return credentialInput(source).bearer()
 }
 
 export const apiKey = bearer
 
-export function header(name: string): (source: Secret | Credential) => Auth
-export function header(name: string, source: Secret | Credential): Auth
-export function header(name: string, source?: Secret | Credential) {
+export const apiKeyHeader = (name: string) => fromModelApiKey((key) => ({ [name]: key }))
+
+export function header(
+  name: string,
+): (source: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | Credential) => Auth
+export function header(
+  name: string,
+  source: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | Credential,
+): Auth
+export function header(
+  name: string,
+  source?: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | Credential,
+) {
   if (source === undefined) {
-    return (next: Secret | Credential) => credentialInput(next).header(name)
+    return (
+      next: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | Credential,
+    ) => credentialInput(next).header(name)
   }
   return credentialInput(source).header(name)
 }
 
-export function bearerHeader(name: string): (source: Secret | Credential) => Auth
-export function bearerHeader(name: string, source: Secret | Credential): Auth
-export function bearerHeader(name: string, source?: Secret | Credential) {
-  const render = (input: Secret | Credential) =>
-    fromCredential(credentialInput(input), (secret) => ({ [name]: `Bearer ${secret}` }))
+export function bearerHeader(
+  name: string,
+): (source: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | Credential) => Auth
+export function bearerHeader(
+  name: string,
+  source: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | Credential,
+): Auth
+export function bearerHeader(
+  name: string,
+  source?: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | Credential,
+) {
+  const render = (
+    input: string | Redacted.Redacted<string> | Config.Config<string | Redacted.Redacted<string>> | Credential,
+  ) => fromCredential(credentialInput(input), (secret) => ({ [name]: `Bearer ${secret}` }))
   if (source === undefined) return render
   return render(source)
 }

packages/llm/src/route/client.ts

@@ -1,28 +1,31 @@
 import { Cause, Context, Effect, Layer, Schema, Stream } from "effect"
-import * as Option from "effect/Option"
-import { Auth, type Auth as AuthDef } from "./auth"
-import { Endpoint, type EndpointPatch } from "./endpoint"
+import type { Auth as AuthDef } from "./auth"
+import type { Endpoint } from "./endpoint"
 import { RequestExecutor } from "./executor"
 import type { Framing } from "./framing"
 import { HttpTransport } from "./transport"
 import type { Transport, TransportRuntime } from "./transport"
 import { WebSocketExecutor } from "./transport"
+import type { Service as WebSocketExecutorService } from "./transport/websocket"
 import type { Protocol } from "./protocol"
 import { applyCachePolicy } from "../cache-policy"
 import * as ProviderShared from "../protocols/shared"
 import * as ToolRuntime from "../tool-runtime"
 import type { Tools } from "../tool"
-import type { LLMError, LLMEvent, PreparedRequestOf, ProtocolID, ProviderOptions } from "../schema"
+import type { LLMError, LLMEvent, PreparedRequestOf, ProtocolID } from "../schema"
 import {
   GenerationOptions,
   HttpOptions,
   LLMRequest,
   LLMResponse,
-  Model,
+  ModelID,
   ModelLimits,
+  ModelRef,
   LLMError as LLMErrorClass,
+  NoRouteReason,
   PreparedRequest,
   ProviderID,
+  RouteID,
   mergeGenerationOptions,
   mergeHttpOptions,
   mergeProviderOptions,
@@ -39,13 +42,11 @@ export interface Route<Body, Prepared = unknown> {
   readonly id: string
   readonly provider?: ProviderID
   readonly protocol: ProtocolID
-  readonly endpoint: Endpoint<Body>
-  readonly auth: AuthDef
   readonly transport: Transport<Body, Prepared, unknown>
   readonly defaults: RouteDefaults
   readonly body: RouteBody<Body>
   readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared>
-  readonly model: (input: RouteMappedModelInput) => Model
+  readonly model: <Input extends RouteModelInput = RouteModelInput>(input: Input) => ModelRef
   readonly prepareTransport: (body: Body, request: LLMRequest) => Effect.Effect<Prepared, LLMError>
   readonly streamPrepared: (
     prepared: Prepared,
@@ -60,77 +61,116 @@ export interface Route<Body, Prepared = unknown> {
 // oxlint-disable-next-line typescript-eslint/no-explicit-any
 export type AnyRoute = Route<any, any>
 
+const routeRegistry = new Map<string, AnyRoute>()
+
+// Route lookup is intentionally global: model refs name a route id, and
+// importing the provider/protocol/custom-route module registers the runnable
+// implementation. Duplicate ids are bugs because model refs cannot disambiguate
+// them.
+const register = <R extends AnyRoute>(route: R): R => {
+  const existing = routeRegistry.get(route.id)
+  if (existing && existing !== route) throw new Error(`Duplicate LLM route id "${route.id}"`)
+  routeRegistry.set(route.id, route)
+  return route
+}
+
+const registeredRoute = (id: string) => routeRegistry.get(id)
+
 export type HttpOptionsInput = HttpOptions.Input
 
-export type RouteModelInput = Omit<Model.Input, "provider" | "route">
-
-export type RouteRoutedModelInput = Omit<Model.Input, "route">
-
-export interface RouteDefaults {
-  readonly headers?: Record<string, string>
-  readonly limits?: ModelLimits
-  readonly generation?: GenerationOptions
-  readonly providerOptions?: ProviderOptions
-  readonly http?: HttpOptions
-}
-
-export interface RouteDefaultsInput {
-  readonly headers?: Record<string, string>
+export type ModelRefInput = Omit<
+  ConstructorParameters<typeof ModelRef>[0],
+  "id" | "provider" | "route" | "limits" | "generation" | "http" | "auth"
+> & {
+  readonly id: string | ModelID
+  readonly provider: string | ProviderID
+  readonly route: string | RouteID
+  readonly auth?: AuthDef
   readonly limits?: ModelLimits.Input
   readonly generation?: GenerationOptions.Input
-  readonly providerOptions?: ProviderOptions
-  readonly http?: HttpOptions.Input
+  readonly http?: HttpOptionsInput
 }
 
-export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
-  readonly id?: string
+// `baseURL` is required on `ModelRefInput` (every materialized `ModelRef` has
+// a host) but optional at the route-input layers below. The route's `defaults`
+// can supply a canonical URL (e.g. OpenAI/Anthropic) so the user's input may
+// omit it. Routes without a canonical URL (OpenAI-compatible, GitHub Copilot)
+// re-tighten this in their own input type.
+export type RouteModelInput = Omit<ModelRefInput, "provider" | "route" | "baseURL"> & {
+  readonly baseURL?: string
+}
+
+export type RouteModelDefaults = Omit<ModelRefInput, "id" | "route" | "baseURL"> & {
+  readonly baseURL?: string
+}
+
+export type RouteRoutedModelInput = Omit<ModelRefInput, "route" | "baseURL"> & {
+  readonly baseURL?: string
+}
+
+export type RouteRoutedModelDefaults = Partial<Omit<ModelRefInput, "id" | "provider" | "route">>
+
+export type RouteDefaults = Partial<Omit<ModelRefInput, "id" | "provider" | "route">>
+
+export interface RoutePatch<Body, Prepared> extends RouteDefaults {
+  readonly id: string
   readonly provider?: string | ProviderID
-  readonly auth?: AuthDef
   readonly transport?: Transport<Body, Prepared, unknown>
-  readonly endpoint?: EndpointPatch<Body>
 }
 
 type RouteMappedModelInput = RouteModelInput | RouteRoutedModelInput
 
-const makeRouteModel = (route: AnyRoute, mapped: RouteMappedModelInput) => {
-  const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
-  if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
-  if (!endpointBaseURL(route.endpoint))
-    throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`)
-  return Model.make({
-    ...mapped,
-    provider,
-    route,
-  })
+export interface RouteModelOptions<
+  Input extends RouteMappedModelInput,
+  Output extends RouteMappedModelInput = RouteMappedModelInput,
+> {
+  readonly mapInput?: (input: Input) => Output
 }
 
-const mergeRouteDefaults = (base: RouteDefaults | undefined, patch: RouteDefaultsInput): RouteDefaults => {
-  const headers = mergeHeaders(base?.headers, patch.headers)
-  return {
-    ...base,
-    ...patch,
-    headers,
-    limits: patch.limits === undefined ? base?.limits : ModelLimits.make(patch.limits),
-    generation: mergeGenerationOptions(generationOptions(base?.generation), generationOptions(patch.generation)),
-    providerOptions: mergeProviderOptions(base?.providerOptions, patch.providerOptions),
-    http: mergeHttpOptions(
-      base?.http,
-      httpOptions(patch.http),
-      headers === undefined ? undefined : new HttpOptions({ headers }),
-    ),
+export interface RouteMappedModelOptions<Input, Output extends RouteMappedModelInput = RouteMappedModelInput> {
+  readonly mapInput: (input: Input) => Output
+}
+
+const modelWithDefaults =
+  <Input>(
+    route: AnyRoute,
+    defaults: Partial<Omit<ModelRefInput, "id" | "route">>,
+    options: { readonly mapInput?: (input: Input) => RouteMappedModelInput },
+  ) =>
+  (input: Input) => {
+    const mapped = options.mapInput === undefined ? (input as RouteMappedModelInput) : options.mapInput(input)
+    const provider = defaults.provider ?? route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
+    if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
+    const baseURL = mapped.baseURL ?? defaults.baseURL ?? route.defaults.baseURL
+    if (!baseURL)
+      throw new Error(`Route.model(${route.id}) requires a baseURL — supply it via input, defaults, or route defaults`)
+    const generation = mergeGenerationOptions(route.defaults.generation, defaults.generation)
+    const providerOptions = mergeProviderOptions(route.defaults.providerOptions, defaults.providerOptions)
+    const http = mergeHttpOptions(httpOptions(route.defaults.http), httpOptions(defaults.http))
+    return modelRef({
+      ...route.defaults,
+      ...defaults,
+      ...mapped,
+      baseURL,
+      provider,
+      route: route.id,
+      limits: mapped.limits ?? defaults.limits ?? route.defaults.limits,
+      generation: mergeGenerationOptions(generation, mapped.generation),
+      providerOptions: mergeProviderOptions(providerOptions, mapped.providerOptions),
+      http: mergeHttpOptions(http, httpOptions(mapped.http)),
+    })
   }
-}
 
-const endpointBaseURL = <Body>(endpoint: Endpoint<Body>) =>
-  typeof endpoint.baseURL === "string" ? endpoint.baseURL : undefined
+const mergeRouteDefaults = (base: RouteDefaults | undefined, patch: RouteDefaults): RouteDefaults => ({
+  ...base,
+  ...patch,
+  limits: patch.limits ?? base?.limits,
+  generation: mergeGenerationOptions(generationOptions(base?.generation), generationOptions(patch.generation)),
+  providerOptions: mergeProviderOptions(base?.providerOptions, patch.providerOptions),
+  http: mergeHttpOptions(httpOptions(base?.http), httpOptions(patch.http)),
+})
 
-const mergeHeaders = (...items: ReadonlyArray<Record<string, string> | undefined>) => {
-  const entries = items.flatMap((item) =>
-    item === undefined ? [] : Object.entries(item).filter((entry): entry is [string, string] => entry[1] !== undefined),
-  )
-  if (entries.length === 0) return undefined
-  return Object.fromEntries(entries)
-}
+export const modelLimits = ModelLimits.make
 
 export const generationOptions = (input: GenerationOptions.Input | undefined) =>
   input === undefined ? undefined : GenerationOptions.make(input)
@@ -140,6 +180,40 @@ export const httpOptions = (input: HttpOptionsInput | undefined) => {
   return HttpOptions.make(input)
 }
 
+export const modelRef = (input: ModelRefInput) =>
+  new ModelRef({
+    ...input,
+    id: ModelID.make(input.id),
+    provider: ProviderID.make(input.provider),
+    route: RouteID.make(input.route),
+    limits: modelLimits(input.limits),
+    generation: generationOptions(input.generation),
+    http: httpOptions(input.http),
+  })
+
+function model<Input extends RouteModelInput = RouteModelInput>(
+  route: AnyRoute,
+  defaults: RouteModelDefaults,
+  options?: RouteModelOptions<Input, RouteModelInput>,
+): (input: Input) => ModelRef
+function model<Input extends RouteRoutedModelInput = RouteRoutedModelInput>(
+  route: AnyRoute,
+  defaults?: RouteRoutedModelDefaults,
+  options?: RouteModelOptions<Input, RouteRoutedModelInput>,
+): (input: Input) => ModelRef
+function model<Input, Output extends RouteMappedModelInput = RouteMappedModelInput>(
+  route: AnyRoute,
+  defaults: Partial<Omit<ModelRefInput, "id" | "route">>,
+  options: RouteMappedModelOptions<Input, Output>,
+): (input: Input) => ModelRef
+function model<Input>(
+  route: AnyRoute,
+  defaults: Partial<Omit<ModelRefInput, "id" | "route">> = {},
+  options: { readonly mapInput?: (input: Input) => RouteMappedModelInput } = {},
+) {
+  return modelWithDefaults(route, defaults, options)
+}
+
 export interface Interface {
   /**
    * Compile a request through protocol body construction, validation, and HTTP
@@ -168,16 +242,22 @@ export interface GenerateMethod {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/LLMClient") {}
 
+const noRoute = (model: ModelRef) =>
+  new LLMErrorClass({
+    module: "LLMClient",
+    method: "resolveRoute",
+    reason: new NoRouteReason({ route: model.route, provider: model.provider, model: model.id }),
+  })
+
 const resolveRequestOptions = (request: LLMRequest) =>
   LLMRequest.update(request, {
-    generation:
-      mergeGenerationOptions(request.model.route.defaults.generation, request.generation) ?? new GenerationOptions({}),
-    providerOptions: mergeProviderOptions(request.model.route.defaults.providerOptions, request.providerOptions),
-    http: mergeHttpOptions(request.model.route.defaults.http, request.http),
+    generation: mergeGenerationOptions(request.model.generation, request.generation) ?? new GenerationOptions({}),
+    providerOptions: mergeProviderOptions(request.model.providerOptions, request.providerOptions),
+    http: mergeHttpOptions(request.model.http, request.http),
   })
 
 export interface MakeInput<Body, Frame, Event, State> {
-  /** Route id used in diagnostics and prepared request metadata. */
+  /** Route id used in registry lookup and error messages. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
   readonly provider?: string | ProviderID
@@ -185,33 +265,27 @@ export interface MakeInput<Body, Frame, Event, State> {
   readonly protocol: Protocol<Body, Frame, Event, State>
   /** Where the request is sent. */
   readonly endpoint: Endpoint<Body>
-  /** Per-request transport auth. Provider facades override this via `route.with(...)`. */
+  /** Per-request transport auth. Model-level `Auth` overrides this. */
   readonly auth?: AuthDef
   /** Stream framing — bytes -> frames before `protocol.stream.event` decoding. */
   readonly framing: Framing<Frame>
   /** Static / per-request headers added before `auth` runs. */
   readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
-  /** Route/request defaults used when compiling requests for this route. */
-  readonly defaults?: RouteDefaultsInput
+  /** Model defaults used by the route's `.model(...)` helper. */
+  readonly defaults?: RouteDefaults
 }
 
 export interface MakeTransportInput<Body, Prepared, Frame, Event, State> {
-  /** Route id used in diagnostics and prepared request metadata. */
+  /** Route id used in registry lookup and error messages. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
   readonly provider?: string | ProviderID
   /** Semantic API contract — owns body construction, body schema, and parsing. */
   readonly protocol: Protocol<Body, Frame, Event, State>
-  /** Where the request is sent. */
-  readonly endpoint: Endpoint<Body>
-  /** Per-request transport auth. Provider facades override this via `route.with(...)`. */
-  readonly auth?: AuthDef
-  /** Static / per-request headers added before `auth` runs. */
-  readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
   /** Runnable transport route. */
   readonly transport: Transport<Body, Prepared, Frame>
-  /** Route/request defaults used when compiling requests for this route. */
-  readonly defaults?: RouteDefaultsInput
+  /** Provider/model defaults used by the route's `.model(...)` helper. */
+  readonly defaults?: RouteDefaults
 }
 
 const streamError = (route: string, message: string, cause: Cause.Cause<unknown>) => {
@@ -224,7 +298,6 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
   input: MakeTransportInput<Body, Prepared, Frame, Event, State>,
 ): Route<Body, Prepared> {
   const protocol = input.protocol
-  const encodeBody = Schema.encodeSync(Schema.fromJsonString(protocol.body.schema))
   const decodeEventEffect = Schema.decodeUnknownEffect(protocol.stream.event)
   const decodeEvent = (route: string) => (frame: Frame) =>
     decodeEventEffect(frame).pipe(
@@ -237,44 +310,29 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
       ),
     )
 
-  type BuiltRouteInput = Omit<MakeTransportInput<Body, Prepared, Frame, Event, State>, "defaults"> & {
-    readonly defaults?: RouteDefaults
-  }
-
-  const build = (routeInput: BuiltRouteInput): Route<Body, Prepared> => {
+  const build = (routeInput: MakeTransportInput<Body, Prepared, Frame, Event, State>): Route<Body, Prepared> => {
     const route: Route<Body, Prepared> = {
       id: routeInput.id,
       provider: routeInput.provider === undefined ? undefined : ProviderID.make(routeInput.provider),
       protocol: protocol.id,
-      endpoint: routeInput.endpoint,
-      auth: routeInput.auth ?? Auth.none,
       transport: routeInput.transport,
       defaults: routeInput.defaults ?? {},
       body: protocol.body,
       with: (patch: RoutePatch<Body, Prepared>) => {
-        const { id, provider, auth, transport, endpoint, ...defaults } = patch
+        const { id, provider, transport, ...defaults } = patch
+        if (!id || id === routeInput.id) throw new Error(`Route.with(${routeInput.id}) requires a new route id`)
         return build({
           ...routeInput,
-          id: id ?? routeInput.id,
+          id,
           provider: provider ?? routeInput.provider,
-          auth: auth ?? routeInput.auth,
-          endpoint: endpoint ? Endpoint.merge(routeInput.endpoint, endpoint) : routeInput.endpoint,
           transport: (transport as Transport<Body, Prepared, Frame> | undefined) ?? routeInput.transport,
-          defaults: mergeRouteDefaults(route.defaults, defaults),
+          defaults: mergeRouteDefaults(routeInput.defaults, defaults),
         })
       },
-      model: (input) => makeRouteModel(route, input),
-      prepareTransport: (body, request) =>
-        routeInput.transport.prepare({
-          body,
-          request,
-          endpoint: routeInput.endpoint,
-          auth: routeInput.auth ?? Auth.none,
-          encodeBody,
-          headers: routeInput.headers,
-        }),
+      model: (input: RouteModelInput): ModelRef => modelWithDefaults<RouteModelInput>(route, {}, {})(input),
+      prepareTransport: routeInput.transport.prepare,
       streamPrepared: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => {
-        const route = `${request.model.provider}/${request.model.route.id}`
+        const route = `${request.model.provider}/${request.model.route}`
         const events = routeInput.transport
           .frames(prepared, request, runtime)
           .pipe(
@@ -291,10 +349,10 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
         )
       },
     } satisfies Route<Body, Prepared>
-    return route
+    return register(route)
   }
 
-  return build({ ...input, defaults: mergeRouteDefaults(undefined, input.defaults ?? {}) })
+  return build(input)
 }
 
 export function make<Body, Prepared, Frame, Event, State>(
@@ -323,14 +381,18 @@ export function make<Body, Prepared, Frame, Event, State>(
 ): Route<Body, Prepared> | Route<Body, HttpTransport.HttpPrepared<Frame>> {
   if ("transport" in input) return makeFromTransport(input)
   const protocol = input.protocol
+  const encodeBody = Schema.encodeSync(Schema.fromJsonString(protocol.body.schema))
   return makeFromTransport({
     id: input.id,
     provider: input.provider,
     protocol,
-    endpoint: input.endpoint,
-    auth: input.auth,
-    headers: input.headers,
-    transport: HttpTransport.httpJson({ framing: input.framing }),
+    transport: HttpTransport.httpJson({
+      endpoint: input.endpoint,
+      auth: input.auth,
+      framing: input.framing,
+      encodeBody,
+      headers: input.headers,
+    }),
     defaults: input.defaults,
   })
 }
@@ -340,7 +402,8 @@ export function make<Body, Prepared, Frame, Event, State>(
 // execute transport.
 const compile = Effect.fn("LLM.compile")(function* (request: LLMRequest) {
   const resolved = applyCachePolicy(resolveRequestOptions(request))
-  const route = resolved.model.route
+  const route = registeredRoute(resolved.model.route)
+  if (!route) return yield* noRoute(resolved.model)
 
   const body = yield* route.body
     .from(resolved)
@@ -432,21 +495,31 @@ export const streamRequest = (request: LLMRequest) =>
 export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const stream = streamWith(
-      streamRequestWith({
-        http: yield* RequestExecutor.Service,
-        webSocket: Option.getOrUndefined(yield* Effect.serviceOption(WebSocketExecutor.Service)),
-      }),
-    )
+    const stream = streamWith(streamRequestWith({ http: yield* RequestExecutor.Service }))
     return Service.of({ prepare: prepareWith as Interface["prepare"], stream, generate: generateWith(stream) })
   }),
 )
 
-export const Route = { make } as const
+export const layerWithWebSocket: Layer.Layer<Service, never, RequestExecutor.Service | WebSocketExecutorService> =
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const stream = streamWith(
+        streamRequestWith({
+          http: yield* RequestExecutor.Service,
+          webSocket: yield* WebSocketExecutor.Service,
+        }),
+      )
+      return Service.of({ prepare: prepareWith as Interface["prepare"], stream, generate: generateWith(stream) })
+    }),
+  )
+
+export const Route = { make, model } as const
 
 export const LLMClient = {
   Service,
   layer,
+  layerWithWebSocket,
   prepare,
   stream,
   generate,

packages/llm/src/route/endpoint.ts

@@ -11,42 +11,28 @@ export type EndpointPart<Body> = string | ((input: EndpointInput<Body>) => strin
 /**
  * Declarative URL construction for one route.
  *
- * `Endpoint` carries URL construction for one route. Routes with a canonical
- * host put `baseURL` here; provider helpers can override it by configuring the
- * route before selecting a model.
+ * `Endpoint` carries only the path. The host always lives on `model.baseURL`,
+ * supplied by the provider helper that constructs the model. `render(...)`
+ * just appends the path (and any `model.queryParams`) to that host.
  *
  * `path` may be a string or a function of `EndpointInput`, for routes whose
  * URL embeds the model id, region, or another body field (e.g. Bedrock,
  * Gemini).
  */
 export interface Endpoint<Body> {
-  readonly baseURL?: string
   readonly path: EndpointPart<Body>
-  readonly query?: Record<string, string>
 }
 
-export type EndpointPatch<Body> = Partial<Endpoint<Body>>
-
 /** Construct an `Endpoint` from a path string or path function. */
-export const path = <Body>(value: EndpointPart<Body>, options: Omit<Endpoint<Body>, "path"> = {}): Endpoint<Body> => ({
-  ...options,
-  path: value,
-})
-
-export const merge = <Body>(base: Endpoint<Body>, patch: EndpointPatch<Body>): Endpoint<Body> => ({
-  ...base,
-  ...patch,
-  baseURL: patch.baseURL ?? base.baseURL,
-  path: patch.path ?? base.path,
-  query: patch.query === undefined ? base.query : { ...base.query, ...patch.query },
-})
+export const path = <Body>(value: EndpointPart<Body>): Endpoint<Body> => ({ path: value })
 
 const renderPart = <Body>(part: EndpointPart<Body>, input: EndpointInput<Body>) =>
   typeof part === "function" ? part(input) : part
 
 export const render = <Body>(endpoint: Endpoint<Body>, input: EndpointInput<Body>) => {
-  const url = new URL(`${ProviderShared.trimBaseUrl(endpoint.baseURL ?? "")}${renderPart(endpoint.path, input)}`)
-  for (const [key, value] of Object.entries(endpoint.query ?? {})) url.searchParams.set(key, value)
+  const url = new URL(`${ProviderShared.trimBaseUrl(input.request.model.baseURL)}${renderPart(endpoint.path, input)}`)
+  const params = input.request.model.queryParams
+  if (params) for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value)
   return url
 }
 

packages/llm/src/route/index.ts

@@ -1,13 +1,14 @@
-export { Route, LLMClient } from "./client"
+export { Route, LLMClient, modelLimits, modelRef } from "./client"
 export type {
   Route as RouteShape,
+  RouteModelDefaults,
   RouteModelInput,
+  RouteRoutedModelDefaults,
   RouteRoutedModelInput,
-  RouteDefaults,
-  RouteDefaultsInput,
   AnyRoute,
   Interface as LLMClientShape,
   Service as LLMClientService,
+  ModelRefInput,
 } from "./client"
 export * from "./executor"
 export { Auth } from "./auth"

packages/llm/src/route/transport/http.ts

@@ -1,13 +1,20 @@
 import { Effect, Stream } from "effect"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
-import { Auth } from "../auth"
-import { render as renderEndpoint } from "../endpoint"
-import { Framing, type Framing as FramingDef } from "../framing"
-import type { Transport, TransportPrepareInput } from "./index"
+import { Auth, type Auth as AuthDef } from "../auth"
+import { type Endpoint, render as renderEndpoint } from "../endpoint"
+import type { Framing } from "../framing"
+import type { Transport } from "./index"
 import * as ProviderShared from "../../protocols/shared"
 import { mergeJsonRecords, type LLMRequest } from "../../schema"
 
-export type JsonRequestInput<Body> = TransportPrepareInput<Body>
+export interface JsonRequestInput<Body> {
+  readonly body: Body
+  readonly request: LLMRequest
+  readonly endpoint: Endpoint<Body>
+  readonly auth: AuthDef
+  readonly encodeBody: (body: Body) => string
+  readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
+}
 
 export interface JsonRequestParts<Body = unknown> {
   readonly url: string
@@ -18,7 +25,7 @@ export interface JsonRequestParts<Body = unknown> {
 
 export interface HttpPrepared<Frame> {
   readonly request: HttpClientRequest.HttpClientRequest
-  readonly framing: FramingDef<Frame>
+  readonly framing: Framing<Frame>
 }
 
 const applyQuery = (url: string, query: Record<string, string> | undefined) => {
@@ -45,21 +52,28 @@ export const jsonRequestParts = <Body>(input: JsonRequestInput<Body>) =>
       input.request.http?.query,
     )
     const body = yield* bodyWithOverlay(input.body, input.request, input.encodeBody)
-    const headers = yield* Auth.toEffect(input.auth)({
-      request: input.request,
-      method: "POST",
-      url,
-      body: body.bodyText,
-      headers: Headers.fromInput({
-        ...input.headers?.({ request: input.request }),
-        ...input.request.http?.headers,
-      }),
-    })
+    const headers = yield* Auth.toEffect(Auth.isAuth(input.request.model.auth) ? input.request.model.auth : input.auth)(
+      {
+        request: input.request,
+        method: "POST",
+        url,
+        body: body.bodyText,
+        headers: Headers.fromInput({
+          ...(input.headers?.({ request: input.request }) ?? {}),
+          ...input.request.model.headers,
+          ...input.request.http?.headers,
+        }),
+      },
+    )
     return { url, jsonBody: body.jsonBody, bodyText: body.bodyText, headers }
   })
 
-export interface HttpJsonInput<_Body, Frame> {
-  readonly framing: FramingDef<Frame>
+export interface HttpJsonInput<Body, Frame> {
+  readonly endpoint: Endpoint<Body>
+  readonly auth?: AuthDef
+  readonly framing: Framing<Frame>
+  readonly encodeBody: (body: Body) => string
+  readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
 }
 
 export type HttpJsonPatch<Body, Frame> = Partial<HttpJsonInput<Body, Frame>>
@@ -71,9 +85,14 @@ export interface HttpJsonTransport<Body, Frame> extends Transport<Body, HttpPrep
 export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJsonTransport<Body, Frame> => ({
   id: "http-json",
   with: (patch) => httpJson({ ...input, ...patch }),
-  prepare: (prepareInput) =>
+  prepare: (body, request) =>
     jsonRequestParts({
-      ...prepareInput,
+      body,
+      request,
+      endpoint: input.endpoint,
+      auth: input.auth ?? Auth.bearer(),
+      encodeBody: input.encodeBody,
+      headers: input.headers,
     }).pipe(
       Effect.map((parts) => ({
         request: ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),
@@ -90,8 +109,8 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
               response.stream.pipe(
                 Stream.mapError((error) =>
                   ProviderShared.eventError(
-                    `${request.model.provider}/${request.model.route.id}`,
-                    `Failed to read ${request.model.provider}/${request.model.route.id} stream`,
+                    `${request.model.provider}/${request.model.route}`,
+                    `Failed to read ${request.model.provider}/${request.model.route} stream`,
                     ProviderShared.errorText(error),
                   ),
                 ),
@@ -101,8 +120,3 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
         ),
     ),
 })
-
-export const sseJson = {
-  id: "http-json/sse",
-  with: <Body>() => httpJson<Body, string>({ framing: Framing.sse }),
-} as const

packages/llm/src/route/transport/index.ts

@@ -1,6 +1,4 @@
 import type { Effect, Stream } from "effect"
-import type { Endpoint } from "../endpoint"
-import type { Auth } from "../auth"
 import type { Interface as RequestExecutorInterface } from "../executor"
 import type { Interface as WebSocketExecutorInterface } from "./websocket"
 import type { LLMError, LLMRequest } from "../../schema"
@@ -12,7 +10,7 @@ export interface TransportRuntime {
 
 export interface Transport<Body, Prepared, Frame> {
   readonly id: string
-  readonly prepare: (input: TransportPrepareInput<Body>) => Effect.Effect<Prepared, LLMError>
+  readonly prepare: (body: Body, request: LLMRequest) => Effect.Effect<Prepared, LLMError>
   readonly frames: (
     prepared: Prepared,
     request: LLMRequest,
@@ -20,14 +18,5 @@ export interface Transport<Body, Prepared, Frame> {
   ) => Stream.Stream<Frame, LLMError>
 }
 
-export interface TransportPrepareInput<Body> {
-  readonly body: Body
-  readonly request: LLMRequest
-  readonly endpoint: Endpoint<Body>
-  readonly auth: Auth
-  readonly encodeBody: (body: Body) => string
-  readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
-}
-
 export * as HttpTransport from "./http"
 export { WebSocketExecutor, WebSocketTransport } from "./websocket"

packages/llm/src/route/transport/websocket.ts

@@ -1,6 +1,7 @@
-import { Cause, Context, Effect, Layer, Queue, Stream } from "effect"
+import { Cause, Context, Effect, Queue, Stream } from "effect"
 import { Headers } from "effect/unstable/http"
-import { Auth } from "../auth"
+import { Auth, type Auth as AuthDef } from "../auth"
+import type { Endpoint } from "../endpoint"
 import { LLMError, TransportReason, type LLMRequest } from "../../schema"
 import * as HttpTransport from "./http"
 import type { Transport } from "./index"
@@ -134,8 +135,6 @@ export const open = (input: WebSocketRequest) =>
       }),
   }).pipe(Effect.flatMap((ws) => fromWebSocket(ws, input)))
 
-export const layer: Layer.Layer<Service> = Layer.succeed(Service, Service.of({ open }))
-
 export const fromWebSocket = (
   ws: globalThis.WebSocket,
   input: WebSocketRequest,
@@ -214,8 +213,12 @@ export interface JsonPrepared {
 }
 
 export interface JsonInput<Body, Message> {
+  readonly endpoint: Endpoint<Body>
+  readonly auth?: AuthDef
+  readonly encodeBody: (body: Body) => string
   readonly toMessage: (body: Body | Record<string, unknown>) => Effect.Effect<Message, LLMError>
   readonly encodeMessage: (message: Message) => string
+  readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
 }
 
 export type JsonPatch<Body, Message> = Partial<JsonInput<Body, Message>>
@@ -227,10 +230,15 @@ export interface JsonTransport<Body, Message> extends Transport<Body, JsonPrepar
 export const json = <Body, Message>(input: JsonInput<Body, Message>): JsonTransport<Body, Message> => ({
   id: "websocket-json",
   with: (patch) => json({ ...input, ...patch }),
-  prepare: (prepareInput) =>
+  prepare: (body, request) =>
     Effect.gen(function* () {
       const parts = yield* HttpTransport.jsonRequestParts({
-        ...prepareInput,
+        body,
+        request,
+        endpoint: input.endpoint,
+        auth: input.auth ?? Auth.bearer(),
+        encodeBody: input.encodeBody,
+        headers: input.headers,
       })
       return {
         url: yield* webSocketUrl(parts.url),
@@ -262,14 +270,8 @@ export const json = <Body, Message>(input: JsonInput<Body, Message>): JsonTransp
   },
 })
 
-export const jsonTransport = {
-  id: "websocket-json",
-  with: json,
-} as const
-
 export const WebSocketExecutor = {
   Service,
-  layer,
   open,
   fromWebSocket,
   messageText,
@@ -277,5 +279,4 @@ export const WebSocketExecutor = {
 
 export const WebSocketTransport = {
   json,
-  jsonTransport,
 } as const

packages/llm/src/schema/events.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect"
 import { ContentBlockID, FinishReason, ProtocolID, ProviderMetadata, RouteID, ToolCallID } from "./ids"
-import { ModelSchema } from "./options"
+import { ModelRef } from "./options"
 import { ToolResultValue } from "./messages"
 
 /**
@@ -290,7 +290,7 @@ export class PreparedRequest extends Schema.Class<PreparedRequest>("LLM.Prepared
   id: Schema.String,
   route: RouteID,
   protocol: ProtocolID,
-  model: ModelSchema,
+  model: ModelRef,
   body: Schema.Unknown,
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 }) {}

packages/llm/src/schema/messages.ts

@@ -1,7 +1,9 @@
 import { Schema } from "effect"
 import { JsonSchema, MessageRole, ProviderMetadata } from "./ids"
-import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, ModelSchema, ProviderOptions } from "./options"
-import { isRecord } from "../utils/record"
+import { CacheHint, CachePolicy, GenerationOptions, HttpOptions, ModelRef, ProviderOptions } from "./options"
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
 
 const systemPartSchema = Schema.Struct({
   type: Schema.Literal("text"),
@@ -39,49 +41,17 @@ export const MediaPart = Schema.Struct({
 }).annotate({ identifier: "LLM.Content.Media" })
 export type MediaPart = Schema.Schema.Type<typeof MediaPart>
 
-export const ToolResultMediaPart = Schema.Struct({
-  type: Schema.Literal("media"),
-  mediaType: Schema.String,
-  data: Schema.String,
-  filename: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}).annotate({ identifier: "LLM.ToolResult.Media" })
-export type ToolResultMediaPart = Schema.Schema.Type<typeof ToolResultMediaPart>
-
-export const ToolResultContentPart = Schema.Union([TextPart, ToolResultMediaPart])
-export type ToolResultContentPart = Schema.Schema.Type<typeof ToolResultContentPart>
-
 const isToolResultValue = (value: unknown): value is ToolResultValue =>
-  isRecord(value) &&
-  (value.type === "text" || value.type === "json" || value.type === "error" || value.type === "content") &&
-  "value" in value
+  isRecord(value) && (value.type === "text" || value.type === "json" || value.type === "error") && "value" in value
 
 export const ToolResultValue = Object.assign(
-  Schema.Union([
-    Schema.Struct({
-      type: Schema.Literal("json"),
-      value: Schema.Unknown,
-    }),
-    Schema.Struct({
-      type: Schema.Literal("text"),
-      value: Schema.Unknown,
-    }),
-    Schema.Struct({
-      type: Schema.Literal("error"),
-      value: Schema.Unknown,
-    }),
-    Schema.Struct({
-      type: Schema.Literal("content"),
-      value: Schema.Array(ToolResultContentPart),
-    }),
-  ]).annotate({ identifier: "LLM.ToolResult" }),
+  Schema.Struct({
+    type: Schema.Literals(["json", "text", "error"]),
+    value: Schema.Unknown,
+  }).annotate({ identifier: "LLM.ToolResult" }),
   {
-    is: isToolResultValue,
-    make: (value: unknown, type: ToolResultValue["type"] = "json"): ToolResultValue => {
-      if (isToolResultValue(value)) return value
-      if (type === "content") return { type, value: Array.isArray(value) ? value : [] }
-      return { type, value }
-    },
+    make: (value: unknown, type: ToolResultValue["type"] = "json"): ToolResultValue =>
+      isToolResultValue(value) ? value : { type, value },
   },
 )
 export type ToolResultValue = Schema.Schema.Type<typeof ToolResultValue>
@@ -227,7 +197,7 @@ export type ResponseFormat = Schema.Schema.Type<typeof ResponseFormat>
 
 export class LLMRequest extends Schema.Class<LLMRequest>("LLM.Request")({
   id: Schema.optional(Schema.String),
-  model: ModelSchema,
+  model: ModelRef,
   system: Schema.Array(SystemPart),
   messages: Schema.Array(Message),
   tools: Schema.Array(ToolDefinition),

packages/llm/src/schema/options.ts

@@ -1,7 +1,8 @@
 import { Schema } from "effect"
-import { JsonSchema, ModelID, ProviderID } from "./ids"
-import type { AnyRoute } from "../route/client"
-import { isRecord } from "../utils/record"
+import { JsonSchema, ModelID, ProviderID, RouteID } from "./ids"
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
 
 export const mergeJsonRecords = (
   ...items: ReadonlyArray<Record<string, unknown> | undefined>
@@ -134,59 +135,67 @@ export namespace ModelLimits {
     input instanceof ModelLimits ? input : new ModelLimits(input ?? {})
 }
 
-export class Model {
-  readonly id: ModelID
-  readonly provider: ProviderID
-  readonly route: AnyRoute
+export class ModelRef extends Schema.Class<ModelRef>("LLM.ModelRef")({
+  id: ModelID,
+  provider: ProviderID,
+  route: RouteID,
+  baseURL: Schema.String,
+  /** Provider-specific API key convenience. Provider helpers normalize this into `auth`. */
+  apiKey: Schema.optional(Schema.String),
+  /** Optional transport auth policy. Opaque because it may contain functions. */
+  auth: Schema.optional(Schema.Any),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  /**
+   * Query params appended to the request URL by `Endpoint.baseURL`. Used for
+   * deployment-level URL-scoped settings such as Azure's `api-version` or any
+   * provider that requires a per-request key in the URL. Generic concern, so
+   * lives as a typed first-class field instead of `native`.
+   */
+  queryParams: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  limits: ModelLimits,
+  /** Provider-neutral generation defaults. Request-level values override them. */
+  generation: Schema.optional(GenerationOptions),
+  /** Provider-owned typed-at-the-facade options for non-portable knobs. */
+  providerOptions: Schema.optional(ProviderOptions),
+  /** Serializable raw HTTP overlays applied to the final outgoing request. */
+  http: Schema.optional(HttpOptions),
+  /**
+   * Provider-specific opaque options. Reach for this only when the value is
+   * genuinely provider-private and does not fit a typed axis (e.g. Bedrock's
+   * `aws_credentials` / `aws_region` for SigV4). Anything used by more than
+   * one route should grow into a typed field instead.
+   */
+  native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}) {}
 
-  constructor(input: Model.ConstructorInput) {
-    this.id = input.id
-    this.provider = input.provider
-    this.route = input.route
-  }
+export namespace ModelRef {
+  export type Input = ConstructorParameters<typeof ModelRef>[0]
 
-  static make(input: Model.Input) {
-    return new Model({
-      id: ModelID.make(input.id),
-      provider: ProviderID.make(input.provider),
-      route: input.route,
-    })
-  }
+  export const input = (model: ModelRef): Input => ({
+    id: model.id,
+    provider: model.provider,
+    route: model.route,
+    baseURL: model.baseURL,
+    apiKey: model.apiKey,
+    auth: model.auth,
+    headers: model.headers,
+    queryParams: model.queryParams,
+    limits: model.limits,
+    generation: model.generation,
+    providerOptions: model.providerOptions,
+    http: model.http,
+    native: model.native,
+  })
 
-  static input(model: Model): Model.ConstructorInput {
-    return {
-      id: model.id,
-      provider: model.provider,
-      route: model.route,
-    }
-  }
-
-  static update(model: Model, patch: Partial<Model.Input>) {
+  export const update = (model: ModelRef, patch: Partial<Input>) => {
     if (Object.keys(patch).length === 0) return model
-    return Model.make({
-      ...Model.input(model),
+    return new ModelRef({
+      ...input(model),
       ...patch,
     })
   }
 }
 
-export namespace Model {
-  export type ConstructorInput = {
-    readonly id: ModelID
-    readonly provider: ProviderID
-    readonly route: AnyRoute
-  }
-
-  export type Input = Omit<ConstructorInput, "id" | "provider"> & {
-    readonly id: string | ModelID
-    readonly provider: string | ProviderID
-  }
-}
-
-export type ModelInput = Model.Input
-
-export const ModelSchema = Schema.declare((value): value is Model => value instanceof Model, { expected: "LLM.Model" })
-
 export class CacheHint extends Schema.Class<CacheHint>("LLM.CacheHint")({
   type: Schema.Literals(["ephemeral", "persistent"]),
   ttlSeconds: Schema.optional(Schema.Number),

packages/llm/src/tool-runtime.ts

@@ -11,8 +11,7 @@ import {
   ToolCallPart,
   ToolFailure,
   ToolResultPart,
-  ToolResultValue,
-  type ToolResultValue as ToolResultValueType,
+  type ToolResultValue,
   Usage,
 } from "./schema"
 import { type AnyTool, type ExecutableTools, type Tools, toDefinitions } from "./tool"
@@ -277,10 +276,7 @@ const appendStreamingText = (
   state.assistantContent.push({ type, text, providerMetadata })
 }
 
-const dispatch = (
-  tools: Tools,
-  call: ToolCallPart,
-): Effect.Effect<{ result: ToolResultValueType; error?: unknown }> => {
+const dispatch = (tools: Tools, call: ToolCallPart): Effect.Effect<{ result: ToolResultValue; error?: unknown }> => {
   const tool = tools[call.name]
   if (!tool) return Effect.succeed({ result: { type: "error" as const, value: `Unknown tool: ${call.name}` } })
   if (!tool.execute)
@@ -289,7 +285,7 @@ const dispatch = (
   return decodeAndExecute(tool, call).pipe(
     Effect.catchTag("LLM.ToolFailure", (failure) =>
       Effect.succeed({
-        result: { type: "error" as const, value: failure.message } satisfies ToolResultValueType,
+        result: { type: "error" as const, value: failure.message } satisfies ToolResultValue,
         error: failure.error,
       }),
     ),
@@ -297,7 +293,7 @@ const dispatch = (
   )
 }
 
-const decodeAndExecute = (tool: AnyTool, call: ToolCallPart): Effect.Effect<ToolResultValueType, ToolFailure> =>
+const decodeAndExecute = (tool: AnyTool, call: ToolCallPart): Effect.Effect<ToolResultValue, ToolFailure> =>
   tool._decode(call.input).pipe(
     Effect.mapError((error) => new ToolFailure({ message: `Invalid tool input: ${error.message}` })),
     Effect.flatMap((decoded) => tool.execute!(decoded, { id: call.id, name: call.name })),
@@ -311,12 +307,10 @@ const decodeAndExecute = (tool: AnyTool, call: ToolCallPart): Effect.Effect<Tool
         ),
       ),
     ),
-    Effect.map(
-      (encoded): ToolResultValueType => (ToolResultValue.is(encoded) ? encoded : { type: "json", value: encoded }),
-    ),
+    Effect.map((encoded): ToolResultValue => ({ type: "json", value: encoded })),
   )
 
-const emitEvents = (call: ToolCallPart, result: ToolResultValueType, error: unknown): ReadonlyArray<LLMEvent> =>
+const emitEvents = (call: ToolCallPart, result: ToolResultValue, error: unknown): ReadonlyArray<LLMEvent> =>
   result.type === "error"
     ? [
         LLMEvent.toolError({ id: call.id, name: call.name, message: String(result.value), error }),
@@ -327,7 +321,7 @@ const emitEvents = (call: ToolCallPart, result: ToolResultValueType, error: unkn
 const followUpRequest = (
   request: LLMRequest,
   state: StepState,
-  dispatched: ReadonlyArray<readonly [ToolCallPart, ToolResultValueType]>,
+  dispatched: ReadonlyArray<readonly [ToolCallPart, ToolResultValue]>,
 ) =>
   LLMRequest.update(request, {
     messages: [

packages/llm/src/utils/record.ts

@@ -1,3 +0,0 @@
-/** Plain-record narrowing. Excludes arrays so JSON object checks don't accept tuples as key/value bags. */
-export const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value)

packages/llm/test/adapter.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect } from "bun:test"
 import { Effect, Schema, Stream } from "effect"
 import { LLM } from "../src"
-import { Route, Endpoint, LLMClient, Protocol, type FramingDef } from "../src/route"
-import { Model } from "../src/schema"
+import { Route, Endpoint, LLMClient, Protocol, type RouteModelInput, type FramingDef } from "../src/route"
+import { ModelRef } from "../src/schema"
 import { testEffect } from "./lib/effect"
 import { dynamicResponse } from "./lib/http"
 
-const updateModel = (model: Model, patch: Partial<Model.Input>) => Model.update(model, patch)
+const updateModel = (model: ModelRef, patch: Partial<ModelRef.Input>) => ModelRef.update(model, patch)
 
 const Json = Schema.fromJsonString(Schema.Unknown)
 const encodeJson = Schema.encodeSync(Json)
@@ -38,6 +38,17 @@ const fakeFraming: FramingDef<FakeEvent> = {
     ).pipe(Stream.flatMap(Stream.fromIterable)),
 }
 
+const request = LLM.request({
+  id: "req_1",
+  model: LLM.model({
+    id: "fake-model",
+    provider: "fake-provider",
+    route: "fake",
+    baseURL: "https://fake.local",
+  }),
+  prompt: "hello",
+})
+
 const raiseEvent = (event: FakeEvent): import("../src/schema").LLMEvent =>
   event.type === "finish"
     ? { type: "finish", reason: event.reason }
@@ -73,7 +84,6 @@ const fake = Route.make({
   endpoint: Endpoint.path("/chat"),
   framing: fakeFraming,
 })
-const configuredFake = fake.with({ endpoint: { baseURL: "https://fake.local" } })
 
 const gemini = Route.make({
   id: "gemini-fake",
@@ -81,17 +91,6 @@ const gemini = Route.make({
   endpoint: Endpoint.path("/chat"),
   framing: fakeFraming,
 })
-const configuredGemini = gemini.with({ endpoint: { baseURL: "https://fake.local" } })
-
-const request = LLM.request({
-  id: "req_1",
-  model: Model.make({
-    id: "fake-model",
-    provider: "fake-provider",
-    route: configuredFake,
-  }),
-  prompt: "hello",
-})
 
 const echoLayer = dynamicResponse(({ text, respond }) =>
   Effect.succeed(
@@ -118,47 +117,61 @@ describe("llm route", () => {
     }),
   )
 
-  it.effect("selects routes by model route value", () =>
+  it.effect("selects routes by request route", () =>
     Effect.gen(function* () {
       const llm = yield* LLMClient.Service
       const prepared = yield* llm.prepare(
-        LLM.updateRequest(request, { model: updateModel(request.model, { route: configuredGemini }) }),
+        LLM.updateRequest(request, { model: updateModel(request.model, { route: "gemini-fake" }) }),
       )
 
       expect(prepared.route).toBe("gemini-fake")
     }),
   )
 
-  it.effect("builds models from configured routes", () =>
+  it.effect("maps model input before building refs", () =>
     Effect.gen(function* () {
-      const configured = fake.with({ provider: "fake-provider", endpoint: { baseURL: "https://fake.local" } })
+      const mapped = Route.model<RouteModelInput & { readonly region?: string }>(
+        fake,
+        { provider: "fake-provider", baseURL: "https://fake.local" },
+        {
+          mapInput: (input) => {
+            const { region, ...rest } = input
+            return { ...rest, native: { region } }
+          },
+        },
+      )
 
-      expect(configured.model({ id: "fake-model" })).toMatchObject({
-        provider: "fake-provider",
-      })
+      expect(mapped({ id: "fake-model", region: "us-east-1" }).native).toEqual({ region: "us-east-1" })
     }),
   )
 
-  it.effect("does not register duplicate route ids globally", () =>
+  it.effect("rejects duplicate route ids", () =>
     Effect.gen(function* () {
-      const duplicate = Route.make({
-        id: "fake",
-        protocol: Protocol.make({
-          ...fakeProtocol,
-          body: {
-            ...fakeProtocol.body,
-            from: () => Effect.succeed({ body: "late-default" }),
-          },
+      expect(() =>
+        Route.make({
+          id: "fake",
+          protocol: Protocol.make({
+            ...fakeProtocol,
+            body: {
+              ...fakeProtocol.body,
+              from: () => Effect.succeed({ body: "late-default" }),
+            },
+          }),
+          endpoint: Endpoint.path("/chat"),
+          framing: fakeFraming,
         }),
-        endpoint: Endpoint.path("/chat", { baseURL: "https://fake.local" }),
-        framing: fakeFraming,
-      })
+      ).toThrow('Duplicate LLM route id "fake"')
+    }),
+  )
 
-      const prepared = yield* (yield* LLMClient.Service).prepare(
-        LLM.updateRequest(request, { model: updateModel(request.model, { route: duplicate }) }),
-      )
+  it.effect("rejects missing route", () =>
+    Effect.gen(function* () {
+      const llm = yield* LLMClient.Service
+      const error = yield* llm
+        .prepare(LLM.updateRequest(request, { model: updateModel(request.model, { route: "missing" }) }))
+        .pipe(Effect.flip)
 
-      expect(prepared.body).toEqual({ body: "late-default" })
+      expect(error.message).toContain("No LLM route")
     }),
   )
 })

packages/llm/test/auth-options.types.ts

@@ -2,17 +2,8 @@ import { Config } from "effect"
 import type { Auth } from "../src/route/auth"
 import type { ModelFactory } from "../src/route/auth-options"
 import { Auth as RuntimeAuth } from "../src/route/auth"
-import * as OpenAIChat from "../src/protocols/openai-chat"
-import * as AmazonBedrock from "../src/providers/amazon-bedrock"
-import * as Anthropic from "../src/providers/anthropic"
 import * as Azure from "../src/providers/azure"
-import * as Cloudflare from "../src/providers/cloudflare"
-import * as GitHubCopilot from "../src/providers/github-copilot"
-import * as Google from "../src/providers/google"
 import * as OpenAI from "../src/providers/openai"
-import * as OpenAICompatible from "../src/providers/openai-compatible"
-import * as OpenRouter from "../src/providers/openrouter"
-import * as XAI from "../src/providers/xai"
 
 type BaseOptions = {
   readonly baseURL?: string
@@ -28,20 +19,6 @@ declare const optionalAuthModel: ModelFactory<BaseOptions, "optional", Model>
 declare const requiredAuthModel: ModelFactory<BaseOptions, "required", Model>
 const configApiKey = Config.redacted("OPENAI_API_KEY")
 
-OpenAIChat.route.model({ id: "gpt-4.1-mini" })
-
-// @ts-expect-error route model selection does not configure endpoints.
-OpenAIChat.route.model({ id: "gpt-4.1-mini", baseURL: "https://gateway.example.com/v1" })
-
-// @ts-expect-error route model selection does not configure query params.
-OpenAIChat.route.model({ id: "gpt-4.1-mini", queryParams: { debug: "1" } })
-
-// @ts-expect-error route model selection does not configure auth.
-OpenAIChat.route.model({ id: "gpt-4.1-mini", auth })
-
-// @ts-expect-error route model selection does not configure api keys.
-OpenAIChat.route.model({ id: "gpt-4.1-mini", apiKey: "sk-test" })
-
 optionalAuthModel("gpt-4.1-mini")
 optionalAuthModel("gpt-4.1-mini", {})
 optionalAuthModel("gpt-4.1-mini", { apiKey: "sk-test" })
@@ -68,101 +45,56 @@ requiredAuthModel("custom-model", {})
 requiredAuthModel("custom-model", { apiKey: "key", auth })
 
 OpenAI.responses("gpt-4.1-mini")
-OpenAI.configure({}).responses("gpt-4.1-mini")
-OpenAI.configure({ apiKey: "sk-test" }).responses("gpt-4.1-mini")
-OpenAI.configure({ apiKey: configApiKey }).responses("gpt-4.1-mini")
-OpenAI.configure({ auth: RuntimeAuth.bearer("oauth-token") }).responses("gpt-4.1-mini")
-OpenAI.configure({
+OpenAI.responses("gpt-4.1-mini", {})
+OpenAI.responses("gpt-4.1-mini", { apiKey: "sk-test" })
+OpenAI.responses("gpt-4.1-mini", { apiKey: configApiKey })
+OpenAI.responses("gpt-4.1-mini", { auth: RuntimeAuth.bearer("oauth-token") })
+OpenAI.responses("gpt-4.1-mini", {
   auth: RuntimeAuth.headers({ authorization: "Bearer gateway" }),
   baseURL: "https://gateway.example.com/v1",
-}).responses("gpt-4.1-mini")
-OpenAI.configure({
+})
+OpenAI.responses("gpt-4.1-mini", {
   generation: { maxTokens: 100 },
   providerOptions: { openai: { store: false } },
-}).responses("gpt-4.1-mini")
-
-// @ts-expect-error OpenAI model selectors only accept model ids.
-OpenAI.configure({ apiKey: "sk-test" }).responses("gpt-4.1-mini", {})
+})
 
 // @ts-expect-error apiKey only accepts string, Redacted<string>, or Config<string | Redacted<string>>.
-OpenAI.configure({ apiKey: 123 })
+OpenAI.responses("gpt-4.1-mini", { apiKey: 123 })
 
 // @ts-expect-error provider helpers reject unknown top-level options.
-OpenAI.configure({ bogus: true })
+OpenAI.responses("gpt-4.1-mini", { bogus: true })
 
 // @ts-expect-error common generation options remain typed.
-OpenAI.configure({ generation: { maxTokens: "many" } })
+OpenAI.responses("gpt-4.1-mini", { generation: { maxTokens: "many" } })
 
 // @ts-expect-error provider-native options remain typed.
-OpenAI.configure({ providerOptions: { openai: { store: "false" } } })
+OpenAI.responses("gpt-4.1-mini", { providerOptions: { openai: { store: "false" } } })
 
 // @ts-expect-error auth is an override, so OpenAI rejects apiKey with auth.
-OpenAI.configure({ apiKey: "sk-test", auth: RuntimeAuth.bearer("oauth-token") })
+OpenAI.responses("gpt-4.1-mini", { apiKey: "sk-test", auth: RuntimeAuth.bearer("oauth-token") })
 
 OpenAI.chat("gpt-4.1-mini")
-OpenAI.configure({ apiKey: "sk-test" }).chat("gpt-4.1-mini")
-OpenAI.configure({ apiKey: configApiKey }).chat("gpt-4.1-mini")
-OpenAI.configure({ auth: RuntimeAuth.bearer("oauth-token") }).chat("gpt-4.1-mini")
-
-// @ts-expect-error OpenAI chat selectors only accept model ids.
-OpenAI.configure({ apiKey: "sk-test" }).chat("gpt-4.1-mini", {})
+OpenAI.chat("gpt-4.1-mini", { apiKey: "sk-test" })
+OpenAI.chat("gpt-4.1-mini", { apiKey: configApiKey })
+OpenAI.chat("gpt-4.1-mini", { auth: RuntimeAuth.bearer("oauth-token") })
 
 // @ts-expect-error auth is an override, so OpenAI Chat rejects apiKey with auth.
-OpenAI.configure({ apiKey: "sk-test", auth: RuntimeAuth.bearer("oauth-token") })
+OpenAI.chat("gpt-4.1-mini", { apiKey: "sk-test", auth: RuntimeAuth.bearer("oauth-token") })
 
 // @ts-expect-error Azure requires at least one of `resourceName` or `baseURL`.
-Azure.configure()
-Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).responses("deployment")
-Azure.configure({ apiKey: configApiKey, resourceName: "resource" }).responses("deployment")
-Azure.configure({ auth: RuntimeAuth.header("api-key", "azure-key"), resourceName: "resource" }).responses("deployment")
-
-// @ts-expect-error Azure model selectors only accept deployment ids.
-Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).responses("deployment", {})
+Azure.responses("deployment")
+Azure.responses("deployment", { apiKey: "azure-key", resourceName: "resource" })
+Azure.responses("deployment", { apiKey: configApiKey, resourceName: "resource" })
+Azure.responses("deployment", { auth: RuntimeAuth.header("api-key", "azure-key"), resourceName: "resource" })
 
 // @ts-expect-error auth is an override, so Azure rejects apiKey with auth.
-Azure.configure({ resourceName: "resource", apiKey: "azure-key", auth: RuntimeAuth.header("api-key", "override") })
+Azure.responses("deployment", { apiKey: "azure-key", auth: RuntimeAuth.header("api-key", "override") })
 
-Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).chat("deployment")
-Azure.configure({ apiKey: configApiKey, resourceName: "resource" }).chat("deployment")
-Azure.configure({ auth: RuntimeAuth.header("api-key", "azure-key"), resourceName: "resource" }).chat("deployment")
-
-// @ts-expect-error Azure chat model selectors only accept deployment ids.
-Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).chat("deployment", {})
+// @ts-expect-error Azure requires at least one of `resourceName` or `baseURL`.
+Azure.chat("deployment")
+Azure.chat("deployment", { apiKey: "azure-key", resourceName: "resource" })
+Azure.chat("deployment", { apiKey: configApiKey, resourceName: "resource" })
+Azure.chat("deployment", { auth: RuntimeAuth.header("api-key", "azure-key"), resourceName: "resource" })
 
 // @ts-expect-error auth is an override, so Azure Chat rejects apiKey with auth.
-Azure.configure({ resourceName: "resource", apiKey: "azure-key", auth: RuntimeAuth.header("api-key", "override") })
-
-Anthropic.configure({ apiKey: "anthropic-key" }).model("claude-haiku")
-// @ts-expect-error Anthropic model selectors only accept model ids.
-Anthropic.configure({ apiKey: "anthropic-key" }).model("claude-haiku", {})
-
-Google.configure({ apiKey: "google-key" }).model("gemini-2.5-flash")
-// @ts-expect-error Google model selectors only accept model ids.
-Google.configure({ apiKey: "google-key" }).model("gemini-2.5-flash", {})
-
-AmazonBedrock.configure({ apiKey: "bedrock-key" }).model("anthropic.claude")
-// @ts-expect-error Bedrock model selectors only accept model ids.
-AmazonBedrock.configure({ apiKey: "bedrock-key" }).model("anthropic.claude", {})
-
-OpenRouter.configure({ apiKey: "openrouter-key" }).model("openai/gpt-4o-mini")
-// @ts-expect-error OpenRouter model selectors only accept model ids.
-OpenRouter.configure({ apiKey: "openrouter-key" }).model("openai/gpt-4o-mini", {})
-
-XAI.configure({ apiKey: "xai-key" }).responses("grok-4")
-XAI.configure({ apiKey: "xai-key" }).chat("grok-4")
-// @ts-expect-error xAI Responses selectors only accept model ids.
-XAI.configure({ apiKey: "xai-key" }).responses("grok-4", {})
-// @ts-expect-error xAI Chat selectors only accept model ids.
-XAI.configure({ apiKey: "xai-key" }).chat("grok-4", {})
-
-OpenAICompatible.deepseek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat")
-// @ts-expect-error OpenAI-compatible family selectors only accept model ids.
-OpenAICompatible.deepseek.configure({ apiKey: "deepseek-key" }).model("deepseek-chat", {})
-
-Cloudflare.CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama")
-// @ts-expect-error Cloudflare Workers AI model selectors only accept model ids.
-Cloudflare.CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama", {})
-
-GitHubCopilot.configure({ baseURL: "https://copilot.test", apiKey: "copilot-key" }).model("gpt-4.1")
-// @ts-expect-error GitHub Copilot model selectors only accept model ids.
-GitHubCopilot.configure({ baseURL: "https://copilot.test", apiKey: "copilot-key" }).model("gpt-4.1", {})
+Azure.chat("deployment", { apiKey: "azure-key", auth: RuntimeAuth.header("api-key", "override") })

packages/llm/test/auth.test.ts

@@ -3,13 +3,11 @@ import { ConfigProvider, Effect } from "effect"
 import { Headers } from "effect/unstable/http"
 import { LLM } from "../src"
 import { Auth } from "../src/route/auth"
-import * as OpenAIChat from "../src/protocols/openai-chat"
-import { Model } from "../src/schema"
 import { it } from "./lib/effect"
 
 const request = LLM.request({
   id: "req_auth",
-  model: Model.make({ id: "fake-model", provider: "fake", route: OpenAIChat.route }),
+  model: LLM.model({ id: "fake-model", provider: "fake", route: "fake", baseURL: "https://fake.local" }),
   prompt: "hello",
 })
 

packages/llm/test/cache-policy.test.ts

@@ -1,32 +1,36 @@
 import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { CacheHint, LLM, Message } from "../src"
-import { Auth, LLMClient } from "../src/route"
-import { AmazonBedrock } from "../src/providers"
+import { LLMClient } from "../src/route"
 import * as AnthropicMessages from "../src/protocols/anthropic-messages"
+import * as BedrockConverse from "../src/protocols/bedrock-converse"
 import * as Gemini from "../src/protocols/gemini"
 import * as OpenAIChat from "../src/protocols/openai-chat"
 import { applyCachePolicy } from "../src/cache-policy"
 import { it } from "./lib/effect"
 
-const anthropicModel = AnthropicMessages.route
-  .with({ endpoint: { baseURL: "https://api.anthropic.test/v1/" }, auth: Auth.header("x-api-key", "test") })
-  .model({ id: "claude-sonnet-4-5" })
+const anthropicModel = AnthropicMessages.model({
+  id: "claude-sonnet-4-5",
+  baseURL: "https://api.anthropic.test/v1/",
+  headers: { "x-api-key": "test" },
+})
 
-const bedrockModel = AmazonBedrock.configure({
+const bedrockModel = BedrockConverse.model({
+  id: "anthropic.claude-3-5-sonnet-20241022-v2:0",
   credentials: { region: "us-east-1", accessKeyId: "fixture", secretAccessKey: "fixture" },
-}).model("anthropic.claude-3-5-sonnet-20241022-v2:0")
+})
 
-const openaiModel = OpenAIChat.route
-  .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
-  .model({ id: "gpt-4o-mini" })
+const openaiModel = OpenAIChat.model({
+  id: "gpt-4o-mini",
+  baseURL: "https://api.openai.test/v1/",
+  headers: { authorization: "Bearer test" },
+})
 
-const geminiModel = Gemini.route
-  .with({
-    endpoint: { baseURL: "https://generativelanguage.test/v1beta/" },
-    auth: Auth.header("x-goog-api-key", "test"),
-  })
-  .model({ id: "gemini-2.5-flash" })
+const geminiModel = Gemini.model({
+  id: "gemini-2.5-flash",
+  baseURL: "https://generativelanguage.test/v1beta/",
+  headers: { "x-goog-api-key": "test" },
+})
 
 describe("applyCachePolicy", () => {
   it.effect("undefined cache resolves to 'auto' (the recommended default)", () =>