fix(core): import credentials from previous channel database

fix(tui): open authorization links (#40912 )
refactor(mcp): remove unused registration status (#40904 )
2026-08-07 01:29:44 -04:00 · 2026-08-06 16:11:56 -04:00 · 2026-08-06 15:26:13 -04:00 · 2026-08-06 13:59:22 -05:00 · 2026-08-06 13:45:06 -05:00
39 changed files with 491 additions and 456 deletions
@@ -12,7 +12,6 @@ type GenericModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
  ProviderAuthOption<"optional"> & {
    readonly provider?: string
    readonly baseURL: string
-    readonly queryParams?: Readonly<Record<string, string>>
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

@@ -20,8 +19,6 @@ export interface Settings extends ProviderPackage.Settings {
  readonly apiKey?: string
  readonly baseURL: string
  readonly provider?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-  readonly queryParams?: Readonly<Record<string, string>>
 }

 export type FamilyModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
@@ -34,11 +31,11 @@ export const routes = [OpenAICompatibleChat.route]

 export const configure = (input: GenericModelOptions) => {
  const provider = input.provider ?? "openai-compatible"
-  const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, queryParams, ...rest } = input
+  const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
  const route = OpenAICompatibleChat.route.with({
    ...rest,
    provider,
-    endpoint: { baseURL, query: queryParams },
+    endpoint: { baseURL },
    auth: AuthOptions.bearer(input, []),
  })
  return {
@@ -78,8 +75,6 @@ export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsIn
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
    limits: settings.limits,
    provider: settings.provider,
-    providerOptions: settings.providerOptions,
-    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
  }).model(modelID)

 export const baseten = define(profiles.baseten)
@@ -64,24 +64,6 @@ describe("provider package entrypoints", () => {
    expect(xai.route.defaults.providerOptions).toMatchObject({ xai: { reasoningEffort: "high", store: false } })
  })

-  test("maps OpenAI-compatible package settings onto the executable model", async () => {
-    const OpenAICompatible = await import("@opencode-ai/ai/providers/openai-compatible")
-    const selected = OpenAICompatible.model("custom-model", {
-      apiKey: "fixture",
-      baseURL: "https://provider.example.test/v1",
-      provider: "example",
-      queryParams: { version: "preview" },
-      providerOptions: { openai: { reasoningEffort: "high" } },
-    })
-
-    expect(String(selected.provider)).toBe("example")
-    expect(selected.route.endpoint).toMatchObject({
-      baseURL: "https://provider.example.test/v1",
-      query: { version: "preview" },
-    })
-    expect(selected.route.defaults.providerOptions).toEqual({ openai: { reasoningEffort: "high" } })
-  })
-
  test("maps package settings onto the executable model", () => {
    const selected = model("gpt-5", {
      apiKey: "fixture",
@@ -10,7 +10,6 @@ const statusLabels = {
  connected: "mcp.status.connected",
  failed: "mcp.status.failed",
  needs_auth: "mcp.status.needs_auth",
-  needs_client_registration: "mcp.status.needs_client_registration",
  disabled: "mcp.status.disabled",
 } as const

@@ -57,7 +56,7 @@ export const DialogSelectMcp: Component = () => {
          }
          const error = () => {
            const s = mcpStatus()
-            if (s?.status === "failed" || s?.status === "needs_client_registration") return s.error
+            if (s?.status === "failed") return s.error
          }
          const enabled = () => status() === "connected"
          return (
@@ -426,8 +426,7 @@ export function StatusPopoverBody(props: { shown: Accessor<boolean> }) {
                            "bg-icon-success-base": status() === "connected",
                            "bg-icon-critical-base": status() === "failed",
                            "bg-border-weak-base": status() === "disabled",
-                            "bg-icon-warning-base":
-                              status() === "needs_auth" || status() === "needs_client_registration",
+                            "bg-icon-warning-base": status() === "needs_auth",
                          }}
                        />
                        <span class="flex flex-col min-w-0 flex-1">
@@ -35,7 +35,6 @@ describe("hasNonBlockingServiceIssue", () => {
  test("detects MCP failures that do not block chatting", () => {
    expect(hasNonBlockingServiceIssue({ mcp: ["failed"], lsp: [] })).toBe(true)
    expect(hasNonBlockingServiceIssue({ mcp: ["needs_auth"], lsp: [] })).toBe(true)
-    expect(hasNonBlockingServiceIssue({ mcp: ["needs_client_registration"], lsp: [] })).toBe(true)
    expect(hasNonBlockingServiceIssue({ mcp: ["connected", "pending", "disabled"], lsp: [] })).toBe(false)
  })

@@ -48,7 +47,6 @@ describe("hasNonBlockingServiceIssue", () => {
 describe("hasServiceNeedingAttention", () => {
  test("detects MCP states that need user attention", () => {
    expect(hasServiceNeedingAttention({ mcp: ["needs_auth"] })).toBe(true)
-    expect(hasServiceNeedingAttention({ mcp: ["needs_client_registration"] })).toBe(true)
  })

  test("ignores states that do not need user attention", () => {
@@ -2,7 +2,7 @@ import type { LspStatus } from "@/types"
 import type { McpServer } from "@opencode-ai/client/promise"

 export function hasServiceNeedingAttention(input: { mcp: Array<McpServer["status"]["status"]> }) {
-  return input.mcp.some((status) => status === "needs_auth" || status === "needs_client_registration")
+  return input.mcp.some((status) => status === "needs_auth")
 }

 export function hasNonBlockingServiceIssue(input: {
@@ -13,7 +13,6 @@ export async function toggleMcp(input: {
    needs_auth: input.authenticate,
    disabled: input.connect,
    failed: input.connect,
-    needs_client_registration: input.connect,
  }[input.status]()
  await input.refresh()
 }
@@ -34,7 +34,6 @@ function icon(status: McpServer["status"]) {
    case "needs_auth":
      return "⚠"
    case "failed":
-    case "needs_client_registration":
      return "✗"
    default:
      return "○"
@@ -45,8 +44,6 @@ function describe(status: McpServer["status"]) {
  switch (status.status) {
    case "needs_auth":
      return "needs authentication"
-    case "needs_client_registration":
-      return `needs client registration: ${status.error}`
    case "failed":
      return `failed: ${status.error}`
    default:
@@ -259,8 +259,6 @@ export type McpStatusFailed = { status: "failed"; error: string }

 export type McpStatusNeedsAuth = { status: "needs_auth" }

-export type McpStatusNeedsClientRegistration = { status: "needs_client_registration"; error: string }
-
 export type McpResource = { server: string; name: string; uri: string; description?: string; mimeType?: string }

 export type McpResourceTemplate = {
@@ -1261,13 +1259,7 @@ export type ConnectionInfo = ConnectionCredentialInfo | ConnectionEnvInfo

 export type McpServer = {
  name: string
-  status:
-    | McpStatusConnected
-    | McpStatusPending
-    | McpStatusDisabled
-    | McpStatusFailed
-    | McpStatusNeedsAuth
-    | McpStatusNeedsClientRegistration
+  status: McpStatusConnected | McpStatusPending | McpStatusDisabled | McpStatusFailed | McpStatusNeedsAuth
  integrationID?: string
 }

@@ -12,7 +12,6 @@ export interface Mapping {

 export interface MapInput {
  readonly packageName: string | undefined
-  readonly providerID: string
  readonly settings: Readonly<Record<string, unknown>>
  readonly modelID: string
 }
@@ -52,8 +51,6 @@ export function map(input: MapInput): Mapping | undefined {
          ...mapGoogleOptions(input.settings),
        },
      }
-    case "@ai-sdk/openai-compatible":
-      return mapOpenAICompatible(input, baseSettings)
    case "@openrouter/ai-sdk-provider":
      return mapOpenRouter(input.settings, baseSettings)
    case "@ai-sdk/xai":
@@ -66,25 +63,6 @@ export function map(input: MapInput): Mapping | undefined {
        },
      }
  }
-  return undefined
-}
-
-function mapOpenAICompatible(
-  input: MapInput,
-  baseSettings: Readonly<Record<string, unknown>>,
-): Mapping | undefined {
-  if (typeof baseSettings.baseURL !== "string") return undefined
-  return {
-    package: "@opencode-ai/ai/providers/openai-compatible",
-    settings: {
-      baseURL: baseSettings.baseURL,
-      ...mapAPIKey(input.settings),
-      provider: input.providerID,
-      ...(isStringRecord(input.settings.queryParams) ? { queryParams: input.settings.queryParams } : {}),
-      ...mapOpenAIOptions(input.settings),
-    },
-    ...(isStringRecord(input.settings.headers) ? { headers: input.settings.headers } : {}),
-  }
 }

 function mapBedrockMantle(input: MapInput, baseSettings: Readonly<Record<string, unknown>>): Mapping | undefined {
@@ -42,5 +42,6 @@ export const migrations = (
    import("./migration/20260622202450_simplify_session_input"),
    import("./migration/20260804233008_loose_psylocke"),
    import("./migration/20260805200742_import_legacy_credentials"),
+    import("./migration/20260806200000_import_next_credentials"),
  ])
 ).map((module) => module.default) satisfies DatabaseMigration.Migration[]
@@ -0,0 +1,89 @@
+import path from "node:path"
+import { existsSync } from "node:fs"
+import { sql } from "drizzle-orm"
+import { Effect, Option, Schema } from "effect"
+import { Credential } from "@opencode-ai/schema/credential"
+import { Global } from "@opencode-ai/util/global"
+import type { DatabaseMigration } from "../migration"
+
+const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
+const decodeValue = Schema.decodeUnknownOption(Credential.Value)
+
+export default {
+  id: "20260806200000_import_next_credentials",
+  up(tx) {
+    return importNextCredentials(tx, path.join(Global.Path.data, "opencode-next.db"))
+  },
+} satisfies DatabaseMigration.Migration
+
+/**
+ * The next channel stored credentials in its own `opencode-next.db` before the
+ * channel databases were consolidated into `opencode.db`. The legacy import
+ * only reads V1 `auth.json`, so a credential that existed only in the previous
+ * channel database was silently dropped. Copy those rows over, keeping any
+ * credential the target database already has for the same integration.
+ */
+export function importNextCredentials(tx: Parameters<DatabaseMigration.Migration["up"]>[0], sourcePath: string) {
+  return Effect.gen(function* () {
+    if (!existsSync(sourcePath)) return
+    for (const row of yield* readSourceCredentials(sourcePath)) {
+      const integrationID = typeof row.integration_id === "string" && row.integration_id.length ? row.integration_id : undefined
+      if (!integrationID) continue
+      if (typeof row.value !== "string") continue
+      const json = Option.getOrUndefined(decodeJson(row.value))
+      if (json === undefined || Option.isNone(decodeValue(json))) continue
+      if (yield* tx.get(sql`SELECT id FROM credential WHERE integration_id = ${integrationID}`)) continue
+      const now = Date.now()
+      yield* tx.run(sql`
+        INSERT OR IGNORE INTO credential (
+          id, integration_id, label, value, connector_id, method_id, active, time_created, time_updated
+        ) VALUES (
+          ${typeof row.id === "string" && row.id.length ? row.id : Credential.ID.create()},
+          ${integrationID},
+          ${typeof row.label === "string" && row.label.length ? row.label : "default"},
+          ${row.value},
+          ${typeof row.connector_id === "string" ? row.connector_id : null},
+          ${typeof row.method_id === "string" ? row.method_id : null},
+          ${typeof row.active === "number" ? row.active : null},
+          ${typeof row.time_created === "number" ? row.time_created : now},
+          ${typeof row.time_updated === "number" ? row.time_updated : now}
+        )
+      `)
+    }
+  })
+}
+
+type SourceRow = Record<string, unknown>
+
+// An unreadable or incompatible source database skips the import instead of
+// failing the migration and blocking startup; the source is never modified.
+function readSourceCredentials(sourcePath: string) {
+  return Effect.scoped(
+    Effect.gen(function* () {
+      const sqlite = yield* Effect.promise(() => import("bun:sqlite"))
+      const source = yield* Effect.acquireRelease(
+        Effect.try({
+          try: () => new sqlite.Database(sourcePath, { readonly: true, strict: true }),
+          catch: (error) => error,
+        }),
+        (database) => Effect.sync(() => database.close()),
+      )
+      return yield* Effect.try({
+        try: () => {
+          const table = source
+            .query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'credential'")
+            .get()
+          if (!table) return [] as SourceRow[]
+          return source.query<SourceRow, []>("SELECT * FROM credential").all()
+        },
+        catch: (error) => error,
+      })
+    }),
+  ).pipe(
+    Effect.catch((error) =>
+      Effect.logWarning("Skipped incompatible opencode-next.db credentials", { path: sourcePath, error }).pipe(
+        Effect.as([] as SourceRow[]),
+      ),
+    ),
+  )
+}
@@ -5,6 +5,8 @@ import { LanguageModel } from "@opencode-ai/ai"
 // ast-grep-ignore: no-star-import
 import * as AnthropicMessages from "@opencode-ai/ai/protocols/anthropic-messages"
 // ast-grep-ignore: no-star-import
+import * as OpenAICompatibleChat from "@opencode-ai/ai/protocols/openai-compatible-chat"
+// ast-grep-ignore: no-star-import
 import * as OpenAIResponses from "@opencode-ai/ai/protocols/openai-responses"
 import { Auth, type AnyRoute } from "@opencode-ai/ai/route"
 import { Context, Effect, Layer, Schema } from "effect"
@@ -16,7 +18,6 @@ import { Credential } from "./credential"
 import { Integration } from "./integration"
 import { Capabilities, ID, Info, Ref, VariantID } from "./model"
 import { Npm } from "@opencode-ai/util/npm"
-import { PluginHooks } from "./plugin/hooks"
 import { Provider } from "./provider"

 export class VariantUnavailableError extends Schema.TaggedErrorClass<VariantUnavailableError>()(
@@ -134,11 +135,6 @@ export const withVariant = (
 export interface Dependencies {
  readonly loadPackage?: (specifier: string) => Effect.Effect<Provider.ProviderPackage, Provider.LoadError>
  readonly loadAISDK?: (model: Info) => Effect.Effect<LanguageModel, AISDK.InitError>
-  readonly resolveProvider?: (input: {
-    readonly model: Info
-    readonly credential?: Credential.Value
-    readonly settings: Record<string, unknown>
-  }) => Effect.Effect<Record<string, unknown>>
 }

 export const fromCatalogModel = (
@@ -148,6 +144,8 @@ export const fromCatalogModel = (
 ): Effect.Effect<LanguageModel, UnsupportedPackageError> => {
  const resolved = produce(model, (draft) => {
    if (draft.settings?.apiKey === "") delete draft.settings.apiKey
+    if (credential?.type === "key" && credential.metadata !== undefined)
+      draft.body = Provider.mergeOverlay(draft.body, credential.metadata)
  })
  const packageName = Provider.packageName(resolved.package)
  const key = apiKey(resolved, credential)
@@ -166,11 +164,21 @@ export const fromCatalogModel = (
        .model({ id: resolved.modelID ?? resolved.id, compatibility: resolved.compatibility }),
    )
  }
+  if (
+    Provider.isAISDK(resolved.package) &&
+    packageName === "@ai-sdk/openai-compatible" &&
+    typeof resolved.settings?.baseURL === "string"
+  ) {
+    return Effect.succeed(
+      withDefaults(resolved, OpenAICompatibleChat.route)
+        .with({ auth: key === undefined ? Auth.none : Auth.bearer(key) })
+        .model({ id: resolved.modelID ?? resolved.id, compatibility: resolved.compatibility }),
+    )
+  }
  const configured = { ...resolved.settings, ...credential?.metadata }
  const mapping = Provider.isAISDK(resolved.package)
    ? AISDKNative.map({
        packageName,
-        providerID: resolved.providerID,
        settings: configured,
        modelID: resolved.modelID ?? resolved.id,
      })
@@ -249,25 +257,7 @@ export const resolveModel = (
  variant: VariantID | undefined,
  credential?: Credential.Value,
  dependencies?: Dependencies,
-) =>
-  withVariant(model, variant).pipe(
-    Effect.flatMap((model) => {
-      if (!dependencies?.resolveProvider) return fromCatalogModel(model, credential, dependencies)
-      return dependencies
-        .resolveProvider({ model, credential, settings: { ...model.settings, ...credential?.metadata } })
-        .pipe(
-          Effect.flatMap((settings) =>
-            fromCatalogModel(
-              produce(model, (draft) => {
-                draft.settings = settings
-              }),
-              credential,
-              dependencies,
-            ),
-          ),
-        )
-    }),
-  )
+) => withVariant(model, variant).pipe(Effect.flatMap((model) => fromCatalogModel(model, credential, dependencies)))

 export const supported = (model: Info) => Boolean(model.package)

@@ -279,7 +269,6 @@ export const layer = Layer.effect(
    const integrations = yield* Integration.Service
    const npm = yield* Npm.Service
    const aisdk = yield* AISDK.Service
-    const hooks = yield* PluginHooks.Service
    const load = Effect.fn("ModelResolver.resolveModel")(function* (selected: Info, variant?: VariantID) {
      const provider = yield* catalog.provider.get(selected.providerID)
      const connection = yield* integrations.connection.active(
@@ -292,8 +281,6 @@ export const layer = Layer.effect(
        {
          loadPackage: (specifier) => Provider.loadPackage(specifier, npm),
          loadAISDK: (model) => aisdk.model(model),
-          resolveProvider: (input) =>
-            hooks.trigger("provider", "resolve", input).pipe(Effect.map((event) => event.settings)),
        },
      )
      return {
@@ -331,5 +318,5 @@ export const layer = Layer.effect(
 export const node = makeLocationNode({
  service: Service,
  layer,
-  deps: [Catalog.node, Integration.node, Npm.node, AISDK.node, PluginHooks.node],
+  deps: [Catalog.node, Integration.node, Npm.node, AISDK.node],
 })
@@ -1,7 +1,6 @@
 export * as PluginHooks from "./hooks"

 import type { AISDKHooks } from "@opencode-ai/plugin/effect/aisdk"
-import type { ProviderHooks } from "@opencode-ai/plugin/effect/provider"
 import type { SessionHooks } from "@opencode-ai/plugin/effect/session"
 import type { ShellHooks } from "@opencode-ai/plugin/effect/shell"
 import type { ToolHooks } from "@opencode-ai/plugin/effect/tool"
@@ -11,7 +10,6 @@ import { State } from "../state"

 export interface Domains {
  readonly aisdk: AISDKHooks
-  readonly provider: ProviderHooks
  readonly session: SessionHooks
  readonly shell: ShellHooks
  readonly tool: ToolHooks
@@ -273,9 +273,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
    plugin: {
      list: () => response(plugin.list()),
    },
-    provider: {
-      hook: (name, callback) => hooks.register("provider", name, callback),
-    },
    reference: {
      list: () => response(reference.list()),
      reload: reference.reload,
@@ -84,10 +84,6 @@ export function fromPromise(plugin: Plugin) {
            transform: transform(host.catalog),
            reload: () => run(host.catalog.reload()),
          },
-          provider: {
-            hook: (name, callback) =>
-              register(host.provider.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
-          },
          command: {
            list: (input) => run(host.command.list(input)),
            transform: transform(host.command),
@@ -14,34 +14,72 @@ export const CloudflareWorkersAIPlugin = define({
      if (!item) return
      evt.provider.update(item.provider.id, (provider) => {
        if (!Provider.isAISDK(provider.package)) return
-        const baseURL = resolveBaseURL(provider.settings ?? {})
-        if (baseURL) provider.settings = { ...provider.settings, baseURL }
-        provider.headers = Provider.mergeHeaders(provider.headers, {
-          "User-Agent": `${App.useragent(ctx.app)} cloudflare-workers-ai (${os.platform()} ${os.release()}; ${os.arch()})`,
-        })
+        if (typeof provider.settings?.baseURL === "string") return
+        const accountId = resolveAccountId(provider.settings ?? {})
+        if (accountId) provider.settings = { ...provider.settings, baseURL: workersEndpoint(accountId) }
      })
    })
-    yield* ctx.provider.hook(
-      "resolve",
+    yield* ctx.aisdk.hook(
+      "sdk",
      Effect.fn(function* (evt) {
        if (evt.model.providerID !== providerID) return
-        const baseURL = resolveBaseURL(evt.settings)
-        if (baseURL) evt.settings.baseURL = baseURL
+        if (evt.package !== "@ai-sdk/openai-compatible") return
+
+        const accountId = resolveAccountId(evt.options)
+        if (!hasWorkersEndpoint(evt.model) && !accountId) return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"))
+        evt.sdk = mod.createOpenAICompatible(
+          sdkOptions(
+            {
+              ...evt.options,
+              baseURL: evt.options.baseURL ?? (accountId ? workersEndpoint(accountId) : undefined),
+            },
+            ctx.app,
+          ) as any,
+        )
+      }),
+    )
+    yield* ctx.aisdk.hook(
+      "language",
+      Effect.fn(function* (evt) {
+        if (evt.model.providerID !== providerID) return
+        evt.language = evt.sdk.languageModel(evt.model.modelID ?? evt.model.id)
      }),
    )
  }),
 })

-function resolveBaseURL(options: Record<string, unknown>) {
-  const baseURL = stringOption(options, "baseURL")
-  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId")
-  if (!accountId) return baseURL
-  if (baseURL) return baseURL.replaceAll("${CLOUDFLARE_ACCOUNT_ID}", encodeURIComponent(accountId))
-  return workersEndpoint(accountId)
+function resolveAccountId(options: Record<string, unknown>) {
+  return process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId")
 }

 function workersEndpoint(accountId: string) {
-  return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/ai/v1`
+  return `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/v1`
+}
+
+function hasWorkersEndpoint(model: {
+  readonly package?: string
+  readonly settings?: Readonly<Record<string, unknown>>
+}) {
+  return Provider.isAISDK(model.package) && typeof model.settings?.baseURL === "string"
+}
+
+function sdkOptions(options: Record<string, any>, app: App.Info) {
+  return {
+    ...options,
+    baseURL: expandAccountId(options.baseURL),
+    apiKey: process.env.CLOUDFLARE_API_KEY ?? options.apiKey,
+    headers: {
+      "User-Agent": `${App.useragent(app)} cloudflare-workers-ai (${os.platform()} ${os.release()}; ${os.arch()})`,
+      ...options.headers,
+    },
+    name: providerID,
+  }
+}
+
+function expandAccountId(baseURL: unknown) {
+  if (typeof baseURL !== "string") return baseURL
+  return baseURL.replaceAll("${CLOUDFLARE_ACCOUNT_ID}", process.env.CLOUDFLARE_ACCOUNT_ID ?? "${CLOUDFLARE_ACCOUNT_ID}")
 }

 function stringOption(options: Record<string, unknown>, key: string) {
@@ -20,7 +20,7 @@ import type { Info } from "../model"
 import { SessionUsage } from "./usage"

 const DEFAULT_BUFFER = 20_000
-const DEFAULT_KEEP_TOKENS = 8_000
+const DEFAULT_KEEP_TOKENS = 15_000
 const OUTPUT_TOKEN_MAX = 32_000
 const TOOL_OUTPUT_MAX_CHARS = 2_000
 const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown inside <template> and keep the section order unchanged. Do not include the <template> tags in your response.
@@ -1,12 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import { AISDKNative } from "@opencode-ai/core/aisdk-native"

-const map = (
-  packageName: string,
-  settings: Readonly<Record<string, unknown>>,
-  modelID = "test-model",
-  providerID = "test-provider",
-) => AISDKNative.map({ packageName, providerID, settings, modelID })
+const map = (packageName: string, settings: Readonly<Record<string, unknown>>, modelID = "test-model") =>
+  AISDKNative.map({ packageName, settings, modelID })

 describe("AISDKNative", () => {
  test("maps both models.dev Bedrock packages to native providers", () => {
@@ -45,52 +41,6 @@ describe("AISDKNative", () => {
    )
  })

-  test("maps Cloudflare Workers AI to the generic OpenAI-compatible provider", () => {
-    expect(
-      map(
-        "@ai-sdk/openai-compatible",
-        {
-          accountId: "account/id",
-          apiKey: "secret",
-          baseURL: "https://api.cloudflare.com/client/v4/accounts/account%2Fid/ai/v1",
-          headers: { "x-custom": "value" },
-          queryParams: { version: "preview" },
-          reasoningEffort: "high",
-        },
-        "@cf/model",
-        "cloudflare-workers-ai",
-      ),
-    ).toEqual({
-      package: "@opencode-ai/ai/providers/openai-compatible",
-      settings: {
-        apiKey: "secret",
-        baseURL: "https://api.cloudflare.com/client/v4/accounts/account%2Fid/ai/v1",
-        provider: "cloudflare-workers-ai",
-        queryParams: { version: "preview" },
-        providerOptions: { openai: { reasoningEffort: "high" } },
-      },
-      headers: { "x-custom": "value" },
-    })
-  })
-
-  test("maps generic OpenAI-compatible providers to the native package", () => {
-    expect(
-      map("@ai-sdk/openai-compatible", {
-        apiKey: "secret",
-        baseURL: "https://provider.example/v1",
-        reasoningEffort: "high",
-      }),
-    ).toEqual({
-      package: "@opencode-ai/ai/providers/openai-compatible",
-      settings: {
-        apiKey: "secret",
-        baseURL: "https://provider.example/v1",
-        provider: "test-provider",
-        providerOptions: { openai: { reasoningEffort: "high" } },
-      },
-    })
-  })
-
  test("maps Bedrock provider and request options", () => {
    expect(
      map(
@@ -12,6 +12,7 @@ import { Database } from "@opencode-ai/core/database/database"
 import { tmpdir } from "./fixture/tmpdir"
 import type { SqlClient } from "effect/unstable/sql/SqlClient"
 import { importLegacyCredentials } from "@opencode-ai/core/database/migration/20260805200742_import_legacy_credentials"
+import { importNextCredentials } from "@opencode-ai/core/database/migration/20260806200000_import_next_credentials"

 const run = <A, E>(effect: Effect.Effect<A, E, SqlClient>) =>
  Effect.runPromise(
@@ -164,6 +165,75 @@ describe("DatabaseMigration", () => {
    expect(await Bun.file(source).text()).toBe(content)
  })

+  test("imports previous channel database credentials without replacing existing integrations", async () => {
+    await using tmp = await tmpdir()
+    const source = path.join(tmp.path, "opencode-next.db")
+    const { Database: Sqlite } = await import("bun:sqlite")
+    const sourceDb = new Sqlite(source, { strict: true })
+    sourceDb.run(`
+      CREATE TABLE credential (
+        id text PRIMARY KEY, integration_id text, label text NOT NULL, value text NOT NULL,
+        connector_id text, method_id text, active integer, time_created integer NOT NULL, time_updated integer NOT NULL
+      )
+    `)
+    const insert = sourceDb.prepare(
+      "INSERT INTO credential (id, integration_id, label, value, connector_id, method_id, active, time_created, time_updated) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+    )
+    insert.run("cred_next_opencode", "opencode", "anomaly", JSON.stringify({ type: "key", key: "zen-key" }), null, "console", null, 100, 200)
+    insert.run(
+      "cred_next_anthropic",
+      "anthropic",
+      "default",
+      JSON.stringify({ type: "oauth", methodID: "oauth", refresh: "next-refresh", access: "next-access", expires: 456 }),
+      null,
+      null,
+      null,
+      100,
+      200,
+    )
+    insert.run("cred_next_invalid", "invalid", "default", "not-json", null, null, null, 100, 200)
+    sourceDb.close()
+
+    await run(
+      Effect.gen(function* () {
+        const db = yield* makeDb
+        yield* DatabaseMigration.apply(db)
+        const now = Date.now()
+        yield* db.run(sql`
+          INSERT INTO credential (id, integration_id, label, value, time_created, time_updated)
+          VALUES ('existing', 'anthropic', 'Existing', ${JSON.stringify({ type: "key", key: "current-key" })}, ${now}, ${now})
+        `)
+
+        yield* db.transaction((tx) => importNextCredentials(tx, source))
+        // A second run is a no-op because the integration now has a credential.
+        yield* db.transaction((tx) => importNextCredentials(tx, source))
+        // A missing source database is a no-op.
+        yield* db.transaction((tx) => importNextCredentials(tx, path.join(tmp.path, "missing.db")))
+
+        expect(
+          yield* db.all(sql`SELECT id, integration_id, label, value, method_id, time_created FROM credential ORDER BY integration_id`),
+        ).toEqual([
+          {
+            id: "existing",
+            integration_id: "anthropic",
+            label: "Existing",
+            value: JSON.stringify({ type: "key", key: "current-key" }),
+            method_id: null,
+            time_created: now,
+          },
+          {
+            id: "cred_next_opencode",
+            integration_id: "opencode",
+            label: "anomaly",
+            value: JSON.stringify({ type: "key", key: "zen-key" }),
+            method_id: "console",
+            time_created: 100,
+          },
+        ])
+      }),
+    )
+  })
+
  test("rolls back a failed migration without recording it", async () => {
    await run(
      Effect.gen(function* () {
@@ -7,7 +7,6 @@ import { Catalog } from "@opencode-ai/core/catalog"
 import { Generate } from "@opencode-ai/core/generate"
 import { Integration } from "@opencode-ai/core/integration"
 import { ModelResolver } from "@opencode-ai/core/model-resolver"
-import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { ID, Info, Ref } from "@opencode-ai/core/model"
 import { Provider } from "@opencode-ai/core/provider"
 import { Npm } from "@opencode-ai/util/npm"
@@ -66,13 +65,9 @@ const aisdk = Layer.mock(AISDK.Service, {
  },
  model: () => Effect.succeed(runtime),
 })
-const hooks = Layer.mock(PluginHooks.Service, {
-  register: () => Effect.die("unused"),
-  trigger: (_domain, _name, event) => Effect.succeed(event),
-})
 const client = TestLLM.clientLayer.pipe(Layer.provide(TestLLM.layer({ fallback: TestLLM.text("OK", "generate") })))

-const resolver = ModelResolver.layer.pipe(Layer.provide(Layer.mergeAll(catalog, integrations, npm, aisdk, hooks)))
+const resolver = ModelResolver.layer.pipe(Layer.provide(Layer.mergeAll(catalog, integrations, npm, aisdk)))
 const it = testEffect(Generate.layer.pipe(Layer.provide(Layer.merge(resolver, client))))
 const resolverIt = testEffect(resolver)

@@ -131,56 +131,6 @@ describe("ModelResolver", () => {
    }),
  )

-  it.effect("routes Cloudflare Workers AI through the generic OpenAI-compatible provider", () =>
-    Effect.gen(function* () {
-      const resolved = yield* ModelResolver.resolveModel(
-        model(Provider.aisdk("@ai-sdk/openai-compatible"), {
-          providerID: Provider.ID.make("cloudflare-workers-ai"),
-          modelID: "@cf/meta/llama-3.1-8b-instruct",
-          settings: {
-            baseURL: "https://api.cloudflare.com/client/v4/accounts/${CLOUDFLARE_ACCOUNT_ID}/ai/v1",
-            queryParams: { version: "preview" },
-            reasoningEffort: "high",
-          },
-        }),
-        undefined,
-        Credential.Key.make({ type: "key", key: "secret", metadata: { accountId: "account/id" } }),
-        {
-          loadAISDK: () => Effect.die("AI SDK loader should not be called"),
-          resolveProvider: (input) =>
-            Effect.succeed({
-              ...input.settings,
-              baseURL: String(input.settings.baseURL).replace(
-                "${CLOUDFLARE_ACCOUNT_ID}",
-                encodeURIComponent(String(input.settings.accountId)),
-              ),
-            }),
-        },
-      )
-      const headers = yield* resolved.route.auth.apply({
-        request: LLM.request({ model: resolved, prompt: "Hello" }),
-        method: "POST",
-        url: "https://example.com",
-        body: "{}",
-        headers: Headers.empty,
-      })
-
-      expect(resolved.route.id).toBe("openai-compatible-chat")
-      expect(String(resolved.provider)).toBe("cloudflare-workers-ai")
-      expect(resolved.route.endpoint.baseURL).toBe("https://api.cloudflare.com/client/v4/accounts/account%2Fid/ai/v1")
-      expect(resolved.route.endpoint.query).toEqual({ version: "preview" })
-      expect(resolved.route.defaults.providerOptions).toEqual({ openai: { reasoningEffort: "high" } })
-      expect(resolved.route.defaults.http?.body).toEqual({ custom_extension: { enabled: true } })
-      const prepared = yield* compileRequest(LLM.request({ model: resolved, prompt: "Hello" }))
-      expect(prepared.body).toMatchObject({
-        reasoning_effort: "high",
-        stream_options: { include_usage: true },
-      })
-      expect(prepared.body).not.toHaveProperty("accountId")
-      expect(headers.authorization).toBe("Bearer secret")
-    }),
-  )
-
  it.effect("uses the API modelID instead of the catalog ID for native OpenAI routes", () =>
    Effect.gen(function* () {
      const catalog = model(Provider.aisdk("@ai-sdk/openai"), {
@@ -406,7 +356,7 @@ describe("ModelResolver", () => {
    }),
  )

-  it.effect("keeps key credential metadata out of request bodies", () =>
+  it.effect("prefers stored credentials over configured auth", () =>
    Effect.gen(function* () {
      const credential = Credential.Key.make({ type: "key", key: "stored-secret", metadata: { tenant: "work" } })
      const resolved = yield* ModelResolver.fromCatalogModel(
@@ -426,7 +376,7 @@ describe("ModelResolver", () => {
      })

      expect(headers.authorization).toBe("Bearer stored-secret")
-      expect(resolved.route.defaults.http?.body).toEqual({})
+      expect(resolved.route.defaults.http?.body).toEqual({ tenant: "work" })
    }),
  )

@@ -29,9 +29,6 @@ export function host(overrides: Overrides = {}): Plugin.Context {
    aisdk: overrides.aisdk ?? {
      hook: () => Effect.die("unused aisdk.hook"),
    },
-    provider: overrides.provider ?? {
-      hook: () => Effect.die("unused provider.hook"),
-    },
    catalog: overrides.catalog ?? {
      provider: {
        list: () => Effect.die("unused catalog.provider.list"),
@@ -1,13 +1,13 @@
-import { Catalog } from "@opencode-ai/core/catalog"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
-import { CloudflareWorkersAIPlugin } from "@opencode-ai/core/plugin/provider/cloudflare-workers-ai"
-import { Provider } from "@opencode-ai/core/provider"
-import { Credential } from "@opencode-ai/core/credential"
-import { ID, Info } from "@opencode-ai/core/model"
+import { AISDK } from "@opencode-ai/core/aisdk"
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
+import { Catalog } from "@opencode-ai/core/catalog"
+import { Model } from "@opencode-ai/core/model"
+import { Plugin } from "@opencode-ai/core/plugin"
+import { PluginHost } from "@opencode-ai/core/plugin/host"
+import { CloudflareWorkersAIPlugin } from "@opencode-ai/core/plugin/provider/cloudflare-workers-ai"
+import { Provider } from "@opencode-ai/core/provider"
+import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"

@@ -15,7 +15,9 @@ const it = testEffect(PluginTestLayer)

 const addPlugin = Effect.fn(function* () {
  const plugin = yield* Plugin.Service
-  yield* CloudflareWorkersAIPlugin.effect(yield* PluginHost.make(plugin))
+  const aisdk = yield* AISDK.Service
+  const host = yield* PluginHost.make(plugin)
+  yield* CloudflareWorkersAIPlugin.effect(host)
 })

 function required<T>(value: T | undefined): T {
@@ -23,130 +25,243 @@ function required<T>(value: T | undefined): T {
  return value
 }

-function withEnv<A, E, R>(value: string | undefined, effect: () => Effect.Effect<A, E, R>) {
+function withEnv<A, E, R>(vars: Record<string, string | undefined>, effect: () => Effect.Effect<A, E, R>) {
  return Effect.acquireUseRelease(
    Effect.sync(() => {
-      const previous = process.env.CLOUDFLARE_ACCOUNT_ID
-      if (value === undefined) delete process.env.CLOUDFLARE_ACCOUNT_ID
-      else process.env.CLOUDFLARE_ACCOUNT_ID = value
+      const previous = Object.fromEntries(Object.keys(vars).map((key) => [key, process.env[key]]))
+      Object.entries(vars).forEach(([key, value]) => {
+        if (value === undefined) delete process.env[key]
+        else process.env[key] = value
+      })
      return previous
    }),
    effect,
    (previous) =>
-      Effect.sync(() => {
-        if (previous === undefined) delete process.env.CLOUDFLARE_ACCOUNT_ID
-        else process.env.CLOUDFLARE_ACCOUNT_ID = previous
-      }),
+      Effect.sync(() =>
+        Object.entries(previous).forEach(([key, value]) => {
+          if (value === undefined) delete process.env[key]
+          else process.env[key] = value
+        }),
+      ),
  )
 }

-const providerID = Provider.ID.make("cloudflare-workers-ai")
+function fakeSelectorSdk(calls: string[]) {
+  const make = (method: string) => (id: string) => {
+    calls.push(`${method}:${id}`)
+    return { modelId: id, provider: method, specificationVersion: "v3" } as unknown as LanguageModelV3
+  }
+  return {
+    responses: make("responses"),
+    messages: make("messages"),
+    chat: make("chat"),
+    languageModel: make("languageModel"),
+  }
+}
+
+function cloudflareLanguage(sdk: unknown, modelID = "@cf/model") {
+  return (sdk as { languageModel: (id: string) => { config: CloudflareConfig; provider: string } }).languageModel(
+    modelID,
+  )
+}
+
+type CloudflareConfig = {
+  url: (input: { path: string; modelId: string }) => string
+  headers: () => Record<string, string> | Promise<Record<string, string>>
+}
+
+function cloudflareURL(sdk: unknown, modelID = "@cf/model") {
+  return cloudflareLanguage(sdk, modelID).config.url({ path: "/chat/completions", modelId: modelID })
+}
+
+function cloudflareHeaders(sdk: unknown, modelID = "@cf/model") {
+  return cloudflareLanguage(sdk, modelID).config.headers()
+}

 describe("CloudflareWorkersAIPlugin", () => {
-  it.effect("resolves the account environment variable into the native endpoint", () =>
-    withEnv("account/id", () =>
+  it.effect("maps account ID to endpoint URL and creates an OpenAI-compatible SDK", () =>
+    withEnv({ CLOUDFLARE_ACCOUNT_ID: "acct", CLOUDFLARE_API_KEY: "key" }, () =>
      Effect.gen(function* () {
+        const plugin = yield* Plugin.Service
+        const aisdk = yield* AISDK.Service
        const catalog = yield* Catalog.Service
-        yield* catalog.transform((draft) =>
-          draft.provider.update(providerID, (provider) => {
-            provider.package = Provider.aisdk("@ai-sdk/openai-compatible")
+        yield* catalog.transform((catalog) =>
+          catalog.provider.update(Provider.ID.make("cloudflare-workers-ai"), (provider) => {
+            provider.package = Provider.aisdk("test-provider")
          }),
        )
        yield* addPlugin()
+        const provider = required(yield* catalog.provider.get(Provider.ID.make("cloudflare-workers-ai")))
+        const sdk = yield* aisdk.runSDK({
+          model: Model.Info.make({
+            ...Model.Info.default(Provider.ID.make("cloudflare-workers-ai"), Model.ID.make("@cf/model")),
+            modelID: Model.ID.make("@cf/model"),
+            package: provider.package,
+            settings: provider.settings,
+          }),
+          package: "@ai-sdk/openai-compatible",
+          options: { name: "cloudflare-workers-ai", headers: { custom: "header" } },
+        })
+        expect(provider).toMatchObject({
+          package: "aisdk:test-provider",
+          settings: { baseURL: "https://api.cloudflare.com/client/v4/accounts/acct/ai/v1" },
+        })
+        expect(sdk.sdk).toBeDefined()
+      }),
+    ),
+  )

-        expect(required(yield* catalog.provider.get(providerID))).toMatchObject({
-          settings: { baseURL: "https://api.cloudflare.com/client/v4/accounts/account%2Fid/ai/v1" },
-          headers: { "User-Agent": expect.stringContaining("cloudflare-workers-ai") },
+  it.effect("preserves a configured endpoint URL instead of deriving one from account ID", () =>
+    withEnv({ CLOUDFLARE_ACCOUNT_ID: "acct" }, () =>
+      Effect.gen(function* () {
+        const catalog = yield* Catalog.Service
+        yield* catalog.transform((catalog) =>
+          catalog.provider.update(Provider.ID.make("cloudflare-workers-ai"), (provider) => {
+            provider.package = Provider.aisdk("test-provider")
+            provider.settings = { ...provider.settings, baseURL: "https://proxy.example/v1" }
+          }),
+        )
+        yield* addPlugin()
+        expect(required(yield* catalog.provider.get(Provider.ID.make("cloudflare-workers-ai")))).toMatchObject({
+          package: "aisdk:test-provider",
+          settings: { baseURL: "https://proxy.example/v1" },
        })
      }),
    ),
  )

-  it.effect("resolves an account ID from provider settings", () =>
-    withEnv(undefined, () =>
+  it.effect("allows a configured baseURL without account ID", () =>
+    withEnv({ CLOUDFLARE_ACCOUNT_ID: undefined, CLOUDFLARE_API_KEY: "key" }, () =>
      Effect.gen(function* () {
-        const catalog = yield* Catalog.Service
-        yield* catalog.transform((draft) =>
-          draft.provider.update(providerID, (provider) => {
-            provider.package = Provider.aisdk("@ai-sdk/openai-compatible")
-            provider.settings = { accountId: "configured/account" }
-          }),
-        )
+        const plugin = yield* Plugin.Service
+        const aisdk = yield* AISDK.Service
        yield* addPlugin()
-
-        expect(required(yield* catalog.provider.get(providerID)).settings?.baseURL).toBe(
-          "https://api.cloudflare.com/client/v4/accounts/configured%2Faccount/ai/v1",
-        )
+        const result = yield* aisdk.runSDK({
+          model: Model.Info.make({
+            ...Model.Info.default(Provider.ID.make("cloudflare-workers-ai"), Model.ID.make("@cf/model")),
+            modelID: Model.ID.make("@cf/model"),
+            package: "aisdk:@ai-sdk/openai-compatible",
+            settings: { baseURL: "https://proxy.example/v1" },
+          }),
+          package: "@ai-sdk/openai-compatible",
+          options: { name: "cloudflare-workers-ai", baseURL: "https://proxy.example/v1" },
+        })
+        expect(cloudflareURL(result.sdk)).toBe("https://proxy.example/v1/chat/completions")
      }),
    ),
  )

-  it.effect("resolves an account ID from credential metadata before native routing", () =>
-    withEnv(undefined, () =>
+  it.effect("uses env account ID over configured account ID", () =>
+    withEnv({ CLOUDFLARE_ACCOUNT_ID: "env-acct" }, () =>
      Effect.gen(function* () {
-        yield* addPlugin()
-        const event = yield* (yield* PluginHooks.Service).trigger("provider", "resolve", {
-          model: Info.make({
-            id: ID.make("model"),
-            modelID: ID.make("@cf/model"),
-            providerID,
-            name: "Model",
-            package: Provider.aisdk("@ai-sdk/openai-compatible"),
-            settings: {},
-            capabilities: { tools: true, input: ["text"], output: ["text"] },
-            variants: [],
-            time: { released: 0 },
-            cost: [],
-            status: "active",
-            enabled: true,
-            limit: { context: 128_000, output: 8_192 },
+        const catalog = yield* Catalog.Service
+        yield* catalog.transform((catalog) =>
+          catalog.provider.update(Provider.ID.make("cloudflare-workers-ai"), (provider) => {
+            provider.package = Provider.aisdk("test-provider")
+            provider.settings = { ...provider.settings, accountId: "configured-acct" }
          }),
-          credential: Credential.Key.make({ type: "key", key: "secret", metadata: { accountId: "stored/account" } }),
-          settings: {
-            accountId: "stored/account",
+        )
+        yield* addPlugin()
+        expect(required(yield* catalog.provider.get(Provider.ID.make("cloudflare-workers-ai")))).toMatchObject({
+          package: "aisdk:test-provider",
+          settings: { baseURL: "https://api.cloudflare.com/client/v4/accounts/env-acct/ai/v1" },
+        })
+      }),
+    ),
+  )
+
+  it.effect("uses env API key over auth or configured API key and keeps the Cloudflare User-Agent", () =>
+    withEnv({ CLOUDFLARE_ACCOUNT_ID: "acct", CLOUDFLARE_API_KEY: "env-key" }, () =>
+      Effect.gen(function* () {
+        const plugin = yield* Plugin.Service
+        const aisdk = yield* AISDK.Service
+        yield* addPlugin()
+        const result = yield* aisdk.runSDK({
+          model: Model.Info.make({
+            ...Model.Info.default(Provider.ID.make("cloudflare-workers-ai"), Model.ID.make("@cf/model")),
+            modelID: Model.ID.make("@cf/model"),
+            package: "aisdk:@ai-sdk/openai-compatible",
+            settings: { baseURL: "https://proxy.example/v1" },
+          }),
+          package: "@ai-sdk/openai-compatible",
+          options: {
+            name: "cloudflare-workers-ai",
+            apiKey: "auth-key",
+            baseURL: "https://proxy.example/v1",
+            headers: { custom: "header" },
+          },
+        })
+        const headers = yield* Effect.promise(() => Promise.resolve(cloudflareHeaders(result.sdk)))
+        expect(headers.authorization).toBe("Bearer env-key")
+        expect(headers.custom).toBe("header")
+        expect(headers["user-agent"]).toMatch(/^opencode\/.* cloudflare-workers-ai \(.+\) ai-sdk\/openai-compatible\//)
+      }),
+    ),
+  )
+
+  it.effect("expands account ID vars in endpoint URLs", () =>
+    withEnv({ CLOUDFLARE_ACCOUNT_ID: "acct", CLOUDFLARE_API_KEY: "key" }, () =>
+      Effect.gen(function* () {
+        const plugin = yield* Plugin.Service
+        const aisdk = yield* AISDK.Service
+        yield* addPlugin()
+        const result = yield* aisdk.runSDK({
+          model: Model.Info.make({
+            ...Model.Info.default(Provider.ID.make("cloudflare-workers-ai"), Model.ID.make("@cf/model")),
+            modelID: Model.ID.make("@cf/model"),
+            package: "aisdk:@ai-sdk/openai-compatible",
+            settings: { baseURL: "https://api.cloudflare.com/client/v4/accounts/${CLOUDFLARE_ACCOUNT_ID}/ai/v1" },
+          }),
+          package: "@ai-sdk/openai-compatible",
+          options: {
+            name: "cloudflare-workers-ai",
            baseURL: "https://api.cloudflare.com/client/v4/accounts/${CLOUDFLARE_ACCOUNT_ID}/ai/v1",
          },
        })
-
-        expect(event.settings.baseURL).toBe(
-          "https://api.cloudflare.com/client/v4/accounts/stored%2Faccount/ai/v1",
+        expect(cloudflareURL(result.sdk)).toBe(
+          "https://api.cloudflare.com/client/v4/accounts/acct/ai/v1/chat/completions",
        )
      }),
    ),
  )

-  it.effect("expands account placeholders and preserves configured endpoints", () =>
-    withEnv("env-account", () =>
-      Effect.gen(function* () {
-        const catalog = yield* Catalog.Service
-        yield* catalog.transform((draft) =>
-          draft.provider.update(providerID, (provider) => {
-            provider.package = Provider.aisdk("@ai-sdk/openai-compatible")
-            provider.settings = {
-              baseURL: "https://api.cloudflare.com/client/v4/accounts/${CLOUDFLARE_ACCOUNT_ID}/ai/v1",
-            }
-          }),
-        )
-        yield* addPlugin()
-        expect(required(yield* catalog.provider.get(providerID)).settings?.baseURL).toBe(
-          "https://api.cloudflare.com/client/v4/accounts/env-account/ai/v1",
-        )
-      }),
-    ),
+  it.effect("selects languageModel with the API model ID", () =>
+    Effect.gen(function* () {
+      const plugin = yield* Plugin.Service
+      const aisdk = yield* AISDK.Service
+      const calls: string[] = []
+      yield* addPlugin()
+      const result = yield* aisdk.runLanguage({
+        model: Model.Info.make({
+          ...Model.Info.default(Provider.ID.make("cloudflare-workers-ai"), Model.ID.make("alias")),
+          modelID: Model.ID.make("@cf/api-model"),
+          package: "aisdk:test-provider",
+        }),
+        sdk: fakeSelectorSdk(calls),
+        options: {},
+      })
+      expect(result.language).toBeDefined()
+      expect(calls).toEqual(["languageModel:@cf/api-model"])
+    }),
  )

-  it.effect("preserves a custom endpoint when an account ID is configured", () =>
-    withEnv(undefined, () =>
+  it.effect("does not create an SDK for non OpenAI-compatible packages", () =>
+    withEnv({ CLOUDFLARE_ACCOUNT_ID: "acct", CLOUDFLARE_API_KEY: "key" }, () =>
      Effect.gen(function* () {
-        const catalog = yield* Catalog.Service
-        yield* catalog.transform((draft) =>
-          draft.provider.update(providerID, (provider) => {
-            provider.package = Provider.aisdk("@ai-sdk/openai-compatible")
-            provider.settings = { accountId: "configured-account", baseURL: "https://proxy.example/v1" }
-          }),
-        )
+        const plugin = yield* Plugin.Service
+        const aisdk = yield* AISDK.Service
        yield* addPlugin()
-        expect(required(yield* catalog.provider.get(providerID)).settings?.baseURL).toBe("https://proxy.example/v1")
+        const result = yield* aisdk.runSDK({
+          model: Model.Info.make({
+            ...Model.Info.default(Provider.ID.make("cloudflare-workers-ai"), Model.ID.make("@cf/model")),
+            modelID: Model.ID.make("@cf/model"),
+            package: "aisdk:@ai-sdk/anthropic",
+            settings: { baseURL: "https://proxy.example/v1" },
+          }),
+          package: "@ai-sdk/anthropic",
+          options: { name: "cloudflare-workers-ai" },
+        })
+        expect(result.sdk).toBeUndefined()
      }),
    ),
  )
@@ -8,7 +8,6 @@ import type { CatalogDomain } from "./catalog.js"
 import type { CommandDomain } from "./command.js"
 import type { EventDomain } from "./event.js"
 import type { IntegrationDomain } from "./integration.js"
-import type { ProviderDomain } from "./provider.js"
 import type { ReferenceDomain } from "./reference.js"
 import type { SessionDomain } from "./session.js"
 import type { ShellDomain } from "./shell.js"
@@ -26,7 +25,6 @@ export interface Context {
  readonly event: EventDomain
  readonly integration: IntegrationDomain
  readonly plugin: PluginApi<unknown>
-  readonly provider: ProviderDomain
  readonly reference: ReferenceDomain
  readonly session: SessionDomain
  readonly shell: ShellDomain
@@ -1,15 +0,0 @@
-import type { Credential } from "@opencode-ai/schema/credential"
-import type { Model } from "@opencode-ai/schema/model"
-import type { Hooks } from "./registration.js"
-
-export interface ProviderHooks {
-  resolve: {
-    readonly model: Model.Info
-    readonly credential?: Credential.Value
-    readonly settings: Record<string, unknown>
-  }
-}
-
-export interface ProviderDomain {
-  readonly hook: Hooks<ProviderHooks>
-}
@@ -7,7 +7,6 @@ import type { CatalogDomain } from "./catalog.js"
 import type { CommandDomain } from "./command.js"
 import type { EventDomain } from "./event.js"
 import type { IntegrationDomain } from "./integration.js"
-import type { ProviderDomain } from "./provider.js"
 import type { ReferenceDomain } from "./reference.js"
 import type { SessionDomain } from "./session.js"
 import type { ShellDomain } from "./shell.js"
@@ -25,7 +24,6 @@ export interface Context {
  readonly event: EventDomain
  readonly integration: IntegrationDomain
  readonly plugin: PluginApi
-  readonly provider: ProviderDomain
  readonly reference: ReferenceDomain
  readonly session: SessionDomain
  readonly shell: ShellDomain
@@ -1,15 +0,0 @@
-import type { Credential } from "@opencode-ai/schema/credential"
-import type { Model } from "@opencode-ai/schema/model"
-import type { Hooks } from "./registration.js"
-
-export interface ProviderHooks {
-  resolve: {
-    readonly model: Model.Info
-    readonly credential?: Credential.Value
-    readonly settings: Record<string, unknown>
-  }
-}
-
-export interface ProviderDomain {
-  readonly hook: Hooks<ProviderHooks>
-}
@@ -20687,25 +20687,6 @@
        ],
        "additionalProperties": false
      },
-      "Mcp.Status.NeedsClientRegistration": {
-        "type": "object",
-        "properties": {
-          "status": {
-            "type": "string",
-            "enum": [
-              "needs_client_registration"
-            ]
-          },
-          "error": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "status",
-          "error"
-        ],
-        "additionalProperties": false
-      },
      "Mcp.Server": {
        "type": "object",
        "properties": {
@@ -20728,9 +20709,6 @@
              },
              {
                "$ref": "#/components/schemas/Mcp.Status.NeedsAuth"
-              },
-              {
-                "$ref": "#/components/schemas/Mcp.Status.NeedsClientRegistration"
              }
            ]
          },
@@ -68,13 +68,9 @@ const Failed = Schema.Struct({ status: Schema.Literal("failed"), error: Schema.S
 const NeedsAuth = Schema.Struct({ status: Schema.Literal("needs_auth") }).annotate({
  identifier: "Mcp.Status.NeedsAuth",
 })
-const NeedsClientRegistration = Schema.Struct({
-  status: Schema.Literal("needs_client_registration"),
-  error: Schema.String,
-}).annotate({ identifier: "Mcp.Status.NeedsClientRegistration" })

 export type Status = typeof Status.Type
-export const Status = Schema.Union([Connected, Pending, Disabled, Failed, NeedsAuth, NeedsClientRegistration]).pipe(
+export const Status = Schema.Union([Connected, Pending, Disabled, Failed, NeedsAuth]).pipe(
  Schema.toTaggedUnion("status"),
 )

@@ -6,6 +6,7 @@ import type {
  IntegrationOauthConnectOutput,
  IntegrationOAuthMethod,
 } from "@opencode-ai/client"
+import open from "open"
 import { createMemo, createSignal, onCleanup, onMount, Show } from "solid-js"
 import { useClipboard } from "../context/clipboard"
 import { useData } from "../context/data"
@@ -445,6 +446,19 @@ function OAuthAuto(props: {
  Keymap.createLayer(() => ({
    mode: "modal",
    commands: [
+      {
+        bind: "o",
+        title: "Open authorization URL",
+        group: "Dialog",
+        run: () => {
+          open(props.attempt.url).catch(() =>
+            toast.show({
+              message: "Could not open the browser. Copy the URL and continue manually.",
+              variant: "error",
+            }),
+          )
+        },
+      },
      {
        bind: "c",
        title: "Copy authorization details",
@@ -502,6 +516,7 @@ function OAuthAuto(props: {
      instructions={props.attempt.instructions}
      message="Waiting for authorization..."
      copy
+      open
    />
  )
 }
@@ -559,7 +574,14 @@ function OAuthCode(props: {
  )
 }

-function OAuthView(props: { title: string; url?: string; instructions?: string; message: string; copy?: boolean }) {
+function OAuthView(props: {
+  title: string
+  url?: string
+  instructions?: string
+  message: string
+  copy?: boolean
+  open?: boolean
+}) {
  const dialog = useDialog()
  const theme = useTheme("elevated")
  return (
@@ -583,11 +605,18 @@ function OAuthView(props: { title: string; url?: string; instructions?: string;
        )}
      </Show>
      <text fg={theme.text.subdued}>{props.message}</text>
-      <Show when={props.copy}>
-        <text fg={theme.text.default}>
-          c <span style={{ fg: theme.text.subdued }}>copy</span>
-        </text>
-      </Show>
+      <box flexDirection="row" gap={2}>
+        <Show when={props.open}>
+          <text fg={theme.text.default}>
+            o <span style={{ fg: theme.text.subdued }}>open</span>
+          </text>
+        </Show>
+        <Show when={props.copy}>
+          <text fg={theme.text.default}>
+            c <span style={{ fg: theme.text.subdued }}>copy</span>
+          </text>
+        </Show>
+      </box>
    </box>
  )
 }
@@ -15,7 +15,7 @@ import { useConfig } from "../config"
 import { getScrollAcceleration } from "../util/scroll"

 function statusError(status: McpServer["status"]) {
-  if (status.status === "failed" || status.status === "needs_client_registration") return status.error
+  if (status.status === "failed") return status.error
  return undefined
 }

@@ -14,7 +14,6 @@ export function DialogStatus() {
    if (status === "connected") return theme.text.feedback.success.default
    if (status === "failed") return theme.text.feedback.error.default
    if (status === "needs_auth") return theme.text.feedback.warning.default
-    if (status === "needs_client_registration") return theme.text.feedback.error.default
    return theme.text.subdued
  }
  return (
@@ -46,9 +45,6 @@ export function DialogStatus() {
                      <Match when={item.status.status === "failed" && item.status}>{(val) => val().error}</Match>
                      <Match when={item.status.status === "disabled"}>Disabled in configuration</Match>
                      <Match when={item.status.status === "needs_auth"}>Needs authentication</Match>
-                      <Match when={item.status.status === "needs_client_registration" && item.status}>
-                        {(val) => (val() as { error: string }).error}
-                      </Match>
                    </Switch>
                  </span>
                </text>
@@ -8,13 +8,7 @@ function View(props: { context: Plugin.Context; sessionID: string }) {
  const list = createMemo(() => props.context.data.location.mcp.server.list(session()?.location) ?? [])
  const on = createMemo(() => list().filter((item) => item.status.status === "connected").length)
  const bad = createMemo(
-    () =>
-      list().filter(
-        (item) =>
-          item.status.status === "failed" ||
-          item.status.status === "needs_auth" ||
-          item.status.status === "needs_client_registration",
-      ).length,
+    () => list().filter((item) => item.status.status === "failed" || item.status.status === "needs_auth").length,
  )

  const dot = (status: string) => {
@@ -22,7 +16,6 @@ function View(props: { context: Plugin.Context; sessionID: string }) {
    if (status === "failed") return theme.text.feedback.error.default
    if (status === "disabled") return theme.text.subdued
    if (status === "needs_auth") return theme.text.feedback.warning.default
-    if (status === "needs_client_registration") return theme.text.feedback.error.default
    return theme.text.subdued
  }

@@ -65,7 +58,6 @@ function View(props: { context: Plugin.Context; sessionID: string }) {
                      </Match>
                      <Match when={item.status.status === "disabled"}>Disabled</Match>
                      <Match when={item.status.status === "needs_auth"}>Needs auth</Match>
-                      <Match when={item.status.status === "needs_client_registration"}>Needs client ID</Match>
                    </Switch>
                  </span>
                </text>
@@ -28,7 +28,7 @@ export function Link(props: LinkProps) {
        open(props.href).catch(() => {})
      }}
    >
-      {displayText}
+      <a href={props.href}>{displayText}</a>
    </text>
  )
 }
@@ -83,7 +83,7 @@ Add `compaction` to any [OpenCode configuration file](/config):
    "auto": true,
    "prune": false,
    "keep": {
-      "tokens": 8000
+      "tokens": 15000
    },
    "buffer": 20000
  }
@@ -94,7 +94,7 @@ Add `compaction` to any [OpenCode configuration file](/config):
 | --- | ---: | --- |
 | `auto` | `true` | Runs the preflight context-size check. It does not disable manual compaction or one-shot provider-overflow recovery. |
 | `prune` | None | Accepted by the V2 schema, but currently has no runtime effect. V2 does not prune old tool outputs in place. |
-| `keep.tokens` | `8000` | Approximate number of tokens from the newest serialized conversation context to retain beside the summary. |
+| `keep.tokens` | `15000` | Approximate number of tokens from the newest serialized conversation context to retain beside the summary. |
 | `buffer` | `20000` | Safety reserve below an explicit input limit. Without one, it is the minimum context reserve and the model output allowance wins when larger. |

 `keep.tokens` and `buffer` accept non-negative integers. Larger `keep.tokens`
@@ -329,7 +329,7 @@ Control automatic context compaction and how much recent context it preserves.
  "compaction": {
    "auto": true,
    "keep": {
-      "tokens": 8000
+      "tokens": 15000
    },
    "buffer": 20000
  }
@@ -20687,25 +20687,6 @@
        ],
        "additionalProperties": false
      },
-      "Mcp.Status.NeedsClientRegistration": {
-        "type": "object",
-        "properties": {
-          "status": {
-            "type": "string",
-            "enum": [
-              "needs_client_registration"
-            ]
-          },
-          "error": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "status",
-          "error"
-        ],
-        "additionalProperties": false
-      },
      "Mcp.Server": {
        "type": "object",
        "properties": {
@@ -20728,9 +20709,6 @@
              },
              {
                "$ref": "#/components/schemas/Mcp.Status.NeedsAuth"
-              },
-              {
-                "$ref": "#/components/schemas/Mcp.Status.NeedsClientRegistration"
              }
            ]
          },
@@ -20687,25 +20687,6 @@
        ],
        "additionalProperties": false
      },
-      "Mcp.Status.NeedsClientRegistration": {
-        "type": "object",
-        "properties": {
-          "status": {
-            "type": "string",
-            "enum": [
-              "needs_client_registration"
-            ]
-          },
-          "error": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "status",
-          "error"
-        ],
-        "additionalProperties": false
-      },
      "Mcp.Server": {
        "type": "object",
        "properties": {
@@ -20728,9 +20709,6 @@
              },
              {
                "$ref": "#/components/schemas/Mcp.Status.NeedsAuth"
-              },
-              {
-                "$ref": "#/components/schemas/Mcp.Status.NeedsClientRegistration"
              }
            ]
          },
Author	SHA1	Message	Date
Kit Langton	d3bc3a61dc	fix(core): import credentials from previous channel database	2026-08-06 16:11:56 -04:00
Kit Langton	c66d84169a	fix(tui): open authorization links (#40912 )	2026-08-06 15:26:13 -04:00
Aiden Cline	7dbe8c4c13	refactor(mcp): remove unused registration status (#40904 )	2026-08-06 13:59:22 -05:00
Aiden Cline	8864b01d0b	feat(core): increase retained compaction context (#40906 )	2026-08-06 13:45:06 -05:00