@@ -0,0 +1,82 @@
+export * as ProviderModels from "./models.js"
+
+import { Effect, Schema } from "effect"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"
+import { Credential } from "../../credential.js"
+import { Provider } from "../../provider.js"
+
+const Data = Schema.Struct({
+  data: Schema.Array(Schema.Struct({ id: Schema.String, mode: Schema.optional(Schema.NullOr(Schema.String)) })),
+  has_more: Schema.optional(Schema.Boolean),
+  last_id: Schema.optional(Schema.String),
+})
+const Gemini = Schema.Struct({
+  models: Schema.Array(Schema.Struct({ name: Schema.String })),
+  nextPageToken: Schema.optional(Schema.String),
+})
+
+// Select the wire format by adapter, not by the configurable provider name.
+export function protocol(pkg: string | undefined) {
+  if (pkg === "@opencode/ai/providers/anthropic" || pkg === "@opencode/ai/providers/anthropic-compatible")
+    return "anthropic"
+  if (pkg === "@opencode/ai/providers/google") return "google"
+  if (
+    pkg === "@opencode/ai/providers/openai" ||
+    pkg === "@opencode/ai/providers/openai/chat" ||
+    pkg === "@opencode/ai/providers/openai/responses" ||
+    pkg === "@opencode/ai/providers/openai-compatible"
+  )
+    return "openai"
+}
+
+export const fetch = Effect.fn("ProviderModels.fetch")(function* (
+  provider: Provider.Info,
+  format: NonNullable<ReturnType<typeof protocol>>,
+  baseURL: string,
+  credential: Credential.Value | undefined,
+) {
+  const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient)
+  const settings = provider.settings
+  const key =
+    credential?.type === "key" ? credential.key : credential?.type === "oauth" ? credential.access : settings?.apiKey
+  const bearer =
+    format === "openai" ||
+    (format === "anthropic" &&
+      (credential?.type === "oauth" || (!credential && typeof settings?.authToken === "string")))
+  const token =
+    !credential && format === "anthropic" && typeof settings?.authToken === "string" ? settings.authToken : key
+  const headers: Record<string, string> = {}
+  if (format === "anthropic") headers["anthropic-version"] = "2023-06-01"
+  if (typeof token === "string")
+    headers[bearer ? "Authorization" : format === "google" ? "x-goog-api-key" : "x-api-key"] = bearer
+      ? `Bearer ${token}`
+      : token
+  const request = HttpClientRequest.get(`${baseURL.replace(/\/+$/, "")}/models`).pipe(
+    HttpClientRequest.setHeaders(Provider.mergeHeaders(headers, provider.headers) ?? headers),
+  )
+  const ids = new Set<string>()
+  const cursors = new Set<string>()
+  let page: string | undefined
+  do {
+    const response = yield* http.execute(
+      page
+        ? request.pipe(HttpClientRequest.setUrlParam(format === "google" ? "pageToken" : "after_id", page))
+        : request,
+    )
+    if (format === "google") {
+      const body = yield* HttpClientResponse.schemaBodyJson(Gemini)(response)
+      body.models.forEach((model) => ids.add(model.name.replace(/^models\//, "")))
+      page = body.nextPageToken
+    } else {
+      const body = yield* HttpClientResponse.schemaBodyJson(Data)(response)
+      body.data
+        .filter((model) => model.id.length > 0 && (!model.mode || ["chat", "responses"].includes(model.mode)))
+        .forEach((model) => ids.add(model.id))
+      page = body.has_more ? (body.last_id ?? body.data.at(-1)?.id) : undefined
+      if (body.has_more && !page) return yield* Effect.fail(new Error("Missing model-list cursor"))
+    }
+    if (page && cursors.has(page)) return yield* Effect.fail(new Error("Repeated model-list cursor"))
+    if (page) cursors.add(page)
+  } while (page)
+  return ids
+})
@@ -1,84 +1,104 @@
 import { define } from "@opencode/plugin/effect/plugin"
 import type { Document, Entry } from "@opencode/schema/config"
-import { type Duration, Effect, Schedule, Schema, Semaphore, Stream } from "effect"
-import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"
+import { type Duration, Effect, Semaphore, Stream } from "effect"
+import { HttpClient } from "effect/http"
 import { Bus } from "../../bus.js"
 import { Config } from "../../config.js"
 import { Credential } from "../../credential.js"
 import { Provider } from "../../provider.js"
+import { IntegrationConnection } from "../../integration/connection.js"
+import { ProviderModels } from "./models.js"
 import type { PluginInternal } from "../internal.js"
 import { foldSettings } from "./configured.js"
 
-const Models = Schema.Struct({
-  data: Schema.Array(
-    Schema.Struct({
-      id: Schema.String,
-      mode: Schema.NullOr(Schema.String).pipe(Schema.optional),
-    }),
-  ),
-})
-
-// Gateways such as LiteLLM also list embedding, image, and audio models.
-const chat = new Set(["chat", "responses"])
-
-const packages = new Set(["@ai-sdk/openai-compatible", "@opencode/ai/providers/openai-compatible"])
-
 // These providers have dedicated discovery plugins that own their whole model list.
 const dedicated = new Set(["ollama", "lmstudio", "vllm"])
 
-type Target = ReturnType<typeof targets>[number]
-
 export function make(interval: Duration.Input = "5 minutes") {
   return define({
     id: "opencode.provider.openai-compatible",
     effect: Effect.fn(function* (ctx) {
       const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient)
       const bus = yield* Bus.Service
       const config = yield* Config.Service
+      const providers = yield* Provider.Service
       const loading = Semaphore.makeUnsafe(1)
-      const loaded = { inventory: new Map<Provider.ID, { source: string; ids: readonly string[] }>(), hash: "[]" }
+      const loaded = {
+        inventory: new Map<
+          Provider.ID,
+          {
+            source: string
+            ids: readonly string[]
+            connection?: Effect.Success<ReturnType<typeof ctx.integration.connection.active>>
+          }
+        >(),
+        hash: "[]",
+      }
 
-      // An empty update creates missing models and leaves configured ones untouched.
+      // Configuration has already captured alias metadata. Its late model edits retain final precedence.
       yield* ctx.provider.transform((providers) => {
         for (const [providerID, item] of loaded.inventory) {
-          if (!providers.get(providerID)) continue
-          for (const id of item.ids) providers.models.update(providerID, id, () => {})
+          const current = providers.get(providerID)
+          if (!current) continue
+          providers.add({
+            info: current.provider,
+            models: Array.from(current.models.values()).filter((model) => item.ids.includes(model.modelID ?? model.id)),
+            sourceConnection: item.connection,
+          })
+          // Retain #57161's additive discovery for generic gateways; native adapters use catalog metadata only.
+          if (current.provider.package === "@opencode/ai/providers/openai-compatible")
+            for (const id of item.ids) providers.models.update(providerID, id, () => {})
         }
       })
 
-      const inventory = Effect.fnUntraced(function* (target: Target) {
-        const connection = yield* ctx.integration.connection.active(target.providerID)
+      const inventory = Effect.fnUntraced(function* (providerID: Provider.ID) {
+        const current = yield* providers.get(providerID)
+        if (!current) return []
+        // Config observers run independently; discovery must not read the previous endpoint during a reload.
+        const entries = yield* config.entries()
+        const configured = entries
+          .filter((entry): entry is Document => entry.type === "document")
+          .flatMap((entry) => entry.info.providers?.[providerID] ?? [])
+        const provider = {
+          ...current,
+          settings: foldSettings(entries, providerID, current.settings),
+          headers: configured.reduce((headers, item) => Provider.mergeHeaders(headers, item.headers), current.headers),
+        }
+        const format = ProviderModels.protocol(provider.package)
+        const baseURL = provider.settings?.baseURL
+        if (!format || typeof baseURL !== "string" || !URL.canParse(baseURL)) return []
+        if (!["http:", "https:"].includes(new URL(baseURL).protocol)) return []
+        const integrationID = provider.integrationID ?? providerID
+        const connection = yield* ctx.integration.connection.active(integrationID)
         const credential = connection
           ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => undefined))
           : undefined
         // Same precedence as requests: a stored key replaces the configured one.
-        const apiKey = credential?.type === "key" ? credential.key : target.apiKey
-        const source = JSON.stringify([target.baseURL, apiKey, target.headers])
-        const previous = loaded.inventory.get(target.providerID)
-        const request = HttpClientRequest.get(`${target.baseURL}/models`).pipe(
-          HttpClientRequest.acceptJson,
-          HttpClientRequest.setHeaders(target.headers ?? {}),
-        )
-        const ids = yield* http.execute(apiKey ? request.pipe(HttpClientRequest.bearerToken(apiKey)) : request).pipe(
-          Effect.flatMap(HttpClientResponse.schemaBodyJson(Models)),
+        const source = JSON.stringify([
+          provider.package,
+          provider.settings,
+          provider.headers,
+          credential,
+          IntegrationConnection.key(connection),
+        ])
+        const previous = loaded.inventory.get(providerID)
+        const ids = yield* ProviderModels.fetch(provider, format, baseURL, credential).pipe(
+          Effect.provideService(HttpClient.HttpClient, http),
           Effect.timeout("5 seconds"),
-          Effect.map((response) =>
-            response.data
-              .filter((model) => model.id.length > 0 && (!model.mode || chat.has(model.mode)))
-              .map((model) => model.id)
-              .toSorted(),
-          ),
-          // Log the message only: the request in the cause carries configured headers, which may hold secrets.
-          Effect.tapError((error) =>
-            Effect.logDebug("openai-compatible model discovery failed", {
-              providerID: target.providerID,
-              message: error.message,
-            }),
+          Effect.map((ids) => [...ids].toSorted()),
+          // Do not log the HTTP cause: it can contain credentials and configured headers.
+          Effect.tapError(() =>
+            Effect.logWarning("Endpoint model discovery failed; retaining fallback", { providerID }),
           ),
           // Keep the last successful inventory through transient outages while the endpoint and key are unchanged.
           Effect.orElseSucceed(() => (previous?.source === source ? previous.ids : undefined)),
         )
-        return ids === undefined ? [] : [[target.providerID, { source, ids }] as const]
+        if (
+          IntegrationConnection.key(connection) !==
+          IntegrationConnection.key(yield* ctx.integration.connection.active(integrationID))
+        )
+          return []
+        return ids === undefined ? [] : [[providerID, { source, ids, connection }] as const]
       })
 
       const load = Effect.fn("OpenAICompatiblePlugin.load")(function* () {
@@ -97,11 +117,12 @@ export function make(interval: Duration.Input = "5 minutes") {
         Stream.runForEach(refresh),
         Effect.forkScoped({ startImmediately: true }),
       )
-      yield* bus.subscribe(Credential.Event.Switched).pipe(
-        Stream.runForEach(refresh),
-        Effect.forkScoped({ startImmediately: true }),
-      )
-      yield* refresh().pipe(Effect.ignore, Effect.repeat(Schedule.spaced(interval)), Effect.forkScoped)
+      yield* bus
+        .subscribe(Credential.Event.Switched)
+        .pipe(Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }))
+      // Settle availability before the first model list is served, then re-discover on the interval.
+      yield* refresh()
+      yield* Effect.sleep(interval).pipe(Effect.andThen(refresh), Effect.forever, Effect.ignore, Effect.forkScoped)
     }),
   } satisfies PluginInternal.InternalPlugin)
 }
@@ -113,23 +134,9 @@ function targets(entries: readonly Entry[]) {
   const ids = new Set(documents.flatMap((file) => Object.keys(file.info.providers ?? {})))
   return [...ids].flatMap((id) => {
     if (dedicated.has(id)) return []
-    const configured = documents.flatMap((file) => file.info.providers?.[id] ?? [])
-    const pkg = configured.findLast((item) => item.package !== undefined)?.package
-    // Migrated V1 configs store the package as `aisdk:@ai-sdk/openai-compatible`.
-    if (pkg === undefined || !packages.has(Provider.packageName(pkg))) return []
     const settings = foldSettings(entries, id, undefined)
     const baseURL = typeof settings?.baseURL === "string" ? settings.baseURL.replace(/\/+$/, "") : ""
     if (!URL.canParse(baseURL) || !["http:", "https:"].includes(new URL(baseURL).protocol)) return []
-    return [
-      {
-        providerID: Provider.ID.make(id),
-        baseURL,
-        apiKey: typeof settings?.apiKey === "string" && settings.apiKey !== "" ? settings.apiKey : undefined,
-        headers: configured.reduce(
-          (headers: Record<string, string> | undefined, item) => Provider.mergeHeaders(headers, item.headers),
-          undefined,
-        ),
-      },
-    ]
+    return [Provider.ID.make(id)]
   })
 }