refactor(app): use shared client connection (#43001)

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

@@ -1,4 +1,4 @@
-import { ProviderID, type ModelID, type ReasoningEffort } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
 import type { RouteDefaultsInput } from "../route/client.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
@@ -19,7 +19,6 @@ export interface Settings extends ProviderPackage.Settings {
   readonly apiKey?: string
   readonly baseURL: string
   readonly provider?: string
-  readonly reasoningEffort?: ReasoningEffort
 }
 
 export type FamilyModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
@@ -76,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.reasoningEffort === undefined ? undefined : { openai: { reasoningEffort: settings.reasoningEffort } },
   }).model(modelID)
 
 export const baseten = define(profiles.baseten)

packages/ai/test/provider-package.test.ts

@@ -106,18 +106,6 @@ describe("provider package entrypoints", () => {
     })
   })
 
-  test("maps OpenAI-compatible Chat reasoning effort onto the executable model", async () => {
-    const OpenAICompatible = await import("@opencode-ai/ai/providers/openai-compatible")
-    const selected = OpenAICompatible.model("custom-model", {
-      baseURL: "https://chat.example.test/v1",
-      provider: "example",
-      reasoningEffort: "high",
-    })
-
-    expect(String(selected.provider)).toBe("example")
-    expect(selected.route.defaults.providerOptions).toEqual({ openai: { reasoningEffort: "high" } })
-  })
-
   test("maps Anthropic-compatible settings onto the executable model", async () => {
     const AnthropicCompatible = await import("@opencode-ai/ai/providers/anthropic-compatible")
     const selected = AnthropicCompatible.model("compatible-model", {

packages/client/src/solid/connection.ts

@@ -75,8 +75,7 @@ export function createClientConnection(initialApi: OpenCodeClient, options: Clie
       if (signal.aborted) return { error: undefined, connectedAt }
       if (first.done)
         return {
-          error:
-            request.signal.reason instanceof Error ? request.signal.reason : new Error("Event stream disconnected"),
+          error: request.signal.reason instanceof Error ? request.signal.reason : new Error("Event stream disconnected"),
           connectedAt,
         }
       if (first.value.type !== "server.connected")

packages/core/src/plugin/provider.ts

@@ -15,10 +15,8 @@ import { GoogleVertexPlugin } from "./provider/google-vertex.js"
 import { GroqPlugin } from "./provider/groq.js"
 import { KiloPlugin } from "./provider/kilo.js"
 import { LLMGatewayPlugin } from "./provider/llmgateway.js"
-import { LMStudioPlugin } from "./provider/lmstudio.js"
 import { MistralPlugin } from "./provider/mistral.js"
 import { NvidiaPlugin } from "./provider/nvidia.js"
-import { OllamaPlugin } from "./provider/ollama.js"
 import { OpenAIPlugin } from "./provider/openai.js"
 import { SnowflakeCortexPlugin } from "./provider/snowflake-cortex.js"
 import { OpenAICompatiblePlugin } from "./provider/openai-compatible.js"
@@ -29,7 +27,6 @@ import { SapAICorePlugin } from "./provider/sap-ai-core.js"
 import { TogetherAIPlugin } from "./provider/togetherai.js"
 import { VercelPlugin } from "./provider/vercel.js"
 import { VenicePlugin } from "./provider/venice.js"
-import { VLLMPlugin } from "./provider/vllm.js"
 import { XAIPlugin } from "./provider/xai.js"
 import { ZenmuxPlugin } from "./provider/zenmux.js"
 import type { PluginInternal } from "./internal.js"
@@ -51,10 +48,8 @@ export const ProviderPlugins: PluginInternal.InternalPlugin[] = [
   GroqPlugin,
   KiloPlugin,
   LLMGatewayPlugin,
-  LMStudioPlugin,
   MistralPlugin,
   NvidiaPlugin,
-  OllamaPlugin,
   OpencodePlugin,
   SnowflakeCortexPlugin,
   OpenAICompatiblePlugin,
@@ -65,7 +60,6 @@ export const ProviderPlugins: PluginInternal.InternalPlugin[] = [
   TogetherAIPlugin,
   VercelPlugin,
   VenicePlugin,
-  VLLMPlugin,
   XAIPlugin,
   ZenmuxPlugin,
   DynamicProviderPlugin,

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

@@ -1,180 +0,0 @@
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Document, type Entry } from "@opencode-ai/schema/config"
-import { Duration, Effect, Schedule, Schema, Semaphore, Stream } from "effect"
-import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { Config } from "../../config.js"
-import { Model } from "../../model.js"
-import { Provider } from "../../provider.js"
-import type { PluginInternal } from "../internal.js"
-import { LocalReasoning } from "./local-reasoning.js"
-
-const providerID = "lmstudio"
-
-const RemoteModel = Schema.Struct({
-  type: Schema.Literals(["llm", "embedding"]),
-  key: Schema.String,
-  display_name: Schema.String,
-  architecture: Schema.NullOr(Schema.String).pipe(Schema.optional),
-  loaded_instances: Schema.Array(
-    Schema.Struct({
-      config: Schema.Struct({ context_length: Schema.Int }),
-    }),
-  ),
-  max_context_length: Schema.Int,
-  capabilities: Schema.Struct({
-    vision: Schema.Boolean,
-    trained_for_tool_use: Schema.Boolean,
-    reasoning: Schema.Struct({
-      allowed_options: Schema.Array(Schema.Literals(["off", "on", "low", "medium", "high"])),
-      default: Schema.Literals(["off", "on", "low", "medium", "high"]),
-    }).pipe(Schema.optional),
-  }).pipe(Schema.optional),
-})
-
-const Response = Schema.Struct({ models: Schema.Array(RemoteModel) })
-const discovery = new Map<string, { checked: number; apiKey?: string; models?: (typeof RemoteModel.Type)[] }>()
-const discoveryLock = Semaphore.makeUnsafe(1)
-
-export function make(origin = "http://127.0.0.1:1234", interval: Duration.Input = "30 seconds") {
-  return define({
-    id: "opencode.provider.lmstudio",
-    effect: Effect.fn(function* (ctx) {
-      const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient)
-      const config = yield* Config.Service
-      const source = { current: configured(yield* config.entries(), origin) }
-      const loaded = { models: [] as (typeof RemoteModel.Type)[], hash: "[]" }
-
-      yield* ctx.integration.transform((integrations) => {
-        if (loaded.models.length === 0) return
-        integrations.remove(providerID)
-      })
-
-      yield* ctx.catalog.transform((catalog) => {
-        if (loaded.models.length === 0) return
-        for (const model of catalog.provider.get(providerID)?.models.values() ?? []) {
-          catalog.model.remove(providerID, model.id)
-        }
-        catalog.provider.update(providerID, (provider) => {
-          provider.name = "LM Studio"
-          provider.activation = "enabled"
-          provider.package = "@opencode-ai/ai/providers/openai-compatible"
-          provider.settings = {
-            baseURL: source.current.baseURL,
-            provider: providerID,
-            apiKey: source.current.apiKey ?? "",
-          }
-          provider.integrationID = undefined
-        })
-        for (const item of loaded.models) {
-          catalog.model.update(providerID, item.key, (model) => {
-            model.modelID = Model.ID.make(item.key)
-            model.name = item.display_name || item.key
-            model.family = item.architecture ? Model.Family.make(item.architecture) : undefined
-            model.capabilities = {
-              tools: item.capabilities?.trained_for_tool_use ?? false,
-              input: ["text", ...(item.capabilities?.vision ? ["image"] : [])],
-              output: ["text"],
-            }
-            model.variants = LocalReasoning.fromOptions(item.capabilities?.reasoning?.allowed_options ?? [])
-            model.limit = {
-              context:
-                item.loaded_instances.length === 0
-                  ? item.max_context_length
-                  : Math.min(...item.loaded_instances.map((instance) => instance.config.context_length)),
-              output: 0,
-            }
-          })
-        }
-      })
-
-      const discover = Effect.fn("LMStudioPlugin.discover")(function* () {
-        const current = source.current
-        if (!current.endpoint) return undefined
-        return yield* discoveryLock.withPermit(
-          Effect.gen(function* () {
-            const cached = discovery.get(current.endpoint)
-            if (cached && cached.apiKey === current.apiKey && Date.now() - cached.checked < Duration.toMillis(interval))
-              return { source: current, models: cached.models }
-            discovery.set(current.endpoint, {
-              checked: Date.now(),
-              apiKey: current.apiKey,
-              models: cached && cached.apiKey === current.apiKey ? cached.models : undefined,
-            })
-            const request = current.apiKey
-              ? HttpClientRequest.get(current.endpoint).pipe(
-                  HttpClientRequest.acceptJson,
-                  HttpClientRequest.bearerToken(current.apiKey),
-                )
-              : HttpClientRequest.get(current.endpoint).pipe(HttpClientRequest.acceptJson)
-            const response = yield* http
-              .execute(request)
-              .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Response)), Effect.timeout("1 second"))
-            const models = response.models
-              .filter((model) => model.type === "llm" && model.key.length > 0)
-              .toSorted((a, b) => a.key.localeCompare(b.key))
-            discovery.set(current.endpoint, { checked: Date.now(), apiKey: current.apiKey, models })
-            return { source: current, models }
-          }),
-        )
-      })
-
-      const refresh = Effect.fn("LMStudioPlugin.refresh")(function* () {
-        const result = yield* discover()
-        if (!result?.models || result.source !== source.current) return
-        const hash = JSON.stringify(result.models)
-        if (hash === loaded.hash) return
-        loaded.models = result.models
-        loaded.hash = hash
-        yield* ctx.integration.reload()
-        yield* ctx.catalog.reload()
-      })
-
-      // Keep the last successful inventory through transient outages instead of flickering model availability.
-      yield* refresh().pipe(Effect.ignore, Effect.repeat(Schedule.spaced(interval)), Effect.forkScoped)
-      const reload = Effect.fn("LMStudioPlugin.reload")(function* () {
-        const next = configured(yield* config.entries(), origin)
-        if (
-          next.baseURL === source.current.baseURL &&
-          next.apiKey === source.current.apiKey &&
-          next.endpoint === source.current.endpoint
-        )
-          return
-        source.current = next
-        loaded.models = []
-        loaded.hash = "[]"
-        yield* ctx.integration.reload()
-        yield* ctx.catalog.reload()
-        yield* refresh().pipe(Effect.ignore)
-      })
-      yield* ctx.event.subscribe().pipe(
-        Stream.filter((event) => event.type === "config.updated"),
-        Stream.runForEach(reload),
-        Effect.forkScoped({ startImmediately: true }),
-      )
-    }),
-  } satisfies PluginInternal.InternalPlugin)
-}
-
-export const LMStudioPlugin = make()
-
-function configured(entries: readonly Entry[], origin: string) {
-  const settings = entries
-    .filter((entry): entry is Document => entry.type === "document")
-    .flatMap((entry) => {
-      const settings = entry.info.providers?.[providerID]?.settings
-      return settings ? [settings] : []
-    })
-    .reduce<Provider.Settings | undefined>((result, item) => Provider.mergeOverlay(result, item), undefined)
-  const baseURL = (
-    typeof settings?.baseURL === "string" ? settings.baseURL : `${origin.replace(/\/+$/, "")}/v1`
-  ).replace(/\/+$/, "")
-  const apiKey = typeof settings?.apiKey === "string" ? settings.apiKey : undefined
-  if (!URL.canParse(baseURL)) return { baseURL, apiKey }
-  const url = new URL(baseURL)
-  if (url.protocol !== "http:" && url.protocol !== "https:") return { baseURL, apiKey }
-  const prefix = url.pathname.endsWith("/v1") ? url.pathname.slice(0, -3) : url.pathname.replace(/\/+$/, "")
-  url.pathname = `${prefix}/api/v1/models`
-  url.search = ""
-  url.hash = ""
-  return { baseURL, apiKey, endpoint: url.toString() }
-}

packages/core/src/plugin/provider/local-reasoning.ts

@@ -1,47 +0,0 @@
-export * as LocalReasoning from "./local-reasoning.js"
-
-import { Model } from "../../model.js"
-
-type Option = "off" | "on" | "low" | "medium" | "high"
-
-export function fromOptions(options: readonly Option[]) {
-  return variants(
-    options.map((option) => {
-      if (option === "off") return ["none", "none"] as const
-      if (option === "on") return ["thinking", "medium"] as const
-      return [option, option] as const
-    }),
-  )
-}
-
-export function infer(engine: "ollama" | "vllm", model: string) {
-  const id = model.toLowerCase().replaceAll("_", "-")
-  if (id.includes("gpt-oss") || id.includes("gptoss"))
-    return variants([
-      ["low", "low"],
-      ["medium", "medium"],
-      ["high", "high"],
-    ])
-  if (id.includes("deepseek-v4") || id.includes("deepseekv4"))
-    return variants([
-      ["none", "none"],
-      ["high", "high"],
-      ["max", "max"],
-    ])
-  if (id.includes("qwen3") || id.includes("gemma-4") || id.includes("gemma4")) return toggle()
-  return engine === "ollama" ? toggle() : []
-}
-
-function toggle() {
-  return variants([
-    ["none", "none"],
-    ["thinking", "medium"],
-  ])
-}
-
-function variants(items: ReadonlyArray<readonly [id: string, effort: string]>) {
-  return items.map(([id, effort]) => ({
-    id: Model.VariantID.make(id),
-    settings: { reasoningEffort: effort },
-  }))
-}

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

@@ -1,237 +0,0 @@
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Document, type Entry } from "@opencode-ai/schema/config"
-import { Duration, Effect, Schedule, Schema, Semaphore, Stream } from "effect"
-import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { Config } from "../../config.js"
-import { Model } from "../../model.js"
-import { Provider } from "../../provider.js"
-import type { PluginInternal } from "../internal.js"
-import { LocalReasoning } from "./local-reasoning.js"
-
-const providerID = "ollama"
-
-const Details = Schema.Struct({
-  parent_model: Schema.String.pipe(Schema.optional),
-  format: Schema.String,
-  family: Schema.String,
-  families: Schema.Array(Schema.String).pipe(Schema.optional),
-  parameter_size: Schema.String,
-  quantization_level: Schema.String,
-})
-
-const RemoteModel = Schema.Struct({
-  name: Schema.String,
-  model: Schema.String,
-  remote_model: Schema.String.pipe(Schema.optional),
-  remote_host: Schema.String.pipe(Schema.optional),
-  modified_at: Schema.String,
-  size: Schema.Int,
-  digest: Schema.String,
-  details: Details,
-})
-
-const TagsResponse = Schema.Struct({ models: Schema.Array(RemoteModel) })
-const ShowRequest = Schema.Struct({ model: Schema.String })
-const ShowResponse = Schema.Struct({
-  parameters: Schema.String.pipe(Schema.optional),
-  license: Schema.String.pipe(Schema.optional),
-  modified_at: Schema.String.pipe(Schema.optional),
-  details: Details.pipe(Schema.optional),
-  template: Schema.String.pipe(Schema.optional),
-  capabilities: Schema.Array(Schema.String).pipe(Schema.optional),
-  model_info: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
-})
-
-type DiscoveredModel = typeof RemoteModel.Type & { show: typeof ShowResponse.Type }
-type Discovery = {
-  checked: number
-  apiKey?: string
-  models?: DiscoveredModel[]
-  shows: Map<string, { digest: string; info: typeof ShowResponse.Type }>
-}
-
-const discovery = new Map<string, Discovery>()
-const discoveryLock = Semaphore.makeUnsafe(1)
-
-export function make(origin = "http://127.0.0.1:11434", interval: Duration.Input = "30 seconds") {
-  return define({
-    id: "opencode.provider.ollama",
-    effect: Effect.fn(function* (ctx) {
-      const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient)
-      const config = yield* Config.Service
-      const source = { current: configured(yield* config.entries(), origin) }
-      const loaded = { models: [] as DiscoveredModel[], hash: "[]" }
-
-      yield* ctx.integration.transform((integrations) => {
-        if (loaded.models.length === 0) return
-        integrations.remove(providerID)
-      })
-
-      yield* ctx.catalog.transform((catalog) => {
-        if (loaded.models.length === 0) return
-        for (const model of catalog.provider.get(providerID)?.models.values() ?? []) {
-          catalog.model.remove(providerID, model.id)
-        }
-        catalog.provider.update(providerID, (provider) => {
-          provider.name = "Ollama"
-          provider.activation = "enabled"
-          provider.package = "@opencode-ai/ai/providers/openai-compatible"
-          provider.settings = {
-            baseURL: source.current.baseURL,
-            provider: providerID,
-            apiKey: source.current.apiKey ?? "",
-          }
-          provider.integrationID = undefined
-        })
-        for (const item of loaded.models) {
-          catalog.model.update(providerID, item.model, (model) => {
-            model.modelID = Model.ID.make(item.model)
-            model.name = item.name || item.model
-            model.family = item.show.details?.family
-              ? Model.Family.make(item.show.details.family)
-              : item.details.family
-                ? Model.Family.make(item.details.family)
-                : undefined
-            model.capabilities = {
-              tools: item.show.capabilities?.includes("tools") ?? false,
-              input: ["text", ...(item.show.capabilities?.includes("vision") ? ["image"] : [])],
-              output: ["text"],
-            }
-            model.variants = item.show.capabilities?.includes("thinking")
-              ? LocalReasoning.infer("ollama", `${item.model} ${model.family ?? ""}`)
-              : []
-            model.limit = {
-              context:
-                Object.entries(item.show.model_info ?? {}).flatMap(([key, value]) =>
-                  key.endsWith(".context_length") && typeof value === "number" && value > 0 ? [value] : [],
-                )[0] ?? 0,
-              output: 0,
-            }
-          })
-        }
-      })
-
-      const discover = Effect.fn("OllamaPlugin.discover")(function* () {
-        const current = source.current
-        if (!current.tagsEndpoint || !current.showEndpoint) return undefined
-        return yield* discoveryLock.withPermit(
-          Effect.gen(function* () {
-            const cached = discovery.get(current.tagsEndpoint)
-            if (cached && cached.apiKey === current.apiKey && Date.now() - cached.checked < Duration.toMillis(interval))
-              return { source: current, models: cached.models }
-            const previous: Discovery =
-              cached && cached.apiKey === current.apiKey
-                ? cached
-                : { checked: 0, apiKey: current.apiKey, shows: new Map() }
-            discovery.set(current.tagsEndpoint, { ...previous, checked: Date.now(), apiKey: current.apiKey })
-            const tagsRequest = current.apiKey
-              ? HttpClientRequest.get(current.tagsEndpoint).pipe(
-                  HttpClientRequest.acceptJson,
-                  HttpClientRequest.bearerToken(current.apiKey),
-                )
-              : HttpClientRequest.get(current.tagsEndpoint).pipe(HttpClientRequest.acceptJson)
-            const response = yield* http
-              .execute(tagsRequest)
-              .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(TagsResponse)), Effect.timeout("1 second"))
-            const summaries = response.models
-              .filter((model) => model.model.length > 0)
-              .toSorted((a, b) => a.model.localeCompare(b.model))
-            const shows = new Map<string, { digest: string; info: typeof ShowResponse.Type }>()
-            const models = yield* Effect.forEach(
-              summaries,
-              (model) =>
-                Effect.gen(function* () {
-                  const saved = previous.shows.get(model.model)
-                  const info =
-                    saved?.digest === model.digest
-                      ? saved.info
-                      : yield* HttpClientRequest.post(current.showEndpoint).pipe(
-                          HttpClientRequest.acceptJson,
-                          current.apiKey ? HttpClientRequest.bearerToken(current.apiKey) : (request) => request,
-                          HttpClientRequest.schemaBodyJson(ShowRequest)({ model: model.model }),
-                          Effect.flatMap(http.execute),
-                          Effect.flatMap(HttpClientResponse.schemaBodyJson(ShowResponse)),
-                          Effect.timeout("1 second"),
-                        )
-                  shows.set(model.model, { digest: model.digest, info })
-                  return { ...model, show: info }
-                }).pipe(Effect.catch(() => Effect.succeed(undefined))),
-              { concurrency: 4 },
-            )
-            const filtered = models.filter(
-              (model): model is DiscoveredModel =>
-                model !== undefined && (model.show.capabilities?.includes("completion") ?? false),
-            )
-            discovery.set(current.tagsEndpoint, {
-              checked: Date.now(),
-              apiKey: current.apiKey,
-              models: filtered,
-              shows,
-            })
-            return { source: current, models: filtered }
-          }),
-        )
-      })
-
-      const refresh = Effect.fn("OllamaPlugin.refresh")(function* () {
-        const result = yield* discover()
-        if (!result?.models || result.source !== source.current) return
-        const hash = JSON.stringify(result.models)
-        if (hash === loaded.hash) return
-        loaded.models = result.models
-        loaded.hash = hash
-        yield* ctx.integration.reload()
-        yield* ctx.catalog.reload()
-      })
-
-      // Keep the last successful inventory through transient outages instead of flickering model availability.
-      yield* refresh().pipe(Effect.ignore, Effect.repeat(Schedule.spaced(interval)), Effect.forkScoped)
-      const reload = Effect.fn("OllamaPlugin.reload")(function* () {
-        const next = configured(yield* config.entries(), origin)
-        if (
-          next.baseURL === source.current.baseURL &&
-          next.apiKey === source.current.apiKey &&
-          next.tagsEndpoint === source.current.tagsEndpoint
-        )
-          return
-        source.current = next
-        loaded.models = []
-        loaded.hash = "[]"
-        yield* ctx.integration.reload()
-        yield* ctx.catalog.reload()
-        yield* refresh().pipe(Effect.ignore)
-      })
-      yield* ctx.event.subscribe().pipe(
-        Stream.filter((event) => event.type === "config.updated"),
-        Stream.runForEach(reload),
-        Effect.forkScoped({ startImmediately: true }),
-      )
-    }),
-  } satisfies PluginInternal.InternalPlugin)
-}
-
-export const OllamaPlugin = make()
-
-function configured(entries: readonly Entry[], origin: string) {
-  const settings = entries
-    .filter((entry): entry is Document => entry.type === "document")
-    .flatMap((entry) => {
-      const settings = entry.info.providers?.[providerID]?.settings
-      return settings ? [settings] : []
-    })
-    .reduce<Provider.Settings | undefined>((result, item) => Provider.mergeOverlay(result, item), undefined)
-  const baseURL = (
-    typeof settings?.baseURL === "string" ? settings.baseURL : `${origin.replace(/\/+$/, "")}/v1`
-  ).replace(/\/+$/, "")
-  const apiKey = typeof settings?.apiKey === "string" ? settings.apiKey : undefined
-  if (!URL.canParse(baseURL)) return { baseURL, apiKey }
-  const url = new URL(baseURL)
-  if (url.protocol !== "http:" && url.protocol !== "https:") return { baseURL, apiKey }
-  const prefix = url.pathname.endsWith("/v1") ? url.pathname.slice(0, -3) : url.pathname.replace(/\/+$/, "")
-  url.pathname = `${prefix}/api/tags`
-  url.search = ""
-  url.hash = ""
-  const tagsEndpoint = url.toString()
-  url.pathname = `${prefix}/api/show`
-  return { baseURL, apiKey, tagsEndpoint, showEndpoint: url.toString() }
-}

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

