refactor(schema): separate provider and model settings (#49850)

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-TRfKunG6/UE8rQFyRkx/pX+pe7GT542IJWLEKcFFfAY=",
-    "aarch64-linux": "sha256-JxCYBQoHeJVuEMEe4Ef5f6UxxUCAuhPo96jqMT047Fc=",
-    "aarch64-darwin": "sha256-UEgjeQMivNC7JVsLEDlNbuqp9LJH84f9nHgLHTZ2zDI=",
-    "x86_64-darwin": "sha256-jEs/Oadjf2LVAinY0xyFna0V+NTwoCKXiXmQ83OchF8="
+    "x86_64-linux": "sha256-W2QBi7/jtbvLp3Gj+nR49+wqVgCB0qfnQ30C0PQOjO4=",
+    "aarch64-linux": "sha256-R4YKo8JUvKd77QYehTNpj/65oodeLBQ8mdxLzBLrFdw=",
+    "aarch64-darwin": "sha256-7v2ABLG6zsIMSzsYu06BWEqbLL4HOeKyZFBx/gx87SI=",
+    "x86_64-darwin": "sha256-emKRoQILMzB5ko45dtMPuZGV2pAyszcwzKUh9ey9JZM="
   }
 }

packages/client/src/promise/generated/types.ts

@@ -456,6 +456,10 @@ export type V2EventServerConnected = {
   data: {}
 }
 
