fix(core): refresh Console auth before catalog load

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

@@ -89,14 +89,24 @@ export const OpencodePlugin = define<HttpClient.HttpClient | Bus.Service | Scope
     const http = yield* HttpClient.HttpClient
     const loading = Semaphore.makeUnsafe(1)
     let connected = false
+    let savedConnection = false
     let providers: typeof ConfigV1.Info.Type.provider | undefined
 
     const load = Effect.fn("OpencodePlugin.load")(function* () {
       const connection = yield* ctx.integration.connection.active("opencode")
-      const credential = connection
+      const resolved = connection
         ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.catch(() => Effect.succeed(undefined)))
         : undefined
+      // Plugin activation batches transforms, so the first resolve can precede this plugin's OAuth registration.
+      const credential =
+        connection && resolved?.type === "oauth" && resolved.expires <= Date.now() + Duration.toMillis(Duration.minutes(5))
+          ? yield* ctx.integration.reload().pipe(
+              Effect.andThen(ctx.integration.connection.resolve(connection)),
+              Effect.catch(() => Effect.succeed(undefined)),
+            )
+          : resolved
       connected = connection !== undefined
+      savedConnection = connection?.type === "credential"
       providers = credential
         ? yield* fetchProviders(http, credential).pipe(
             Effect.catch((cause) =>
@@ -116,6 +126,7 @@ export const OpencodePlugin = define<HttpClient.HttpClient | Bus.Service | Scope
 
     yield* load()
     yield* ctx.catalog.transform((catalog) => {
+      if (savedConnection && providers === undefined) catalog.provider.remove(Provider.ID.opencode)
       for (const [providerID, item] of Object.entries(providers ?? {})) {
         catalog.provider.update(providerID, (provider) => {
           provider.integrationID = Integration.ID.make("opencode")

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

@@ -10,6 +10,7 @@ import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { OpencodePlugin } from "@opencode-ai/core/plugin/provider/opencode"
 import { Provider } from "@opencode-ai/core/provider"
+import { State } from "@opencode-ai/core/state"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 
@@ -283,6 +284,96 @@ describe("OpencodePlugin", () => {
     ),
   )
 
+  it.live("refreshes saved OAuth before loading the Console catalog on cold startup", () =>
+    Effect.acquireUseRelease(
+      Effect.sync(() => {
+        const requests: string[] = []
+        return {
+          requests,
+          server: Bun.serve({
+            port: 0,
+            fetch: (request) => {
+              const url = new URL(request.url)
+              if (url.pathname === "/auth/device/token") {
+                requests.push("refresh")
+                return Response.json({ access_token: "fresh", refresh_token: "next", expires_in: 600 })
+              }
+              if (url.pathname === "/api/config") {
+                requests.push(`config:${request.headers.get("authorization")}`)
+                return Response.json({
+                  config: {
+                    provider: {
+                      console: {
+                        name: "Console",
+                        npm: "@ai-sdk/openai-compatible",
+                        models: { current: { name: "Current" } },
+                      },
+                    },
+                  },
+                })
+              }
+              return new Response("Not found", { status: 404 })
+            },
+          }),
+        }
+      }),
+      ({ requests, server }) =>
+        Effect.gen(function* () {
+          yield* (yield* Credential.Service).create({
+            integrationID: Integration.ID.make("opencode"),
+            value: Credential.OAuth.make({
+              type: "oauth",
+              methodID: Integration.MethodID.make("device"),
+              access: "expired",
+              refresh: "refresh",
+              expires: 1,
+              metadata: { server: server.url.origin },
+            }),
+          })
+
+          yield* State.batch(addPlugin())
+
+          expect(requests).toEqual(["refresh", "config:Bearer fresh"])
+          expect(
+            yield* (yield* Catalog.Service).model.get(Provider.ID.make("console"), Model.ID.make("current")),
+          ).toBeDefined()
+        }),
+      ({ server }) => Effect.promise(() => server.stop(true)),
+    ),
+  )
+
+  it.live("hides legacy fallback models when Console configuration fails", () =>
+    Effect.acquireUseRelease(
+      Effect.sync(() =>
+        Bun.serve({
+          port: 0,
+          fetch: () => new Response("Unauthorized", { status: 401 }),
+        }),
+      ),
+      (server) =>
+        Effect.gen(function* () {
+          const catalog = yield* Catalog.Service
+          yield* catalog.transform((draft) => {
+            draft.provider.update(Provider.ID.opencode, () => {})
+            draft.model.update(Provider.ID.opencode, Model.ID.make("legacy"), () => {})
+          })
+          yield* (yield* Credential.Service).create({
+            integrationID: Integration.ID.make("opencode"),
+            value: Credential.Key.make({
+              type: "key",
+              key: "console-key",
+              metadata: { server: server.url.origin },
+            }),
+          })
+
+          yield* State.batch(addPlugin())
+
+          expect(yield* catalog.model.get(Provider.ID.opencode, Model.ID.make("legacy"))).toBeUndefined()
+        }),
+      (server) => Effect.promise(() => server.stop(true)),
+    ),
+  )
+
   it.effect("uses a public key and disables paid models without credentials", () =>
     withEnv({ OPENCODE_API_KEY: undefined }, () =>
       Effect.gen(function* () {

packages/tui/src/component/prompt/index.tsx

@@ -327,7 +327,10 @@ export function Prompt(props: PromptProps) {
     if (!session) return
     const agent = session.agent && local.agent.list().find((agent) => agent.id === session.agent)
     if (agent && !args.agent) local.agent.set(agent.id)
-    if (!local.model.hydrate(session.model)) return
+    if (session.model) {
+      local.model.set({ providerID: session.model.providerID, modelID: session.model.id })
+      local.model.variant.set(session.model.variant)
+    }
     syncedSessionID = sessionID
   })
 

packages/tui/src/context/local.tsx

@@ -6,6 +6,7 @@ import { useEvent } from "./event"
 import path from "path"
 import { useTuiPaths } from "./runtime"
 import { useArgs } from "./args"
+import { useClient } from "./client"
 import { RGBA } from "@opentui/core"
 import { readJson, writeJsonAtomic } from "../util/persistence"
 import {
@@ -47,6 +48,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
   name: "Local",
   init: () => {
     const data = useData()
+    const client = useClient()
     const toast = useToast()
     const theme = useTheme()
     const { mode } = useThemes()
@@ -208,47 +210,6 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
         )
       })
 
-      function select(model: ModelPreferenceModel, options?: { recent?: boolean }) {
-        batch(() => {
-          if (!isModelValid(model)) return
-          const a = agent.current()
-          if (!a) return
-          setModelStore("model", a.id, model)
-          if (!options?.recent) return
-          setModelStore("recent", recentModels(model, modelStore.recent))
-          save()
-        })
-      }
-
-      function selectVariant(value: string | undefined) {
-        const model = currentModel()
-        if (!model) return
-        const key = modelPreferenceKey(model)
-        const variant = normalizeModelVariant(value)
-        if (modelStore.variant[key] === variant) return
-        setModelStore("variant", key, variant)
-        save()
-      }
-
-      function matches(model?: { providerID: string; id: string }) {
-        if (!modelStore.ready) return false
-        const current = currentModel()
-        if (!current) return false
-        if (!model) return true
-        return current.providerID === model.providerID && current.modelID === model.id
-      }
-
-      function hydrate(model?: { providerID: string; id: string; variant?: string }) {
-        if (!modelStore.ready) return false
-        if (!model) return true
-        if (data.location.model.list() === undefined) return false
-        const selected = { providerID: model.providerID, modelID: model.id }
-        if (!isModelValid(selected)) return false
-        select(selected)
-        selectVariant(model.variant)
-        return matches(model)
-      }
-
       return {
         current: currentModel,
         get ready() {
@@ -260,8 +221,6 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
         favorite() {
           return modelStore.favorite
         },
-        hydrate,
-        matches,
         parsed: createMemo(() => {
           const value = currentModel()
           if (!value) {
@@ -326,7 +285,18 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           setModelStore("recent", recentModels(next, modelStore.recent))
           save()
         },
-        set: select,
+        set(model: { providerID: string; modelID: string }, options?: { recent?: boolean }) {
+          batch(() => {
+            if (!isModelValid(model)) return
+            const a = agent.current()
+            if (!a) return
+            setModelStore("model", a.id, model)
+            if (options?.recent) {
+              setModelStore("recent", recentModels(model, modelStore.recent))
+              save()
+            }
+          })
+        },
         toggleFavorite(model: { providerID: string; modelID: string }) {
           batch(() => {
             if (!isModelValid(model)) return
@@ -363,7 +333,10 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
             return info?.variants?.map((variant) => variant.id) ?? []
           },
           set(value: string | undefined) {
-            selectVariant(value)
+            const m = currentModel()
+            if (!m) return
+            setModelStore("variant", modelPreferenceKey(m), normalizeModelVariant(value))
+            save()
           },
           cycle() {
             const variants = this.list()

packages/tui/src/routes/session/index.tsx

@@ -360,7 +360,7 @@ export function Session() {
   createEffect(() => {
     const current = prompt()
     if (sent || !current || !synced() || !local.model.ready) return
-    if (!local.agent.current() || !local.model.matches(session()?.model)) return
+    if (!local.agent.current() || !local.model.current()) return
     if (!args.prompt || route.prompt?.text !== args.prompt || current.current.text !== args.prompt) return
     sent = true
     current.submit()

packages/tui/test/app-lifecycle.test.tsx

@@ -226,110 +226,79 @@ test("session title generated while an untitled session is loading remains visib
   }
 })
 
-for (const scenario of [
-  { name: "session startup prompt is submitted exactly once", delayed: false },
-  { name: "session model hydration retries after the model catalog loads", delayed: true },
-]) {
-  test(scenario.name, async () => {
-    const setup = await createTestRenderer({ width: 80, height: 24, useThread: false })
-    const core = await import("@opentui/core")
-    mock.module("@opentui/core", () => ({ ...core, createCliRenderer: async () => setup.renderer }))
-    const events = createEventStream()
-    const cwd = process.cwd()
-    const location = { directory: cwd, project: { id: "project", directory: cwd } }
-    const selected = scenario.delayed ? "selected" : "model"
-    const session = {
-      id: "dummy",
-      title: "Demo session",
-      projectID: "project",
-      location: { directory: cwd },
-      agent: "build",
-      model: { providerID: "provider", id: selected },
-      cost: 0,
-      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-      time: { created: 0, updated: 0 },
+test("session startup prompt is submitted exactly once", async () => {
+  const setup = await createTestRenderer({ width: 80, height: 24, useThread: false })
+  const core = await import("@opentui/core")
+  mock.module("@opentui/core", () => ({ ...core, createCliRenderer: async () => setup.renderer }))
+  const events = createEventStream()
+  const cwd = process.cwd()
+  const location = { directory: cwd, project: { id: "project", directory: cwd } }
+  const session = {
+    id: "dummy",
+    title: "Demo session",
+    projectID: "project",
+    location: { directory: cwd },
+    agent: "build",
+    model: { providerID: "provider", id: "model" },
+    cost: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    time: { created: 0, updated: 0 },
+  }
+  const bodies: unknown[] = []
+  const promptSubmitted = Promise.withResolvers<void>()
+  const calls = createFetch(async (url, request) => {
+    if (url.pathname === "/api/location") return json(location)
+    if (url.pathname === "/api/session") return json({ data: [session], cursor: {} })
+    if (url.pathname === "/api/session/dummy") return json({ data: session })
+    if (url.pathname === "/api/session/dummy/message") return json({ data: [], cursor: {} })
+    if (url.pathname === "/api/session/dummy/pending") return json({ data: [] })
+    if (url.pathname === "/api/session/dummy/permission") return json({ data: [] })
+    if (url.pathname === "/api/agent")
+      return json({
+        location,
+        data: [{ id: "build", mode: "primary", hidden: false, permissions: [] }],
+      })
+    if (url.pathname === "/api/model")
+      return json({
+        location,
+        data: [{ id: "model", providerID: "provider", name: "Model", variants: [] }],
+      })
+    if (url.pathname === "/api/session/dummy/prompt") {
+      bodies.push(await request.json())
+      promptSubmitted.resolve()
+      return json({ data: {} })
     }
-    const sessionRequested = Promise.withResolvers<void>()
-    const modelRequested = Promise.withResolvers<void>()
-    const releaseModels = Promise.withResolvers<void>()
-    const promptSubmitted = Promise.withResolvers<void>()
-    const bodies: unknown[] = []
-    const selections: unknown[] = []
-    const calls = createFetch(async (url, request) => {
-      if (url.pathname === "/api/location") return json(location)
-      if (url.pathname === "/api/session") return json({ data: [session], cursor: {} })
-      if (url.pathname === "/api/session/dummy") {
-        sessionRequested.resolve()
-        return json({ data: session })
-      }
-      if (url.pathname === "/api/session/dummy/message") return json({ data: [], cursor: {} })
-      if (url.pathname === "/api/session/dummy/pending") return json({ data: [] })
-      if (url.pathname === "/api/session/dummy/permission") return json({ data: [] })
-      if (url.pathname === "/api/agent")
-        return json({
-          location,
-          data: [{ id: "build", mode: "primary", hidden: false, permissions: [] }],
-        })
-      if (url.pathname === "/api/model") {
-        modelRequested.resolve()
-        if (scenario.delayed) await releaseModels.promise
-        return json({
-          location,
-          data: [
-            ...(scenario.delayed ? [{ id: "fallback", providerID: "provider", name: "Fallback", variants: [] }] : []),
-            { id: selected, providerID: "provider", name: "Selected", variants: [] },
-          ],
-        })
-      }
-      if (url.pathname === "/api/session/dummy/model") {
-        selections.push(await request.json())
-        return new Response(null, { status: 204 })
-      }
-      if (url.pathname === "/api/session/dummy/prompt") {
-        bodies.push(await request.json())
-        promptSubmitted.resolve()
-        return json({ data: {} })
-      }
-    }, events)
-    const server = Bun.serve({ port: 0, fetch: (request) => calls.fetch(request) })
+  }, events)
+  const server = Bun.serve({ port: 0, fetch: (request) => calls.fetch(request) })
 
-    try {
-      const { run } = await import("../src/app")
-      const task = Effect.runPromise(
-        run({
-          app: { name: "test", version: "test", channel: "test" },
-          server: { endpoint: { url: server.url.toString() } },
-          config: { get: async () => ({}), update: async () => ({}) },
-          packages: { resolve: async () => undefined },
-          args: { sessionID: "dummy", prompt: "RESUME_READY" },
-          log: () => {},
-        }).pipe(Effect.provide(AppNodeBuilder.build(Global.node)), Effect.provide(FileSystem.layerNoop({}))),
-      )
+  try {
+    const { run } = await import("../src/app")
+    const task = Effect.runPromise(
+      run({
+        app: { name: "test", version: "test", channel: "test" },
+        server: { endpoint: { url: server.url.toString() } },
+        config: { get: async () => ({}), update: async () => ({}) },
+        packages: { resolve: async () => undefined },
+        args: { sessionID: "dummy", prompt: "RESUME_READY" },
+        log: () => {},
+      }).pipe(Effect.provide(AppNodeBuilder.build(Global.node)), Effect.provide(FileSystem.layerNoop({}))),
+    )
 
-      if (scenario.delayed) {
-        await Promise.all([sessionRequested.promise, modelRequested.promise])
-        await Bun.sleep(20)
-        expect(bodies).toEqual([])
-        releaseModels.resolve()
-      }
-      await Promise.race([
-        promptSubmitted.promise,
-        Bun.sleep(2000).then(() => {
-          throw new Error("startup prompt was not submitted")
-        }),
-      ])
-      await Bun.sleep(20)
-      setup.renderer.destroy()
-      await task
+    await Promise.race([
+      promptSubmitted.promise,
+      Bun.sleep(2000).then(() => {
+        throw new Error("startup prompt was not submitted")
+      }),
+    ])
+    await Bun.sleep(20)
+    setup.renderer.destroy()
+    await task
 
-      expect(bodies).toHaveLength(1)
-      expect(bodies[0]).toMatchObject({ text: "RESUME_READY" })
-      expect(selections).toEqual([])
-    } finally {
-      releaseModels.resolve()
-      if (!setup.renderer.isDestroyed) setup.renderer.destroy()
-      await server.stop()
-      mock.restore()
-    }
-  })
-}
+    expect(bodies).toHaveLength(1)
+    expect(bodies[0]).toMatchObject({ text: "RESUME_READY" })
+  } finally {
+    if (!setup.renderer.isDestroyed) setup.renderer.destroy()
+    await server.stop()
+    mock.restore()
+  }
+})