@@ -1,164 +0,0 @@
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Document, type Entry } from "@opencode-ai/schema/config"
-import { Duration, Effect, Schedule, Schema, Semaphore, Stream } from "effect"
-import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { Config } from "../../config.js"
-import { Model } from "../../model.js"
-import { Provider } from "../../provider.js"
-import type { PluginInternal } from "../internal.js"
-import { LocalReasoning } from "./local-reasoning.js"
-
-const providerID = "vllm"
-
-const RemoteModel = Schema.Struct({
-  id: Schema.String,
-  owned_by: Schema.String,
-  max_model_len: Schema.NullOr(Schema.Int),
-})
-
-const Response = Schema.Struct({ data: Schema.Array(RemoteModel) })
-const discovery = new Map<string, { checked: number; apiKey?: string; models?: (typeof RemoteModel.Type)[] }>()
-const discoveryLock = Semaphore.makeUnsafe(1)
-
-export function make(origin = "http://127.0.0.1:8000", interval: Duration.Input = "30 seconds") {
-  return define({
-    id: "opencode.provider.vllm",
-    effect: Effect.fn(function* (ctx) {
-      const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient)
-      const config = yield* Config.Service
-      const source = { current: configured(yield* config.entries(), origin) }
-      const loaded = { models: [] as (typeof RemoteModel.Type)[], hash: "[]" }
-
-      yield* ctx.integration.transform((integrations) => {
-        if (loaded.models.length === 0) return
-        integrations.remove(providerID)
-      })
-
-      yield* ctx.catalog.transform((catalog) => {
-        if (loaded.models.length === 0) return
-        for (const model of catalog.provider.get(providerID)?.models.values() ?? []) {
-          catalog.model.remove(providerID, model.id)
-        }
-        catalog.provider.update(providerID, (provider) => {
-          provider.name = "vLLM"
-          provider.package = "@opencode-ai/ai/providers/openai-compatible"
-          provider.settings = {
-            baseURL: source.current.baseURL,
-            provider: providerID,
-            apiKey: source.current.apiKey ?? "",
-          }
-          provider.integrationID = undefined
-          provider.activation = "enabled"
-        })
-        for (const item of loaded.models) {
-          catalog.model.update(providerID, item.id, (model) => {
-            model.modelID = Model.ID.make(item.id)
-            model.name = item.id
-            // Tool calling depends on vLLM server flags and parsers that model discovery does not report.
-            model.capabilities = { tools: false, input: ["text"], output: ["text"] }
-            model.variants = LocalReasoning.infer("vllm", item.id)
-            model.limit = { context: item.max_model_len ?? 0, output: 0 }
-          })
-        }
-      })
-
-      const discover = Effect.fn("VLLMPlugin.discover")(function* () {
-        const current = source.current
-        if (!current.healthEndpoint || !current.modelsEndpoint) return undefined
-        return yield* discoveryLock.withPermit(
-          Effect.gen(function* () {
-            const endpoint = `${current.healthEndpoint}\n${current.modelsEndpoint}`
-            const cached = discovery.get(endpoint)
-            if (cached && cached.apiKey === current.apiKey && Date.now() - cached.checked < Duration.toMillis(interval))
-              return { source: current, models: cached.models }
-            discovery.set(endpoint, {
-              checked: Date.now(),
-              apiKey: current.apiKey,
-              models: cached && cached.apiKey === current.apiKey ? cached.models : undefined,
-            })
-            const request = (endpoint: string) =>
-              current.apiKey
-                ? HttpClientRequest.get(endpoint).pipe(
-                    HttpClientRequest.acceptJson,
-                    HttpClientRequest.bearerToken(current.apiKey),
-                  )
-                : HttpClientRequest.get(endpoint).pipe(HttpClientRequest.acceptJson)
-            yield* http.execute(request(current.healthEndpoint)).pipe(Effect.timeout("1 second"))
-            const response = yield* http
-              .execute(request(current.modelsEndpoint))
-              .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Response)), Effect.timeout("1 second"))
-            const models = response.data
-              .filter((model) => model.owned_by === providerID && model.id.length > 0)
-              .toSorted((a, b) => a.id.localeCompare(b.id))
-            discovery.set(endpoint, { checked: Date.now(), apiKey: current.apiKey, models })
-            return { source: current, models }
-          }),
-        )
-      })
-
-      const refresh = Effect.fn("VLLMPlugin.refresh")(function* () {
-        const result = yield* discover()
-        if (!result?.models || result.source !== source.current) return
-        const hash = JSON.stringify(result.models)
-        if (hash === loaded.hash) return
-        loaded.models = result.models
-        loaded.hash = hash
-        yield* ctx.integration.reload()
-        yield* ctx.catalog.reload()
-      })
-
-      // Keep the last successful inventory through transient outages instead of flickering model availability.
-      yield* refresh().pipe(Effect.ignore, Effect.repeat(Schedule.spaced(interval)), Effect.forkScoped)
-      const reload = Effect.fn("VLLMPlugin.reload")(function* () {
-        const next = configured(yield* config.entries(), origin)
-        if (
-          next.baseURL === source.current.baseURL &&
-          next.apiKey === source.current.apiKey &&
-          next.healthEndpoint === source.current.healthEndpoint &&
-          next.modelsEndpoint === source.current.modelsEndpoint
-        )
-          return
-        source.current = next
-        loaded.models = []
-        loaded.hash = "[]"
-        yield* ctx.integration.reload()
-        yield* ctx.catalog.reload()
-        yield* refresh().pipe(Effect.ignore)
-      })
-      yield* ctx.event.subscribe().pipe(
-        Stream.filter((event) => event.type === "config.updated"),
-        Stream.runForEach(reload),
-        Effect.forkScoped({ startImmediately: true }),
-      )
-    }),
-  } satisfies PluginInternal.InternalPlugin)
-}
-
-export const VLLMPlugin = make()
-
-function configured(entries: readonly Entry[], origin: string) {
-  const settings = entries
-    .filter((entry): entry is Document => entry.type === "document")
-    .flatMap((entry) => {
-      const settings = entry.info.providers?.[providerID]?.settings
-      return settings ? [settings] : []
-    })
-    .reduce<Provider.Settings | undefined>((result, item) => Provider.mergeOverlay(result, item), undefined)
-  const baseURL = (
-    typeof settings?.baseURL === "string" ? settings.baseURL : `${origin.replace(/\/+$/, "")}/v1`
-  ).replace(/\/+$/, "")
-  const apiKey = typeof settings?.apiKey === "string" ? settings.apiKey : undefined
-  if (!URL.canParse(baseURL)) return { baseURL, apiKey }
-  const models = new URL(baseURL)
-  if (models.protocol !== "http:" && models.protocol !== "https:") return { baseURL, apiKey }
-  models.pathname = `${models.pathname.replace(/\/+$/, "")}/models`
-  models.search = ""
-  models.hash = ""
-  const health = new URL(baseURL)
-  const path = health.pathname.replace(/\/+$/, "")
-  const prefix = path.endsWith("/v1") ? path.slice(0, -3) : path
-  health.pathname = `${prefix}/health`
-  health.search = ""
-  health.hash = ""
-  return { baseURL, apiKey, healthEndpoint: health.toString(), modelsEndpoint: models.toString() }
-}