+export type ModelSettings = { compaction?: ProviderCompaction } & { [x: string]: any }
+
+export type ConfigModelSettings = { compaction?: ProviderCompaction } & { [x: string]: JsonValue | null }
+
 export type ProviderSettings = {
   timeout?: number | false
   chunkTimeout?: number
@@ -1656,19 +1660,19 @@ export type SessionInboxMove = {
   payload: SessionInboxMovePayload
 }
 
+export type ModelVariant = {
+  id: string
+  settings?: ModelSettings
+  headers?: { [x: string]: string }
+  body?: { [x: string]: any }
+}
+
 export type ProviderRequest = {
   settings: ProviderSettings
   headers: { [x: string]: string }
   body: { [x: string]: any }
 }
 
-export type ModelVariant = {
-  id: string
-  settings?: ProviderSettings
-  headers?: { [x: string]: string }
-  body?: { [x: string]: any }
-}
-
 export type ProviderInfo = {
   id: string
   canonical?: string
@@ -1898,7 +1902,7 @@ export type ModelInfo = {
   name: string
   compatibility?: ModelCompatibility
   package?: string
-  settings?: ProviderSettings
+  settings?: ModelSettings
   headers?: { [x: string]: string }
   body?: { [x: string]: any }
   capabilities: ModelCapabilities
@@ -2107,13 +2111,13 @@ export type ConfigEntry =
                 name?: string
                 compatibility?: ModelCompatibility
                 package?: string
-                settings?: ConfigProviderSettings
+                settings?: ConfigModelSettings
                 headers?: { [x: string]: string }
                 body?: { [x: string]: JsonValue }
                 capabilities?: ModelCapabilities
                 variants?: Array<{
                   id: string
-                  settings?: ConfigProviderSettings
+                  settings?: ConfigModelSettings
                   headers?: { [x: string]: string }
                   body?: { [x: string]: JsonValue }
                 }>

packages/core/src/aisdk.ts

@@ -34,7 +34,7 @@ import { Auth, Endpoint, RequestExecutor, type AnyRoute } from "@opencode/ai/rou
 import { ProviderShared } from "@opencode/ai/protocols/shared"
 import { Cause, Context, Effect, Layer, Option, Schema, Scope, Stream } from "effect"
 import { makeParser } from "effect/unstable/encoding/Sse"
-import type { ID, Info } from "./model.js"
+import type { ID, RuntimeInfo } from "./model.js"
 import { Provider } from "./provider.js"
 import { State } from "./state.js"
 
@@ -46,14 +46,14 @@ type ToolResultContent = Extract<AssistantContent[number], { type: "tool-result"
 const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown))
 
 export interface SDKEvent {
-  readonly model: Info
+  readonly model: RuntimeInfo
   readonly package: string
   readonly options: Record<string, any>
   sdk?: SDK
 }
 
 export interface LanguageEvent {
-  readonly model: Info
+  readonly model: RuntimeInfo
   readonly sdk: SDK
   readonly options: Record<string, any>
   language?: LanguageModelV3
@@ -116,7 +116,7 @@ function wrapSSE(res: Response, ms: number, ctl: AbortController) {
   })
 }
 
-function prepareOptions(model: Info, pkg: string) {
+function prepareOptions(model: RuntimeInfo, pkg: string) {
   const projected = mapBodyToProviderOptions(model, pkg)
   const options: Record<string, any> = {
     name: model.canonical ?? model.providerID,
@@ -182,8 +182,8 @@ export interface Interface {
   }
   readonly runSDK: (event: SDKEvent) => Effect.Effect<SDKEvent>
   readonly runLanguage: (event: LanguageEvent) => Effect.Effect<LanguageEvent>
-  readonly language: (model: Info) => Effect.Effect<LanguageModelV3, InitError>
-  readonly model: (model: Info) => Effect.Effect<LanguageModel, InitError>
+  readonly language: (model: RuntimeInfo) => Effect.Effect<LanguageModelV3, InitError>
+  readonly model: (model: RuntimeInfo) => Effect.Effect<LanguageModel, InitError>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/AISDK") {}
@@ -302,7 +302,7 @@ export const locationLayer = Layer.effect(
   }),
 )
 
-function modelFromLanguage(info: Info, language: LanguageModelV3) {
+function modelFromLanguage(info: RuntimeInfo, language: LanguageModelV3) {
   const packageName = Provider.packageName(info.package!)
   const projected = mapBodyToProviderOptions(info, packageName)
   const providerID = info.canonical ?? info.providerID
@@ -399,7 +399,7 @@ function requestSettings(settings: Readonly<Record<string, unknown>> | undefined
   return Object.keys(result).length === 0 ? undefined : result
 }
 
-function mapBodyToProviderOptions(model: Info, packageName: string) {
+function mapBodyToProviderOptions(model: RuntimeInfo, packageName: string) {
   const settings = requestSettings(model.settings)
   const pro = Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(model.body?.reasoning)
   const forceReasoning =

packages/core/src/model-resolver.ts

@@ -8,6 +8,7 @@ import { AISDK } from "./aisdk.js"
 import { Credential } from "./credential.js"
 import { Integration } from "./integration.js"
 import { Capabilities, ID, Info, Model, Ref, VariantID } from "./model.js"
+import type { RuntimeInfo } from "./model.js"
 import { Npm } from "@opencode/util/npm"
 import { Provider } from "./provider.js"
 
@@ -117,9 +118,9 @@ export interface Resolved {
   readonly cost: Info["cost"]
   /** Catalog token limits used by Core for context management. */
   readonly limit: Info["limit"]
-  /** Model policy overrides the provider policy; omitted means local compaction. */
+  /** Model policy overrides the provider policy; omitted means summary compaction. */
   readonly compaction?: Provider.Compaction
-  /** Model transport overrides the provider transport; omitted means HTTP. */
+  /** Provider transport policy; omitted means HTTP. */
   readonly transport?: Provider.Transport
 }
 
@@ -149,7 +150,7 @@ export const withVariant = (
     variant
       ? {
           ...model,
-          settings: Provider.mergeOverlay(model.settings, variant.settings),
+          settings: Provider.mergeOverlay(model.settings, Provider.modelSettings(variant.settings)),
           headers: Provider.mergeHeaders(model.headers, variant.headers),
           body: Provider.mergeOverlay(model.body, variant.body),
         }
@@ -159,11 +160,11 @@ export const withVariant = (
 
 export interface Dependencies {
   readonly loadPackage?: (specifier: string) => Effect.Effect<Provider.ProviderPackage, Provider.LoadError>
-  readonly loadAISDK?: (model: Info) => Effect.Effect<LanguageModel, AISDK.InitError>
+  readonly loadAISDK?: (model: RuntimeInfo) => Effect.Effect<LanguageModel, AISDK.InitError>
 }
 
 export const fromCatalogModel = (
-  model: Info,
+  model: RuntimeInfo,
   credential?: Credential.Value,
   dependencies?: Dependencies,
 ): Effect.Effect<
@@ -191,7 +192,7 @@ export const fromCatalogModel = (
   )
 
 const resolveCatalogModel = Effect.fn("ModelResolver.resolveCatalogModel")(function* (
-  model: Info,
+  model: RuntimeInfo,
   credential?: Credential.Value,
   dependencies?: Dependencies,
 ) {
@@ -248,7 +249,7 @@ const resolveCatalogModel = Effect.fn("ModelResolver.resolveCatalogModel")(funct
   })
 })
 
-function prepareRuntimeModel(model: Info, credential: Credential.Value | undefined) {
+function prepareRuntimeModel(model: RuntimeInfo, credential: Credential.Value | undefined) {
   if (model.settings?.apiKey !== "" && (credential?.type !== "key" || credential.metadata === undefined)) return model
   return {
     ...model,
@@ -260,7 +261,7 @@ function prepareRuntimeModel(model: Info, credential: Credential.Value | undefin
 }
 
 function validateProviderVariables(
-  model: Info,
+  model: RuntimeInfo,
   resolved: LanguageModel,
 ): Effect.Effect<LanguageModel, UnresolvedProviderVariablesError> {
   const baseURL = resolved.route.endpoint.baseURL
@@ -270,7 +271,7 @@ function validateProviderVariables(
 }
 
 function prepareProviderSettings(
-  model: Info,
+  model: RuntimeInfo,
   settings: Readonly<Record<string, unknown>>,
 ): Effect.Effect<Readonly<Record<string, unknown>>, UnresolvedProviderVariablesError> {
   const baseURL = settings.baseURL
@@ -280,14 +281,14 @@ function prepareProviderSettings(
   )
 }
 
-function prepareProviderURL(model: Info, baseURL: string): Effect.Effect<string, UnresolvedProviderVariablesError> {
+function prepareProviderURL(model: RuntimeInfo, baseURL: string): Effect.Effect<string, UnresolvedProviderVariablesError> {
   if (!baseURL.includes("${")) return Effect.succeed(baseURL)
   const prepared = baseURL.replace(/\$\{([^}]+)\}/g, (placeholder, name: string) => process.env[name] ?? placeholder)
   const failure = unresolvedProviderVariables(model, prepared)
   return failure ? Effect.fail(failure) : Effect.succeed(prepared)
 }
 
-function unresolvedProviderVariables(model: Info, baseURL: string) {
+function unresolvedProviderVariables(model: RuntimeInfo, baseURL: string) {
   const variables = new Set(Array.from(baseURL.matchAll(/\$\{([^}]+)\}/g), (match) => match[1]))
   if (variables.size === 0) return
   return new UnresolvedProviderVariablesError({
@@ -310,14 +311,14 @@ const nativeCredentialSettings = (specifier: string, credential: Credential.Valu
   return { apiKey: credential.access }
 }
 
-const unsupported = (model: Info) =>
+const unsupported = (model: RuntimeInfo) =>
   new UnsupportedPackageError({
     providerID: model.providerID,
     modelID: model.id,
     package: model.package ?? "unknown",
   })
 
-const initialization = (model: Info, phase: InitializationPhase, cause: unknown) =>
+const initialization = (model: RuntimeInfo, phase: InitializationPhase, cause: unknown) =>
   new ModelInitializationError({
     providerID: model.providerID,
     modelID: model.id,
@@ -359,7 +360,11 @@ export const layer = Layer.effect(
         provider?.integrationID ?? Integration.ID.make(selected.providerID),
       )
       const credential = connection ? yield* integrations.connection.resolve(connection) : undefined
-      const runtimeInfo = yield* withVariant(selected, variant)
+      const selectedVariant = yield* withVariant(selected, variant)
+      const runtimeInfo: RuntimeInfo = {
+        ...selectedVariant,
+        settings: Provider.mergeOverlay(provider?.settings, Provider.modelSettings(selectedVariant.settings)),
+      }
       const model = yield* fromCatalogModel(runtimeInfo, credential, {
         loadPackage: (specifier) => Provider.loadPackage(specifier, npm),
         loadAISDK: (model) => aisdk.model(model),
@@ -382,7 +387,7 @@ export const layer = Layer.effect(
         cost: selected.cost,
         limit: selected.limit,
         compaction: runtimeInfo.settings?.compaction,
-        transport: runtimeInfo.settings?.transport,
+        transport: provider?.settings?.transport,
       }
     })
     return Service.of({
@@ -406,7 +411,7 @@ export const layer = Layer.effect(
   }),
 )
 
-function hasConfiguredAuth(model: Info) {
+function hasConfiguredAuth(model: RuntimeInfo) {
   return [model.settings?.apiKey, model.settings?.authToken, model.settings?.accessToken].some(
     (value) => typeof value === "string" && value !== "",
   )

packages/core/src/model.ts

@@ -36,6 +36,9 @@ export type Ref = typeof Ref.Type
 export const Info = Model.Info
 export type Info = Model.Info
 
+/** Effective provider and model settings used only while constructing a runtime model. */
+export type RuntimeInfo = Omit<Info, "settings"> & { readonly settings?: Provider.Settings }
+
 export type MutableInfo = DeepMutable<Info>
 
 export { Event } from "@opencode/schema/model"
@@ -188,7 +191,10 @@ const layer = Layer.effect(
                     ...model,
                     ...(provider?.canonical === undefined ? {} : { canonical: provider.canonical }),
                     package: model.package ?? provider?.package,
-                    settings: Provider.mergeOverlay(provider?.settings, model.settings),
+                    settings: Provider.mergeOverlay(
+                      Provider.modelSettings(provider?.settings),
+                      Provider.modelSettings(model.settings),
+                    ),
                     headers: Provider.mergeHeaders(provider?.headers, model.headers),
                     body: Provider.mergeOverlay(provider?.body, model.body),
                   } satisfies Info

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

@@ -7,7 +7,6 @@ import { App } from "../../app.js"
 import { Bus } from "../../bus.js"
 import { Credential } from "../../credential.js"
 import { Integration } from "../../integration.js"
-import { Model } from "../../model.js"
 import { Provider } from "../../provider.js"
 import { iife } from "../../util/iife.js"
 import { which } from "../../util/which.js"
@@ -140,16 +139,18 @@ export const AzurePlugin = define({
         )
           continue
         const resourceName = resolveResourceName(item.provider.settings, loaded.resource)
-        if (resourceName)
-          evt.update(item.provider.id, (provider) => {
-            provider.settings = {
-              ...provider.settings,
-              resourceName,
-              ...(typeof provider.settings?.baseURL === "string"
-                ? { baseURL: expandResourceName(provider.settings.baseURL, resourceName) }
-                : {}),
-            }
-          })
+        const websocket = responsesWebSocketCapable(item.provider)
+        if (!resourceName && !websocket) continue
+        evt.update(item.provider.id, (provider) => {
+          provider.settings = {
+            ...provider.settings,
+            ...(resourceName === undefined ? {} : { resourceName }),
+            ...(websocket ? { transport: provider.settings?.transport ?? "websocket" } : {}),
+            ...(resourceName !== undefined && typeof provider.settings?.baseURL === "string"
+              ? { baseURL: expandResourceName(provider.settings.baseURL, resourceName) }
+              : {}),
+          }
+        })
       }
     })
     yield* ctx.model.transform((models) => {
@@ -167,10 +168,6 @@ export const AzurePlugin = define({
                 draft.settings.baseURL,
                 resolveResourceName(draft.settings, resourceName) ?? resourceName,
               )
-            if (responsesWebSocketCapable(item.provider, draft))
-              draft.settings = Provider.mergeOverlay(draft.settings, {
-                transport: item.provider.settings?.transport ?? "websocket",
-              })
           })
         }
       }
@@ -242,9 +239,9 @@ function expandResourceName(baseURL: string, resourceName: string) {
     .replaceAll("${AZURE_COGNITIVE_SERVICES_RESOURCE_NAME}", resourceName)
 }
 
-function responsesWebSocketCapable(provider: Provider.Info, model: Model.Info) {
-  if ((model.package ?? provider.package) !== "@opencode/ai/providers/azure/responses") return false
-  const settings = Provider.mergeOverlay(provider.settings, model.settings)
+function responsesWebSocketCapable(provider: Provider.Info) {
+  if (provider.package !== "@opencode/ai/providers/azure/responses") return false
+  const settings = provider.settings
   if (settings?.useDeploymentBasedUrls === true) return false
   if (settings?.apiVersion !== undefined && settings.apiVersion !== "v1") return false
   if (typeof settings?.baseURL !== "string") return true

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

@@ -254,10 +254,13 @@ export const OpenAIPlugin = define({
     yield* ctx.provider.transform((providers) => {
       const item = providers.get(Provider.ID.openai)
       if (!item) return
-      if (!chatgpt) return
-      const account = chatgpt.metadata?.accountID
+      const account = chatgpt?.metadata?.accountID
       providers.update(item.provider.id, (provider) => {
-        provider.settings = Provider.mergeOverlay(provider.settings, { baseURL: codexBaseURL })
+        provider.settings = Provider.mergeOverlay(provider.settings, {
+          transport: provider.settings?.transport ?? "websocket",
+          ...(chatgpt ? { baseURL: codexBaseURL } : {}),
+        })
+        if (!chatgpt) return
         provider.headers = Provider.mergeHeaders(provider.headers, {
           originator: "opencode",
           "x-codex-beta-features": "remote_compaction_v2",
@@ -270,9 +273,6 @@ export const OpenAIPlugin = define({
         // ChatGPT-plan tokens only authorize codex-eligible models, and the
         // subscription covers usage, so hide the rest and zero the cost.
         models.update(model.providerID, model.id, (draft) => {
-          draft.settings = Provider.mergeOverlay(draft.settings, {
-            transport: models.provider.get(model.providerID)?.provider.settings?.transport ?? "websocket",
-          })
           if (!chatgpt) return
           if (Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(draft.body?.reasoning)) {
             draft.enabled = false

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

@@ -95,14 +95,13 @@ export const XAIPlugin = define({
       editor.method.update(device(ctx.app))
       editor.method.update({ integrationID: "xai", method: { type: "key", label: "Manually enter API Key" } })
     })
-    yield* ctx.model.transform((models) => {
-      for (const model of models.list(providerID)) {
-        models.update(providerID, model.id, (draft) => {
-          draft.settings = Provider.mergeOverlay(draft.settings, {
-            transport: models.provider.get(providerID)?.provider.settings?.transport ?? "websocket",
-          })
+    yield* ctx.provider.transform((providers) => {
+      if (!providers.get(providerID)) return
+      providers.update(providerID, (provider) => {
+        provider.settings = Provider.mergeOverlay(provider.settings, {
+          transport: provider.settings?.transport ?? "websocket",
         })
-      }
+      })
     })
   }),
 })

packages/core/src/provider.ts

@@ -134,11 +134,16 @@ export const loadPackage = Effect.fn("Provider.loadPackage")(function* (input: s
 
 /** opencode settings consumed in Core; native packages never receive them. */
 const CORE_KEYS = ["chunkTimeout", "compaction", "fetch", "timeout", "transport"] as const
+const PROVIDER_ONLY_KEYS = ["chunkTimeout", "timeout", "transport"] as const
 
 export function nativeSettings(settings: Settings): Settings {
   return Struct.omit(settings, CORE_KEYS)
 }
 
+export function modelSettings(settings: Settings | undefined) {
+  return settings && Struct.omit(settings, PROVIDER_ONLY_KEYS)
+}
+
 export function mergeOverlay(
   base: Readonly<Record<string, unknown>> | undefined,
   overlay: Readonly<Record<string, unknown>> | undefined,

packages/core/test/aisdk.test.ts

@@ -27,14 +27,15 @@ import { testEffect } from "./lib/effect"
 
 const it = testEffect(AISDK.locationLayer)
 
-const model = (packageName: string, settings: Record<string, unknown> = {}) =>
-  Model.Info.make({
+const model = (packageName: string, settings: Provider.Settings = {}): Model.RuntimeInfo => ({
+  ...Model.Info.make({
     ...Model.Info.default(Provider.ID.make("test-provider"), Model.ID.make("catalog-model")),
     modelID: Model.ID.make("api-model"),
     package: Provider.aisdk(packageName),
-    settings,
     limit: { context: 100, output: 20 },
-  })
+  }),
+  settings,
+})
 
 const streamModel = (events: ReadonlyArray<LanguageModelV3StreamPart>): LanguageModelV3 => ({
   specificationVersion: "v3",

packages/core/test/catalog.test.ts

@@ -511,7 +511,7 @@ describe("Provider and Model", () => {
     }),
   )
 
-  it.effect("resolves provider and model overlay merges", () =>
+  it.effect("keeps settings scoped while resolving request overlay merges", () =>
     Effect.gen(function* () {
       const providers = yield* Provider.Service
       const models = yield* Model.Service
@@ -533,6 +533,7 @@ describe("Provider and Model", () => {
       })
 
       const model = required(yield* models.get(providerID, modelID))
+      expect((yield* providers.get(providerID))?.settings).toEqual({ provider: true, shared: "provider" })
       expect(model.settings).toEqual({ provider: true, shared: "model", model: true })
       expect(model.headers).toEqual({ provider: "provider", shared: "model", model: "model" })
       expect(model.body).toEqual({ provider: true, shared: "model", model: true })

packages/core/test/config/provider.test.ts

@@ -37,6 +37,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
   it.effect("inherits the provider compaction setting with model overrides and rejects unsupported routes", () =>
     Effect.gen(function* () {
       const models = yield* Model.Service
+      const providers = yield* Provider.Service
       yield* addPlugin([
         new Document({
           type: "document",
@@ -63,6 +64,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
       expect(native.settings?.compaction).toEqual({ type: "native" })
       expect(local.settings?.compaction).toEqual({ type: "summary" })
       expect(defaultModel.settings?.compaction).toBeUndefined()
+      expect((yield* providers.get(Provider.ID.make("custom")))?.settings?.compaction).toEqual({ type: "native" })
       yield* ModelResolver.fromCatalogModel(native)
       yield* ModelResolver.fromCatalogModel(local)
       yield* ModelResolver.fromCatalogModel(defaultModel)
@@ -73,8 +75,9 @@ describe("ConfigProviderPlugin.Plugin", () => {
     }),
   )
 
-  it.effect("inherits the provider websocket policy with model overrides", () =>
+  it.effect("keeps the provider websocket policy out of model settings", () =>
     Effect.gen(function* () {
+      const providers = yield* Provider.Service
       const models = yield* Model.Service
       yield* addPlugin([
         new Document({
@@ -83,8 +86,12 @@ describe("ConfigProviderPlugin.Plugin", () => {
             providers: {
               custom: {
                 package: "@opencode/ai/providers/openai/responses",
-                settings: { transport: "http" },
-                models: { inherited: {}, override: { settings: { transport: "websocket" } } },
+                settings: { transport: "http", timeout: 100, chunkTimeout: 200, shared: "provider" },
+                models: {
+                  inherited: {
+                    settings: { transport: "websocket", timeout: 1, chunkTimeout: 2, model: true },
+                  },
+                },
               },
               default: { package: "@opencode/ai/providers/openai/responses", models: { untouched: {} } },
             },
@@ -92,10 +99,9 @@ describe("ConfigProviderPlugin.Plugin", () => {
         }),
       ])
       const inherited = required(yield* models.get(Provider.ID.make("custom"), Model.ID.make("inherited")))
-      const override = required(yield* models.get(Provider.ID.make("custom"), Model.ID.make("override")))
       const untouched = required(yield* models.get(Provider.ID.make("default"), Model.ID.make("untouched")))
-      expect(inherited.settings?.transport).toBe("http")
-      expect(override.settings?.transport).toBe("websocket")
+      expect((yield* providers.get(Provider.ID.make("custom")))?.settings?.transport).toBe("http")
+      expect(inherited.settings).toEqual({ shared: "provider", model: true })
       expect(untouched.settings?.transport).toBeUndefined()
     }),
   )
@@ -106,7 +112,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
     { id: "azure", model: "gpt-5.6-sol", package: "@opencode/ai/providers/azure/responses", plugin: AzurePlugin },
     { id: "custom-azure", model: "deployment", package: "@opencode/ai/providers/azure/responses", plugin: AzurePlugin },
   ]) {
-    it.live(`provider transport overrides ${builtin.id} defaults while model overrides still win`, () =>
+    it.live(`configured provider transport overrides ${builtin.id} defaults`, () =>
       Effect.gen(function* () {
         const providers = yield* Provider.Service
         const models = yield* Model.Service
@@ -122,7 +128,8 @@ describe("ConfigProviderPlugin.Plugin", () => {
           editor.models.update(providerID, modelID, () => {})
         })
         yield* builtin.plugin.effect(host)
-        expect((yield* models.get(providerID, modelID))?.settings?.transport).toBe("websocket")
+        expect((yield* providers.get(providerID))?.settings?.transport).toBe("websocket")
+        expect((yield* models.get(providerID, modelID))?.settings?.transport).toBeUndefined()
 
         yield* addPlugin([
           new Document({
@@ -131,15 +138,16 @@ describe("ConfigProviderPlugin.Plugin", () => {
               providers: {
                 [builtin.id]: {
                   settings: { transport: "http" },
-                  models: { override: { modelID: builtin.model, settings: { transport: "websocket" } } },
+                  models: { override: { modelID: builtin.model } },
                 },
               },
             }),
           }),
         ])
 
-        expect((yield* models.get(providerID, modelID))?.settings?.transport).toBe("http")
-        expect((yield* models.get(providerID, Model.ID.make("override")))?.settings?.transport).toBe("websocket")
+        expect((yield* providers.get(providerID))?.settings?.transport).toBe("http")
+        expect((yield* models.get(providerID, modelID))?.settings?.transport).toBeUndefined()
+        expect((yield* models.get(providerID, Model.ID.make("override")))?.settings?.transport).toBeUndefined()
       }),
     )
   }

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

@@ -434,7 +434,7 @@ describe("AzurePlugin", () => {
     ),
   )
 
-  it.effect("marks only Azure v1 Responses deployments as WebSocket capable", () =>
+  it.effect("stores the Azure Responses WebSocket preference on the provider", () =>
     withEnv({ AZURE_RESOURCE_NAME: undefined, AZURE_COGNITIVE_SERVICES_RESOURCE_NAME: undefined }, () =>
       Effect.gen(function* () {
         const catalog = yield* Provider.Service
@@ -472,9 +472,8 @@ describe("AzurePlugin", () => {
 
         yield* addPlugin()
 
-        const responses = required(yield* service.get(Provider.ID.azure, models.responses))
-        expect(responses.settings?.transport).toBe("websocket")
-        for (const modelID of [models.chat, models.preview, models.deploymentURL, models.gateway, models.nonAzure]) {
+        expect((yield* catalog.get(Provider.ID.azure))?.settings?.transport).toBe("websocket")
+        for (const modelID of [models.responses, models.chat, models.preview, models.deploymentURL, models.gateway, models.nonAzure]) {
           const model = required(yield* service.get(Provider.ID.azure, modelID))
           expect(model.settings?.transport).toBeUndefined()
         }

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

@@ -205,7 +205,8 @@ describe("OpenAIPlugin", () => {
       expect(model.package).toBe("@opencode/ai/providers/openai")
       expect(model.enabled).toBe(true)
       expect(model.limit).toEqual({ context: 1_050_000, input: 922_000, output: 128_000 })
-      expect(model.settings?.transport).toBe("websocket")
+      expect(provider.settings?.transport).toBe("websocket")
+      expect(model.settings?.transport).toBeUndefined()
       expect(direct.headers).not.toHaveProperty("originator")
       expect(direct.baseURL).toBe("https://api.openai.com/v1")
       expect(provider.headers).not.toHaveProperty("x-codex-beta-features")

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

@@ -83,8 +83,10 @@ describe("XAIPlugin", () => {
 
       yield* addPlugin()
 
+      const provider = yield* providers.get(providerID)
       const model = yield* models.get(providerID, Model.ID.make("grok-4.6"))
-      expect(model?.settings?.transport).toBe("websocket")
+      expect(provider?.settings?.transport).toBe("websocket")
+      expect(model?.settings?.transport).toBeUndefined()
     }),
   )
 })

packages/core/test/provider.test.ts

@@ -42,4 +42,19 @@ describe("Provider", () => {
       reasoningEffort: "high",
     })
   })
+
+  test("inherits shared and loose settings without provider-only policies", () => {
+    expect(
+      Provider.modelSettings({
+        timeout: 60_000,
+        chunkTimeout: 30_000,
+        transport: "websocket",
+        compaction: { type: "native" },
+        reasoningEffort: "high",
+      }),
+    ).toEqual({
+      compaction: { type: "native" },
+      reasoningEffort: "high",
+    })
+  })
 })

packages/desktop/src/main/ipc-handlers/window.ts

@@ -2,14 +2,7 @@ import { BrowserWindow } from "electron"
 import { Effect } from "effect"
 import { WindowRpcs } from "../../shared/ipc-rpc"
 import { IpcPortHandoff } from "../ipc-transport"
-import {
-  getPinchZoomEnabled,
-  saveWindowPrepaint,
-  setPinchZoomEnabled,
-  setTitlebar,
-  setWindowThemeReady,
-  updateTitlebar,
-} from "../windows"
+import { getPinchZoomEnabled, setPinchZoomEnabled, setTitlebar, setWindowThemeReady, updateTitlebar } from "../windows"
 import { sender } from "./context"
 
 export const windowHandlers = WindowRpcs.toLayer(
@@ -45,11 +38,6 @@ export const windowHandlers = WindowRpcs.toLayer(
           const win = BrowserWindow.fromWebContents(sender(handoff, context))
           if (win) setTitlebar(win, theme)
         }),
-      WindowSavePrepaint: ({ html }, context) =>
-        Effect.promise(() => {
-          const win = BrowserWindow.fromWebContents(sender(handoff, context))
-          return win ? saveWindowPrepaint(win, html) : Promise.resolve()
-        }),
     })
   }),
 )

packages/desktop/src/main/ipc.ts

@@ -1,10 +1,10 @@
 export * as Ipc from "./ipc"
 
-import { app, BrowserWindow, ipcMain, MessageChannelMain } from "electron"
+import { app, BrowserWindow, MessageChannelMain } from "electron"
 import { Effect, Layer } from "effect"
 import { RpcServer } from "effect/unstable/rpc"
 import { DesktopRpcs } from "../shared/ipc-rpc"
-import { DragCancelEvent, IpcTransportPort, IpcTransportPortRequest } from "../shared/ipc-transport"
+import { DragCancelEvent, IpcTransportPort } from "../shared/ipc-transport"
 import { DesktopFiles, openExternalURL } from "./files"
 import { appHandlers } from "./ipc-handlers/app"
 import { eventHandlers } from "./ipc-handlers/events"
@@ -23,7 +23,6 @@ import { createMenu, sendMenuCommand } from "./native/menu"
 import { DesktopCli } from "./service/desktop-cli"
 import { Updater } from "./updater"
 import { getLastFocusedWindow } from "./windows"
-import { isRendererUrl } from "./windows/protocol"
 import { Wsl } from "./wsl/start"
 
 const services = Layer.mergeAll(DesktopFiles.layer, Wsl.layer, Ssh.layer)
@@ -66,27 +65,18 @@ export const registerIpcHandlers = Effect.gen(function* () {
       if (input.type !== "keyDown" || input.key !== "Escape") return
       win.webContents.send(DragCancelEvent)
     })
-  }
-  // Each renderer document asks for its own port once its client is listening; see ipc-client.ts.
-  const handPort = (event: Electron.IpcMainEvent) => {
-    const contents = event.sender
-    if (contents.isDestroyed() || !isRendererUrl(contents.getURL())) return
-    const channel = new MessageChannelMain()
-    handoff.bind(contents, channel.port1)
-    contents.postMessage(IpcTransportPort, null, [channel.port2])
+    win.webContents.on("did-finish-load", () => {
+      if (win.isDestroyed() || win.webContents.isDestroyed()) return
+      const channel = new MessageChannelMain()
+      handoff.bind(win.webContents, channel.port1)
+      win.webContents.postMessage(IpcTransportPort, null, [channel.port2])
+    })
   }
   yield* Effect.sync(() => {
     app.on("browser-window-created", wire)
     BrowserWindow.getAllWindows().forEach((win) => wire({} as Electron.Event, win))
-    ipcMain.on(IpcTransportPortRequest, handPort)
   })
-  yield* Effect.addFinalizer(
-    () =>
-      Effect.sync(() => {
-        app.off("browser-window-created", wire)
-        ipcMain.off(IpcTransportPortRequest, handPort)
-      }),
-  )
+  yield* Effect.addFinalizer(() => Effect.sync(() => app.off("browser-window-created", wire)))
   return {
     installMenu: () => createMenu(menu),
   }

packages/desktop/src/main/windows/appearance.ts

@@ -99,9 +99,7 @@ export function setZoomFactor(win: BrowserWindow, factor: number) {
 
 export function wireZoom(win: BrowserWindow) {
   pinchZoomEnabled.set(win, getPinchZoomEnabled())
-  // Setting the factor forces a visual-properties round trip with the renderer, so leave it alone
-  // when it is already 1: the first window has a document on screen by now.
-  if (win.webContents.getZoomFactor() !== 1) win.webContents.setZoomFactor(1)
+  win.webContents.setZoomFactor(1)
   win.webContents.on("zoom-changed", (event, direction) => {
     event.preventDefault()
     if (pinchZoomEnabled.get(win)) {

packages/desktop/src/main/windows/early.ts

@@ -6,11 +6,9 @@ import { windowIDArgument } from "../../shared/window-bootstrap"
 import { WINDOW_IDS_KEY } from "../storage/keys"
 import { getStore } from "../storage/store"
 import { storedBackgroundColor, titlebarOverlay } from "./defaults"
-import { rendererHost, rendererProtocol } from "./scheme"
-import { earlyQuery, serveRenderer } from "./serve"
 import { manageWindowState, readWindowState, resolveWindowState, windowStateFile, type WindowState } from "./window-state"
 
-export type EarlyWindow = { id: string; win: BrowserWindow; state: WindowState; shownAt: number; loaded: boolean }
+export type EarlyWindow = { id: string; win: BrowserWindow; state: WindowState; shownAt: number }
 
 let pending: EarlyWindow | undefined
 
@@ -58,16 +56,7 @@ export function createEarlyWindow() {
     pending = undefined
     app.quit()
   })
-  // In production the window starts its document now - the same index.html without its scripts,
-  // carrying the shell snapshot from the previous run - so the renderer process and the stylesheet
-  // are ready, and the user sees their UI, while the bundle and the layers load. The scripts are
-  // added when restoreWindows() adopts the window. Development keeps loading from the dev server.
-  const loaded = !process.env.ELECTRON_RENDERER_URL
-  if (loaded) {
-    serveRenderer(path.join(root, "../renderer"))
-    void win.loadURL(`${rendererProtocol}://${rendererHost}/index.html?${earlyQuery}=${encodeURIComponent(id)}`)
-  }
-  pending = { id, win, state, shownAt: Date.now(), loaded }
+  pending = { id, win, state, shownAt: Date.now() }
 }
 
 export function takeEarlyWindow() {

packages/desktop/src/main/windows/index.ts

@@ -22,8 +22,6 @@ import {
   wireZoom,
 } from "./appearance"
 import { loadWindow, registerRendererProtocol } from "./protocol"
-import { removePrepaint, writePrepaint } from "./prepaint"
-import { releaseRenderer } from "./serve"
 import { createWindowRegistry } from "./registry"
 import { makeWindowRecovery } from "./recovery"
 import { takeEarlyWindow, type EarlyWindow } from "./early"
@@ -31,7 +29,6 @@ import { manageWindowState, readWindowState, resolveWindowState, windowStateFile
 import { allowRendererPermissions, wireNavigationPolicy, wireRendererHeaders } from "./security"
 
 const themeReady = new WeakMap<BrowserWindow, () => void>()
-const windowIDs = new WeakMap<BrowserWindow, string>()
 const displays = {
   all: () => screen.getAllDisplays().map((display) => display.bounds),
   primary: () => screen.getPrimaryDisplay().bounds,
@@ -83,12 +80,6 @@ export function setWindowThemeReady(win: BrowserWindow) {
   themeReady.get(win)?.()
 }
 
-export function saveWindowPrepaint(win: BrowserWindow, html: string) {
-  const id = windowIDs.get(win)
-  if (!id) return Promise.resolve()
-  return writePrepaint(id, html)
-}
-
 export const makeMainWindows = Effect.fn("Window.make")(function* () {
   const fs = yield* FileSystem.FileSystem
   const path = yield* Path.Path
@@ -135,13 +126,7 @@ export const makeMainWindows = Effect.fn("Window.make")(function* () {
     if (!early) manageWindowState(win, stateFile, state, displays)
     register(win, id)
     wireFullscreen(win)
-    if (early?.loaded) {
-      runFork(
-        Effect.tryPromise(() => releaseRenderer(win, paths.rendererRoot)).pipe(
-          Effect.catch((error) => scoped("window", Effect.logError("failed to release early renderer", { id, error }))),
-        ),
-      )
-    } else loadWindow(win, "index.html")
+    loadWindow(win, "index.html")
     wireZoom(win)
     let contentReady = false
     let appliedTheme = false
@@ -178,7 +163,6 @@ export const makeMainWindows = Effect.fn("Window.make")(function* () {
 
   const register = (win: BrowserWindow, id: string) => {
     registry.register(id, win)
-    windowIDs.set(win, id)
     win.on("focus", () => registry.focused(id))
     // Windows emits session-end, but not before-quit, during shutdown and logoff.
     win.on("session-end", () => registry.setQuitting())
@@ -188,7 +172,6 @@ export const makeMainWindows = Effect.fn("Window.make")(function* () {
         Effect.gen(function* () {
           yield* Effect.try(() => storage.state.clear(windowDataFile(id)))
           yield* fs.remove(path.join(app.getPath("userData"), windowStateFile(id)), { force: true })
-          yield* Effect.promise(() => removePrepaint(id))
         }).pipe(
           Effect.catch((error) => scoped("window", Effect.logError("failed to clean window state", { id, error }))),
         ),

packages/desktop/src/main/windows/prepaint.ts

@@ -1,27 +0,0 @@
-import { mkdir, rename, rm, writeFile } from "node:fs/promises"
-import path from "node:path"
-import { app } from "electron"
-
-// The shell snapshot a window shows before its renderer has booted. It is a file next to the
-// window-state JSON rather than a row in the desktop database because the entry module serves it
-// before the storage layers exist; a snapshot from another app version is ignored, since its class
-// names may no longer match the bundled stylesheet.
-
-export function prepaintFile(id: string) {
-  return `prepaint-${id.replace(/[^a-zA-Z0-9._-]/g, "-")}.html`
-}
-
-export function prepaintMarker(version: string) {
-  return `<!-- opencode ${version} -->`
-}
-
-export async function writePrepaint(id: string, html: string) {
-  const file = path.join(app.getPath("userData"), prepaintFile(id))
-  await mkdir(path.dirname(file), { recursive: true })
-  await writeFile(`${file}.tmp`, `${prepaintMarker(app.getVersion())}\n${html}`)
-  await rename(`${file}.tmp`, file)
-}
-
-export function removePrepaint(id: string) {
-  return rm(path.join(app.getPath("userData"), prepaintFile(id)), { force: true })
-}

packages/desktop/src/main/windows/protocol.ts

@@ -1,19 +1,54 @@
+import { net, protocol } from "electron"
 import type { BrowserWindow } from "electron"
-import { Effect } from "effect"
+import { pathToFileURL } from "node:url"
+import { Effect, Path } from "effect"
 import { scoped } from "../native/logging"
 import { DesktopPaths } from "../paths"
+import { documentPolicyHeader, jsCallStacksDocumentPolicy } from "./headers"
 import { rendererHost, rendererProtocol } from "./scheme"
-import { serveRenderer, setRendererProtocolLogger } from "./serve"
 
-// The entry module normally registers the handler before the bundle loads; this only wires its
-// logging, and registers it when the entry module did not (development, or a window created later).
 export const registerRendererProtocol = Effect.fn("Window.registerRendererProtocol")(function* () {
+  const path = yield* Path.Path
   const paths = yield* DesktopPaths.resolve
   const runFork = Effect.runForkWith(yield* Effect.context<never>())
-  setRendererProtocolLogger((level, message, data) =>
-    runFork(scoped("protocol", level === "error" ? Effect.logError(message, data) : Effect.logWarning(message, data))),
-  )
-  serveRenderer(paths.rendererRoot)
+  if (protocol.isProtocolHandled(rendererProtocol)) return
+
+  protocol.handle(rendererProtocol, async (request) => {
+    const url = new URL(request.url)
+    if (url.host !== rendererHost) {
+      runFork(scoped("protocol", Effect.logWarning("rejected host", { url: request.url })))
+      return new Response("Not found", { status: 404 })
+    }
+
+    const file = path.resolve(paths.rendererRoot, `.${decodeURIComponent(url.pathname)}`)
+    const rel = path.relative(paths.rendererRoot, file)
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+      runFork(scoped("protocol", Effect.logWarning("rejected path", { url: request.url, file })))
+      return new Response("Not found", { status: 404 })
+    }
+
+    try {
+      const range = request.headers.get("range")
+      const response = await net.fetch(pathToFileURL(file).toString(), { headers: range ? { range } : undefined })
+      if (response.status >= 400) {
+        runFork(
+          scoped(
+            "protocol",
+            Effect.logError("fetch failed", {
+              url: request.url,
+              file,
+              status: response.status,
+              statusText: response.statusText,
+            }),
+          ),
+        )
+      }
+      return addDocumentPolicy(response, file)
+    } catch (error) {
+      runFork(scoped("protocol", Effect.logError("fetch error", { url: request.url, file, error })))
+      return new Response("Not found", { status: 404 })
+    }
+  })
 })
 
 export function loadWindow(win: BrowserWindow, html: string) {
@@ -33,4 +68,11 @@ export function isRendererUrl(value?: string, html = false) {
   const devUrl = process.env.ELECTRON_RENDERER_URL
   if (!devUrl || !URL.canParse(devUrl)) return false
   return url.origin === new URL(devUrl).origin
-}
+}
+
+function addDocumentPolicy(response: Response, file: string) {
+  if (!file.toLowerCase().endsWith(".html")) return response
+  const headers = new Headers(response.headers)
+  headers.set(documentPolicyHeader, jsCallStacksDocumentPolicy)
+  return new Response(response.body, { status: response.status, statusText: response.statusText, headers })
+}

packages/desktop/src/main/windows/serve.ts

@@ -1,114 +0,0 @@
-import { readFile } from "node:fs/promises"
-import path from "node:path"
-import { pathToFileURL } from "node:url"
-import { app, net, protocol } from "electron"
-import type { BrowserWindow } from "electron"
-import { documentPolicyHeader, jsCallStacksDocumentPolicy } from "./headers"
-import { prepaintFile, prepaintMarker } from "./prepaint"
-import { rendererHost, rendererProtocol } from "./scheme"
-
-// Serves the renderer bundle over oc://renderer. This module has no Effect dependency because the
-// entry module registers it right after Electron is ready, before the main bundle has loaded, so
-// the first window can start its document while the bundle and the layers evaluate.
-
-export const earlyQuery = "early"
-
-type Log = (level: "warning" | "error", message: string, data: Record<string, unknown>) => void
-let log: Log = () => {}
-
-export function setRendererProtocolLogger(logger: Log) {
-  log = logger
-}
-
-export function serveRenderer(rendererRoot: string) {
-  if (protocol.isProtocolHandled(rendererProtocol)) return
-  protocol.handle(rendererProtocol, async (request) => {
-    const url = new URL(request.url)
-    if (url.host !== rendererHost) {
-      log("warning", "rejected host", { url: request.url })
-      return new Response("Not found", { status: 404 })
-    }
-
-    const file = path.resolve(rendererRoot, `.${decodeURIComponent(url.pathname)}`)
-    const rel = path.relative(rendererRoot, file)
-    if (rel.startsWith("..") || path.isAbsolute(rel)) {
-      log("warning", "rejected path", { url: request.url, file })
-      return new Response("Not found", { status: 404 })
-    }
-
-    const early = url.pathname === "/index.html" ? url.searchParams.get(earlyQuery) : null
-    if (early !== null) return earlyDocument(file, early)
-
-    try {
-      const range = request.headers.get("range")
-      const response = await net.fetch(pathToFileURL(file).toString(), { headers: range ? { range } : undefined })
-      if (response.status >= 400) {
-        log("error", "fetch failed", {
-          url: request.url,
-          file,
-          status: response.status,
-          statusText: response.statusText,
-        })
-      }
-      return addDocumentPolicy(response, file)
-    } catch (error) {
-      log("error", "fetch error", { url: request.url, file, error })
-      return new Response("Not found", { status: 404 })
-    }
-  })
-}
-
-// The early window loads index.html?early=<window id>: the same document without its module
-// scripts, plus the shell snapshot the window captured last time, so the user sees their own UI
-// while the main process is still loading. releaseRenderer() adds the scripts back once the window
-// has been adopted.
-async function earlyDocument(file: string, id: string) {
-  const [html, prepaint] = await Promise.all([
-    readFile(file, "utf8"),
-    readFile(path.join(app.getPath("userData"), prepaintFile(id)), "utf8").catch(() => undefined),
-  ])
-  const body = prepaint?.startsWith(prepaintMarker(app.getVersion()))
-    ? `<div id="oc-prepaint" inert aria-hidden="true" style="position:fixed;inset:0;z-index:100;pointer-events:none;display:flex;flex-direction:column;background-color:var(--background-base)">${prepaint.slice(prepaint.indexOf("\n") + 1)}</div></body>`
-    : "</body>"
-  const text = html.replace(moduleScript, "").replace("</body>", body)
-  return new Response(text, {
-    headers: {
-      "content-type": "text/html; charset=utf-8",
-      "cache-control": "no-store",
-      [documentPolicyHeader]: jsCallStacksDocumentPolicy,
-    },
-  })
-}
-
-const moduleScript = /<script type="module"[^>]*><\/script>\s*/g
-
-export async function releaseRenderer(win: BrowserWindow, rendererRoot: string) {
-  const html = await readFile(path.join(rendererRoot, "index.html"), "utf8")
-  const srcs = [...html.matchAll(moduleScript)].flatMap((match) => {
-    const src = /\bsrc="([^"]+)"/.exec(match[0])
-    return src ? [src[1]] : []
-  })
-  if (win.isDestroyed()) return
-  // async = false keeps the runtime chunk ahead of the entry, as the static tags did. Dropping the
-  // query afterwards makes a reload load the full document.
-  await win.webContents.executeJavaScript(
-    `(() => {
-      for (const src of ${JSON.stringify(srcs)}) {
-        const script = document.createElement("script")
-        script.type = "module"
-        script.async = false
-        script.crossOrigin = ""
-        script.src = src
-        document.head.appendChild(script)
-      }
-      history.replaceState(history.state, "", "/index.html")
-    })()`,
-  )
-}
-
-function addDocumentPolicy(response: Response, file: string) {
-  if (!file.toLowerCase().endsWith(".html")) return response
-  const headers = new Headers(response.headers)
-  headers.set(documentPolicyHeader, jsCallStacksDocumentPolicy)
-  return new Response(response.body, { status: response.status, statusText: response.statusText, headers })
-}

packages/desktop/src/preload/index.ts

@@ -1,5 +1,5 @@
 import { contextBridge, ipcRenderer, webUtils } from "electron"
-import { DragCancelEvent, IpcTransportPort, IpcTransportPortRequest } from "../shared/ipc-transport"
+import { DragCancelEvent, IpcTransportPort } from "../shared/ipc-transport"
 import { windowIDFromArguments } from "../shared/window-bootstrap"
 
 ipcRenderer.on(IpcTransportPort, (event) => {
@@ -11,6 +11,5 @@ ipcRenderer.on(DragCancelEvent, () => window.dispatchEvent(new Event(DragCancelE
 
 contextBridge.exposeInMainWorld("electron", {
   windowID: windowIDFromArguments(process.argv),
-  requestRpcPort: () => ipcRenderer.send(IpcTransportPortRequest),
   getPathForFile: (file: File) => webUtils.getPathForFile(file),
 })

packages/desktop/src/preload/types.ts

@@ -1,5 +1,4 @@
 export type ElectronNative = {
   windowID: string
-  requestRpcPort(): void
   getPathForFile(file: File): string
 }

packages/desktop/src/renderer/api-types.ts

@@ -54,8 +54,6 @@ export type ElectronAPI = {
   draftBlobGet(id: string): Promise<ArrayBuffer | null>
   getWindowID(): string
   themeReady(): Promise<void>
-  // Persists the sanitized shell markup the next launch shows before the renderer boots.
-  savePrepaint(html: string): Promise<void>
   onMenuCommand(cb: (id: string) => void): () => void
   onDeepLink(cb: (urls: string[]) => void): () => void
   openDirectoryPicker(opts?: DirectoryPickerOptions): Promise<string | string[] | null>

packages/desktop/src/renderer/api.ts

@@ -112,7 +112,6 @@ export const api: ElectronAPI = {
 
   getWindowID: () => window.electron.windowID,
   themeReady: () => invoke("WindowThemeReady"),
-  savePrepaint: (html) => invoke("WindowSavePrepaint", { html }),
   onMenuCommand: (cb) => listen("MenuCommandTriggered", (event) => cb(event.id)),
   onDeepLink: (cb) => listen("DeepLinksOpened", (event) => cb(mutable(event.urls))),
 

packages/desktop/src/renderer/desktop-app.tsx

@@ -19,7 +19,7 @@ import {
 } from "@opencode/app/desktop"
 import { useTheme } from "@opencode/ui/theme/context"
 import type { BaseRouterProps } from "@solidjs/router"
-import { createEffect, createMemo, createResource, lazy, on, Show, Suspense } from "solid-js"
+import { createEffect, createMemo, createResource, lazy, Show, Suspense } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { ElectronAPI } from "./api-types"
 import { DesktopFirstLaunchOnboarding } from "./onboarding"
@@ -27,7 +27,6 @@ import { createDesktopPlatform } from "./platform"
 import { bindDesktopMenu } from "./platform/menu"
 import { createSidecarResolver, initializationData, sidecarHttp } from "./startup/initialization"
 import { preloadStoredLocale } from "./startup/locale"
-import { hasPrepaint, removePrepaint, schedulePrepaintCapture } from "./startup/prepaint"
 import { LoadingSplash } from "./startup/splash"
 import { getLastActiveUrl } from "./window/route-storage"
 import { DesktopMemoryRouter } from "./window/router"
@@ -41,12 +40,9 @@ export function DesktopApp(props: { api: ElectronAPI; updater: UpdaterPlatform;
   const initialUrl = getLastActiveUrl(windowState.id)
   const url = new URL(initialUrl, "http://localhost")
   const route = currentRoute(url.pathname, url.search)
-  // With a shell snapshot on screen the splash is not needed; the snapshot is removed when the
-  // interface would otherwise be revealed.
-  const prepaint = hasPrepaint()
   const [startup, setStartup] = createStore({
     ready: false,
-    visible: !prepaint,
+    visible: true,
     themeReady: false,
     onboardingReady: false,
     drawingReady: false,
@@ -76,25 +72,6 @@ export function DesktopApp(props: { api: ElectronAPI; updater: UpdaterPlatform;
     if (!startup.themeReady || firstLaunch.loading) return
     void props.api.themeReady()
   })
-  createEffect(() => {
-    if (!prepaint || firstLaunch() !== true) return
-    removePrepaint()
-    setStartup("visible", true)
-  })
-  createEffect(() => {
-    if (!readyToReveal()) return
-    removePrepaint()
-    schedulePrepaintCapture(props.api.savePrepaint)
-  })
-  createEffect(
-    on(
-      () => startup.route,
-      () => {
-        if (startup.ready) schedulePrepaintCapture(props.api.savePrepaint, 3000)
-      },
-      { defer: true },
-    ),
-  )
 
   function ReadyApp() {
     const wslServers = useWslServers()

packages/desktop/src/renderer/ipc-client.ts

@@ -13,8 +13,6 @@ type InvokeResult<Tag extends InvokeTag> =
   ReturnType<DesktopRpcClient[Tag]> extends Effect.Effect<infer Value, unknown> ? Value : never
 type EventValue<Tag extends EventTag> = Extract<DesktopEvent, { readonly _tag: Tag }>
 
-// The renderer asks for its port rather than receiving one on load: the first window's document
-// is on screen before its scripts, and before the main process has its IPC layer, exist.
 const port = new Promise<MessagePort>((resolve) => {
   const onMessage = (event: MessageEvent) => {
     if (event.source !== window || event.data !== IpcTransportPort) return
@@ -24,7 +22,6 @@ const port = new Promise<MessagePort>((resolve) => {
     resolve(value)
   }
   window.addEventListener("message", onMessage)
-  window.electron.requestRpcPort()
 })
 
 const ClientProtocolLive = Layer.unwrap(Effect.promise(() => port).pipe(Effect.map((value) => clientProtocol(value))))

packages/desktop/src/renderer/startup/prepaint.ts

@@ -1,72 +0,0 @@
-// The early document carries a static copy of this window's shell from the previous run, served by
-// the main process as #oc-prepaint, so the user sees their UI while the renderer boots. It is
-// removed when the real interface is ready to be revealed, and re-captured from the live DOM so the
-// next launch shows the current state.
-
-const prepaintID = "oc-prepaint"
-const maxBytes = 1_000_000
-
-export function hasPrepaint() {
-  return document.getElementById(prepaintID) !== null
-}
-
-export function removePrepaint() {
-  document.getElementById(prepaintID)?.remove()
-}
-
-let timer: number | undefined
-
-// Captures once the renderer is idle; `delay` coalesces bursts of route changes into one capture.
-export function schedulePrepaintCapture(save: (html: string) => Promise<void>, delay = 0) {
-  clearTimeout(timer)
-  timer = window.setTimeout(() => {
-    requestIdleCallback(
-      () => {
-        const root = document.getElementById("root")
-        const html = root && capturePrepaint(root)
-        if (html) void save(html).catch(() => undefined)
-      },
-      { timeout: 2000 },
-    )
-  }, delay)
-}
-
-// Elements that hold live or transient state and would look wrong, or leak, in a static copy.
-const dropped =
-  "script, style, link, iframe, object, embed, canvas, video, audio, dialog, [popover], [role='dialog'], [role='menu'], [role='listbox'], [role='tooltip'], [data-component='startup-overlay']"
-// Attributes that could act, be targeted, or collide with the live document once it mounts.
-const stripped = new Set(["id", "href", "tabindex", "contenteditable", "autofocus", "for", "name", "action", "formaction"])
-
-export function capturePrepaint(root: HTMLElement) {
-  const clone = root.cloneNode(true) as HTMLElement
-  clone.querySelectorAll(dropped).forEach((element) => element.remove())
-  const symbols = new Set<string>()
-  for (const element of clone.querySelectorAll("*")) {
-    if (element instanceof HTMLTextAreaElement || element instanceof HTMLInputElement) element.removeAttribute("value")
-    if (element.hasAttribute("contenteditable")) element.replaceChildren()
-    for (const attribute of Array.from(element.attributes)) {
-      const name = attribute.name
-      if (name.startsWith("on")) element.removeAttribute(name)
-      // SVG keeps its ids and hrefs: gradients, clip paths and <use> references are local visuals.
-      if (element instanceof SVGElement) {
-        if (name === "href" && attribute.value.startsWith("#")) symbols.add(attribute.value.slice(1))
-        continue
-      }
-      if (stripped.has(name)) element.removeAttribute(name)
-      if (name === "src" && !/^(\.\/|\/|oc:|data:)/.test(attribute.value)) element.removeAttribute(name)
-    }
-  }
-  const root_ = document.documentElement
-  const html = `<div class="${document.body.className} flex flex-col h-dvh" lang="${root_.lang}" dir="${root_.dir}">${sprite(symbols)}${clone.innerHTML}</div>`
-  return html.length <= maxBytes ? html : undefined
-}
-
-// Icons are <use href="#symbol"> into a sprite outside #root; copy only the symbols the shell uses.
-function sprite(symbols: Set<string>) {
-  const defs = [...symbols]
-    .map((id) => document.getElementById(id))
-    .filter((element) => element instanceof SVGSymbolElement)
-    .map((element) => element.outerHTML)
-  if (!defs.length) return ""
-  return `<svg aria-hidden="true" width="0" height="0" style="position:absolute;overflow:hidden">${defs.join("")}</svg>`
-}

packages/desktop/src/shared/ipc-rpc/window.ts

@@ -24,9 +24,6 @@ export const WindowSetTitlebar = Rpc.make("WindowSetTitlebar", {
     }),
   },
 })
-export const WindowSavePrepaint = Rpc.make("WindowSavePrepaint", {
-  payload: { html: Schema.String },
-})
 export const WindowRpcs = RpcGroup.make(
   WindowThemeReady,
   WindowGetFocused,
@@ -38,5 +35,4 @@ export const WindowRpcs = RpcGroup.make(
   WindowGetPinchZoomEnabled,
   WindowSetPinchZoomEnabled,
   WindowSetTitlebar,
-  WindowSavePrepaint,
 )

packages/desktop/src/shared/ipc-transport.ts

@@ -1,3 +1,2 @@
 export const IpcTransportPort = "desktop-rpc-port"
-export const IpcTransportPortRequest = "desktop-rpc-port-request"
 export const DragCancelEvent = "opencode:drag-cancel"

packages/protocol/openapi.json

@@ -13251,6 +13251,27 @@
         "required": ["input", "output"],
         "additionalProperties": false
       },
+      "Config.Model.Settings": {
+        "type": "object",
+        "properties": {
+          "compaction": {
+            "$ref": "#/components/schemas/Provider.Compaction"
+          }
+        },
+        "allOf": [
+          {
+            "type": "object",
+            "additionalProperties": {
+              "anyOf": [
+                {},
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          }
+        ]
+      },
       "Config.ModelEncoded": {
         "type": "object",
         "properties": {
@@ -13270,7 +13291,7 @@
             "type": "string"
           },
           "settings": {
-            "$ref": "#/components/schemas/Config.Provider.Settings"
+            "$ref": "#/components/schemas/Config.Model.Settings"
           },
           "headers": {
             "type": "object",
@@ -13293,7 +13314,7 @@
                   "type": "string"
                 },
                 "settings": {
-                  "$ref": "#/components/schemas/Config.Provider.Settings"
+                  "$ref": "#/components/schemas/Config.Model.Settings"
                 },
                 "headers": {
                   "type": "object",
@@ -15508,7 +15529,7 @@
             "type": "string"
           },
           "settings": {
-            "$ref": "#/components/schemas/Provider.Settings"
+            "$ref": "#/components/schemas/Model.Settings"
           },
           "headers": {
             "type": "object",
@@ -15614,6 +15635,20 @@
         "required": ["id", "providerID"],
         "additionalProperties": false
       },
+      "Model.Settings": {
+        "type": "object",
+        "properties": {
+          "compaction": {
+            "$ref": "#/components/schemas/Provider.Compaction"
+          }
+        },
+        "allOf": [
+          {
+            "type": "object",
+            "additionalProperties": {}
+          }
+        ]
+      },
       "Model.Variant": {
         "type": "object",
         "properties": {
@@ -15621,7 +15656,7 @@
             "type": "string"
           },
           "settings": {
-            "$ref": "#/components/schemas/Provider.Settings"
+            "$ref": "#/components/schemas/Model.Settings"
           },
           "headers": {
             "type": "object",

packages/schema/src/config/provider.ts

@@ -17,6 +17,14 @@ export const Settings = Schema.StructWithRest(
 ).annotate({ identifier: "Config.Provider.Settings" })
 export type Settings = typeof Settings.Type
 
+export const ModelSettings = Schema.StructWithRest(
+  Schema.Struct({
+    compaction: Provider.Compaction.pipe(optional),
+  }),
+  [Schema.Record(Schema.String, Schema.UndefinedOr(Schema.Json))],
+).annotate({ identifier: "Config.Model.Settings" })
+export type ModelSettings = typeof ModelSettings.Type
+
 const JsonRecord = Schema.Record(Schema.String, Schema.Json)
 
 export const Overlays = {
@@ -25,6 +33,12 @@ export const Overlays = {
   body: JsonRecord.pipe(optional),
 }
 
+const ModelOverlays = {
+  settings: ModelSettings.pipe(optional),
+  headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
+  body: JsonRecord.pipe(optional),
+}
+
 export class Request extends Schema.Class<Request>("Config.Provider.Request")({
   headers: Overlays.headers,
   body: Overlays.body,
@@ -57,11 +71,11 @@ class Model extends Schema.Class<Model>("Config.Model")({
   name: Schema.String.pipe(optional),
   compatibility: Compatibility.pipe(optional),
   package: Schema.String.pipe(optional),
-  ...Overlays,
+  ...ModelOverlays,
   capabilities: Capabilities.pipe(optional),
   variants: Schema.Struct({
     id: VariantID,
-    ...Overlays,
+    ...ModelOverlays,
   }).pipe(Schema.Array, optional),
   cost: Schema.Union([Cost, Cost.pipe(Schema.Array)]).pipe(optional),
   disabled: Schema.Boolean.pipe(optional),

packages/schema/src/model.ts

@@ -56,6 +56,21 @@ export const MaxTokensField = Schema.Literals(["max_completion_tokens", "max_tok
 })
 export type MaxTokensField = typeof MaxTokensField.Type
 
+export const Settings = Schema.StructWithRest(
+  Schema.Struct({
+    compaction: Provider.Compaction.pipe(optional),
+  }),
+  // Provider packages may define arbitrary model-level options beyond OpenCode's shared compaction policy.
+  [Schema.Record(Schema.String, Schema.Any)],
+).annotate({ identifier: "Model.Settings" })
+export type Settings = typeof Settings.Type
+
+export const Overlays = {
+  settings: Settings.pipe(optional),
+  headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
+  body: Schema.Record(Schema.String, Schema.Any).pipe(optional),
+}
+
 export interface Compatibility extends Schema.Schema.Type<typeof Compatibility> {}
 export const Compatibility = Schema.Struct({
   reasoningField: ReasoningField.pipe(optional),
@@ -97,7 +112,7 @@ export const Cost = Schema.Struct({
 export interface Variant extends Schema.Schema.Type<typeof Variant> {}
 export const Variant = Schema.Struct({
   id: VariantID,
-  ...Provider.Overlays,
+  ...Overlays,
 }).annotate({ identifier: "Model.Variant" })
 
 export interface Info extends Schema.Schema.Type<typeof Info> {}
@@ -110,7 +125,7 @@ export const Info = Schema.Struct({
   name: Schema.String,
   compatibility: Compatibility.pipe(optional),
   package: Provider.Package.pipe(optional),
-  ...Provider.Overlays,
+  ...Overlays,
   capabilities: Capabilities,
   variants: Schema.Array(Variant),
   time: Schema.Struct({

packages/schema/test/contract-hygiene.test.ts

@@ -169,6 +169,7 @@ describe("contract hygiene", () => {
   test("reusable public identifiers are stable and unique", () => {
     const identifiers = [
       Agent.Color,
+      ConfigProvider.ModelSettings,
       ConfigProvider.Settings,
       FileSystem.Submatch,
       Form.Field,
@@ -183,6 +184,7 @@ describe("contract hygiene", () => {
       Model.Ref,
       Model.Capabilities,
       Model.Cost,
+      Model.Settings,
       Model.Variant,
       Project.Current,
       Worktree.Directory,
@@ -239,11 +241,12 @@ describe("contract hygiene", () => {
 
     expect(
       sources
-        .filter((item) => item.file !== "provider.ts" && item.file !== "integration.ts")
+        .filter((item) => item.file !== "provider.ts" && item.file !== "model.ts" && item.file !== "integration.ts")
         .map((item) => item.source)
         .join("\n"),
     ).not.toContain("Schema.Any")
     expect(sources.find((item) => item.file === "provider.ts")?.source.match(/Schema\.Any/g)).toHaveLength(3)
+    expect(sources.find((item) => item.file === "model.ts")?.source.match(/Schema\.Any/g)).toHaveLength(2)
     expect(sources.find((item) => item.file === "integration.ts")?.source.match(/Schema\.Any/g)).toHaveLength(2)
     expect(source).not.toContain("Schema.mutable")
   })

packages/schema/test/model.test.ts

@@ -75,13 +75,10 @@ describe("Model.Info", () => {
   })
 })
 
-describe("Model.Capabilities", () => {
-  test("decodes the optional transport setting", () => {
-    const model = Model.Info.default(Provider.ID.openai, Model.ID.make("gpt-5.4-mini"))
-    expect(Schema.encodeSync(Model.Info)({ ...model, settings: { transport: undefined } }).settings).toEqual({})
-    expect(Schema.decodeUnknownSync(Model.Info)({ ...model, settings: { transport: "websocket" } }).settings).toEqual({
-      transport: "websocket",
+describe("Model.Settings", () => {
+  test("preserves provider-specific model options", () => {
+    expect(Schema.decodeUnknownSync(Model.Settings)({ providerOption: true })).toEqual({
+      providerOption: true,
     })
-    expect(() => Schema.decodeUnknownSync(Model.Info)({ ...model, settings: { transport: "sse" } })).toThrow()
   })
 })

services/www/openapi.json

@@ -13251,6 +13251,27 @@
         "required": ["input", "output"],
         "additionalProperties": false
       },
+      "Config.Model.Settings": {
+        "type": "object",
+        "properties": {
+          "compaction": {
+            "$ref": "#/components/schemas/Provider.Compaction"
+          }
+        },
+        "allOf": [
+          {
+            "type": "object",
+            "additionalProperties": {
+              "anyOf": [
+                {},
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          }
+        ]
+      },
       "Config.ModelEncoded": {
         "type": "object",
         "properties": {
@@ -13270,7 +13291,7 @@
             "type": "string"
           },
           "settings": {
-            "$ref": "#/components/schemas/Config.Provider.Settings"
+            "$ref": "#/components/schemas/Config.Model.Settings"
           },
           "headers": {
             "type": "object",
@@ -13293,7 +13314,7 @@
                   "type": "string"
                 },
                 "settings": {
-                  "$ref": "#/components/schemas/Config.Provider.Settings"
+                  "$ref": "#/components/schemas/Config.Model.Settings"
                 },
                 "headers": {
                   "type": "object",
@@ -15508,7 +15529,7 @@
             "type": "string"
           },
           "settings": {
-            "$ref": "#/components/schemas/Provider.Settings"
+            "$ref": "#/components/schemas/Model.Settings"
           },
           "headers": {
             "type": "object",
@@ -15614,6 +15635,20 @@
         "required": ["id", "providerID"],
         "additionalProperties": false
       },
+      "Model.Settings": {
+        "type": "object",
+        "properties": {
+          "compaction": {
+            "$ref": "#/components/schemas/Provider.Compaction"
+          }
+        },
+        "allOf": [
+          {
+            "type": "object",
+            "additionalProperties": {}
+          }
+        ]
+      },
       "Model.Variant": {
         "type": "object",
         "properties": {
@@ -15621,7 +15656,7 @@
             "type": "string"
           },
           "settings": {
-            "$ref": "#/components/schemas/Provider.Settings"
+            "$ref": "#/components/schemas/Model.Settings"
           },
           "headers": {
             "type": "object",

services/www/public/openapi.json

@@ -13251,6 +13251,27 @@
         "required": ["input", "output"],
         "additionalProperties": false
       },
+      "Config.Model.Settings": {
+        "type": "object",
+        "properties": {
+          "compaction": {
+            "$ref": "#/components/schemas/Provider.Compaction"
+          }
+        },
+        "allOf": [
+          {
+            "type": "object",
+            "additionalProperties": {
+              "anyOf": [
+                {},
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          }
+        ]
+      },
       "Config.ModelEncoded": {
         "type": "object",
         "properties": {
@@ -13270,7 +13291,7 @@
             "type": "string"
           },
           "settings": {
-            "$ref": "#/components/schemas/Config.Provider.Settings"
+            "$ref": "#/components/schemas/Config.Model.Settings"
           },
           "headers": {
             "type": "object",
@@ -13293,7 +13314,7 @@
                   "type": "string"
                 },
                 "settings": {
-                  "$ref": "#/components/schemas/Config.Provider.Settings"
+                  "$ref": "#/components/schemas/Config.Model.Settings"
                 },
                 "headers": {
                   "type": "object",
@@ -15508,7 +15529,7 @@
             "type": "string"
           },
           "settings": {
-            "$ref": "#/components/schemas/Provider.Settings"
+            "$ref": "#/components/schemas/Model.Settings"
           },
           "headers": {
             "type": "object",
@@ -15614,6 +15635,20 @@
         "required": ["id", "providerID"],
         "additionalProperties": false
       },
+      "Model.Settings": {
+        "type": "object",
+        "properties": {
+          "compaction": {
+            "$ref": "#/components/schemas/Provider.Compaction"
+          }
+        },
+        "allOf": [
+          {
+            "type": "object",
+            "additionalProperties": {}
+          }
+        ]
+      },
       "Model.Variant": {
         "type": "object",
         "properties": {
@@ -15621,7 +15656,7 @@
             "type": "string"
           },
           "settings": {
-            "$ref": "#/components/schemas/Provider.Settings"
+            "$ref": "#/components/schemas/Model.Settings"
           },
           "headers": {
             "type": "object",

services/www/src/docs/content/config.mdx

@@ -506,7 +506,6 @@ headers, and model variants.
 }
 ```
 
-`settings.transport: "websocket"` on a provider or model selects its session
-WebSocket; a model value overrides the provider value.
+Provider `settings.transport: "websocket"` selects its session WebSocket.
 
 See the [providers guide](/providers) for credentials, custom endpoints, provider packages, the WebSocket transport, and model configuration.

services/www/src/docs/content/providers.mdx

@@ -558,9 +558,6 @@ sessions.
   "providers": {
     "openai": {
       "settings": { "transport": "http" },
-      "models": {
-        "gpt-5.5": { "settings": { "transport": "websocket" } },
-      },
     },
   },
 }
@@ -568,9 +565,8 @@ sessions.
 
 WebSocket behavior follows these rules:
 
-- Built-in providers opt supported models in according to their own policy.
-- `settings.transport: "websocket"` enables a provider or model; `"http"` disables it.
-- A model value overrides its provider value.
+- Built-in providers opt supported routes in according to their own policy.
+- Provider `settings.transport: "websocket"` enables it; `"http"` disables it.
 - `"websocket"` on a route without a WebSocket channel logs a warning and falls back to HTTP.
 - OpenAI provider compaction uses the same connection.
 - xAI continues from stored responses only. With its default `store: false`, each step is sent in full over the reused