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

packages/cli/src/commands/commands.ts

@@ -272,10 +272,6 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
       params: {
         hostname: Flag.string("hostname").pipe(Flag.optional),
         port: Flag.integer("port").pipe(Flag.optional),
-        noAuth: Flag.boolean("no-auth").pipe(
-          Flag.withDescription("Disable server authentication"),
-          Flag.withDefault(false),
-        ),
         service: Flag.boolean("service").pipe(Flag.withDefault(false)),
         stdio: Flag.boolean("stdio").pipe(Flag.withDefault(false)),
       },

packages/cli/src/commands/handlers/serve.ts

@@ -11,7 +11,6 @@ export default Runtime.handler(
       mode: input.service ? "service" : input.stdio ? "stdio" : "default",
       hostname: Option.getOrUndefined(input.hostname),
       port: Option.getOrUndefined(input.port),
-      noAuth: input.noAuth,
     })
   }),
 )

packages/cli/src/env.ts

@@ -12,8 +12,4 @@ export const password = Config.redacted("OPENCODE_PASSWORD").pipe(
   Config.withDefault(undefined),
 )
 
-// Whether servers require authentication. Prefer a positive environment
-// variable so deployments can opt out with an explicit `false`.
-export const auth = Config.boolean("OPENCODE_AUTH").pipe(Config.withDefault(true))
-
 export * as Env from "./env"

packages/cli/src/server-process.ts

@@ -21,7 +21,6 @@ export type Options = {
   readonly mode: Mode
   readonly hostname?: string
   readonly port?: number
-  readonly noAuth?: boolean
 }
 
 // The process effect lives until server shutdown; tracing it would parent every request to one process-lifetime trace.
@@ -57,19 +56,18 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
       if (incumbent !== undefined) return
       const { start } = yield* Effect.promise(() => import("@opencode-ai/server/process"))
       const environmentPassword = yield* Env.password
-      const auth = !options.noAuth && (yield* Env.auth)
       // Keep the lease credential out of the environment inherited by tools.
       if (options.mode === "stdio") {
         delete process.env.OPENCODE_PASSWORD
         delete process.env.OPENCODE_SERVER_PASSWORD
       }
-      const password = !auth
-        ? undefined
-        : options.mode === "service"
+      const password =
+        options.mode === "service"
           ? config.password || randomBytes(32).toString("base64url")
           : environmentPassword
             ? Redacted.value(environmentPassword)
             : randomBytes(32).toString("base64url")
+      if (!password) return yield* Effect.fail(new Error("Missing server password"))
       const instanceID = randomUUID()
       const transform = yield* WebUi.handler()
       const server = yield* start(
@@ -122,7 +120,7 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
               instanceID,
               onListen: (address, shutdown) =>
                 Effect.gen(function* () {
-                  if (password && !config.password) yield* ServiceConfig.password(password)
+                  if (!config.password) yield* ServiceConfig.password(password)
                   return yield* register(address, password, instanceID, serviceOptions.file, shutdown)
                 }),
             },
@@ -148,7 +146,7 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
       if (server === undefined) return
       const url = HttpServer.formatAddress(server.address)
       console.log(options.mode === "stdio" ? JSON.stringify({ url }) : `server listening on ${url}`)
-      if (foreground && password && !environmentPassword) console.log(`server password ${password}`)
+      if (foreground && !environmentPassword) console.log(`server password ${password}`)
       const updater = yield* Updater.Service
       yield* updater.check().pipe(Effect.schedule(Schedule.spaced("10 minutes")), Effect.forkScoped)
       return yield* options.mode === "service"