packages/core/src/plugin/skill/opencode.md

@@ -29,41 +29,10 @@ V1 documentation and syntax may be consulted only when the user explicitly
 asks about V1 or when needed as migration input. Outputs and recommendations
 must still use V2 unless the user specifically requests a V1 result.
 
-## [CLI](https://opencode.ai/v2/docs/cli)
+## [Configuration](https://opencode.ai/v2/docs/config)
 
-For questions about the terminal interface, command-line invocation, `run`,
-`mini`, terminal providers, or other CLI behavior, fetch the
-[CLI guide](https://opencode.ai/v2/docs/cli) and the relevant page linked from
-that section.
-
-CLI and TUI preferences are separate from OpenCode's server and project
-configuration. They live in the global `~/.config/opencode/cli.json`, or
-`$XDG_CONFIG_HOME/opencode/cli.json` when `XDG_CONFIG_HOME` is set. There is no
-project-local CLI configuration. Most preferences can also be changed from the
-TUI by pressing `Ctrl+P` and selecting **Open settings**.
-
-Fetch the full [CLI configuration guide](https://opencode.ai/v2/docs/cli/config)
-before editing `cli.json`. It covers terminal-only settings such as themes,
-keybindings, terminal plugins, scrolling, attention alerts, diff presentation,
-and terminal integration. Do not put these settings in `opencode.json(c)`.
-
-### [Keybinds](https://opencode.ai/v2/docs/cli/keybinds)
-
-Configure keybindings under `keybinds` in `cli.json`. The leader key is the
-`keybinds.leader` entry; leader timing is configured separately under
-`leader.timeout`. Bindings can use a string, an array of strings, or an object
-when event behavior such as `preventDefault` is required. Disable a binding
-with `"none"` or `false`.
-
-Never guess a command ID, default binding, or accepted key syntax. Fetch the
-full [keybind reference](https://opencode.ai/v2/docs/cli/keybinds), which lists
-the current IDs and defaults, before answering or editing a binding.
-
-## [OpenCode configuration](https://opencode.ai/v2/docs/config)
-
-OpenCode's server and project configuration uses JSON or JSONC. Include the
-published schema so the user's editor can validate fields and provide
-autocomplete:
+OpenCode configuration uses JSON or JSONC. Include the published schema so the
+user's editor can validate fields and provide autocomplete:
 
 ```jsonc
 {
@@ -86,10 +55,6 @@ Common configuration fields include `model`, `default_agent`, `permissions`,
 `agents`, `commands`, `plugins`, `providers`, `mcp`, `skills`, `instructions`,
 `references`, `formatter`, and `lsp`.
 
-This configuration is distinct from `cli.json`. Use the
-[CLI configuration guide](https://opencode.ai/v2/docs/cli/config) for terminal
-preferences, especially themes and keybindings.
-
 Do not guess field names or shapes. Fetch the V2 configuration guide and its
 linked topic guide as the source of truth, and preserve unrelated settings when
 editing an existing file. Keep the published `$schema` URL in configuration

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

@@ -1,349 +0,0 @@
-import { Bus } from "@opencode-ai/core/bus"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { Config } from "@opencode-ai/core/config"
-import { Integration } from "@opencode-ai/core/integration"
-import { Model } from "@opencode-ai/core/model"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { LMStudioPlugin, make } from "@opencode-ai/core/plugin/provider/lmstudio"
-import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
-import { Provider } from "@opencode-ai/core/provider"
-import { Document, Event, Info } from "@opencode-ai/schema/config"
-import { describe, expect } from "bun:test"
-import { Duration, Effect, Layer, Schema } from "effect"
-import { testEffect } from "../lib/effect"
-import { PluginTestLayer } from "./fixture"
-
-const it = testEffect(Layer.merge(PluginTestLayer, Config.testLayer()))
-const decode = Schema.decodeUnknownSync(Info)
-
-const addPlugin = Effect.fn(function* (origin: string, interval: Duration.Input = "1 hour") {
-  const plugin = yield* Plugin.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* make(origin, interval).effect(host)
-})
-
-function eventually<A>(
-  effect: Effect.Effect<A>,
-  predicate: (value: A) => boolean,
-  remaining = 3000,
-): Effect.Effect<A, Error> {
-  return Effect.gen(function* () {
-    const value = yield* effect
-    if (predicate(value)) return value
-    if (remaining === 0) return yield* Effect.fail(new Error("Timed out waiting for value"))
-    yield* Effect.promise(() => Bun.sleep(1))
-    return yield* eventually(effect, predicate, remaining - 1)
-  })
-}
-
-describe("LMStudioPlugin", () => {
-  it.effect("is registered as a built-in provider plugin", () =>
-    Effect.sync(() => {
-      expect(LMStudioPlugin.id).toBe("opencode.provider.lmstudio")
-      expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.lmstudio")
-    }),
-  )
-
-  it.live("discovers local language models with their capabilities and effective context", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() =>
-        Bun.serve({
-          port: 0,
-          fetch: () =>
-            Response.json({
-              models: [
-                {
-                  type: "llm",
-                  key: "google/gemma-4-26b-a4b",
-                  display_name: "Gemma 4 26B A4B",
-                  architecture: "gemma4",
-                  loaded_instances: [{ config: { context_length: 32_768 } }, { config: { context_length: 16_384 } }],
-                  max_context_length: 262_144,
-                  capabilities: {
-                    vision: true,
-                    trained_for_tool_use: true,
-                    reasoning: { allowed_options: ["off", "on"], default: "on" },
-                  },
-                },
-                {
-                  type: "llm",
-                  key: "deepseek-r1",
-                  display_name: "DeepSeek R1",
-                  architecture: "deepseek",
-                  loaded_instances: [],
-                  max_context_length: 131_072,
-                  capabilities: { vision: false, trained_for_tool_use: false },
-                },
-                {
-                  type: "embedding",
-                  key: "nomic-embed",
-                  display_name: "Nomic Embed",
-                  loaded_instances: [],
-                  max_context_length: 2048,
-                },
-              ],
-            }),
-        }),
-      ),
-      (server) =>
-        Effect.gen(function* () {
-          const catalog = yield* Catalog.Service
-          yield* addPlugin(server.url.origin)
-          const providerID = Provider.ID.make("lmstudio")
-          const gemma = yield* eventually(
-            catalog.model.get(providerID, Model.ID.make("google/gemma-4-26b-a4b")),
-            (model) => model !== undefined,
-          )
-
-          expect(yield* catalog.provider.get(providerID)).toEqual({
-            id: providerID,
-            name: "LM Studio",
-            activation: "enabled",
-            package: "@opencode-ai/ai/providers/openai-compatible",
-            settings: { baseURL: `${server.url.origin}/v1`, provider: "lmstudio", apiKey: "" },
-          })
-          expect((yield* catalog.provider.available()).map((provider) => provider.id)).toContain(providerID)
-          expect(gemma).toMatchObject({
-            family: "gemma4",
-            name: "Gemma 4 26B A4B",
-            capabilities: { tools: true, input: ["text", "image"], output: ["text"] },
-            limit: { context: 16_384, output: 0 },
-            variants: [
-              { id: "none", settings: { reasoningEffort: "none" } },
-              { id: "thinking", settings: { reasoningEffort: "medium" } },
-            ],
-          })
-          expect(yield* catalog.model.get(providerID, Model.ID.make("deepseek-r1"))).toMatchObject({
-            capabilities: { tools: false, input: ["text"], output: ["text"] },
-            limit: { context: 131_072, output: 0 },
-          })
-          expect(yield* catalog.model.get(providerID, Model.ID.make("nomic-embed"))).toBeUndefined()
-        }),
-      (server) => Effect.promise(() => server.stop(true)),
-    ),
-  )
-
-  it.live("refreshes the catalog when LM Studio models change", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const models: Array<Record<string, unknown>> = []
-        return {
-          models,
-          server: Bun.serve({ port: 0, fetch: () => Response.json({ models }) }),
-        }
-      }),
-      ({ models, server }) =>
-        Effect.gen(function* () {
-          const catalog = yield* Catalog.Service
-          const providerID = Provider.ID.make("lmstudio")
-          yield* addPlugin(server.url.origin, "5 millis")
-          expect(yield* catalog.provider.get(providerID)).toBeUndefined()
-
-          models.push({
-            type: "llm",
-            key: "qwen/qwen3-coder",
-            display_name: "Qwen 3 Coder",
-            architecture: "qwen3",
-            loaded_instances: [],
-            max_context_length: 65_536,
-            capabilities: { vision: false, trained_for_tool_use: true },
-          })
-          expect(
-            yield* eventually(
-              catalog.model.get(providerID, Model.ID.make("qwen/qwen3-coder")),
-              (model) => model !== undefined,
-            ),
-          ).toMatchObject({ name: "Qwen 3 Coder" })
-
-          models.splice(0)
-          yield* eventually(catalog.provider.get(providerID), (provider) => provider === undefined)
-        }),
-      ({ server }) => Effect.promise(() => server.stop(true)),
-    ),
-  )
-
-  it.live(
-    "discovers from configured endpoints with bearer authentication",
-    () =>
-      Effect.acquireUseRelease(
-        Effect.sync(() => {
-          const requests: Array<{ authorization: string | null; path: string }> = []
-          const model = (key: string) => ({
-            type: "llm",
-            key,
-            display_name: key,
-            loaded_instances: [],
-            max_context_length: 32_768,
-          })
-          return {
-            requests,
-            initial: Bun.serve({ port: 0, fetch: () => Response.json({ models: [model("initial-model")] }) }),
-            configured: Bun.serve({
-              port: 0,
-              fetch: (request) => {
-                requests.push({
-                  authorization: request.headers.get("authorization"),
-                  path: new URL(request.url).pathname,
-                })
-                return Response.json({ models: [model("configured-model")] })
-              },
-            }),
-          }
-        }),
-        ({ requests, initial, configured }) =>
-          Effect.gen(function* () {
-            const bus = yield* Bus.Service
-            const catalog = yield* Catalog.Service
-            const config = yield* Config.Test
-            const providerID = Provider.ID.make("lmstudio")
-            yield* addPlugin(initial.url.origin)
-            yield* eventually(
-              catalog.model.get(providerID, Model.ID.make("initial-model")),
-              (model) => model !== undefined,
-            )
-
-            const baseURL = `${configured.url.origin}/proxy/v1`
-            yield* config.setEntries([configuration(baseURL, "secret")])
-            yield* bus.publish(Event.Updated, {})
-            yield* eventually(
-              catalog.model.get(providerID, Model.ID.make("configured-model")),
-              (model) => model !== undefined,
-            )
-
-            expect(requests).toContainEqual({ authorization: "Bearer secret", path: "/proxy/api/v1/models" })
-            expect(yield* catalog.model.get(providerID, Model.ID.make("initial-model"))).toBeUndefined()
-            expect((yield* catalog.provider.get(providerID))?.settings).toEqual({
-              baseURL,
-              provider: "lmstudio",
-              apiKey: "secret",
-            })
-
-            requests.splice(0)
-            yield* config.setEntries([configuration(baseURL, "secret"), configuration(baseURL, null)])
-            yield* bus.publish(Event.Updated, {})
-            yield* eventually(catalog.provider.get(providerID), (provider) => provider?.settings?.apiKey === "")
-            expect(requests).toContainEqual({ authorization: null, path: "/proxy/api/v1/models" })
-          }),
-        ({ initial, configured }) => Effect.promise(() => Promise.all([initial.stop(true), configured.stop(true)])),
-      ),
-    10_000,
-  )
-
-  it.live("shares discovery requests across plugin instances", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const requests = { count: 0 }
-        return {
-          requests,
-          server: Bun.serve({
-            port: 0,
-            fetch: () => {
-              requests.count++
-              return Response.json({
-                models: [
-                  {
-                    type: "llm",
-                    key: "shared-model",
-                    display_name: "Shared Model",
-                    loaded_instances: [],
-                    max_context_length: 32_768,
-                  },
-                ],
-              })
-            },
-          }),
-        }
-      }),
-      ({ requests, server }) =>
-        Effect.gen(function* () {
-          const catalog = yield* Catalog.Service
-          yield* addPlugin(server.url.origin)
-          yield* addPlugin(server.url.origin)
-          yield* eventually(
-            catalog.model.get(Provider.ID.make("lmstudio"), Model.ID.make("shared-model")),
-            (model) => model !== undefined,
-          )
-          expect(requests.count).toBe(1)
-        }),
-      ({ server }) => Effect.promise(() => server.stop(true)),
-    ),
-  )
-
-  it.live("replaces the credential-gated Models.dev catalog when discovery succeeds", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const models = [
-          {
-            type: "llm",
-            key: "discovered-model",
-            display_name: "Discovered Model",
-            loaded_instances: [],
-            max_context_length: 32_768,
-          },
-        ]
-        return { models, server: Bun.serve({ port: 0, fetch: () => Response.json({ models }) }) }
-      }),
-      ({ models, server }) =>
-        Effect.gen(function* () {
-          const catalog = yield* Catalog.Service
-          const integrations = yield* Integration.Service
-          const providerID = Provider.ID.make("lmstudio")
-          yield* integrations.transform((draft) => {
-            draft.update(Integration.ID.make("lmstudio"), (integration) => {
-              integration.name = "LMStudio"
-            })
-            draft.method.update({
-              integrationID: Integration.ID.make("lmstudio"),
-              method: { type: "env", names: ["LMSTUDIO_API_KEY"] },
-            })
-          })
-          yield* catalog.transform((draft) => {
-            draft.provider.update(providerID, (provider) => {
-              provider.name = "LMStudio"
-              provider.package = "aisdk:@ai-sdk/openai-compatible"
-              provider.integrationID = Integration.ID.make("lmstudio")
-            })
-            draft.model.update(providerID, Model.ID.make("static-model"), () => {})
-          })
-
-          expect((yield* catalog.provider.available()).map((provider) => provider.id)).not.toContain(providerID)
-          yield* addPlugin(server.url.origin, "5 millis")
-          yield* eventually(
-            catalog.model.get(providerID, Model.ID.make("discovered-model")),
-            (model) => model !== undefined,
-          )
-
-          expect(yield* integrations.get(Integration.ID.make("lmstudio"))).toBeUndefined()
-          expect((yield* catalog.provider.get(providerID))?.integrationID).toBeUndefined()
-          expect(yield* catalog.model.get(providerID, Model.ID.make("static-model"))).toBeUndefined()
-          expect((yield* catalog.provider.available()).map((provider) => provider.id)).toContain(providerID)
-
-          yield* integrations.transform((draft) => {
-            draft.update(Integration.ID.make("lmstudio"), (integration) => {
-              integration.name = "Configured LM Studio"
-            })
-            draft.method.update({ integrationID: Integration.ID.make("lmstudio"), method: { type: "key" } })
-          })
-          expect((yield* catalog.provider.available()).map((provider) => provider.id)).toContain(providerID)
-
-          models.splice(0)
-          yield* eventually(
-            catalog.model.get(providerID, Model.ID.make("static-model")),
-            (model) => model !== undefined,
-          )
-          expect(yield* catalog.model.get(providerID, Model.ID.make("discovered-model"))).toBeUndefined()
-          expect(yield* integrations.get(Integration.ID.make("lmstudio"))).toBeDefined()
-          expect((yield* catalog.provider.get(providerID))?.integrationID).toBe(Integration.ID.make("lmstudio"))
-        }),
-      ({ server }) => Effect.promise(() => server.stop(true)),
-    ),
-  )
-})
-
-function configuration(baseURL: string, apiKey: string | null) {
-  return new Document({
-    type: "document",
-    info: decode({ providers: { lmstudio: { settings: { baseURL, apiKey } } } }),
-  })
-}

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

@@ -1,356 +0,0 @@
-import { Bus } from "@opencode-ai/core/bus"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { Config } from "@opencode-ai/core/config"
-import { Integration } from "@opencode-ai/core/integration"
-import { Model } from "@opencode-ai/core/model"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { OllamaPlugin, make } from "@opencode-ai/core/plugin/provider/ollama"
-import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
-import { Provider } from "@opencode-ai/core/provider"
-import { Document, Event, Info } from "@opencode-ai/schema/config"
-import { describe, expect } from "bun:test"
-import { Duration, Effect, Layer, Schema } from "effect"
-import { testEffect } from "../lib/effect"
-import { PluginTestLayer } from "./fixture"
-
-const it = testEffect(Layer.merge(PluginTestLayer, Config.testLayer()))
-const decode = Schema.decodeUnknownSync(Info)
-const decodeShowRequest = Schema.decodeUnknownSync(Schema.Struct({ model: Schema.String }))
-
-const addPlugin = Effect.fn(function* (origin: string, interval: Duration.Input = "1 hour") {
-  const plugin = yield* Plugin.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* make(origin, interval).effect(host)
-})
-
-function eventually<A>(
-  effect: Effect.Effect<A>,
-  predicate: (value: A) => boolean,
-  remaining = 3000,
-): Effect.Effect<A, Error> {
-  return Effect.gen(function* () {
-    const value = yield* effect
-    if (predicate(value)) return value
-    if (remaining === 0) return yield* Effect.fail(new Error("Timed out waiting for value"))
-    yield* Effect.promise(() => Bun.sleep(1))
-    return yield* eventually(effect, predicate, remaining - 1)
-  })
-}
-
-describe("OllamaPlugin", () => {
-  it.live("discovers local completion models and native metadata", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const requests: Array<{ method: string; path: string; model?: string }> = []
-        return {
-          requests,
-          server: Bun.serve({
-            port: 0,
-            fetch: async (request) => {
-              const path = new URL(request.url).pathname
-              if (request.method === "GET") {
-                requests.push({ method: request.method, path })
-                return Response.json({
-                  models: [
-                    summary("gemma3:4b", "gemma-digest", "gemma3"),
-                    summary("gpt-oss:20b", "gpt-oss-digest", "gptoss"),
-                    summary("nomic-embed", "embed-digest"),
-                    summary("removed-model", "removed-digest"),
-                  ],
-                })
-              }
-              const body = decodeShowRequest(await request.json())
-              requests.push({ method: request.method, path, model: body.model })
-              if (body.model === "removed-model") return new Response("Not found", { status: 404 })
-              return Response.json(
-                body.model === "gemma3:4b"
-                  ? {
-                      capabilities: ["completion", "tools", "vision", "thinking"],
-                      model_info: { "gemma3.context_length": 131_072 },
-                    }
-                  : body.model === "gpt-oss:20b"
-                    ? show({ family: "gptoss", capabilities: ["completion", "thinking"], context: 131_072 })
-                    : show({ family: "nomic-bert", capabilities: ["embedding"], context: 8192 }),
-              )
-            },
-          }),
-        }
-      }),
-      ({ requests, server }) =>
-        Effect.gen(function* () {
-          const catalog = yield* Catalog.Service
-          const providerID = Provider.ID.make("ollama")
-          expect(OllamaPlugin.id).toBe("opencode.provider.ollama")
-          expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.ollama")
-          yield* addPlugin(server.url.origin)
-          const model = yield* eventually(
-            catalog.model.get(providerID, Model.ID.make("gemma3:4b")),
-            (item) => item !== undefined,
-          )
-
-          expect(yield* catalog.provider.get(providerID)).toEqual({
-            id: providerID,
-            name: "Ollama",
-            activation: "enabled",
-            package: "@opencode-ai/ai/providers/openai-compatible",
-            settings: { baseURL: `${server.url.origin}/v1`, provider: "ollama", apiKey: "" },
-          })
-          expect(model).toMatchObject({
-            modelID: "gemma3:4b",
-            name: "gemma3:4b",
-            family: "gemma3",
-            capabilities: { tools: true, input: ["text", "image"], output: ["text"] },
-            limit: { context: 131_072, output: 0 },
-            variants: [
-              { id: "none", settings: { reasoningEffort: "none" } },
-              { id: "thinking", settings: { reasoningEffort: "medium" } },
-            ],
-          })
-          expect(yield* catalog.model.get(providerID, Model.ID.make("gpt-oss:20b"))).toMatchObject({
-            variants: [
-              { id: "low", settings: { reasoningEffort: "low" } },
-              { id: "medium", settings: { reasoningEffort: "medium" } },
-              { id: "high", settings: { reasoningEffort: "high" } },
-            ],
-          })
-          expect(yield* catalog.model.get(providerID, Model.ID.make("nomic-embed"))).toBeUndefined()
-          expect(requests).toContainEqual({ method: "GET", path: "/api/tags" })
-          expect(requests).toContainEqual({ method: "POST", path: "/api/show", model: "gemma3:4b" })
-          expect(requests).toContainEqual({ method: "POST", path: "/api/show", model: "nomic-embed" })
-          expect(requests).toContainEqual({ method: "POST", path: "/api/show", model: "removed-model" })
-        }),
-      ({ server }) => Effect.promise(() => server.stop(true)),
-    ),
-  )
-
-  it.live("refreshes changed digests and retains inventory through transient failures", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const state = { digest: "digest-1", context: 32_768, fail: false }
-        const requests = { tags: 0, show: 0 }
-        return {
-          state,
-          requests,
-          server: Bun.serve({
-            port: 0,
-            fetch: async (request) => {
-              if (request.method === "GET") {
-                requests.tags++
-                if (state.fail) return new Response("unavailable", { status: 503 })
-                return Response.json({ models: [summary("qwen3:8b", state.digest, "qwen3")] })
-              }
-              decodeShowRequest(await request.json())
-              requests.show++
-              return Response.json(
-                show({ family: "qwen3", capabilities: ["completion", "tools"], context: state.context }),
-              )
-            },
-          }),
-        }
-      }),
-      ({ state, requests, server }) =>
-        Effect.gen(function* () {
-          const catalog = yield* Catalog.Service
-          const providerID = Provider.ID.make("ollama")
-          const modelID = Model.ID.make("qwen3:8b")
-          yield* addPlugin(server.url.origin, "5 millis")
-          yield* eventually(catalog.model.get(providerID, modelID), (model) => model?.limit.context === 32_768)
-          yield* eventually(
-            Effect.sync(() => requests.tags),
-            (count) => count >= 2,
-          )
-          expect(requests.show).toBe(1)
-
-          state.digest = "digest-2"
-          state.context = 65_536
-          yield* eventually(catalog.model.get(providerID, modelID), (model) => model?.limit.context === 65_536)
-          expect(requests.show).toBe(2)
-
-          state.fail = true
-          yield* Effect.promise(() => Bun.sleep(30))
-          expect((yield* catalog.model.get(providerID, modelID))?.limit.context).toBe(65_536)
-        }),
-      ({ server }) => Effect.promise(() => server.stop(true)),
-    ),
-  )
-
-  it.live("replaces and restores the same-ID Models.dev provider", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const models = [summary("discovered-model", "digest")]
-        return {
-          models,
-          server: Bun.serve({
-            port: 0,
-            fetch: async (request) => {
-              if (request.method === "GET") return Response.json({ models })
-              decodeShowRequest(await request.json())
-              return Response.json(show({ capabilities: ["completion"], context: 32_768 }))
-            },
-          }),
-        }
-      }),
-      ({ models, server }) =>
-        Effect.gen(function* () {
-          const catalog = yield* Catalog.Service
-          const integrations = yield* Integration.Service
-          const providerID = Provider.ID.make("ollama")
-          yield* integrations.transform((draft) => {
-            draft.update(Integration.ID.make("ollama"), (integration) => {
-              integration.name = "Ollama"
-            })
-            draft.method.update({
-              integrationID: Integration.ID.make("ollama"),
-              method: { type: "env", names: ["OLLAMA_API_KEY"] },
-            })
-          })
-          yield* catalog.transform((draft) => {
-            draft.provider.update(providerID, (provider) => {
-              provider.name = "Ollama"
-              provider.package = "aisdk:@ai-sdk/openai-compatible"
-              provider.integrationID = Integration.ID.make("ollama")
-            })
-            draft.model.update(providerID, Model.ID.make("static-model"), () => {})
-          })
-
-          yield* addPlugin(server.url.origin, "5 millis")
-          yield* eventually(
-            catalog.model.get(providerID, Model.ID.make("discovered-model")),
-            (model) => model !== undefined,
-          )
-          expect(yield* integrations.get(Integration.ID.make("ollama"))).toBeUndefined()
-          expect((yield* catalog.provider.get(providerID))?.activation).toBe("enabled")
-          expect(yield* catalog.model.get(providerID, Model.ID.make("static-model"))).toBeUndefined()
-
-          models.splice(0)
-          yield* eventually(
-            catalog.model.get(providerID, Model.ID.make("static-model")),
-            (model) => model !== undefined,
-          )
-          expect(yield* catalog.model.get(providerID, Model.ID.make("discovered-model"))).toBeUndefined()
-          expect(yield* integrations.get(Integration.ID.make("ollama"))).toBeDefined()
-          expect((yield* catalog.provider.get(providerID))?.activation).toBe("auto")
-          expect((yield* catalog.provider.get(providerID))?.integrationID).toBe(Integration.ID.make("ollama"))
-        }),
-      ({ server }) => Effect.promise(() => server.stop(true)),
-    ),
-  )
-
-  it.live(
-    "reloads layered endpoint and bearer authentication settings",
-    () =>
-      Effect.acquireUseRelease(
-        Effect.sync(() => {
-          const requests: Array<{ authorization: string | null; method: string; path: string }> = []
-          return {
-            requests,
-            initial: Bun.serve({
-              port: 0,
-              fetch: async (request) => {
-                if (request.method === "GET")
-                  return Response.json({ models: [summary("initial-model", "initial-digest")] })
-                decodeShowRequest(await request.json())
-                return Response.json(show({ capabilities: ["completion"], context: 4096 }))
-              },
-            }),
-            configured: Bun.serve({
-              port: 0,
-              fetch: async (request) => {
-                requests.push({
-                  authorization: request.headers.get("authorization"),
-                  method: request.method,
-                  path: new URL(request.url).pathname,
-                })
-                if (request.method === "GET")
-                  return Response.json({ models: [summary("configured-model", "configured-digest")] })
-                decodeShowRequest(await request.json())
-                return Response.json(show({ capabilities: ["completion", "vision"], context: 65_536 }))
-              },
-            }),
-          }
-        }),
-        ({ requests, initial, configured }) =>
-          Effect.gen(function* () {
-            const bus = yield* Bus.Service
-            const catalog = yield* Catalog.Service
-            const config = yield* Config.Test
-            const providerID = Provider.ID.make("ollama")
-            yield* addPlugin(initial.url.origin)
-            yield* eventually(
-              catalog.model.get(providerID, Model.ID.make("initial-model")),
-              (model) => model !== undefined,
-            )
-
-            const baseURL = `${configured.url.origin}/proxy/v1`
-            yield* config.setEntries([configuration({ baseURL, apiKey: "old" }), configuration({ apiKey: "secret" })])
-            yield* bus.publish(Event.Updated, {})
-            yield* eventually(
-              catalog.model.get(providerID, Model.ID.make("configured-model")),
-              (model) => model !== undefined,
-            )
-            expect(requests).toContainEqual({ authorization: "Bearer secret", method: "GET", path: "/proxy/api/tags" })
-            expect(requests).toContainEqual({ authorization: "Bearer secret", method: "POST", path: "/proxy/api/show" })
-            expect(yield* catalog.model.get(providerID, Model.ID.make("initial-model"))).toBeUndefined()
-            expect((yield* catalog.provider.get(providerID))?.settings).toEqual({
-              baseURL,
-              provider: "ollama",
-              apiKey: "secret",
-            })
-
-            requests.splice(0)
-            yield* config.setEntries([configuration({ baseURL, apiKey: "secret" }), configuration({ apiKey: null })])
-            yield* bus.publish(Event.Updated, {})
-            yield* eventually(catalog.provider.get(providerID), (provider) => provider?.settings?.apiKey === "")
-            expect(requests).toContainEqual({ authorization: null, method: "GET", path: "/proxy/api/tags" })
-            expect(requests).toContainEqual({ authorization: null, method: "POST", path: "/proxy/api/show" })
-          }),
-        ({ initial, configured }) => Effect.promise(() => Promise.all([initial.stop(true), configured.stop(true)])),
-      ),
-    10_000,
-  )
-})
-
-function summary(model: string, digest: string, family = "llama") {
-  return {
-    name: model,
-    model,
-    modified_at: "2026-01-01T00:00:00Z",
-    size: 1_000_000,
-    digest,
-    details: {
-      format: "gguf",
-      family,
-      families: [family],
-      parameter_size: "8B",
-      quantization_level: "Q4_K_M",
-    },
-  }
-}
-
-function show(input: { family?: string; capabilities: string[]; context: number }) {
-  const family = input.family ?? "llama"
-  return {
-    parameters: "temperature 0.7",
-    details: {
-      parent_model: "",
-      format: "gguf",
-      family,
-      families: [family],
-      parameter_size: "8B",
-      quantization_level: "Q4_K_M",
-    },
-    capabilities: input.capabilities,
-    model_info: {
-      "general.architecture": family,
-      [`${family}.context_length`]: input.context,
-    },
-  }
-}
-
-function configuration(settings: Record<string, string | null>) {
-  return new Document({
-    type: "document",
-    info: decode({ providers: { ollama: { settings } } }),
-  })
-}

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

@@ -1,297 +0,0 @@
-import { Bus } from "@opencode-ai/core/bus"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { Config } from "@opencode-ai/core/config"
-import { Integration } from "@opencode-ai/core/integration"
-import { Model } from "@opencode-ai/core/model"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
-import { make, VLLMPlugin } from "@opencode-ai/core/plugin/provider/vllm"
-import { Provider } from "@opencode-ai/core/provider"
-import { Document, Event, Info } from "@opencode-ai/schema/config"
-import { describe, expect } from "bun:test"
-import { Duration, Effect, Layer, Schema } from "effect"
-import { testEffect } from "../lib/effect"
-import { PluginTestLayer } from "./fixture"
-
-const it = testEffect(Layer.merge(PluginTestLayer, Config.testLayer()))
-const decode = Schema.decodeUnknownSync(Info)
-
-const addPlugin = Effect.fn(function* (origin: string, interval: Duration.Input = "1 hour") {
-  const plugin = yield* Plugin.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* make(origin, interval).effect(host)
-})
-
-function eventually<A>(
-  effect: Effect.Effect<A>,
-  predicate: (value: A) => boolean,
-  remaining = 3000,
-): Effect.Effect<A, Error> {
-  return Effect.gen(function* () {
-    const value = yield* effect
-    if (predicate(value)) return value
-    if (remaining === 0) return yield* Effect.fail(new Error("Timed out waiting for value"))
-    yield* Effect.promise(() => Bun.sleep(1))
-    return yield* eventually(effect, predicate, remaining - 1)
-  })
-}
-
-const remoteModel = (id: string, max_model_len = 32_768, owned_by = "vllm") => ({
-  id,
-  object: "model",
-  created: 1,
-  owned_by,
-  root: id,
-  parent: null,
-  max_model_len,
-  permission: [],
-})
-
-describe("VLLMPlugin", () => {
-  it.live("waits for readiness and discovers official vLLM model metadata", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const state = { healthy: false, models: 0 }
-        return {
-          state,
-          server: Bun.serve({
-            port: 0,
-            fetch: (request) => {
-              const path = new URL(request.url).pathname
-              if (path === "/health") return new Response(null, { status: state.healthy ? 200 : 503 })
-              state.models++
-              return Response.json({
-                object: "list",
-                data: [
-                  remoteModel("deepseek-ai/DeepSeek-V4-Flash", 65_536),
-                  remoteModel("foreign-model", 4096, "other"),
-                ],
-              })
-            },
-          }),
-        }
-      }),
-      ({ state, server }) =>
-        Effect.gen(function* () {
-          const catalog = yield* Catalog.Service
-          const providerID = Provider.ID.make("vllm")
-          expect(VLLMPlugin.id).toBe("opencode.provider.vllm")
-          expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.vllm")
-          yield* addPlugin(server.url.origin, "5 millis")
-          yield* Effect.promise(() => Bun.sleep(20))
-          expect(yield* catalog.provider.get(providerID)).toBeUndefined()
-          expect(state.models).toBe(0)
-
-          state.healthy = true
-          const model = yield* eventually(
-            catalog.model.get(providerID, Model.ID.make("deepseek-ai/DeepSeek-V4-Flash")),
-            (item) => item !== undefined,
-          )
-          expect(yield* catalog.provider.get(providerID)).toEqual({
-            id: providerID,
-            name: "vLLM",
-            package: "@opencode-ai/ai/providers/openai-compatible",
-            settings: { baseURL: `${server.url.origin}/v1`, provider: "vllm", apiKey: "" },
-            activation: "enabled",
-          })
-          expect((yield* catalog.provider.available()).map((provider) => provider.id)).toContain(providerID)
-          expect(model).toMatchObject({
-            modelID: "deepseek-ai/DeepSeek-V4-Flash",
-            name: "deepseek-ai/DeepSeek-V4-Flash",
-            capabilities: { tools: false, input: ["text"], output: ["text"] },
-            limit: { context: 65_536, output: 0 },
-            variants: [
-              { id: "none", settings: { reasoningEffort: "none" } },
-              { id: "high", settings: { reasoningEffort: "high" } },
-              { id: "max", settings: { reasoningEffort: "max" } },
-            ],
-          })
-          expect(yield* catalog.model.get(providerID, Model.ID.make("foreign-model"))).toBeUndefined()
-        }),
-      ({ server }) => Effect.promise(() => server.stop(true)),
-    ),
-  )
-
-  it.live("refreshes inventory while retaining the last success through transient failures", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const state = { failing: false, models: [remoteModel("first-model")] }
-        return {
-          state,
-          server: Bun.serve({
-            port: 0,
-            fetch: (request) => {
-              if (state.failing) return new Response(null, { status: 503 })
-              if (new URL(request.url).pathname === "/health") return new Response()
-              return Response.json({ object: "list", data: state.models })
-            },
-          }),
-        }
-      }),
-      ({ state, server }) =>
-        Effect.gen(function* () {
-          const catalog = yield* Catalog.Service
-          const providerID = Provider.ID.make("vllm")
-          yield* addPlugin(server.url.origin, "5 millis")
-          yield* eventually(catalog.model.get(providerID, Model.ID.make("first-model")), (model) => model !== undefined)
-
-          state.failing = true
-          state.models = [remoteModel("second-model")]
-          yield* Effect.promise(() => Bun.sleep(30))
-          expect(yield* catalog.model.get(providerID, Model.ID.make("first-model"))).toBeDefined()
-          expect(yield* catalog.model.get(providerID, Model.ID.make("second-model"))).toBeUndefined()
-
-          state.failing = false
-          yield* eventually(
-            catalog.model.get(providerID, Model.ID.make("second-model")),
-            (model) => model !== undefined,
-          )
-          expect(yield* catalog.model.get(providerID, Model.ID.make("first-model"))).toBeUndefined()
-        }),
-      ({ server }) => Effect.promise(() => server.stop(true)),
-    ),
-  )
-
-  it.live("replaces and restores same-ID Models.dev entries after an empty success", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const models = [remoteModel("discovered-model")]
-        return {
-          models,
-          server: Bun.serve({
-            port: 0,
-            fetch: (request) =>
-              new URL(request.url).pathname === "/health"
-                ? new Response()
-                : Response.json({ object: "list", data: models }),
-          }),
-        }
-      }),
-      ({ models, server }) =>
-        Effect.gen(function* () {
-          const catalog = yield* Catalog.Service
-          const integrations = yield* Integration.Service
-          const providerID = Provider.ID.make("vllm")
-          yield* integrations.transform((draft) => {
-            draft.update(Integration.ID.make("vllm"), (integration) => {
-              integration.name = "vLLM"
-            })
-            draft.method.update({
-              integrationID: Integration.ID.make("vllm"),
-              method: { type: "env", names: ["VLLM_API_KEY"] },
-            })
-          })
-          yield* catalog.transform((draft) => {
-            draft.provider.update(providerID, (provider) => {
-              provider.name = "vLLM"
-              provider.package = "aisdk:@ai-sdk/openai-compatible"
-              provider.integrationID = Integration.ID.make("vllm")
-              provider.activation = "auto"
-            })
-            draft.model.update(providerID, Model.ID.make("static-model"), () => {})
-          })
-
-          yield* addPlugin(server.url.origin, "5 millis")
-          yield* eventually(
-            catalog.model.get(providerID, Model.ID.make("discovered-model")),
-            (model) => model !== undefined,
-          )
-          expect(yield* integrations.get(Integration.ID.make("vllm"))).toBeUndefined()
-          expect((yield* catalog.provider.get(providerID))?.integrationID).toBeUndefined()
-          expect((yield* catalog.provider.get(providerID))?.activation).toBe("enabled")
-          expect(yield* catalog.model.get(providerID, Model.ID.make("static-model"))).toBeUndefined()
-
-          models.splice(0)
-          yield* eventually(
-            catalog.model.get(providerID, Model.ID.make("static-model")),
-            (model) => model !== undefined,
-          )
-          expect(yield* catalog.model.get(providerID, Model.ID.make("discovered-model"))).toBeUndefined()
-          expect(yield* integrations.get(Integration.ID.make("vllm"))).toBeDefined()
-          expect((yield* catalog.provider.get(providerID))?.integrationID).toBe(Integration.ID.make("vllm"))
-          expect((yield* catalog.provider.get(providerID))?.activation).toBe("auto")
-        }),
-      ({ server }) => Effect.promise(() => server.stop(true)),
-    ),
-  )
-
-  it.live(
-    "reloads layered custom endpoint and bearer authentication settings",
-    () =>
-      Effect.acquireUseRelease(
-        Effect.sync(() => {
-          const requests: Array<{ authorization: string | null; path: string }> = []
-          return {
-            requests,
-            initial: Bun.serve({
-              port: 0,
-              fetch: (request) =>
-                new URL(request.url).pathname === "/health"
-                  ? new Response()
-                  : Response.json({ object: "list", data: [remoteModel("initial-model")] }),
-            }),
-            configured: Bun.serve({
-              port: 0,
-              fetch: (request) => {
-                requests.push({
-                  authorization: request.headers.get("authorization"),
-                  path: new URL(request.url).pathname,
-                })
-                if (new URL(request.url).pathname === "/proxy/health") return new Response()
-                return Response.json({ object: "list", data: [remoteModel("configured-model")] })
-              },
-            }),
-          }
-        }),
-        ({ requests, initial, configured }) =>
-          Effect.gen(function* () {
-            const bus = yield* Bus.Service
-            const catalog = yield* Catalog.Service
-            const config = yield* Config.Test
-            const providerID = Provider.ID.make("vllm")
-            yield* addPlugin(initial.url.origin)
-            yield* eventually(
-              catalog.model.get(providerID, Model.ID.make("initial-model")),
-              (model) => model !== undefined,
-            )
-
-            const baseURL = `${configured.url.origin}/proxy/v1`
-            yield* config.setEntries([configuration({ baseURL }), configuration({ apiKey: "secret" })])
-            yield* bus.publish(Event.Updated, {})
-            yield* eventually(
-              catalog.model.get(providerID, Model.ID.make("configured-model")),
-              (model) => model !== undefined,
-            )
-
-            expect(requests).toContainEqual({ authorization: "Bearer secret", path: "/proxy/health" })
-            expect(requests).toContainEqual({ authorization: "Bearer secret", path: "/proxy/v1/models" })
-            expect(yield* catalog.model.get(providerID, Model.ID.make("initial-model"))).toBeUndefined()
-            expect((yield* catalog.provider.get(providerID))?.settings).toEqual({
-              baseURL,
-              provider: "vllm",
-              apiKey: "secret",
-            })
-
-            requests.splice(0)
-            yield* config.setEntries([configuration({ baseURL }), configuration({ apiKey: "next-secret" })])
-            yield* bus.publish(Event.Updated, {})
-            yield* eventually(
-              catalog.provider.get(providerID),
-              (provider) => provider?.settings?.apiKey === "next-secret",
-            )
-            expect(requests).toContainEqual({ authorization: "Bearer next-secret", path: "/proxy/health" })
-            expect(requests).toContainEqual({ authorization: "Bearer next-secret", path: "/proxy/v1/models" })
-          }),
-        ({ initial, configured }) => Effect.promise(() => Promise.all([initial.stop(true), configured.stop(true)])),
-      ),
-    10_000,
-  )
-})
-
-function configuration(settings: { baseURL?: string; apiKey?: string }) {
-  return new Document({
-    type: "document",
-    info: decode({ providers: { vllm: { settings } } }),
-  })
-}

packages/tui/src/component/dialog-experiments.tsx

@@ -13,7 +13,13 @@ type Experiment = {
 // In-flight features anyone can opt into. Each entry is temporary: an
 // experiment either graduates (delete the entry, make the behavior
 // unconditional) or dies (delete the entry and the branch it gated).
-export const experiments: Experiment[] = []
+export const experiments: Experiment[] = [
+  {
+    id: "tab_scroll",
+    title: "Remember tab scroll",
+    description: "Keep each open tab's reading position and show a shortcut back to the bottom.",
+  },
+]
 
 export function DialogExperiments() {
   const config = useConfig()

packages/tui/src/context/session-tabs.tsx

@@ -87,6 +87,11 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       renderer.off("blur", onBlur)
     })
 
+    createEffect(() => {
+      if (config.experimental?.tab_scroll === true) return
+      scrollAnchors.clear()
+    })
+
     function state() {
       if (config.tabs.scope === "cwd") return store.cwd[paths.cwd] ?? fallback
       return store.global

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

@@ -429,6 +429,7 @@ export function Session(props: { verticalTabsWidth: number }) {
     return scroll.scrollTop < Math.max(0, scroll.scrollHeight - scroll.viewport.height) - 1
   }
   function updateAwayFromBottom() {
+    if (config.experimental?.tab_scroll !== true) return
     if (awayTimer) clearTimeout(awayTimer)
     awayTimer = setTimeout(() => {
       awayTimer = undefined
@@ -439,7 +440,7 @@ export function Session(props: { verticalTabsWidth: number }) {
     })
   }
   function saveScrollAnchor() {
-    if (!isAwayFromBottom()) {
+    if (config.experimental?.tab_scroll !== true || !isAwayFromBottom()) {
       sessionTabs.setScrollAnchor(sessionID, undefined)
       return
     }
@@ -456,7 +457,7 @@ export function Session(props: { verticalTabsWidth: number }) {
     else sessionTabs.setScrollAnchor(sessionID, undefined)
   }
   function restoreScrollPosition() {
-    const anchor = sessionTabs.scrollAnchor(sessionID)
+    const anchor = config.experimental?.tab_scroll === true ? sessionTabs.scrollAnchor(sessionID) : undefined
     const index = anchor ? boundaries().indexOf(anchor.messageID) : -1
     if (!anchor || index === -1) {
       scroll.scrollTo(scroll.scrollHeight)
@@ -1194,21 +1195,15 @@ export function Session(props: { verticalTabsWidth: number }) {
               </scrollbox>
             </box>
             <box height={1} flexShrink={0} flexDirection="row" justifyContent="flex-end">
-              <Show when={awayFromBottom()}>
-                <box
-                  paddingLeft={1}
-                  paddingRight={1}
-                  backgroundColor={
-                    latestHovered() ? theme.background.action.primary.focused : theme.background.action.primary.default
-                  }
+              <Show when={config.experimental?.tab_scroll === true && awayFromBottom()}>
+                <text
+                  fg={latestHovered() ? theme.text.default : theme.text.subdued}
                   onMouseOver={() => setLatestHovered(true)}
                   onMouseOut={() => setLatestHovered(false)}
                   onMouseUp={toBottom}
                 >
-                  <text fg={latestHovered() ? theme.text.action.primary.focused : theme.text.action.primary.default}>
-                    Jump to latest ↓
-                  </text>
-                </box>
+                  Latest ↓
+                </text>
               </Show>
             </box>
             <box flexShrink={0}>

packages/tui/test/context/session-tabs.test.tsx

@@ -239,23 +239,6 @@ test("stores session tabs for the current working directory by default", async (
   }
 })
 
-test("keeps scroll anchors for open session tabs", async () => {
-  const setup = await renderSessionTabs("first")
-
-  try {
-    await wait(() => setup.tabs.current() === "first")
-    setup.tabs.setScrollAnchor("first", { messageID: "msg_1", screenY: -3 })
-
-    expect(setup.tabs.scrollAnchor("first")).toEqual({ messageID: "msg_1", screenY: -3 })
-
-    setup.tabs.close("first")
-    await wait(() => setup.tabs.tabs().every((tab) => tab.sessionID !== "first"))
-    expect(setup.tabs.scrollAnchor("first")).toBeUndefined()
-  } finally {
-    await setup.destroy()
-  }
-})
-
 test("only the foreground TUI mutates unread state", async () => {
   await using temporary = await tmpdir()
   let foreground: Awaited<ReturnType<typeof renderSessionTabs>> | undefined

packages/ui/src/components/animated-number.css

@@ -17,7 +17,7 @@
   }
 
   [data-slot="animated-number-digit"] {
-    display: inline-grid;
+    display: inline-block;
     width: 1ch;
     height: 1em;
     line-height: 1em;
@@ -41,12 +41,19 @@
     mask-repeat: no-repeat;
   }
 
-  [data-slot="animated-number-static"],
   [data-slot="animated-number-strip"] {
-    grid-area: 1 / 1;
+    display: inline-flex;
+    flex-direction: column;
+    transform: translateY(calc(var(--animated-number-offset, 10) * -1em));
+    transition-property: transform;
+    transition-duration: var(--animated-number-duration, 560ms);
+    transition-timing-function: var(--tool-motion-ease, cubic-bezier(0.22, 1, 0.36, 1));
+  }
+
+  [data-slot="animated-number-strip"][data-animating="false"] {
+    transition-duration: 0ms;
   }
 
-  [data-slot="animated-number-static"],
   [data-slot="animated-number-cell"] {
     display: inline-flex;
     align-items: center;
@@ -55,24 +62,6 @@
     height: 1em;
     line-height: 1em;
   }
-
-  [data-slot="animated-number-digit"][data-animating="true"] [data-slot="animated-number-static"] {
-    visibility: hidden;
-  }
-
-  [data-slot="animated-number-strip"] {
-    display: inline-flex;
-    flex-direction: column;
-    margin-top: calc(var(--animated-number-offset, 10) * -1em);
-    transition-property: margin-top;
-    transition-duration: var(--animated-number-duration, 560ms);
-    transition-timing-function: var(--tool-motion-ease, cubic-bezier(0.22, 1, 0.36, 1));
-  }
-
-  [data-slot="animated-number-digit"][data-animating="false"] [data-slot="animated-number-strip"] {
-    transition-duration: 0ms;
-    visibility: hidden;
-  }
 }
 
 @media (prefers-reduced-motion: reduce) {
@@ -82,12 +71,5 @@
 
   [data-component="animated-number"] [data-slot="animated-number-strip"] {
     transition-duration: 0ms;
-    visibility: hidden;
-  }
-
-  [data-component="animated-number"]
-    [data-slot="animated-number-digit"][data-animating]
-    [data-slot="animated-number-static"] {
-    visibility: visible;
   }
 }

packages/ui/src/components/animated-number.tsx

@@ -43,10 +43,10 @@ function Digit(props: { value: number; direction: 1 | -1 }) {
   )
 
   return (
-    <span data-slot="animated-number-digit" data-animating={animating() ? "true" : "false"}>
-      <span data-slot="animated-number-static">{props.value}</span>
+    <span data-slot="animated-number-digit">
       <span
         data-slot="animated-number-strip"
+        data-animating={animating() ? "true" : "false"}
         onTransitionEnd={() => {
           setState("animating", false)
           setState("step", (value) => normalize(value) + 10)

packages/www/content/docs/(Configure)/models.mdx

@@ -152,116 +152,6 @@ provider and model configuration. An unknown variant fails model resolution inst
 
 ### Local models
 
-#### Ollama
-
-OpenCode automatically discovers language models from an Ollama server listening on its default address,
-`http://127.0.0.1:11434`. Discovered models use the `ollama` provider ID and Ollama's model name:
-
-```jsonc title="opencode.jsonc"
-{
-  "$schema": "https://opencode.ai/config.json",
-  "model": "ollama/gemma3:4b",
-}
-```
-
-OpenCode refreshes the inventory in the background and reads context, vision, and tool-use capabilities from Ollama.
-Thinking-capable models also expose reasoning variants.
-Embedding-only models are excluded because they cannot drive a session. Disable discovery with
-`"plugins": ["-opencode.provider.ollama"]`.
-
-For a different host or port, configure Ollama's OpenAI-compatible base URL. Models are still discovered through the
-native Ollama API at the same path prefix:
-
-```jsonc title="opencode.jsonc"
-{
-  "$schema": "https://opencode.ai/config.json",
-  "providers": {
-    "ollama": {
-      "settings": {
-        "baseURL": "http://127.0.0.1:5678/v1",
-        "apiKey": "{env:OLLAMA_API_KEY}",
-      },
-    },
-  },
-}
-```
-
-Omit `apiKey` when the Ollama endpoint does not require bearer authentication.
-
-#### LM Studio
-
-OpenCode automatically discovers language models from an unauthenticated LM Studio server listening on its default
-address, `http://127.0.0.1:1234`. Discovered models use the `lmstudio` provider ID and LM Studio's model key:
-
-```jsonc title="opencode.jsonc"
-{
-  "$schema": "https://opencode.ai/config.json",
-  "model": "lmstudio/google/gemma-4-26b-a4b",
-}
-```
-
-OpenCode refreshes the inventory in the background and reads context, vision, tool-use, and reasoning capabilities from
-LM Studio. Available reasoning controls become model variants. Embedding models are excluded because they cannot drive
-a session. Disable discovery with
-`"plugins": ["-opencode.provider.lmstudio"]`.
-
-For a different host or port, configure the OpenAI-compatible base URL. Models are still discovered automatically:
-
-```jsonc title="opencode.jsonc"
-{
-  "$schema": "https://opencode.ai/config.json",
-  "providers": {
-    "lmstudio": {
-      "settings": {
-        "baseURL": "http://127.0.0.1:5678/v1",
-        "apiKey": "{env:LMSTUDIO_API_KEY}",
-      },
-    },
-  },
-}
-```
-
-Omit `apiKey` when LM Studio authentication is disabled.
-
-#### vLLM
-
-OpenCode automatically discovers models from a vLLM server listening on its default address, `http://127.0.0.1:8000`.
-Discovered models use the `vllm` provider ID and the model ID reported by vLLM:
-
-```jsonc title="opencode.jsonc"
-{
-  "$schema": "https://opencode.ai/config.json",
-  "model": "vllm/Qwen/Qwen3-Coder-30B-A3B-Instruct",
-}
-```
-
-OpenCode checks vLLM's `/health` endpoint and refreshes `/v1/models` in the background. It uses the reported
-`max_model_len` as the context limit and only includes model cards owned by `vllm`. Discovered vLLM models advertise
-text input and output, but not vision or tools. Tool calling is conservative because vLLM enables it with server-level
-flags such as `--enable-auto-tool-choice` and `--tool-call-parser`, which model discovery does not report. Disable
-discovery with `"plugins": ["-opencode.provider.vllm"]`.
-
-Recognized reasoning models expose reasoning variants.
-
-For a different endpoint or an authenticated server, configure its OpenAI-compatible base URL:
-
-```jsonc title="opencode.jsonc"
-{
-  "$schema": "https://opencode.ai/config.json",
-  "providers": {
-    "vllm": {
-      "settings": {
-        "baseURL": "http://127.0.0.1:9000/v1",
-        "apiKey": "{env:VLLM_API_KEY}",
-      },
-    },
-  },
-}
-```
-
-Omit `apiKey` when authentication is disabled. Path-prefixed proxy URLs are supported; for example,
-`https://example.com/vllm/v1` checks `/vllm/health` and discovers `/vllm/v1/models`.
-
 For an OpenAI-compatible server, define a provider package, endpoint, and at least one model:
 
 ```jsonc title="opencode.jsonc"
@@ -271,7 +161,7 @@ For an OpenAI-compatible server, define a provider package, endpoint, and at lea
   "providers": {
     "local": {
       "name": "Local server",
-      "package": "@opencode-ai/ai/providers/openai-compatible",
+      "package": "aisdk:@ai-sdk/openai-compatible",
       "settings": {
         "baseURL": "http://127.0.0.1:1234/v1",
       },