@@ -166,7 +164,7 @@ const decodeInfo = Schema.decodeUnknownEffect(infoJson)
 
 const register = Effect.fnUntraced(function* (
   address: HttpServer.Address,
-  password: string | undefined,
+  password: string,
   id: string,
   file: string,
   shutdown: Effect.Effect<void>,
@@ -179,7 +177,7 @@ const register = Effect.fnUntraced(function* (
     version: OPENCODE_VERSION,
     url: HttpServer.formatAddress(address),
     pid: process.pid,
-    ...(password ? { password } : {}),
+    password,
   }
   const encoded = yield* encodeInfo(info)
   const current = fs.readFileString(file).pipe(

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,174 +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"
-
-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,
-  }).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.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/ollama.ts

@@ -1,233 +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"
-
-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.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,162 +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"
-
-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.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/test/plugin/provider-lmstudio.test.ts

@@ -1,341 +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 },
-                },
-                {
-                  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 },
-          })
-          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,342 +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("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"],
-                      model_info: { "gemma3.context_length": 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 },
-          })
-          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,289 +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("Qwen/Qwen3-Coder", 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("Qwen/Qwen3-Coder")),
-            (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: "Qwen/Qwen3-Coder",
-            name: "Qwen/Qwen3-Coder",
-            capabilities: { tools: false, input: ["text"], output: ["text"] },
-            limit: { context: 65_536, output: 0 },
-          })
-          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/server/src/process.ts

@@ -47,6 +47,7 @@ export const start = Effect.fn("ServerProcess.start")(function* <E, R>(
   transform?: Transform,
 ) {
   const password = options.password
+  if (!password) return yield* Effect.fail(new Error("Missing server password"))
   const hostname = options.hostname ?? "127.0.0.1"
   const port = Option.fromNullishOr(options.port)
   const shutdown = yield* Deferred.make<void>()
@@ -159,13 +160,13 @@ function addressInUse(error: unknown) {
 }
 
 function dispatch(
-  password: string | undefined,
+  password: string,
   status: Status.Interface,
   application: Ref.Ref<Option.Option<App>>,
   shutdown: Deferred.Deferred<void>,
   version: string,
 ): App {
-  const auth = ServerAuth.Config.of({ password: Option.fromNullishOr(password), username: "opencode" })
+  const auth = ServerAuth.Config.of({ password: Option.some(password), username: "opencode" })
   return Effect.gen(function* () {
     const request = yield* HttpServerRequest.HttpServerRequest
     const url = new URL(request.url, "http://localhost")
@@ -176,18 +177,13 @@ function dispatch(
           ? "stop"
           : undefined
     if (lifecycle !== undefined) {
-      if (ServerAuth.required(auth) && !(yield* authorizedRequest(request, auth))) return unauthorized()
+      if (!(yield* authorizedRequest(request, auth))) return unauthorized()
       return yield* control(request, lifecycle, status, () => Deferred.doneUnsafe(shutdown, Effect.void), version)
     }
     const state = yield* status.current
     const app = yield* Ref.get(application)
     const ready = state.type === "ready" && Option.isSome(app)
-    if (
-      ServerAuth.required(auth) &&
-      (!ready || !hasPtyConnectTicketURL(url)) &&
-      !(yield* authorizedRequest(request, auth))
-    )
-      return unauthorized()
+    if ((!ready || !hasPtyConnectTicketURL(url)) && !(yield* authorizedRequest(request, auth))) return unauthorized()
     if (ready) return yield* app.value
     return unavailable(state)
   })

packages/server/test/process.test.ts

@@ -60,20 +60,3 @@ it.live("allows browser preflight requests without credentials", () =>
     expect(yield* Effect.promise(() => missing.text())).toBe("fallback")
   }),
 )
-
-it.live("allows requests without credentials when authentication is disabled", () =>
-  Effect.gen(function* () {
-    const server = yield* ServerProcess.start<never, never>({
-      hostname: "127.0.0.1",
-      port: 0,
-      app: { version: "test-version" },
-      database: { path: ":memory:" },
-    })
-    const response = yield* Effect.promise(() =>
-      fetch(new URL("/api/health", HttpServer.formatAddress(server.address))),
-    )
-
-    expect(response.status).toBe(200)
-    expect(yield* Effect.promise(() => response.json())).toMatchObject({ version: "test-version" })
-  }),
-)

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,112 +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.
-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, and tool-use capabilities from LM
-Studio. 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"]`.
-
-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"
@@ -267,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",
       },