refactor(codemode): make functions program objects with name and length

refactor: flatten provider settings across core and the AI package (#48429 )
refactor(codemode): give programs their own objects and arrays (#48527 )
2026-09-11 19:36:25 +00:00 · 2026-09-11 13:43:38 -05:00 · 2026-09-11 13:37:24 -05:00 · 2026-09-11 13:36:35 -05:00 · 2026-09-11 12:41:20 -05:00 · 2026-09-11 12:29:18 -05:00
249 changed files with 9666 additions and 4571 deletions
@@ -122,13 +122,14 @@ Keep provider facades small and explicit:

 ### Provider Package Entrypoints

-Catalog-selected native providers use package-like export paths from `@opencode/ai`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model(modelID, settings)`, where settings are serializable provider configuration plus common `headers`, `body`, and `limits` overlays.
+Catalog-selected native providers use package-like export paths from `@opencode/ai`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model(modelID, settings)`, where settings are one flat serializable object: the connection keys the entrypoint declares (`apiKey`, `baseURL`, `region`, …), the common `headers` and `body` overlays, and the protocol's request options (`reasoningEffort`, `thinking`, …) side by side. Each entrypoint destructures its own connection keys and passes the rest to the route as `providerOptions`; there is no nested `providerOptions` at the entrypoint.

 ```ts
 import { model } from "@opencode/ai/providers/openai/responses"

 const selected = model("gpt-5", {
  apiKey,
+  reasoningEffort: "high",
 })
 ```

@@ -1708,7 +1708,10 @@ export const transport = <
 }

 function requiredBetaHeaders(body: Pick<AnthropicMessagesBody, "messages" | "context_management" | "thinking">) {
-  const betas: string[] = []
+  // Always request interleaved thinking. The API accepts the header on any
+  // model and ignores it where unsupported, while manual-thinking models need
+  // it for thinking between tool calls.
+  const betas: string[] = ["interleaved-thinking-2025-05-14"]
  const requestsCompaction = (body.context_management?.edits.length ?? 0) > 0
  const replaysCompaction = body.messages.some((message) =>
    message.content.some((block) => block.type === "compaction"),
@@ -18,7 +18,6 @@ const WebSocketResponseCreate = Schema.StructWithRest(Schema.Struct({ type: Sche
 ])
 const decodeMessage = ProviderShared.validateWith(Schema.decodeUnknownEffect(WebSocketResponseCreate))
 const encodeMessage = Schema.encodeSync(Schema.fromJsonString(WebSocketResponseCreate))
-const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)

 export interface Options {
  readonly id: string
@@ -27,6 +26,7 @@ export interface Options {
  readonly enabled?: (url: string) => boolean
  readonly url?: (url: string) => string
  readonly headers?: (headers: Headers.Headers) => Headers.Headers
+  readonly continuation?: OpenResponsesContinuation.Shape
 }

 export interface Prepared {
@@ -60,7 +60,7 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
      }),
    observe: (_create, frame) =>
      Effect.gen(function* () {
-        const event = yield* decodeEvent(frame).pipe(
+        const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(
          Effect.mapError((cause) =>
            ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause),
          ),
@@ -163,6 +163,7 @@ export const transport = <Body>(options: Options): Transport<Body, Prepared, str
                    request: create.request,
                    message: create.message,
                    base,
+                    continuation: options.continuation,
                  }),
                }
              })
@@ -6,7 +6,6 @@ import { OpenResponses } from "./open-responses.js"

 const PROTOCOL = "open-responses.websocket.v1"
 const VERSION = 1
-const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)

 interface CheckpointValue {
  readonly version: typeof VERSION
@@ -15,12 +14,19 @@ interface CheckpointValue {
  readonly output: ReadonlyArray<unknown>
 }

+/**
+ * Fields to send next to `previous_response_id` on an incremental step, or undefined to send the step in full.
+ * Whether omitted fields carry over from the continued response is provider behavior the route must know.
+ */
+export type Shape = (request: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>> | undefined
+
 export interface DriverInput {
  readonly id: string
  readonly name: string
  readonly request: Readonly<Record<string, unknown>>
  readonly message: string
  readonly base: WebSocketChannelDriver
+  readonly continuation?: Shape
 }

 const checkpointValue = (checkpoint: ChannelCheckpoint | undefined): CheckpointValue | undefined => {
@@ -127,22 +133,26 @@ const rejected = (

 export const driver = (input: DriverInput): WebSocketChannelDriver => {
  const { previous_response_id: _previousResponseID, ...request } = input.request
+  const shape = input.continuation ?? ((fields: Readonly<Record<string, unknown>>) => fields)
  let output: OpenResponses.StreamItem[] = []
  return {
    create: (checkpoint) =>
      Effect.sync(() => {
        output = []
        const previous = checkpointValue(checkpoint)
-        const delta = previous ? incremental(request, previous) : undefined
-        if (!previous || !delta) return { message: ProviderShared.encodeJson(request), mode: "full" as const }
+        // Ask the route first: diffing the whole history is wasted when it declines the continuation.
+        const fields = previous ? shape(request) : undefined
+        const delta = previous && fields ? incremental(request, previous) : undefined
+        if (!previous || !fields || !delta)
+          return { message: ProviderShared.encodeJson(request), mode: "full" as const }
        return {
-          message: ProviderShared.encodeJson({ ...request, input: delta, previous_response_id: previous.responseID }),
+          message: ProviderShared.encodeJson({ ...fields, input: delta, previous_response_id: previous.responseID }),
          mode: "incremental" as const,
        }
      }),
    observe: (create, frame) =>
      Effect.gen(function* () {
-        const event = yield* decodeEvent(frame).pipe(
+        const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(
          Effect.mapError((cause) =>
            ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause),
          ),
@@ -195,4 +205,4 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
  }
 }

-export const OpenResponsesContinuation = { driver } as const
+export * as OpenResponsesContinuation from "./open-responses-continuation.js"
@@ -1,4 +1,4 @@
-import { Effect, Option, Schema } from "effect"
+import { Effect, Option, Schema, SchemaGetter } from "effect"
 import type { Content } from "@opencode/schema/tool"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
@@ -325,9 +325,8 @@ export const StreamItem = Schema.StructWithRest(
 export type StreamItem = Schema.Schema.Type<typeof StreamItem>
 export type OutputItem = StreamItem & { readonly id: string }

-// The Responses schema puts streaming error details at the top level and
-// response failures under `response.error`. WebSocket failures use an
-// event-level `error` envelope, so accept all three shapes here.
+// Responses-compatible providers put streaming error details at the top level or
+// under `error`, and response failures under `response.error`. Accept all three shapes.
 // https://www.openresponses.org/specification
 const OpenResponsesErrorPayload = Schema.Struct({
  type: optionalNull(Schema.String),
@@ -401,10 +400,39 @@ export const Event = Schema.StructWithRest(
    headers: Schema.optional(Schema.Unknown),
  }),
  [Schema.Record(Schema.String, Schema.Unknown)],
+).pipe(
+  Schema.decode({
+    decode: SchemaGetter.transform((event) => {
+      if (event.type !== "error" || event.error != null) return event
+      const { code, message, param, ...rest } = event
+      if (code === undefined && message === undefined && param === undefined) return event
+      // Flat errors (for example, Meta's) can also arrive through generic Responses endpoints.
+      return { ...rest, error: { code, message, param } }
+    }),
+    encode: SchemaGetter.passthrough(),
+  }),
 )
 export type Event = Schema.Schema.Type<typeof Event>
 export type NormalizedEvent = Event & { readonly item?: OutputItem | null }

+const decodeEventValue = Schema.decodeUnknownEffect(Event)
+const decodeFrame = Schema.decodeUnknownEffect(ProviderShared.Json)
+
+/**
+ * Decodes one WebSocket frame. xAI answers a rejected `response.create` with `{ "error": { "message", "type" } }` and no
+ * event type; that envelope reads as an error event so the failure classifies instead of failing decoding.
+ */
+export const decodeChannelEvent = (frame: string) =>
+  decodeFrame(frame).pipe(
+    Effect.flatMap((value) =>
+      decodeEventValue(
+        ProviderShared.isRecord(value) && value.type === undefined && ProviderShared.isRecord(value.error)
+          ? { ...value, type: "error" }
+          : value,
+      ),
+    ),
+  )
+
 export interface ProviderAdapter {
  readonly id: string
  readonly name: string
@@ -1,6 +1,10 @@
 import type { LanguageModel, ProviderOptions } from "./schema/index.js"
 import type { CompactionOperations } from "./route/client.js"

+/**
+ * Flat, serializable settings for `model(modelID, settings)`. Each entrypoint declares the connection keys it
+ * reads; every other key is a request option for the route's protocol.
+ */
 export interface Settings extends Readonly<Record<string, unknown>> {
  readonly baseURL?: string
  readonly headers?: Readonly<Record<string, string>>
@@ -1,3 +1,4 @@
+import { Struct } from "effect"
 import type { ProviderPackage } from "../provider-package.js"
 import { AlibabaChat } from "../protocols/alibaba-chat.js"
 import { AlibabaMessages } from "../protocols/alibaba-messages.js"
@@ -6,7 +7,7 @@ import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
-import { ProviderID, ToolDefinition, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, ToolDefinition, type ModelID } from "../schema/index.js"

 export const id = ProviderID.make("alibaba")

@@ -34,9 +35,9 @@ export type Config = Location &
    readonly providerOptions?: ChatOptionsInput | MessagesOptionsInput | ResponsesOptionsInput
  }
 export type Settings<Options = ChatOptionsInput> = Location &
-  ProviderPackage.Settings & {
+  ProviderPackage.Settings &
+  Options & {
    readonly apiKey?: string
-    readonly providerOptions?: Options
  }

 const hosts = new Map<string, string>([
@@ -82,8 +83,13 @@ export const configure = (input: Config) => {
        ? hosts.get(region)
        : `${workspaceID}.${region}.maas.aliyuncs.com`
  if (baseURL === undefined) {
-    if (region === undefined) throw new Error("Alibaba requires region or baseURL")
-    if (host === undefined) throw new Error(`Alibaba region ${region} requires workspaceID or baseURL`)
+    if (region === undefined)
+      throw new ProviderConfigurationError({ provider: id, message: "Alibaba requires region or baseURL" })
+    if (host === undefined)
+      throw new ProviderConfigurationError({
+        provider: id,
+        message: `Alibaba region ${region} requires workspaceID or baseURL`,
+      })
  }
  const opts = { ...rest, auth: AuthOptions.bearer(input, ["DASHSCOPE_API_KEY", "ALIBABA_API_KEY"]) }
  const common = { ...opts, endpoint: { baseURL: baseURL ?? `https://${host}/compatible-mode/v1` } }
@@ -115,7 +121,11 @@ export const responsesModel: ProviderPackage.Definition<

 function fromSettings(input: Settings<Config["providerOptions"]>) {
  const { body, ...rest } = input
-  return configure({ ...rest, http: body === undefined ? undefined : { body } })
+  return configure({
+    ...rest,
+    http: body === undefined ? undefined : { body },
+    providerOptions: Struct.omit(rest, ["apiKey", "baseURL", "headers", "region", "workspaceID"]),
+  })
 }

 export const webSearch = () => hostedTool("web_search", "Search the web with Alibaba's hosted search tool.")
@@ -4,7 +4,7 @@ import type { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
 import { OpenResponses } from "../protocols/open-responses.js"
 import { BedrockAuth, type Credentials } from "../protocols/utils/bedrock-auth.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"

 export const id = ProviderID.make("amazon-bedrock")
@@ -23,16 +23,16 @@ export type Config = RouteDefaultsInput & {
  readonly providerOptions?: OpenAIProviderOptionsInput
 }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly auth?: "bearer" | "sigv4"
-  readonly baseURL?: string
-  readonly credentials?: Credentials
-  readonly profile?: string
-  readonly region?: string
-  readonly topP?: number
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly auth?: "bearer" | "sigv4"
+    readonly baseURL?: string
+    readonly credentials?: Credentials
+    readonly profile?: string
+    readonly region?: string
+    readonly topP?: number
+  }

 const responsesRoute = Route.make({
  id: "bedrock-mantle-responses",
@@ -79,9 +79,12 @@ const defaults = (input: Config) => {

 export const configure = (input: Config = {}) => {
  if (input.auth === "bearer" && input.apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-    throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey")
+    throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock Mantle bearer auth requires apiKey" })
  if (input.auth === "sigv4" && input.apiKey !== undefined)
-    throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Amazon Bedrock Mantle SigV4 auth does not accept apiKey",
+    })
  const configuredResponsesRoute = configuredRoute(responsesRoute, input)
  const configuredChatRoute = configuredRoute(chatRoute, input)
  const modelDefaults = defaults(input)
@@ -105,18 +108,29 @@ export const configure = (input: Config = {}) => {

 export const provider = configure()

-const fromSettings = (settings: Settings) =>
+const fromSettings = ({
+  apiKey,
+  auth,
+  baseURL,
+  body,
+  credentials,
+  headers,
+  profile,
+  region,
+  topP,
+  ...providerOptions
+}: Settings) =>
  configure({
-    apiKey: settings.apiKey,
-    auth: settings.auth,
-    baseURL: settings.baseURL,
-    credentials: settings.credentials,
-    generation: settings.topP === undefined ? undefined : { topP: settings.topP },
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    profile: settings.profile,
-    providerOptions: settings.providerOptions,
-    region: settings.region,
+    apiKey,
+    auth,
+    baseURL,
+    credentials,
+    generation: topP === undefined ? undefined : { topP },
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    profile,
+    providerOptions,
+    region,
  })

 export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
@@ -1,6 +1,6 @@
 import type { RouteDefaultsInput } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import * as BedrockConverse from "../protocols/bedrock-converse.js"
 import type { BedrockCredentials } from "../protocols/bedrock-converse.js"
 import { BedrockAuth } from "../protocols/utils/bedrock-auth.js"
@@ -39,8 +39,9 @@ const bedrockBaseURL = (region: string) => `https://bedrock-runtime.${region}.am
 const configuredRoute = (input: Config) => {
  const { apiKey, auth, credentials, profile, region, baseURL, ...rest } = input
  if (auth === "bearer" && apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-    throw new Error("Amazon Bedrock bearer auth requires apiKey")
-  if (auth === "sigv4" && apiKey !== undefined) throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey")
+    throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock bearer auth requires apiKey" })
+  if (auth === "sigv4" && apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock SigV4 auth does not accept apiKey" })
  const resolvedRegion = BedrockAuth.resolveRegion(input)
  return BedrockConverse.route.with({
    ...rest,
@@ -3,7 +3,7 @@ import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
 import type { RouteDefaultsInput } from "../route/client.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"

 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
 export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
@@ -19,13 +19,13 @@ export type Config = RouteDefaultsInput &
  }

 export type Settings = ProviderPackage.Settings &
+  AnthropicMessages.ProviderOptionsInput &
  (
    | { readonly apiKey?: string; readonly authToken?: never }
    | { readonly apiKey?: never; readonly authToken?: string }
  ) & {
    readonly baseURL: string
    readonly provider?: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
  }

 export const routes = [AnthropicMessages.route]
@@ -36,8 +36,12 @@ const auth = (input: ProviderAuthOption<"optional">) => {
 }

 export const configure = (input: Config) => {
-  if (!input.baseURL) throw new Error("Anthropic-compatible providers require a baseURL")
  const provider = input.provider ?? "anthropic-compatible"
+  if (!input.baseURL)
+    throw new ProviderConfigurationError({
+      provider: ProviderID.make(provider),
+      message: "Anthropic-compatible providers require a baseURL",
+    })
  const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
  const route = AnthropicMessages.route.with({
    ...rest,
@@ -59,17 +63,20 @@ export const provider = {

 export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, authToken, baseURL, body, headers, provider, ...providerOptions },
 ) => {
-  if (settings.apiKey !== undefined && settings.authToken !== undefined)
-    throw new Error("Anthropic-compatible apiKey cannot be combined with authToken")
+  if (apiKey !== undefined && authToken !== undefined)
+    throw new ProviderConfigurationError({
+      provider: ProviderID.make(provider ?? id),
+      message: "Anthropic-compatible apiKey cannot be combined with authToken",
+    })
  return configure({
-    ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    provider: settings.provider,
-    providerOptions: settings.providerOptions,
+    ...(authToken === undefined ? { apiKey: apiKey } : { auth: Auth.bearer(authToken) }),
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    provider,
+    providerOptions,
  }).model(modelID)
 }

@@ -2,7 +2,7 @@ import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { AnthropicCompatible } from "./anthropic-compatible.js"

@@ -21,12 +21,12 @@ export type Config = RouteDefaultsInput &
  }

 export type Settings = ProviderPackage.Settings &
+  AnthropicMessages.ProviderOptionsInput &
  (
    | { readonly apiKey?: string; readonly authToken?: never }
    | { readonly apiKey?: never; readonly authToken?: string }
  ) & {
    readonly baseURL?: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
  }

 const auth = (options: ProviderAuthOption<"optional">) => {
@@ -54,15 +54,18 @@ export const configure = (input: Config = {}) => {
 export const provider = configure()
 export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, authToken, baseURL, body, headers, ...providerOptions },
 ) => {
-  if (settings.apiKey !== undefined && settings.authToken !== undefined)
-    throw new Error("Anthropic apiKey cannot be combined with authToken")
+  if (apiKey !== undefined && authToken !== undefined)
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Anthropic apiKey cannot be combined with authToken",
+    })
  return configure({
-    ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    ...(authToken === undefined ? { apiKey: apiKey } : { auth: Auth.bearer(authToken) }),
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
 }
@@ -3,7 +3,7 @@ import { Auth } from "../route/auth.js"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
 import type { Route, RouteDefaultsInput, CompactionOperations } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import * as OpenAIResponses from "../protocols/openai-responses.js"
 import { ProviderShared } from "../protocols/shared.js"
@@ -28,12 +28,12 @@ export type LanguageModelOptions = AzureURL &
 export type Config = LanguageModelOptions

 export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput &
  AzureURL & {
    readonly apiKey?: string
    readonly apiVersion?: string
    readonly queryParams?: Readonly<Record<string, string>>
    readonly useDeploymentBasedUrls?: boolean
-    readonly providerOptions?: OpenAIProviderOptionsInput
  }

 const resourceBaseURL = (resourceName: string) => `https://${resourceName.trim()}.openai.azure.com/openai`
@@ -151,19 +151,29 @@ export const provider = {
  configure,
 }

-const config = (settings: Settings): Config => {
+const config = ({
+  apiKey,
+  apiVersion,
+  baseURL,
+  body,
+  headers,
+  queryParams,
+  resourceName,
+  useDeploymentBasedUrls,
+  ...providerOptions
+}: Settings): Config => {
  const common = {
-    apiKey: settings.apiKey,
-    apiVersion: settings.apiVersion,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
-    useDeploymentBasedUrls: settings.useDeploymentBasedUrls,
+    apiKey,
+    apiVersion,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
+    queryParams: queryParams === undefined ? undefined : { ...queryParams },
+    useDeploymentBasedUrls,
  }
-  if (settings.baseURL !== undefined) return { ...common, baseURL: settings.baseURL }
-  if (settings.resourceName !== undefined) return { ...common, resourceName: settings.resourceName }
-  throw new Error("Azure requires resourceName or baseURL")
+  if (baseURL !== undefined) return { ...common, baseURL }
+  if (resourceName !== undefined) return { ...common, resourceName }
+  throw new ProviderConfigurationError({ provider: id, message: "Azure requires resourceName or baseURL" })
 }

 export const responsesModel: ProviderPackage.Definition<
@@ -15,11 +15,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "baseten-chat",
@@ -48,13 +48,16 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as Baseten from "./baseten.js"
@@ -15,11 +15,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "cerebras-chat",
@@ -52,11 +52,14 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js"
 import type { AtLeastOne, ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"

 export const id = ProviderID.make("cloudflare-ai-gateway")
@@ -27,15 +27,19 @@ export type LanguageModelOptions = GatewayURL &
  }

 export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput &
  GatewayURL & {
    readonly apiKey?: string
    readonly gatewayApiKey?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
  }

 export const baseURL = (input: GatewayURL) => {
  if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied")
+  if (!input.accountId)
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "CloudflareAIGateway.configure requires accountId unless baseURL is supplied",
+    })
  return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`
 }

@@ -85,14 +89,25 @@ export const configure = (input: LanguageModelOptions) => {

 export const provider = { id, configure }

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    gatewayApiKey: settings.gatewayApiKey,
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
+  const {
+    accountId: _,
+    apiKey,
+    baseURL: _url,
+    body,
+    gatewayApiKey,
+    gatewayId: _id,
+    headers,
+    ...providerOptions
+  } = settings
+  return configure({
+    apiKey,
+    gatewayApiKey,
    baseURL: baseURL(settings),
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
+}

 export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js"
@@ -3,7 +3,7 @@ import { OpenAIChat } from "../protocols/openai-chat.js"
 import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"

 export const id = ProviderID.make("cloudflare-workers-ai")
@@ -21,14 +21,18 @@ export type LanguageModelOptions = WorkersAIURL &
  }

 export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput &
  WorkersAIURL & {
    readonly apiKey?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
  }

 export const baseURL = (input: WorkersAIURL) => {
  if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied")
+  if (!input.accountId)
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "CloudflareWorkersAI.configure requires accountId unless baseURL is supplied",
+    })
  return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(input.accountId)}/ai/v1`
 }

@@ -59,13 +63,15 @@ export const configure = (input: LanguageModelOptions) => {

 export const provider = { id, configure }

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
+  const { accountId: _, apiKey, baseURL: _url, body, headers, ...providerOptions } = settings
+  return configure({
+    apiKey,
    baseURL: baseURL(settings),
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
+}

 export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js"
@@ -15,11 +15,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "deepinfra-chat",
@@ -55,11 +55,14 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
@@ -15,11 +15,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "deepseek-chat",
@@ -52,13 +52,16 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as DeepSeek from "./deepseek.js"
@@ -15,11 +15,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "fireworks-chat",
@@ -48,13 +48,16 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as Fireworks from "./fireworks.js"
@@ -2,7 +2,7 @@ import type { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"

@@ -16,14 +16,14 @@ export type Config = RouteDefaultsInput &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly accessToken?: string
-  readonly apiKey?: never
-  readonly baseURL?: string
-  readonly location?: string
-  readonly project?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly accessToken?: string
+    readonly apiKey?: never
+    readonly baseURL?: string
+    readonly location?: string
+    readonly project?: string
+  }

 const route = Route.make({
  id: "google-vertex-chat",
@@ -37,7 +37,8 @@ const route = Route.make({
 export const routes = [route]

 const configuredRoute = (input: Config) => {
-  if ("apiKey" in input && input.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
+  if ("apiKey" in input && input.apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Chat does not support API keys" })
  const {
    accessToken: _accessToken,
    auth: _auth,
@@ -73,15 +74,19 @@ export const provider = {
  configure,
 }

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { accessToken, apiKey, baseURL, body, headers, location, project, ...providerOptions },
+) => {
+  if (apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Chat does not support API keys" })
  return configure({
-    accessToken: settings.accessToken,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
+    accessToken,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    location,
+    project,
+    providerOptions,
  }).model(modelID)
 }
@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"

 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
@@ -25,14 +25,14 @@ export type Config = RouteDefaultsInput &
    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly accessToken?: string
-  readonly apiKey?: never
-  readonly baseURL?: string
-  readonly location?: string
-  readonly project?: string
-  readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  AnthropicMessages.ProviderOptionsInput & {
+    readonly accessToken?: string
+    readonly apiKey?: never
+    readonly baseURL?: string
+    readonly location?: string
+    readonly project?: string
+  }

 const route = Route.make({
  id: "google-vertex-messages",
@@ -67,7 +67,7 @@ export const routes = [route]

 const configuredRoute = (input: Config) => {
  if ("apiKey" in input && input.apiKey !== undefined)
-    throw new Error("Google Vertex Messages does not support API keys")
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Messages does not support API keys" })
  const {
    accessToken: _accessToken,
    auth: _auth,
@@ -105,16 +105,17 @@ export const provider = {

 export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { accessToken, apiKey, baseURL, body, headers, location, project, ...providerOptions },
 ) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Messages does not support API keys")
+  if (apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Messages does not support API keys" })
  return configure({
-    accessToken: settings.accessToken,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
+    accessToken,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    location,
+    project,
+    providerOptions,
  }).model(modelID)
 }
@@ -2,7 +2,7 @@ import type { ProviderPackage } from "../provider-package.js"
 import { OpenResponses } from "../protocols/open-responses.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"

@@ -16,14 +16,14 @@ export type Config = RouteDefaultsInput &
    readonly providerOptions?: OpenResponsesProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly accessToken?: string
-  readonly apiKey?: never
-  readonly baseURL?: string
-  readonly location?: string
-  readonly project?: string
-  readonly providerOptions?: OpenResponsesProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenResponsesProviderOptionsInput & {
+    readonly accessToken?: string
+    readonly apiKey?: never
+    readonly baseURL?: string
+    readonly location?: string
+    readonly project?: string
+  }

 const route = Route.make({
  id: "google-vertex-responses",
@@ -39,7 +39,7 @@ export const routes = [route]

 const configuredRoute = (input: Config) => {
  if ("apiKey" in input && input.apiKey !== undefined)
-    throw new Error("Google Vertex Responses does not support API keys")
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Responses does not support API keys" })
  const {
    accessToken: _accessToken,
    auth: _auth,
@@ -77,16 +77,17 @@ export const provider = {

 export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { accessToken, apiKey, baseURL, body, headers, location, project, ...providerOptions },
 ) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Responses does not support API keys")
+  if (apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Responses does not support API keys" })
  return configure({
-    accessToken: settings.accessToken,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
+    accessToken,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    location,
+    project,
+    providerOptions,
  }).model(modelID)
 }
@@ -1,8 +1,10 @@
 import type { AnyAuthClient } from "google-auth-library"
 import { Effect, Redacted } from "effect"
 import { Auth, MissingCredentialError } from "../route/auth.js"
+import { ProviderConfigurationError, ProviderID } from "../schema/index.js"

 const SCOPE = "https://www.googleapis.com/auth/cloud-platform"
+const id = ProviderID.make("google-vertex")

 export type OAuthOptions =
  | { readonly accessToken?: string; readonly auth?: never }
@@ -35,12 +37,18 @@ export const host = (location: string) => {

 export const requireProject = (value: string | undefined) => {
  if (value) return value
-  throw new Error("Google Vertex requires a project when baseURL is not configured")
+  throw new ProviderConfigurationError({
+    provider: id,
+    message: "Google Vertex requires a project when baseURL is not configured",
+  })
 }

 export const apiKey = (input: ApiKeyOptions) => {
  if (input.apiKey !== undefined && (input.accessToken !== undefined || input.auth !== undefined))
-    throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Google Vertex apiKey cannot be combined with accessToken or auth",
+    })
  if (input.accessToken !== undefined || input.auth !== undefined) return undefined
  return input.apiKey ?? process.env.GOOGLE_VERTEX_API_KEY
 }
@@ -68,7 +76,10 @@ const adc = (project?: string) => {

 export const oauth = (input: OAuthOptions, project?: string) => {
  if (input.accessToken !== undefined && input.auth !== undefined)
-    throw new Error("Google Vertex accessToken cannot be combined with auth")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Google Vertex accessToken cannot be combined with auth",
+    })
  if (input.auth) return input.auth
  if (input.accessToken !== undefined) return Auth.bearer(input.accessToken)
  return adc(project)
@@ -6,7 +6,7 @@ import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
-import { ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"

 export interface GeminiOptionsInput extends Gemini.OptionsInput {
@@ -26,6 +26,7 @@ export type Config = RouteDefaultsInput &
  }

 export type Settings = ProviderPackage.Settings &
+  GeminiProviderOptionsInput &
  (
    | { readonly accessToken?: string; readonly apiKey?: never }
    | { readonly accessToken?: never; readonly apiKey?: string }
@@ -33,7 +34,6 @@ export type Settings = ProviderPackage.Settings &
    readonly baseURL?: string
    readonly location?: string
    readonly project?: string
-    readonly providerOptions?: GeminiProviderOptionsInput
  }

 const fromRequest = Effect.fn("GoogleVertex.fromRequest")(function* (request: LLMRequest) {
@@ -93,7 +93,10 @@ const configuredRoute = (input: Config, modelID: string | ModelID) => {
  const apiKey = GoogleVertexShared.apiKey(input)
  const endpointModel = String(modelID).startsWith("endpoints/")
  if (apiKey !== undefined && endpointModel)
-    throw new Error("Google Vertex tuned models do not support Express Mode API keys")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Google Vertex tuned models do not support Express Mode API keys",
+    })
  const location = GoogleVertexShared.location(inputLocation, "us-central1")
  const project = GoogleVertexShared.project(inputProject)
  const endpoint =
@@ -121,16 +124,22 @@ export const provider = {
  id,
  configure,
 }
-export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"] = (modelID, settings) => {
-  if (settings.apiKey !== undefined && settings.accessToken !== undefined)
-    throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth")
+export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"] = (
+  modelID,
+  { accessToken, apiKey, baseURL, body, headers, location, project, ...providerOptions },
+) => {
+  if (apiKey !== undefined && accessToken !== undefined)
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Google Vertex apiKey cannot be combined with accessToken or auth",
+    })
  return configure({
-    ...(settings.apiKey === undefined ? { accessToken: settings.accessToken } : { apiKey: settings.apiKey }),
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
+    ...(apiKey === undefined ? { accessToken: accessToken } : { apiKey: apiKey }),
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    location,
+    project,
+    providerOptions,
  }).model(modelID)
 }
@@ -20,11 +20,11 @@ export type Config = RouteDefaultsInput &
    readonly providerOptions?: Gemini.ProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: Gemini.ProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  Gemini.ProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 const auth = (options: ProviderAuthOption<"optional">) => {
  if ("auth" in options && options.auth) return options.auth
@@ -57,13 +57,16 @@ export const configure = (input: Config = {}) => {
 }

 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export const image = provider.image
@@ -26,11 +26,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: ProviderOptions
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: ProviderOptions
-}
+export type Settings = ProviderPackage.Settings &
+  ProviderOptions & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 const Options = Schema.Struct({
  includeReasoning: Schema.optional(Schema.Boolean),
@@ -103,13 +103,16 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as Groq from "./groq.js"
@@ -79,11 +79,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: ProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: ProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  ProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 const responsesRoute = Route.make({
  id: "meta-responses",
@@ -169,13 +169,13 @@ export const chatModel: ProviderPackage.Definition<Settings, OpenResponsesProvid
 export const messagesModel: ProviderPackage.Definition<Settings, MessagesOptionsInput>["model"] = (modelID, settings) =>
  fromSettings(settings).messages(modelID)

-function fromSettings(settings: Settings) {
+function fromSettings({ apiKey, baseURL, body, headers, ...providerOptions }: Settings) {
  return configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  })
 }

@@ -40,11 +40,11 @@ export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: ProviderOptionsInput
  }

-export interface Settings<Options = MessagesOptionsInput> extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: Options
-}
+export type Settings<Options = MessagesOptionsInput> = ProviderPackage.Settings &
+  Options & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 const ChatOptions = Schema.Struct({
  thinking: Schema.optional(Schema.Struct({ type: Schema.String })),
@@ -127,14 +127,14 @@ export const provider = configure()

 export const model: ProviderPackage.Definition<Settings<MessagesOptionsInput>, MessagesOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, baseURL, body, headers, ...providerOptions },
 ) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export const messages = provider.messages
@@ -3,11 +3,14 @@ import { MiniMax } from "../minimax.js"

 export type Settings = MiniMax.Settings<MiniMax.ChatOptionsInput>

-export const model: ProviderPackage.Definition<Settings, MiniMax.ChatOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, MiniMax.ChatOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  MiniMax.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).chat(modelID)
@@ -5,12 +5,12 @@ export type Settings = MiniMax.Settings<MiniMax.ResponsesOptionsInput>

 export const model: ProviderPackage.Definition<Settings, MiniMax.ResponsesOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, baseURL, body, headers, ...providerOptions },
 ) =>
  MiniMax.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).responses(modelID)
@@ -14,11 +14,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: ProviderOptions
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: ProviderOptions
-}
+export type Settings = ProviderPackage.Settings &
+  ProviderOptions & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = MistralChat.route
 export const routes = [route]
@@ -39,13 +39,16 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as Mistral from "./mistral.js"
@@ -42,11 +42,11 @@ export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: ChatOptionsInput | MessagesOptionsInput | ResponsesOptionsInput
  }

-export interface Settings<Options = ChatOptionsInput> extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: Options
-}
+export type Settings<Options = ChatOptionsInput> = ProviderPackage.Settings &
+  Options & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 const ChatOptions = Schema.Struct({
  reasoningEffort: Schema.optional(Schema.String),
@@ -133,13 +133,16 @@ export const chat = provider.chat
 export const messages = provider.messages
 export const responses = provider.responses

-export const model: ProviderPackage.Definition<Settings, ChatOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, ChatOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as Moonshot from "./moonshot.js"
@@ -5,12 +5,12 @@ export type Settings = Moonshot.Settings<Moonshot.MessagesOptionsInput>

 export const model: ProviderPackage.Definition<Settings, Moonshot.MessagesOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, baseURL, body, headers, ...providerOptions },
 ) =>
  Moonshot.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).messages(modelID)
@@ -5,12 +5,12 @@ export type Settings = Moonshot.Settings<Moonshot.ResponsesOptionsInput>

 export const model: ProviderPackage.Definition<Settings, Moonshot.ResponsesOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, baseURL, body, headers, ...providerOptions },
 ) =>
  Moonshot.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).responses(modelID)
@@ -16,12 +16,12 @@ export type Config = RouteDefaultsInput &
    readonly providerOptions?: OpenResponsesProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL: string
-  readonly provider?: string
-  readonly providerOptions?: OpenResponsesProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenResponsesProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL: string
+    readonly provider?: string
+  }

 export const routes = [OpenAICompatibleResponses.route]

@@ -48,13 +48,13 @@ export const provider = {

 export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, baseURL, body, headers, provider, ...providerOptions },
 ) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    provider: settings.provider,
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    provider,
+    providerOptions,
  }).model(modelID)
@@ -14,12 +14,12 @@ type GenericModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL: string
-  readonly provider?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL: string
+    readonly provider?: string
+  }

 export const routes = [OpenAICompatibleChat.route]

@@ -45,14 +45,17 @@ export const provider = {
  configure,
 }

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, provider, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    provider: settings.provider,
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    provider,
+    providerOptions,
  }).model(modelID)

 export * as OpenAICompatible from "./openai-compatible.js"
@@ -57,14 +57,14 @@ export const imageGeneration = (options: ImageGenerationOptions = {}) =>
    },
  })

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly organization?: string
-  readonly project?: string
-  readonly queryParams?: Readonly<Record<string, string>>
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+    readonly organization?: string
+    readonly project?: string
+    readonly queryParams?: Readonly<Record<string, string>>
+  }

 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "OPENAI_API_KEY")

@@ -116,19 +116,28 @@ export const configure = (input: Config = {}) => {

 export const provider = configure()

-const config = (settings: Settings): Config => {
+const config = ({
+  apiKey,
+  baseURL,
+  body,
+  headers: given,
+  organization,
+  project,
+  queryParams,
+  ...providerOptions
+}: Settings): Config => {
  const headers = {
-    ...(settings.organization === undefined ? {} : { "OpenAI-Organization": settings.organization }),
-    ...(settings.project === undefined ? {} : { "OpenAI-Project": settings.project }),
-    ...settings.headers,
+    ...(organization === undefined ? {} : { "OpenAI-Organization": organization }),
+    ...(project === undefined ? {} : { "OpenAI-Project": project }),
+    ...given,
  }
  return {
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
+    apiKey,
+    baseURL,
    headers: Object.keys(headers).length === 0 ? undefined : headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
+    queryParams: queryParams === undefined ? undefined : { ...queryParams },
  }
 }

@@ -77,11 +77,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenRouterProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenRouterProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenRouterProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 const OpenRouterBody = Schema.StructWithRest(Schema.Struct(OpenAIChat.bodyFields), [
  Schema.Record(Schema.String, Schema.Any),
@@ -191,12 +191,12 @@ export const configure = (input: LanguageModelOptions = {}) => {
 export const provider = configure()
 export const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, baseURL, body, headers, ...providerOptions },
 ) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
@@ -15,11 +15,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "togetherai-chat",
@@ -52,11 +52,14 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
@@ -20,11 +20,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: XAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: XAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  XAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export type { XAIImageOptions } from "../protocols/xai-images.js"

@@ -41,6 +41,10 @@ const responsesRoute = Route.make({
    id: "openai-responses",
    name: "xAI Responses",
    rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
+    // xAI continues a chain only from stored responses: with `store: false` (the route default) `previous_response_id`
+    // fails with "Response with id=… not found", so those steps are sent in full over the reused connection. It also
+    // rejects `instructions` next to `previous_response_id` and keeps the instructions of the response it continues.
+    continuation: ({ instructions: _instructions, ...request }) => (request.store === false ? undefined : request),
  }),
  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 })
@@ -106,13 +110,13 @@ export const model: ProviderPackage.Definition<
  Settings,
  XAIProviderOptionsInput,
  typeof responsesRoute.compact
->["model"] = (modelID, settings) =>
+>["model"] = (modelID, { apiKey, baseURL, body, headers, ...providerOptions }) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
 export const responses = provider.responses
 export const chat = provider.chat
@@ -23,11 +23,11 @@ export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: ChatOptionsInput | MessagesOptionsInput | ResponsesOptionsInput
  }

-export interface Settings<Options = ChatOptionsInput> extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: Options
-}
+export type Settings<Options = ChatOptionsInput> = ProviderPackage.Settings &
+  Options & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 const chatRoute = Route.make({
  id: "zai-coding-chat",
@@ -80,13 +80,16 @@ export const chat = provider.chat
 export const messages = provider.messages
 export const responses = provider.responses

-export const model: ProviderPackage.Definition<Settings, ChatOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, ChatOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as ZAICodingPlan from "./zai-coding-plan.js"
@@ -5,12 +5,12 @@ export type Settings = ZAICodingPlan.Settings<ZAICodingPlan.MessagesOptionsInput

 export const model: ProviderPackage.Definition<Settings, ZAICodingPlan.MessagesOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, baseURL, body, headers, ...providerOptions },
 ) =>
  ZAICodingPlan.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).messages(modelID)
@@ -5,12 +5,12 @@ export type Settings = ZAICodingPlan.Settings<ZAICodingPlan.ResponsesOptionsInpu

 export const model: ProviderPackage.Definition<Settings, ZAICodingPlan.ResponsesOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, baseURL, body, headers, ...providerOptions },
 ) =>
  ZAICodingPlan.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).responses(modelID)
@@ -17,11 +17,11 @@ export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: ChatOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: ChatOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  ChatOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export type { ZAIImageOptions } from "../protocols/zai-images.js"

@@ -70,13 +70,16 @@ export const provider = configure()
 export const image = provider.image
 export const chat = provider.chat

-export const model: ProviderPackage.Definition<Settings, ChatOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, ChatOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as ZAI from "./zai.js"
@@ -23,6 +23,7 @@ import {
  LanguageModel,
  LLMEvent,
  InvalidProviderOutputError,
+  ProviderConfigurationError,
  ProviderID,
  mergeGenerationOptions,
  mergeHttpOptions,
@@ -128,7 +129,10 @@ const makeRouteLanguageModel = <Options extends ProviderOptions, Compact extends
  const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
  if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
  if (!endpointBaseURL(route.endpoint))
-    throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`)
+    throw new ProviderConfigurationError({
+      provider: ProviderID.make(provider),
+      message: `Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`,
+    })
  return LanguageModel.make<Options, Compact>({
    ...mapped,
    provider,
@@ -50,6 +50,19 @@ export class UnsupportedOperationError extends Schema.TaggedError<UnsupportedOpe
  route: Schema.optional(RouteID),
 }) {}

+/**
+ * Provider settings that are missing, conflicting, or unsupported, such as
+ * Azure without `resourceName` or `baseURL`. Thrown synchronously while a
+ * provider facade or package entrypoint configures a model, before any
+ * request exists, so it is not an `AIError` reason.
+ */
+export class ProviderConfigurationError extends Schema.TaggedError<ProviderConfigurationError>(
+  "AI.Error.ProviderConfiguration",
+)("ProviderConfiguration", {
+  provider: ProviderID,
+  message: Schema.String,
+}) {}
+
 export class NoRouteError extends Schema.TaggedError<NoRouteError>("AI.Error.NoRoute")("NoRoute", {
  ...ReasonFields,
  route: RouteID,
@@ -3,6 +3,9 @@ import { model } from "@opencode/ai/providers/openai"
 import { LLM } from "../src/index.js"
 import { Endpoint } from "../src/route/endpoint.js"

+const configuration = (provider: string, message: string) =>
+  expect.objectContaining({ _tag: "ProviderConfiguration", provider, message })
+
 describe("provider package entrypoints", () => {
  test("semantic API aliases expose the same contract", async () => {
    const modules = await Promise.all([
@@ -185,13 +188,13 @@ describe("provider package entrypoints", () => {
      baseURL: "https://provider.example.test/v1/",
      headers: { "x-application": "opencode" },
      body: { service_tier: "priority" },
-      providerOptions: { reasoningEffort: "high" as const },
+      reasoningEffort: "high" as const,
    }
    const deepinfra = DeepInfra.model("google/gemma-3-27b-it", settings)

    expect(deepinfra.route.id).toBe("deepinfra-chat")
    expect(deepinfra.route.endpoint.baseURL).toBe("https://provider.example.test/v1/openai")
-    expect(deepinfra.route.defaults.providerOptions).toEqual(settings.providerOptions)
+    expect(deepinfra.route.defaults.providerOptions).toEqual({ reasoningEffort: "high" })
    expect(deepinfra.route.defaults.headers).toEqual(settings.headers)
    expect(deepinfra.route.defaults.http?.body).toEqual(settings.body)
  })
@@ -207,7 +210,7 @@ describe("provider package entrypoints", () => {
        apiKey: "fixture",
        headers: { "x-application": "opencode" },
        body: { custom: true },
-        providerOptions: { reasoningEffort: "high" },
+        reasoningEffort: "high",
      })
      expect(selected.provider).toBe(provider.id)
      expect(selected.route.endpoint.baseURL).toBe(provider.baseURL({ accountId: "account" }))
@@ -228,11 +231,11 @@ describe("provider package entrypoints", () => {
    }
    const openrouter = OpenRouter.model("anthropic/claude-sonnet-4", {
      ...settings,
-      providerOptions: { usage: true },
+      usage: true,
    })
    const xai = XAI.model("grok-4", {
      ...settings,
-      providerOptions: { reasoningEffort: "high" },
+      reasoningEffort: "high",
    })

    for (const selected of [openrouter, xai]) {
@@ -266,7 +269,8 @@ describe("provider package entrypoints", () => {
      provider: "example",
      headers: { "x-application": "opencode" },
      body: { service_tier: "priority" },
-      providerOptions: { reasoningEffort: "low", store: true },
+      reasoningEffort: "low",
+      store: true,
    })

    expect(String(selected.provider)).toBe("example")
@@ -292,7 +296,7 @@ describe("provider package entrypoints", () => {
      provider: "example",
      headers: { "x-application": "opencode" },
      body: { metadata: { user_id: "user_1" } },
-      providerOptions: { effort: "low" },
+      effort: "low",
    })

    expect(String(selected.provider)).toBe("example")
@@ -312,7 +316,7 @@ describe("provider package entrypoints", () => {
    const Anthropic = await import("@opencode/ai/providers/anthropic")
    const selected = Anthropic.model("claude-sonnet-4-6", {
      apiKey: "fixture",
-      providerOptions: { thinking: { type: "adaptive" } },
+      thinking: { type: "adaptive" },
    })

    expect(selected.route.defaults.providerOptions).toEqual({ thinking: { type: "adaptive" } })
@@ -322,7 +326,7 @@ describe("provider package entrypoints", () => {
    const AnthropicCompatible = await import("@opencode/ai/providers/anthropic-compatible")
    expect(() =>
      Reflect.apply(AnthropicCompatible.model, undefined, ["compatible-model", { apiKey: "fixture" }]),
-    ).toThrow("Anthropic-compatible providers require a baseURL")
+    ).toThrow(configuration("anthropic-compatible", "Anthropic-compatible providers require a baseURL"))
  })

  test("rejects conflicting Anthropic-compatible auth settings at runtime", async () => {
@@ -337,10 +341,10 @@ describe("provider package entrypoints", () => {
          baseURL: "https://messages.example.test/v1",
        },
      ]),
-    ).toThrow("Anthropic-compatible apiKey cannot be combined with authToken")
+    ).toThrow(configuration("anthropic-compatible", "Anthropic-compatible apiKey cannot be combined with authToken"))
    expect(() =>
      Reflect.apply(Anthropic.model, undefined, ["claude-sonnet-4-6", { apiKey: "fixture", authToken: "token" }]),
-    ).toThrow("Anthropic apiKey cannot be combined with authToken")
+    ).toThrow(configuration("anthropic", "Anthropic apiKey cannot be combined with authToken"))
  })

  test("maps legacy OpenAI organization and project settings to headers", () => {
@@ -406,7 +410,7 @@ describe("provider package entrypoints", () => {
      baseURL: "https://generativelanguage.test/v1beta",
      headers: { "x-application": "opencode" },
      body: { safetySettings: [] },
-      providerOptions: { thinkingConfig: { thinkingBudget: 1_024 } },
+      thinkingConfig: { thinkingBudget: 1_024 },
    })

    expect(selected.route.id).toBe("gemini")
@@ -490,43 +494,45 @@ describe("provider package entrypoints", () => {
        "gemini-3.5-flash",
        { accessToken: "token", apiKey: "fixture", project: "vertex-project" },
      ]),
-    ).toThrow("Google Vertex apiKey cannot be combined with accessToken or auth")
+    ).toThrow(configuration("google-vertex", "Google Vertex apiKey cannot be combined with accessToken or auth"))
    const configured = Reflect.apply(GoogleVertex.configure, undefined, [
      { accessToken: "token", auth: {}, project: "vertex-project" },
    ])
-    expect(() => configured.model("gemini-3.5-flash")).toThrow("Google Vertex accessToken cannot be combined with auth")
+    expect(() => configured.model("gemini-3.5-flash")).toThrow(
+      configuration("google-vertex", "Google Vertex accessToken cannot be combined with auth"),
+    )
    expect(() =>
      Reflect.apply(GoogleVertexMessages.model, undefined, [
        "claude-sonnet-4-6",
        { apiKey: "fixture", project: "vertex-project" },
      ]),
-    ).toThrow("Google Vertex Messages does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Messages does not support API keys"))
    expect(() =>
      Reflect.apply(Providers.GoogleVertexMessages.configure, undefined, [
        { apiKey: "fixture", project: "vertex-project" },
      ]),
-    ).toThrow("Google Vertex Messages does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Messages does not support API keys"))
    expect(() =>
      Reflect.apply(GoogleVertexChat.model, undefined, [
        "deepseek-ai/deepseek-v3.2-maas",
        { apiKey: "fixture", project: "vertex-project" },
      ]),
-    ).toThrow("Google Vertex Chat does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Chat does not support API keys"))
    expect(() =>
      Reflect.apply(Providers.GoogleVertexChat.configure, undefined, [
        { apiKey: "fixture", project: "vertex-project" },
      ]),
-    ).toThrow("Google Vertex Chat does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Chat does not support API keys"))
    expect(() =>
      Reflect.apply(GoogleVertexResponses.model, undefined, [
        "xai/grok-4.20-reasoning",
        { apiKey: "fixture", project: "vertex-project" },
      ]),
-    ).toThrow("Google Vertex Responses does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Responses does not support API keys"))
    expect(() =>
      Reflect.apply(Providers.GoogleVertexResponses.configure, undefined, [
        { apiKey: "fixture", project: "vertex-project" },
      ]),
-    ).toThrow("Google Vertex Responses does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Responses does not support API keys"))
  })
 })
@@ -76,7 +76,13 @@ it.effect("Alibaba owns regional shared and workspace-specific endpoints", () =>

 test("Alibaba requires explicit placement and supports complete base URL overrides", () => {
  for (const region of ["eu-central-1", "ap-northeast-1", "future-region"])
-    expect(() => Alibaba.configure({ region })).toThrow("requires workspaceID or baseURL")
+    expect(() => Alibaba.configure({ region })).toThrow(
+      expect.objectContaining({
+        _tag: "ProviderConfiguration",
+        provider: "alibaba",
+        message: `Alibaba region ${region} requires workspaceID or baseURL`,
+      }),
+    )
  for (const config of [
    { baseURL: "https://gateway.example/prefix" },
    { region: "future-region", workspaceID: "ignored", baseURL: "https://gateway.example/prefix" },
@@ -69,7 +69,9 @@ for (const model of [
      dynamicResponse(({ request, text, respond }) =>
        Effect.sync(() => {
          const body = JSON.parse(text)
-          expect(request.headers["anthropic-beta"]).toBe("existing-beta,compact-2026-01-12")
+          expect(request.headers["anthropic-beta"]).toBe(
+            "existing-beta,interleaved-thinking-2025-05-14,compact-2026-01-12",
+          )
          if (body.messages.length === 1) {
            expect(body.context_management.edits).toEqual([
              {
@@ -32,7 +32,9 @@ for (const [id, enabled] of [
        enabled ? { type: "adaptive", block_binding: { prefix_mismatch_behavior: "drop_block" } } : undefined,
      )
      expect(prepared.request.headers["anthropic-beta"]).toBe(
-        enabled ? "existing-beta,thinking-binding-controls-2026-08-01" : "existing-beta",
+        enabled
+          ? "existing-beta,interleaved-thinking-2025-05-14,thinking-binding-controls-2026-08-01"
+          : "existing-beta,interleaved-thinking-2025-05-14",
      )
    }),
  )
@@ -53,7 +55,9 @@ it.effect("preserves explicit thinking settings and combines required beta heade
      const prepared = yield* AnthropicMessages.route.prepareTransport(compiled.body, request)
      expect(compiled.body.thinking).toEqual(thinking)
      expect(prepared.request.headers["anthropic-beta"]).toBe(
-        thinking.type === "disabled" ? "compact-2026-01-12" : "compact-2026-01-12,thinking-binding-controls-2026-08-01",
+        thinking.type === "disabled"
+          ? "interleaved-thinking-2025-05-14,compact-2026-01-12"
+          : "interleaved-thinking-2025-05-14,compact-2026-01-12,thinking-binding-controls-2026-08-01",
      )
    }
  }),
@@ -1458,7 +1458,13 @@ describe("Bedrock Converse route", () => {
        expect(headers.get("authorization")).toContain("Credential=AKIACHAINEXAMPLE/")
        expect(headers.get("authorization")).toContain("/ap-southeast-2/bedrock/aws4_request")
      }
-      expect(() => AmazonBedrock.configure({ auth: "sigv4", apiKey: "k" })).toThrow("does not accept apiKey")
+      expect(() => AmazonBedrock.configure({ auth: "sigv4", apiKey: "k" })).toThrow(
+        expect.objectContaining({
+          _tag: "ProviderConfiguration",
+          provider: "amazon-bedrock",
+          message: "Amazon Bedrock SigV4 auth does not accept apiKey",
+        }),
+      )
    }).pipe(
      withProcessEnv({
        ...noAmbientAWS,
@@ -378,7 +378,11 @@ describe("Google Vertex providers", () => {

  test("rejects tuned Gemini models in express mode", () => {
    expect(() => GoogleVertex.configure({ apiKey: "fixture" }).model("endpoints/1234567890")).toThrow(
-      "Google Vertex tuned models do not support Express Mode API keys",
+      expect.objectContaining({
+        _tag: "ProviderConfiguration",
+        provider: "google-vertex",
+        message: "Google Vertex tuned models do not support Express Mode API keys",
+      }),
    )
  })
 })
@@ -34,12 +34,10 @@ it.effect("Groq lowers its own options for custom catalog identities and endpoin
        baseURL: "https://gateway.example/v1",
        headers: { "x-client": "test" },
        body: { custom: "value" },
-        providerOptions: {
-          reasoningEffort: "default",
-          parallelToolCalls: true,
-          serviceTier: "flex",
-          user: "test-user",
-        },
+        reasoningEffort: "default",
+        parallelToolCalls: true,
+        serviceTier: "flex",
+        user: "test-user",
      }),
      { provider: "custom-groq" },
    )
@@ -87,7 +87,7 @@ it.effect("Meta package selectors preserve overrides and Chat token policy on cu
        baseURL: "https://gateway.example/v1",
        headers: { "x-client": "test" },
        body: { custom: "value" },
-        providerOptions: { reasoningEffort: "future-effort" },
+        reasoningEffort: "future-effort",
      })
      expect(model.route.endpoint.baseURL).toBe("https://gateway.example/v1")
      expect(model.route.defaults.headers).toEqual({ "x-client": "test" })
@@ -99,7 +99,7 @@ describe("native OpenAI-compatible providers", () => {
        const settings = {
          apiKey: "fixture",
          baseURL: "https://gateway.example/v1",
-          providerOptions: { reasoningEffort: "high" },
+          reasoningEffort: "high",
        }
        const selected = provider.configure(settings).model("test-model")
        expect(selected.provider).toBe(provider.id)
@@ -143,7 +143,7 @@ describe("native OpenAI-compatible providers", () => {
          tools: [
            ToolDefinition.make({ name: "lookup", description: "Look up data", inputSchema: { type: "object" } }),
          ],
-          providerOptions: { store: true },
+          store: true,
        }),
      )

@@ -168,7 +168,7 @@ describe("native OpenAI-compatible providers", () => {
            ]),
            Message.user("Continue."),
          ],
-          providerOptions: { store: true },
+          store: true,
        }),
      )

@@ -206,7 +206,7 @@ describe("native OpenAI-compatible providers", () => {
        baseURL: "https://gateway.example/v1",
        headers: { "x-application": "opencode" },
        body: { service_tier: "priority" },
-        providerOptions: { reasoningEffort: "high" },
+        reasoningEffort: "high",
      })

      expect(selected.route.endpoint.baseURL).toBe("https://gateway.example/v1")
@@ -0,0 +1,78 @@
+import { expect } from "bun:test"
+import { Effect, Schema } from "effect"
+import { LLM, LLMClient } from "../../src/index.js"
+import { OpenResponses } from "../../src/protocols/open-responses.js"
+import { Meta } from "../../src/providers/index.js"
+import { configure } from "../../src/providers/openai-compatible-responses.js"
+import { it } from "../lib/effect.js"
+import { fixedResponse } from "../lib/http.js"
+import { sseEvents } from "../lib/sse.js"
+
+const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)
+
+it.effect("normalizes flat errors in shared SSE and WebSocket decoding", () =>
+  Effect.gen(function* () {
+    const frame = {
+      type: "error",
+      sequence_number: 4,
+      code: "server_shutting_down",
+      message: "Server is shutting down. Please retry your request.",
+      param: null,
+    }
+    for (const decode of [decodeEvent, OpenResponses.decodeChannelEvent]) {
+      const event = yield* decode(JSON.stringify(frame))
+      expect(event).toEqual({
+        type: "error",
+        sequence_number: 4,
+        error: { code: frame.code, message: frame.message, param: null },
+      })
+
+      for (const unchanged of [
+        event,
+        { type: "error" },
+        {
+          type: "response.failed",
+          response: { id: "resp_failed", error: { code: "server_error", message: "Internal server error" } },
+        },
+        { type: "response.output_text.delta", item_id: "msg_text", delta: "Hello" },
+      ]) {
+        expect(yield* decode(JSON.stringify(unchanged))).toEqual(unchanged)
+      }
+    }
+  }),
+)
+
+it.effect("continues to normalize untyped xAI WebSocket errors", () =>
+  Effect.gen(function* () {
+    const frame = { error: { type: "api_error", message: "gRPC error: Response with id=resp_missing not found" } }
+    expect(yield* OpenResponses.decodeChannelEvent(JSON.stringify(frame))).toEqual({ ...frame, type: "error" })
+  }),
+)
+
+it.effect("retains classification and original error bodies through Meta and generic Responses routes", () =>
+  Effect.gen(function* () {
+    const raw = `{
+  "type": "error",
+  "sequence_number": 4,
+  "code": "server_shutting_down",
+  "message": "Server is shutting down. Please retry your request.",
+  "param": null,
+  "diagnostic": "retain-original-frame"
+}`
+    for (const model of [
+      Meta.configure({ apiKey: "fixture" }).responses("muse-spark-1.3"),
+      configure({ apiKey: "fixture", provider: "gateway", baseURL: "https://responses.example.test/v1" }).model(
+        "example-model",
+      ),
+    ]) {
+      const error = yield* LLMClient.generate(LLM.request({ model, prompt: "Hello" })).pipe(
+        Effect.provide(fixedResponse(sseEvents(raw.replaceAll("\n", "\ndata: ")))),
+        Effect.flip,
+      )
+      expect(error.reason._tag).toBe("ProviderInternal")
+      expect(error.message).toBe("server_shutting_down: Server is shutting down. Please retry your request.")
+      expect(error.reason.body).toBe(raw)
+      expect(error.reason.http?.status).toBe(200)
+    }
+  }),
+)
@@ -90,7 +90,11 @@ const classifyingChannelDriver = (message: string): WebSocketChannelDriver => {
  }
 }

-const continuationDriver = (request: Readonly<Record<string, unknown>>, base = baseChannelDriver) => {
+const continuationDriver = (
+  request: Readonly<Record<string, unknown>>,
+  base = baseChannelDriver,
+  continuation?: OpenResponsesContinuation.Shape,
+) => {
  const message = ProviderShared.encodeJson(request)
  return OpenResponsesContinuation.driver({
    id: "openai-responses",
@@ -98,6 +102,7 @@ const continuationDriver = (request: Readonly<Record<string, unknown>>, base = b
    request,
    message,
    base: base(message),
+    continuation,
  })
 }

@@ -921,6 +926,58 @@ describe("OpenAI Responses route", () => {
        type: "provider-failure",
        error: { reason: { _tag: "InvalidRequest", classification: "context-overflow" } },
      })
+
+      // A retryable failure stays one: the runner retries it, and the transport has already dropped the
+      // checkpoint, so that retry is a full send. xAI reports every rejection this way.
+      const internal = ProviderShared.encodeJson({
+        type: "error",
+        error: { type: "api_error", message: "gRPC error: Response with id=resp_1 not found" },
+      })
+      expect(yield* second.observe(yield* second.create(saved), internal)).toMatchObject({
+        type: "provider-failure",
+        error: { reason: { _tag: "ProviderInternal" } },
+      })
+    }),
+  )
+
+  it.effect("shapes the incremental send with the route continuation", () =>
+    Effect.gen(function* () {
+      const firstRequest = {
+        type: "response.create",
+        model: "grok-4.6",
+        store: true,
+        instructions: "You are terse.",
+        input: [{ role: "user", content: [{ type: "input_text", text: "First" }] }],
+      }
+      const secondRequest = {
+        ...firstRequest,
+        input: [...firstRequest.input, { role: "user", content: [{ type: "input_text", text: "Second" }] }],
+      }
+      const saved = checkpoint(
+        yield* continuationDriver(firstRequest).observe(
+          yield* continuationDriver(firstRequest).create(undefined),
+          ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_1" } }),
+        ),
+      )
+
+      const trimmed = yield* continuationDriver(
+        secondRequest,
+        baseChannelDriver,
+        ({ instructions: _, ...rest }) => rest,
+      ).create(saved)
+      expect(trimmed.mode).toBe("incremental")
+      expect(JSON.parse(trimmed.message)).toEqual({
+        type: "response.create",
+        model: "grok-4.6",
+        store: true,
+        previous_response_id: "resp_1",
+        input: [{ role: "user", content: [{ type: "input_text", text: "Second" }] }],
+      })
+
+      // Declining the continuation sends the step in full and never sends a previous_response_id.
+      const declined = yield* continuationDriver(secondRequest, baseChannelDriver, () => undefined).create(saved)
+      expect(declined.mode).toBe("full")
+      expect(JSON.parse(declined.message)).toEqual(secondRequest)
    }),
  )

@@ -1,11 +1,18 @@
 import { describe, expect } from "bun:test"
-import { Effect } from "effect"
+import { Effect, Layer, Stream } from "effect"
 import { LLM, LLMEvent, Message } from "../../src/index.js"
 import { XAI } from "../../src/providers.js"
 import { OpenResponses } from "../../src/protocols/open-responses.js"
 import { OpenAIResponses } from "../../src/protocols/openai-responses.js"
+import * as ProviderShared from "../../src/protocols/shared.js"
 import { XAIResponses } from "../../src/protocols/xai-responses.js"
-import { LLMClient } from "../../src/route.js"
+import {
+  LLMClient,
+  RequestExecutor,
+  WebSocketTransport,
+  type ChannelCheckpoint,
+  type WebSocketChannelDriver,
+} from "../../src/route.js"
 import { compileRequest } from "../../src/route/client.js"
 import { it } from "../lib/effect.js"
 import { fixedResponse } from "../lib/http.js"
@@ -13,6 +20,35 @@ import { sseEvents } from "../lib/sse.js"

 const model = XAI.configure({ apiKey: "test", baseURL: "https://api.x.ai/v1" }).responses("grok-4.6")

+/** Runs a request through the WebSocket transport and hands back its channel driver; the HTTP fallback answers. */
+const channelDriver = (request: ReturnType<typeof LLM.request>) =>
+  Effect.gen(function* () {
+    let driver: WebSocketChannelDriver | undefined
+    yield* LLMClient.generate(request, {
+      webSocket: {
+        execute: (exchange) =>
+          Effect.sync(() => {
+            driver = exchange.driver
+            return { frames: exchange.fallback(), complete: Effect.void }
+          }),
+      },
+    }).pipe(Effect.provide(fixedResponse(sseEvents({ type: "response.completed", response: { id: "http" } }))))
+    if (!driver) throw new Error("Expected a WebSocket channel driver")
+    return driver
+  })
+
+const completed = (driver: WebSocketChannelDriver, id: string) =>
+  Effect.gen(function* () {
+    const create = yield* driver.create(undefined)
+    yield* driver.observe(create, ProviderShared.encodeJson({ type: "response.created", response: { id } }))
+    const observation = yield* driver.observe(
+      create,
+      ProviderShared.encodeJson({ type: "response.completed", response: { id } }),
+    )
+    if (observation.type !== "completed" || !observation.checkpoint) throw new Error("Expected a checkpoint")
+    return observation.checkpoint
+  })
+
 describe("xAI Responses route", () => {
  it.effect("composes the Open Responses baseline with xAI extensions", () =>
    Effect.gen(function* () {
@@ -162,6 +198,78 @@ describe("xAI Responses route", () => {
    }),
  )

+  it.effect("classifies xAI's untyped WebSocket error envelope", () =>
+    Effect.gen(function* () {
+      // xAI answers a rejected response.create with an error envelope that carries no event type.
+      const envelope = ProviderShared.encodeJson({
+        error: {
+          message:
+            'Request validation error: {"code":"400","error":"Argument not supported: instructions and previous_response_id together"}',
+          type: "api_error",
+        },
+      })
+      const webSocket = WebSocketTransport.makeDirect({
+        open: () =>
+          Effect.succeed({ sendText: () => Effect.void, messages: Stream.make(envelope), close: Effect.void }),
+      })
+      const error = yield* LLMClient.generate(LLM.request({ model, prompt: "Hello" }), { webSocket }).pipe(
+        Effect.provide(
+          LLMClient.layer.pipe(
+            Layer.provide(
+              Layer.succeed(
+                RequestExecutor.Service,
+                RequestExecutor.Service.of({ execute: () => Effect.die("unexpected HTTP request") }),
+              ),
+            ),
+          ),
+        ),
+        Effect.flip,
+      )
+
+      expect(error.reason._tag).toBe("ProviderInternal")
+      expect(error.message).toContain("Argument not supported: instructions and previous_response_id together")
+      expect(error.reason.body).toBe(envelope)
+    }),
+  )
+
+  it.effect("continues stored responses without instructions and sends unstored steps in full", () =>
+    Effect.gen(function* () {
+      const step = (store: boolean, ...prompts: string[]) =>
+        LLM.request({
+          model,
+          system: "You are terse.",
+          messages: prompts.map((prompt) => Message.user(prompt)),
+          providerOptions: { store },
+        })
+      const send = (store: boolean, checkpoint: ChannelCheckpoint) =>
+        channelDriver(step(store, "First", "Second")).pipe(Effect.flatMap((driver) => driver.create(checkpoint)))
+
+      const stored = yield* send(true, yield* completed(yield* channelDriver(step(true, "First")), "resp_1"))
+      expect(stored.mode).toBe("incremental")
+      expect(JSON.parse(stored.message)).toEqual({
+        type: "response.create",
+        model: "grok-4.6",
+        store: true,
+        include: ["reasoning.encrypted_content"],
+        previous_response_id: "resp_1",
+        input: [{ role: "user", content: [{ type: "input_text", text: "Second" }] }],
+      })
+
+      // The connection cache only serves stored responses, so the default store: false never chains.
+      const unstored = yield* send(false, yield* completed(yield* channelDriver(step(false, "First")), "resp_1"))
+      expect(unstored.mode).toBe("full")
+      expect(JSON.parse(unstored.message)).toMatchObject({
+        instructions: "You are terse.",
+        store: false,
+        input: [
+          { role: "user", content: [{ type: "input_text", text: "First" }] },
+          { role: "user", content: [{ type: "input_text", text: "Second" }] },
+        ],
+      })
+      expect(JSON.parse(unstored.message).previous_response_id).toBeUndefined()
+    }),
+  )
+
  it.effect("parses xAI hosted tool items", () =>
    Effect.gen(function* () {
      const item = { type: "x_search_call", id: "x_search_1", status: "completed", action: { query: "news" } }
@@ -19,11 +19,13 @@ story("cancelling a version mismatch permits reconnecting again", async ({ mount
  const component = await mount("app-dialog-ssh--incompatible-session")
  await component.getByRole("button", { name: "Reconnect", exact: true }).click()
  const dialog = page.getByRole("dialog")
-  await expect(dialog.getByRole("alert")).toBeVisible()
+  await expect(dialog.getByRole("status")).toContainText("Server update required")
+  await expect(dialog.getByRole("textbox")).toHaveCount(0)
  await dialog.getByRole("button", { name: "Cancel", exact: true }).click()
  await expect(dialog).toHaveCount(0)
  await component.getByRole("button", { name: "Reconnect", exact: true }).click()
-  await expect(dialog.getByRole("alert")).toBeVisible()
+  await expect(dialog.getByRole("status")).toContainText("Server update required")
+  await expect(dialog.getByRole("textbox")).toHaveCount(0)
  await dialog.getByRole("button", { name: "Cancel", exact: true }).click()
  await expect(dialog).toHaveCount(0)
 })
@@ -43,6 +45,17 @@ story("adding a server keeps all SSH challenges in the original connection dialo
  await expect(dialog).toHaveCount(0)
 })

+story("adding an incompatible server advances to a dedicated update step", async ({ mount, page }) => {
+  await mount("app-dialog-ssh--incompatible-host")
+  const dialog = page.getByRole("dialog")
+  await dialog.getByRole("textbox", { name: "Host or SSH command" }).fill("ssh devbox")
+  await dialog.getByRole("button", { name: "Add server", exact: true }).click()
+  await expect(dialog.getByRole("status")).toContainText("Server update required")
+  await expect(dialog.getByRole("textbox")).toHaveCount(0)
+  await expect(dialog.getByRole("alert")).toHaveCount(0)
+  await expect(dialog.getByRole("button", { name: "Update and reconnect", exact: true })).toBeVisible()
+})
+
 story("updating an incompatible connection continues authentication in the same dialog", async ({ mount, page }) => {
  const component = await mount("app-dialog-ssh--incompatible-session")
  await component.getByRole("button", { name: "Reconnect", exact: true }).click()
@@ -0,0 +1,74 @@
+import { expect, test } from "@playwright/test"
+import { sessionID, setupTimeline, userMessage } from "../performance/timeline-stability/fixture"
+
+test("keeps a submitted prompt in place while its optimistic rows are measured", async ({ page }) => {
+  await setupTimeline(page, { messages: [userMessage()], seedHistory: true })
+  const release = Promise.withResolvers<void>()
+  await page.route(`**/api/session/${sessionID}/prompt`, async (route) => {
+    if (route.request().method() !== "POST") return route.fallback()
+    await release.promise
+    return route.fallback()
+  })
+
+  const editor = page.locator('[data-component="composer"]').getByRole("textbox")
+  await expect(editor).toBeEditable()
+  await editor.fill("Observe optimistic prompt spacing.")
+  await expect
+    .poll(() =>
+      page.locator("[data-timeline-virtual-content]").evaluate((element) => {
+        const root = element.parentElement!
+        return root.scrollHeight - root.clientHeight - root.scrollTop
+      }),
+    )
+    .toBe(0)
+
+  const observation = await page.evaluateHandle(() => {
+    const frames: { prompt?: number; working: boolean }[] = []
+    let frame = 0
+    const sample = () => {
+      const prompt = [...document.querySelectorAll<HTMLElement>('[data-timeline-row="UserMessage"]')].find((row) =>
+        row.textContent?.includes("Observe optimistic prompt spacing."),
+      )
+      frames.push({
+        ...(prompt ? { prompt: prompt.getBoundingClientRect().y } : {}),
+        working: !!document.querySelector('[data-component="session-working"]'),
+      })
+      frame = requestAnimationFrame(sample)
+    }
+    frame = requestAnimationFrame(sample)
+    return {
+      stop: () => {
+        cancelAnimationFrame(frame)
+        return frames
+      },
+    }
+  })
+  const requested = page.waitForRequest(
+    (request) => request.method() === "POST" && new URL(request.url()).pathname === `/api/session/${sessionID}/prompt`,
+  )
+  try {
+    await editor.press("Enter")
+    await requested
+    const prompt = page
+      .locator('[data-timeline-row="UserMessage"]')
+      .filter({ hasText: "Observe optimistic prompt spacing." })
+    await expect(prompt).toBeInViewport()
+    await expect(page.locator('[data-component="session-working"]')).toBeVisible()
+    await expect
+      .poll(() =>
+        page.locator("[data-timeline-virtual-content]").evaluate((element) => {
+          const root = element.parentElement!
+          return root.scrollHeight - root.clientHeight - root.scrollTop
+        }),
+      )
+      .toBe(0)
+    const frames = await observation.evaluate((value) => value.stop())
+    expect(frames.some((frame) => frame.working && frame.prompt === undefined)).toBe(false)
+    const positions = frames.flatMap((frame) => (frame.prompt === undefined ? [] : [frame.prompt]))
+    expect(positions.length).toBeGreaterThan(0)
+    expect(new Set(positions).size).toBe(1)
+  } finally {
+    release.resolve()
+    await observation.dispose()
+  }
+})
@@ -122,7 +122,15 @@ test("renders compaction progress, summary, and outcome in order", async ({ page
  )
  await expect(compaction.getByRole("heading", { name: "Checkpoint" })).toBeVisible()
  await expect(compaction).toContainText("Streamed implementation details.")
-  await expect(compaction.getByRole("status").getByLabel("Compacting", { exact: true })).toBeVisible()
+  const running = compaction.getByRole("status").getByLabel("Compacting", { exact: true })
+  await expect(running).toBeVisible()
+  await expect
+    .poll(async () => {
+      const summary = await compaction.locator('[data-component="text-part"]').boundingBox()
+      const status = await running.boundingBox()
+      return !!summary && !!status && status.y >= summary.y + summary.height
+    })
+    .toBe(true)
  await expect(compaction.getByText("Session compacted", { exact: true })).toHaveCount(0)

  await timeline.send(
@@ -115,7 +115,7 @@ test("combines follow-up patches into one three-file stack inside Used", async (
  })
  const group = page.locator('[data-component="collapsed-tool-group"]')
  await group.getByRole("button", { name: "Used 2 Shell, Patch", exact: true }).click()
-  await expect(group.getByText("2 files", { exact: true })).toBeVisible()
+  await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["a.ts", "b.ts"])
  await timeline.send(
    partUpdated(
      toolPart(
@@ -134,7 +134,6 @@ test("combines follow-up patches into one three-file stack inside Used", async (
    "true",
  )
  await expect(group.locator('[data-component="apply-patch-tool"]')).toHaveCount(1)
-  await expect(group.getByText("3 files", { exact: true })).toBeVisible()
  await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["a.ts", "b.ts", "c.ts"])
 })

@@ -88,8 +88,12 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
      if (value.mode === "normal" && !command) {
        session.handoff?.set(handoffMessage(value))
        const optimisticBusy = !input.adapter.working()
-        if (optimisticBusy) session.data.session.setStatus(session.id, "running")
-        const sending = sendPrompt(session, value, input.adapter.controls().model.selection.trackSessionCommit).then(
+        if (optimisticBusy && input.adapter.kind === "new-session")
+          session.data.session.setStatus(session.id, "running")
+        const sending = sendPrompt(session, value, input.adapter.controls().model.selection.trackSessionCommit, () => {
+          if (optimisticBusy && input.adapter.kind === "active-session")
+            session.data.session.setStatus(session.id, "running")
+        }).then(
          () => ({ ok: true as const }),
          (error) => ({ ok: false as const, error }),
        )
@@ -122,15 +126,9 @@ export function createComposerSubmit(input: ComposerSubmitInput) {

      if (command) {
        clearSubmission(input, submission)
-        // Commands always steer: the server applies a command's configured
-        // agent and model immediately at admission, so queueing one would
-        // reconfigure the turn it is supposed to wait behind.
-        void sendCommand(
-          session,
-          { ...value, delivery: "steer" },
-          command,
-          input.adapter.controls().model.selection.trackSessionCommit,
-        ).catch((error) => failSubmission(input, session, "command", error, restore, value.id))
+        void sendCommand(session, value, command, input.adapter.controls().model.selection.trackSessionCommit).catch(
+          (error) => failSubmission(input, session, "command", error, restore, value.id),
+        )
        return
      }
    } finally {
@@ -322,7 +320,8 @@ async function sendCommand(
  track?: ModelSelection["trackSessionCommit"],
 ) {
  const request = await buildSubmissionRequest(session, value)
-  await applySelection(session, value.selection, track)
+  // Like queued prompts, queued commands must not apply the composer's selection to active work.
+  if (value.delivery === "steer") await applySelection(session, value.selection, track)
  await session.api.command({
    sessionID: session.id,
    command: command.command,
@@ -359,7 +358,8 @@ async function applySelection(
 async function sendPrompt(
  session: ComposerSession,
  value: ComposerSubmission,
-  track?: ModelSelection["trackSessionCommit"],
+  track: ModelSelection["trackSessionCommit"] | undefined,
+  onAdmit: () => void,
 ) {
  const request = await buildSubmissionRequest(session, value)
  // Switching agent or model reconfigures the session immediately, and with it
@@ -389,7 +389,9 @@ async function sendPrompt(
      },
    },
  }
-  await session.data.session.prompt(admission).catch(() => session.data.session.prompt(admission))
+  const sending = session.data.session.prompt(admission).catch(() => session.data.session.prompt(admission))
+  onAdmit()
+  await sending
 }

 async function buildSubmissionRequest(session: ComposerSession, value: ComposerSubmission) {
@@ -54,8 +54,12 @@ export function createWebPlatform(version: string) {

 function getCurrentServerUrl() {
  if (import.meta.env.VITE_OPENCODE_SERVER_MODE === "none") return undefined
-  if (import.meta.env.DEV)
-    return `http://${import.meta.env.VITE_OPENCODE_SERVER_HOST ?? "localhost"}:${import.meta.env.VITE_OPENCODE_SERVER_PORT ?? "4096"}`
+  if (import.meta.env.DEV) {
+    const loopback =
+      location.hostname === "localhost" || location.hostname === "[::1]" || location.hostname.startsWith("127.")
+    const host = import.meta.env.VITE_OPENCODE_SERVER_HOST ?? (loopback ? location.hostname : "localhost")
+    return `http://${host}:${import.meta.env.VITE_OPENCODE_SERVER_PORT ?? "4096"}`
+  }
  return location.origin
 }

@@ -10,6 +10,7 @@ import { createData } from "@opencode/client/solid"
 import type { ServerScope } from "@/runtime/server/scope"
 import { createPermissionAutoApprover } from "@/session/requests/auto-approve"
 import { createServerNotificationState } from "@/shell/notifications/notification"
+import { createNotificationCoordinator } from "@/shell/notifications/coordinator"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import { createDesktopData } from "./data"
 import { ModelState } from "./persistence"
@@ -33,6 +34,7 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
      },
    })
    const models = createGlobalModels()
+    const notificationCoordinator = createNotificationCoordinator()

    const settingsServer = createMemo(() => {
      const list = server.list
@@ -57,7 +59,7 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
      if (existing) return existing
      const serverCtx = createRoot((dispose) => {
        serverCtxDisposers.set(key, dispose)
-        return createServerController(conn, server.scope(key), server.projects.forServer(key))
+        return createServerController(conn, server.scope(key), server.projects.forServer(key), notificationCoordinator)
      }, owner)
      serverCtxs.set(key, serverCtx)
      return serverCtx
@@ -131,6 +133,7 @@ function createServerController(
  conn: ServerConnection.Any,
  scope: ServerScope,
  projects: ReturnType<typeof createServerProjects>,
+  notificationCoordinator: ReturnType<typeof createNotificationCoordinator>,
 ) {
  const language = useLanguage()
  const settings = useSettings()
@@ -159,7 +162,7 @@ function createServerController(
  })
  const sync = createServerSyncContext(sdk, data)
  createPermissionAutoApprover({ sdk, data })
-  const notification = createServerNotificationState({ sdk, data, key: connKey })
+  const notification = createServerNotificationState({ sdk, data, key: connKey, coordinator: notificationCoordinator })

  function enrich(project: { worktree: string; expanded: boolean }) {
    const [childStore] = sync.child(project.worktree, { bootstrap: false })
@@ -278,6 +278,7 @@ function Open(props: { initial?: string }) {
 export default { title: "App/Dialogs/SSH", id: "app-dialog-ssh" }
 export const AuthenticationRequired = { render: () => <Fixture initial="required" /> }
 export const SettingsReconnect = { render: () => <Fixture initial="required" settings connectionDelay={200} /> }
+export const IncompatibleHost = { render: () => <Fixture incompatible /> }
 export const IncompatibleSession = { render: () => <Fixture initial="required" session incompatible /> }
 export const InactiveSession = { render: () => <Fixture initial="required" session connectionDelay={3000} /> }
 export const KeyReconnect = { render: () => <Fixture initial="required" session keyOnly connectionDelay={3000} /> }
@@ -120,7 +120,13 @@ export function DialogSsh(props: {
      <Divider />
      <DialogBody class="flex w-full min-w-0 flex-1 flex-col px-4 pt-4 pb-2">
        <div class="flex w-full min-w-0 flex-col gap-6">
-          <Show when={!props.promptOnly && (!state.prompted || (!!error() && !prompt()))}>
+          <Show
+            when={
+              !props.promptOnly &&
+              item()?.stage !== "incompatible" &&
+              (!state.prompted || (!!error() && !prompt()))
+            }
+          >
            <div class="flex w-full min-w-0 flex-col gap-2">
              <label class="settings-server-dialog-label" for="ssh-target">
                {language.t("ssh.target")}
@@ -160,6 +166,12 @@ export function DialogSsh(props: {
              />
            </div>
          </Show>
+          <Show when={item()?.stage === "incompatible"}>
+            <div class="flex w-full min-w-0 flex-col gap-2" role="status" aria-live="polite">
+              <span class="text-14-medium text-v2-text-text-base">{language.t("ssh.stage.incompatible")}</span>
+              <span class="text-13-regular text-v2-text-text-muted">{language.t("ssh.error.version")}</span>
+            </div>
+          </Show>
          <Show when={prompt()} keyed>
            {(prompt) => (
              <div class="flex w-full min-w-0 flex-col gap-2">
@@ -195,7 +207,7 @@ export function DialogSsh(props: {
              </div>
            )}
          </Show>
-          <Show when={error()}>
+          <Show when={item()?.stage !== "incompatible" && error()}>
            {(error) => (
              <span class="settings-server-dialog-error !leading-[var(--line-height-compact)]" role="alert">
                {error()}
@@ -1,6 +1,6 @@
 import { createMemo, createUniqueId, Show } from "solid-js"
 import { createStore } from "solid-js/store"
-import { createQuery } from "@tanstack/solid-query"
+import { createQuery, keepPreviousData } from "@tanstack/solid-query"
 import { Icon } from "@opencode/ui/icon"
 import { SessionFilePanelV2, SessionFilePanelV2Empty } from "@opencode/session-ui/v2/session-file-panel-v2"
 import { SessionReviewV2Sidebar } from "@opencode/session-ui/v2/session-review-v2"
@@ -56,6 +56,7 @@ export function SessionFileBrowserTab(props: {
      queryKey: [serverSDK.scope, "session-open-file", workspaceKey(), value] as const,
      enabled: serverSDK.connection.status() === "connected" && value.length > 0,
      queryFn: ({ signal }) => file.searchFiles(value, { limit: 200, signal }),
+      placeholderData: keepPreviousData,
    }
  })
  const files = createMemo(() => {
@@ -515,6 +515,19 @@ export function createTimelineVirtualizer(input: Input) {
          <div
            ref={(value) => {
              element = value
+              if (row()._tag !== "UserMessage" || !addedKeys.has(rowProps.rowKey) || !input.pinned() || coldPending)
+                return
+              // The optimistic row can paint before ResizeObserver corrects the tail estimates.
+              // Measure the mounted tail and pin it in this render's microtask instead.
+              queueMicrotask(() => {
+                if (!input.pinned() || !virtualContent?.isConnected) return
+                virtualizer.elementsCache.forEach((item) => {
+                  if (item.isConnected) virtualizer.resizeItem(virtualizer.indexFromElement(item), item.offsetHeight)
+                })
+                virtualizer.resizeItem(item().index, element.offsetHeight)
+                virtualContent.style.height = `${virtualizer.getTotalSize()}px`
+                virtualizer.scrollToEnd()
+              })
            }}
            data-index={item().index}
            style={{ "min-height": ready() ? undefined : `${initialItem.size}px` }}
@@ -0,0 +1,93 @@
+import { onCleanup } from "solid-js"
+
+const FOCUS_LOCK = "opencode:notification-focus"
+const MAX_CLAIMED = 500
+
+export function createNotificationCoordinator() {
+  const locks = typeof navigator === "undefined" ? undefined : navigator.locks
+  const claimed = new Set<string>()
+  const focus = { pending: false, release: undefined as (() => void) | undefined }
+
+  const updateFocus = () => {
+    if (typeof document === "undefined" || !document.hasFocus()) {
+      focus.release?.()
+      return
+    }
+    if (!locks || focus.pending || focus.release) return
+
+    focus.pending = true
+    void locks
+      .request(FOCUS_LOCK, { mode: "shared" }, async () => {
+        focus.pending = false
+        if (!document.hasFocus()) return
+        await new Promise<void>((resolve) => {
+          focus.release = resolve
+        })
+        focus.release = undefined
+      })
+      .catch(() => {
+        focus.pending = false
+      })
+  }
+
+  if (typeof window !== "undefined") {
+    window.addEventListener("focus", updateFocus)
+    window.addEventListener("blur", updateFocus)
+    document.addEventListener("visibilitychange", updateFocus)
+    updateFocus()
+    onCleanup(() => {
+      window.removeEventListener("focus", updateFocus)
+      window.removeEventListener("blur", updateFocus)
+      document.removeEventListener("visibilitychange", updateFocus)
+      focus.release?.()
+    })
+  }
+
+  const once = async (kind: "sound" | "system", eventID: string, run: () => Promise<unknown> | void) => {
+    const key = `${kind}:${eventID}`
+    const execute = async () => {
+      if (!claim(kind, key, claimed)) return
+      await run()
+    }
+    if (!locks) return execute()
+    await locks.request(`opencode:notification:${key}`, execute)
+  }
+
+  return {
+    sound(eventID: string, run: () => Promise<unknown> | void) {
+      return once("sound", eventID, run)
+    },
+    system(eventID: string, run: () => Promise<unknown> | void) {
+      return once("system", eventID, async () => {
+        if (typeof document !== "undefined" && document.hasFocus()) return
+        if (!locks) return run()
+        await locks.request(FOCUS_LOCK, { mode: "exclusive", ifAvailable: true }, async (lock) => {
+          if (!lock) return
+          await run()
+        })
+      })
+    },
+  }
+}
+
+function claim(kind: "sound" | "system", eventID: string, claimed: Set<string>) {
+  if (claimed.has(eventID)) return false
+
+  if (typeof localStorage !== "undefined") {
+    try {
+      const storageKey = `opencode:notification-${kind}`
+      const value: unknown = JSON.parse(localStorage.getItem(storageKey) ?? "[]")
+      const events = Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
+      if (events.includes(eventID)) {
+        claimed.add(eventID)
+        return false
+      }
+      localStorage.setItem(storageKey, JSON.stringify([...events, eventID].slice(-MAX_CLAIMED)))
+    } catch {
+      // The in-memory claim still prevents duplicates in this renderer when storage is unavailable.
+    }
+  }
+
+  claimed.add(eventID)
+  return true
+}
@@ -11,7 +11,8 @@ import { useSettings } from "@/settings/model"
 import { decode64 } from "@/runtime/persistence/base64"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import { Persistence } from "@/runtime/persistence/schema"
-import { playSoundByIdOnce } from "@/shell/notifications/sound"
+import { playSoundById } from "@/shell/notifications/sound"
+import type { createNotificationCoordinator } from "@/shell/notifications/coordinator"
 import { useGlobal } from "@/runtime/server/runtime"
 import { ServerConnection, useServers } from "@/runtime/server/registry"
 import { sessionIDHasOpenTab, useTabs } from "@/shell/tabs/tabs"
@@ -114,7 +115,12 @@ function buildNotificationIndex(list: Notification[]) {
  return index
 }

-export function createServerNotificationState(input: { sdk: ServerSDK; data: Data; key: ServerConnection.Key }) {
+export function createServerNotificationState(input: {
+  sdk: ServerSDK
+  data: Data
+  key: ServerConnection.Key
+  coordinator: ReturnType<typeof createNotificationCoordinator>
+}) {
  const platform = usePlatform()
  const settings = useSettings()
  const language = useLanguage()
@@ -223,7 +229,7 @@ export function createServerNotificationState(input: { sdk: ServerSDK; data: Dat
      if (session.parentID) return

      if (sessionIDHasOpenTab(tabs.store, input.key, sessionID) && settings.sounds.agentEnabled()) {
-        void playSoundByIdOnce(settings.sounds.agent(), `${input.key}\0${eventID}`)
+        void input.coordinator.sound(`${input.key}\0${eventID}`, () => playSoundById(settings.sounds.agent()))
      }

      append({
@@ -235,8 +241,10 @@ export function createServerNotificationState(input: { sdk: ServerSDK; data: Dat
      })

      if (settings.notifications.agent()) {
-        void platform.notify(language.t("notification.session.responseReady.title"), session.title ?? sessionID, () =>
-          openNotificationSession(tabs, input.key, sessionID),
+        void input.coordinator.system(`${input.key}\0${eventID}`, () =>
+          platform.notify(language.t("notification.session.responseReady.title"), session.title ?? sessionID, () =>
+            openNotificationSession(tabs, input.key, sessionID),
+          ),
        )
      }
    })
@@ -248,7 +256,7 @@ export function createServerNotificationState(input: { sdk: ServerSDK; data: Dat
      if (session?.parentID) return

      if (sessionIDHasOpenTab(tabs.store, input.key, sessionID) && settings.sounds.errorsEnabled()) {
-        void playSoundByIdOnce(settings.sounds.errors(), `${input.key}\0${eventID}`)
+        void input.coordinator.sound(`${input.key}\0${eventID}`, () => playSoundById(settings.sounds.errors()))
      }

      append({
@@ -263,8 +271,10 @@ export function createServerNotificationState(input: { sdk: ServerSDK; data: Dat
        session?.title ??
        (typeof error === "string" ? error : language.t("notification.session.error.fallbackDescription"))
      if (settings.notifications.errors()) {
-        void platform.notify(language.t("notification.session.error.title"), description, () =>
-          openNotificationSession(tabs, input.key, sessionID),
+        void input.coordinator.system(`${input.key}\0${eventID}`, () =>
+          platform.notify(language.t("notification.session.error.title"), description, () =>
+            openNotificationSession(tabs, input.key, sessionID),
+          ),
        )
      }
    })
@@ -74,9 +74,6 @@ function getLoads() {
 }

 const cache = new Map<SoundID, Promise<string | undefined>>()
-const claimed = new Set<string>()
-const CLAIMED_STORAGE_KEY = "opencode:notification-sounds"
-const MAX_CLAIMED = 500

 export function soundSrc(id: string | undefined) {
  const loads = getLoads()
@@ -103,34 +100,3 @@ export function playSound(src: string | undefined) {
 export function playSoundById(id: string | undefined) {
  return soundSrc(id).then((src) => playSound(src))
 }
-
-export async function playSoundByIdOnce(id: string | undefined, eventID: string) {
-  const play = async () => {
-    if (!claim(eventID)) return
-    await playSoundById(id)
-  }
-
-  if (typeof navigator === "undefined" || !navigator.locks) return play()
-  await navigator.locks.request(`${CLAIMED_STORAGE_KEY}:${eventID}`, play)
-}
-
-function claim(eventID: string) {
-  if (claimed.has(eventID)) return false
-
-  if (typeof localStorage !== "undefined") {
-    try {
-      const value: unknown = JSON.parse(localStorage.getItem(CLAIMED_STORAGE_KEY) ?? "[]")
-      const events = Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
-      if (events.includes(eventID)) {
-        claimed.add(eventID)
-        return false
-      }
-      localStorage.setItem(CLAIMED_STORAGE_KEY, JSON.stringify([...events, eventID].slice(-MAX_CLAIMED)))
-    } catch {
-      // The in-memory claim still prevents duplicates in this renderer when storage is unavailable.
-    }
-  }
-
-  claimed.add(eventID)
-  return true
-}
@@ -76,7 +76,10 @@ export function buildEffortSelectOption(input: {
    category: "thought_level",
    type: "select",
    currentValue: selectVariant(input.currentVariant, input.variants),
-    options: input.variants.map((variant) => ({ value: variant, name: formatVariantName(variant) })),
+    options: [...new Set([...input.variants, DEFAULT_VARIANT_VALUE])].map((variant) => ({
+      value: variant,
+      name: formatVariantName(variant),
+    })),
  }
 }

@@ -125,6 +128,7 @@ export function formatVariantName(variant: string) {
 }

 function selectVariant(variant: string | undefined, variants: readonly string[]) {
+  if (!variant || variant === DEFAULT_VARIANT_VALUE) return DEFAULT_VARIANT_VALUE
  if (variant && variants.includes(variant)) return variant
  if (variants.includes(DEFAULT_VARIANT_VALUE)) return DEFAULT_VARIANT_VALUE
  return variants[0] ?? DEFAULT_VARIANT_VALUE
@@ -201,7 +201,7 @@ export async function streamTurn(input: {
        if (!child) assistantMessageID = event.data.assistantMessageID
        await send({
          sessionUpdate: "agent_thought_chunk",
-          messageId: event.data.assistantMessageID,
+          messageId: `${event.data.assistantMessageID}:reasoning:${event.data.ordinal}`,
          content: { type: "text", text: event.data.delta },
        })
        continue
@@ -455,6 +455,8 @@ async function replayMessage(
    return
  }
  if (message.type !== "assistant") return
+  // Live reasoning ordinals count only reasoning parts, not the mixed content array.
+  let reasoningOrdinal = 0
  for (const part of message.content) {
    if (part.type === "text") {
      await connection.sessionUpdate({
@@ -472,7 +474,7 @@ async function replayMessage(
        sessionId: sessionID,
        update: {
          sessionUpdate: "agent_thought_chunk",
-          messageId: message.id,
+          messageId: `${message.id}:reasoning:${reasoningOrdinal++}`,
          content: { type: "text", text: part.text },
        },
      })
@@ -41,7 +41,12 @@ import type {
 } from "@agentclientprotocol/sdk"
 import { OPENCODE_VERSION } from "../version"
 import { SessionMessage } from "@opencode/schema/session-message"
-import { buildConfigOptions, parseModelSelection, type ConfigOptionProvider } from "./config-option"
+import {
+  buildConfigOptions,
+  DEFAULT_VARIANT_VALUE,
+  parseModelSelection,
+  type ConfigOptionProvider,
+} from "./config-option"
 import { promptContentToParts } from "./content"
 import {
  ChildSessionUpdateMethod,
@@ -275,7 +280,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
      if (typeof params.value !== "string") throw new ACPError.InvalidConfigOptionError({ configId: params.configId })
      switch (params.configId) {
        case "model": {
-          const selected = requireModel(state.catalog, params.value)
+          const selected = requireModel(state.catalog, params.value, state.model)
          state.model = selected
          await input.client.session.switchModel({ sessionID: state.id, model: selected })
          break
@@ -284,7 +289,10 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
          const model = state.catalog.models.find(
            (item) => item.providerID === state.model.providerID && item.id === state.model.id,
          )
-          if (!model?.variants.some((variant) => variant.id === params.value))
+          if (
+            !model ||
+            (params.value !== DEFAULT_VARIANT_VALUE && !model.variants.some((variant) => variant.id === params.value))
+          )
            throw new ACPError.InvalidEffortError({ effort: params.value })
          state.model = { ...state.model, variant: params.value }
          await input.client.session.switchModel({ sessionID: state.id, model: state.model })
@@ -453,7 +461,7 @@ function providers(models: readonly ModelInfo[]): ConfigOptionProvider[] {
    }))
 }

-function requireModel(catalog: Catalog, modelID: string): ModelRef {
+function requireModel(catalog: Catalog, modelID: string, current: ModelRef): ModelRef {
  const selected = parseModelSelection(modelID, catalog.providers)
  const model = catalog.models.find(
    (item) => item.providerID === selected.model.providerID && item.id === selected.model.modelID,
@@ -461,7 +469,14 @@ function requireModel(catalog: Catalog, modelID: string): ModelRef {
  if (!model) throw new ACPError.InvalidModelError({ providerId: selected.model.providerID, modelId: modelID })
  if (selected.variant && !model.variants.some((variant) => variant.id === selected.variant))
    throw new ACPError.InvalidEffortError({ effort: selected.variant })
-  return { providerID: model.providerID, id: model.id, variant: selected.variant }
+  const variant =
+    selected.variant ??
+    (current.providerID === model.providerID &&
+    current.id === model.id &&
+    (current.variant === DEFAULT_VARIANT_VALUE || model.variants.some((variant) => variant.id === current.variant))
+      ? current.variant
+      : undefined)
+  return { providerID: model.providerID, id: model.id, variant }
 }

 async function selectMode(client: OpenCodeClient, state: Attached, modeID: string) {
@@ -47,7 +47,7 @@ const handler = Effect.fn("cli.session.list")(function* (
          null,
          2,
        )
-      : formatTable(page.data)) + EOL
+      : formatList(page.data)) + EOL
  const write = Effect.tryPromise(
    () =>
      new Promise<void>((resolve, reject) => {
@@ -96,18 +96,14 @@ export default Runtime.handler(Commands.commands.session.commands.list, (input)
  ),
 )

-function formatTable(sessions: ReadonlyArray<SessionInfo>) {
-  const rows = sessions.map((session) => ({
-    id: session.id,
-    title: (session.title ?? "Untitled session").replace(/[\r\n\t]/g, " "),
-    updated: new Date(session.time.updated).toLocaleString(),
-  }))
-  const idWidth = Math.max(20, ...rows.map((row) => row.id.length))
-  const titleWidth = Math.max(25, ...rows.map((row) => row.title.length))
-  const header = `${"Session ID".padEnd(idWidth)}  ${"Title".padEnd(titleWidth)}  Updated`
-  return [
-    header,
-    "─".repeat(header.length),
-    ...rows.map((row) => `${row.id.padEnd(idWidth)}  ${row.title.padEnd(titleWidth)}  ${row.updated}`),
-  ].join(EOL)
+function formatList(sessions: ReadonlyArray<SessionInfo>) {
+  return sessions
+    .map((session) =>
+      [
+        session.id,
+        (session.title ?? "Untitled session").replace(/[\r\n\t]/g, " "),
+        new Date(session.time.updated).toLocaleString(),
+      ].join("\t"),
+    )
+    .join(EOL)
 }
@@ -50,11 +50,11 @@ describe("acp config option subprocess", () => {
    const effort = requireSelectOption((await newSession(acp, fixture.home)).configOptions, "effort")

    expect(effort.category).toBe("thought_level")
-    expect(effort.currentValue).toBe("low")
-    expect(flattenSelectOptions(effort).map((option) => option.value)).toEqual(["low", "high"])
+    expect(effort.currentValue).toBe("default")
+    expect(flattenSelectOptions(effort).map((option) => option.value)).toEqual(["low", "high", "default"])
  }, 60_000)

-  test("effort switch updates currentValue", async () => {
+  test("effort survives model synchronization and can be reset to default", async () => {
    await using fixture = await createAcpFixture()
    const acp = fixture.spawn()
    await initialize(acp)
@@ -70,5 +70,23 @@ describe("acp config option subprocess", () => {
    )

    expect(selectConfigOption(updated.configOptions, "effort")?.currentValue).toBe(nextEffort)
+
+    const synchronized = expectOk(
+      await acp.request<SetSessionConfigOptionResponse>("session/set_config_option", {
+        sessionId: session.sessionId,
+        configId: "model",
+        value: requireSelectOption(session.configOptions, "model").currentValue,
+      }),
+    )
+    expect(selectConfigOption(synchronized.configOptions, "effort")?.currentValue).toBe(nextEffort)
+
+    const reset = expectOk(
+      await acp.request<SetSessionConfigOptionResponse>("session/set_config_option", {
+        sessionId: session.sessionId,
+        configId: "effort",
+        value: "default",
+      }),
+    )
+    expect(selectConfigOption(reset.configOptions, "effort")?.currentValue).toBe("default")
  }, 60_000)
 })
@@ -91,7 +91,7 @@ describe("acp event behavior", () => {
    }
  })

-  test("preserves text and reasoning order before returning the terminal response", async () => {
+  test("preserves reasoning boundaries and update order during streaming and replay", async () => {
    const firstUpdate = Promise.withResolvers<void>()
    const releaseUpdate = Promise.withResolvers<void>()
    const allUpdates = Promise.withResolvers<void>()
@@ -108,6 +108,14 @@ describe("acp event behavior", () => {
            delta: "think-1",
          }),
        )
+        send(
+          ephemeralEvent("session.reasoning.delta", {
+            sessionID: "ses_order",
+            assistantMessageID: "msg_order",
+            ordinal: 0,
+            delta: " continued",
+          }),
+        )
        send(
          ephemeralEvent("session.text.delta", {
            sessionID: "ses_order",
@@ -120,7 +128,7 @@ describe("acp event behavior", () => {
          ephemeralEvent("session.reasoning.delta", {
            sessionID: "ses_order",
            assistantMessageID: "msg_order",
-            ordinal: 2,
+            ordinal: 1,
            delta: "think-2",
          }),
        )
@@ -144,7 +152,7 @@ describe("acp event behavior", () => {
          firstUpdate.resolve()
          await releaseUpdate.promise
        }
-        if (updates.length === 3) allUpdates.resolve()
+        if (updates.length === 4) allUpdates.resolve()
      },
      requestPermission: async () => ({ outcome: { outcome: "cancelled" } }),
    } satisfies Connection
@@ -171,18 +179,48 @@ describe("acp event behavior", () => {
          ) {
            return [
              item.update.sessionUpdate,
+              item.update.messageId,
              item.update.content.type === "text" ? item.update.content.text : undefined,
            ]
          }
          return [item.update.sessionUpdate, undefined]
        }),
      ).toEqual([
-        ["agent_thought_chunk", "think-1"],
-        ["agent_message_chunk", "answer"],
-        ["agent_thought_chunk", "think-2"],
+        ["agent_thought_chunk", "msg_order:reasoning:0", "think-1"],
+        ["agent_thought_chunk", "msg_order:reasoning:0", " continued"],
+        ["agent_message_chunk", "msg_order", "answer"],
+        ["agent_thought_chunk", "msg_order:reasoning:1", "think-2"],
      ])
      expect(fixture.requests.at(-1)?.path).toBe("/api/session/ses_order/message/msg_order")
      expect(response).toMatchObject({ stopReason: "end_turn", usage: { totalTokens: 2 } })
+
+      const replayed: SessionUpdateParams[] = []
+      await replayMessages(recordingConnection(replayed), "ses_order", "/workspace", [
+        {
+          id: "msg_order",
+          type: "assistant",
+          agent: "build",
+          model: { providerID: "test", id: "test-model" },
+          time: { created: 1 },
+          content: [
+            { type: "reasoning", text: "think-1 continued" },
+            { type: "text", text: "answer" },
+            { type: "reasoning", text: "think-2" },
+          ],
+        },
+      ])
+      expect(replayed).toEqual([
+        {
+          sessionId: "ses_order",
+          update: {
+            sessionUpdate: "agent_thought_chunk",
+            messageId: "msg_order:reasoning:0",
+            content: { type: "text", text: "think-1 continued" },
+          },
+        },
+        updates[2],
+        updates[3],
+      ])
    } finally {
      releaseUpdate.resolve()
      releaseSubmit.resolve()
@@ -222,7 +222,7 @@ describe("acp service directory behavior", () => {
    await fixture.service.setSessionMode({ sessionId: session.sessionId, modeId: "build" })

    expect(currentValue(selectedModel, "model")).toBe("test/second-model")
-    expect(currentValue(selectedModel, "effort")).toBe("low")
+    expect(currentValue(selectedModel, "effort")).toBe("default")
    expect(currentValue(selectedEffort, "effort")).toBe("medium")
    expect(currentValue(selectedMode, "mode")).toBe("plan")
    expect(
@@ -32,7 +32,7 @@ describe("acp service lifecycle", () => {
        model: { providerID: "test", id: "second-model" },
      },
    })
-    expect(currentValue(created, "effort")).toBe("none")
+    expect(currentValue(created, "effort")).toBe("default")
  })

  test("loads and forks with paginated replay while resume does not replay", async () => {
@@ -11,6 +11,7 @@ import type { RelativePath } from "@opencode/schema/schema"
 import type { Brand } from "effect"
 import type { Model } from "@opencode/schema/model"
 import type { DateTime } from "effect"
+import type { Permission } from "@opencode/schema/permission"
 import type { SessionMessage } from "@opencode/schema/session-message"
 import type { SessionInbox } from "@opencode/schema/session-inbox"
 import type { PromptInput } from "@opencode/schema/prompt-input"
@@ -26,7 +27,6 @@ import type { Integration } from "@opencode/schema/integration"
 import type { Form } from "@opencode/schema/form"
 import type { Mcp } from "@opencode/schema/mcp"
 import type { Credential } from "@opencode/schema/credential"
-import type { Permission } from "@opencode/schema/permission"
 import type { PermissionSaved } from "@opencode/schema/permission-saved"
 import type { FileSystem } from "@opencode/schema/filesystem"
 import type { Command } from "@opencode/schema/command"
@@ -209,6 +209,7 @@ export type SessionCreateInput = {
  readonly model?: Model.Ref | undefined
  readonly location?: Location.Ref | undefined
  readonly metadata?: Session.Metadata | undefined
+  readonly permissions?: Permission.Ruleset | undefined
 }
 export type SessionCreateOutput = Session.Info
 export type SessionCreateOperation<E = never> = (input?: SessionCreateInput) => Effect.Effect<SessionCreateOutput, E>
@@ -437,6 +438,7 @@ export type SessionLogOutput =
            readonly agent?: Agent.ID | undefined
            readonly model?: Model.Ref | undefined
            readonly metadata?: Session.Metadata | undefined
+            readonly permissions?: Permission.Ruleset | undefined
            readonly version: string
          }
        }
@@ -489,6 +491,15 @@ export type SessionLogOutput =
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID; readonly title: string }
        }
+      | {
+          readonly id: Event.ID
+          readonly created: number
+          readonly metadata?: { readonly [x: string]: unknown } | undefined
+          readonly type: "session.permissions.updated"
+          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
+          readonly location?: Location.Ref | undefined
+          readonly data: { readonly sessionID: Session.ID; readonly permissions: Permission.Ruleset }
+        }
      | {
          readonly id: Event.ID
          readonly created: number
@@ -1585,6 +1596,12 @@ export type PermissionReplyOperation<E = never> = (
  input: PermissionReplyInput,
 ) => Effect.Effect<PermissionReplyOutput, E>

+export type PermissionRulesInput = { readonly sessionID: Session.ID; readonly permissions: Permission.Ruleset }
+export type PermissionRulesOutput = void
+export type PermissionRulesOperation<E = never> = (
+  input: PermissionRulesInput,
+) => Effect.Effect<PermissionRulesOutput, E>
+
 export interface PermissionApi<E = never> {
  readonly request: { readonly list: PermissionRequestListOperation<E> }
  readonly saved: { readonly list: PermissionSavedListOperation<E>; readonly remove: PermissionSavedRemoveOperation<E> }
@@ -1592,6 +1609,7 @@ export interface PermissionApi<E = never> {
  readonly list: PermissionListOperation<E>
  readonly get: PermissionGetOperation<E>
  readonly reply: PermissionReplyOperation<E>
+  readonly rules: PermissionRulesOperation<E>
 }

 export type FileListInput = {
@@ -181,6 +181,8 @@ import type {
  PermissionGetOutput,
  PermissionReplyInput,
  PermissionReplyOutput,
+  PermissionRulesInput,
+  PermissionRulesOutput,
  FileListInput,
  FileListOutput,
  FileFindInput,
@@ -395,6 +397,7 @@ const EndpointSessionCreate = (raw: RawClient["server.session"]) => (input?: Ses
        model: input?.["model"],
        location: input?.["location"],
        metadata: input?.["metadata"],
+        permissions: input?.["permissions"],
      },
    }).pipe(
      Effect.mapError(mapClientError),
@@ -1145,6 +1148,14 @@ const EndpointPermissionReply = (raw: RawClient["server.permission"]) => (input:
    }).pipe(Effect.mapError(mapClientError)),
  )

+const EndpointPermissionRules = (raw: RawClient["server.permission"]) => (input: PermissionRulesInput) =>
+  preserveEffect<PermissionRulesOutput>()(
+    raw["session.permission.rules"]({
+      params: { sessionID: input["sessionID"] },
+      payload: { permissions: input["permissions"] },
+    }).pipe(Effect.mapError(mapClientError)),
+  )
+
 const adaptGroupPermission = (raw: RawClient["server.permission"]) => ({
  request: { list: EndpointPermissionRequestList(raw) },
  saved: { list: EndpointPermissionSavedList(raw), remove: EndpointPermissionSavedRemove(raw) },
@@ -1152,6 +1163,7 @@ const adaptGroupPermission = (raw: RawClient["server.permission"]) => ({
  list: EndpointPermissionList(raw),
  get: EndpointPermissionGet(raw),
  reply: EndpointPermissionReply(raw),
+  rules: EndpointPermissionRules(raw),
 })

 const EndpointFileList = (raw: RawClient["server.fs"]) => (input?: FileListInput) =>
@@ -175,6 +175,8 @@ import type {
  PermissionGetOutput,
  PermissionReplyInput,
  PermissionReplyOutput,
+  PermissionRulesInput,
+  PermissionRulesOutput,
  FileReadInput,
  FileReadOutput,
  FileListInput,
@@ -565,6 +567,7 @@ export function make(options: ClientOptions) {
              model: input?.["model"],
              location: input?.["location"],
              metadata: input?.["metadata"],
+              permissions: input?.["permissions"],
            },
            successStatus: 200,
            declaredStatuses: [400, 401],
@@ -1566,6 +1569,18 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ),
+      rules: (input: PermissionRulesInput, requestOptions?: RequestOptions) =>
+        request<PermissionRulesOutput>(
+          {
+            method: "PUT",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/rules`,
+            body: { permissions: input["permissions"] },
+            successStatus: 204,
+            declaredStatuses: [400, 401, 404],
+            empty: true,
+          },
+          requestOptions,
+        ),
    },
    file: {
      read: (input: FileReadInput, requestOptions?: RequestOptions) =>
@@ -551,28 +551,6 @@ export type InstructionEntryInfo = { key: InstructionEntryKey; value: JsonValue

 export type InstructionEntrySnapshot = Array<{ key: InstructionEntryKey; value: JsonValue; removed: boolean }>

-export type SessionCreated = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.created"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: {
-    sessionID: string
-    projectID: string
-    location: LocationRef
-    subpath?: string
-    parentID?: string
-    slug: string
-    title?: string
-    agent?: string
-    model?: ModelRef
-    metadata?: SessionMetadata
-    version: string
-  }
-}
-
 export type SessionAgentSelected = {
  id: string
  created: number
@@ -1651,24 +1629,6 @@ export type SessionInboxMove = {
  delivery: SessionInboxDelivery
 }

-export type SessionInfo = {
-  id: string
-  parentID?: string
-  fork?: { sessionID: string; boundary: SessionForkBoundary }
-  projectID: string
-  agent?: string
-  model?: ModelRef
-  cost: MoneyUSD
-  tokens: TokenUsageInfo
-  outcome?: "succeeded" | "failed" | "interrupted"
-  time: { created: number; updated: number; idle?: number; viewed?: number; archived?: number }
-  title?: string
-  location: LocationRef
-  subpath?: string
-  metadata?: SessionMetadata
-  revert?: SessionRevert
-}
-
 export type SessionRevertStaged = {
  id: string
  created: number
@@ -1912,6 +1872,58 @@ export type AgentInfo = {
  permissions: PermissionRuleset
 }

+export type SessionPermissionsUpdated = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.permissions.updated"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string; permissions: PermissionRuleset }
+}
+
+export type SessionInfo = {
+  id: string
+  parentID?: string
+  fork?: { sessionID: string; boundary: SessionForkBoundary }
+  projectID: string
+  agent?: string
+  model?: ModelRef
+  cost: MoneyUSD
+  tokens: TokenUsageInfo
+  outcome?: "succeeded" | "failed" | "interrupted"
+  time: { created: number; updated: number; idle?: number; viewed?: number; archived?: number }
+  title?: string
+  location: LocationRef
+  subpath?: string
+  metadata?: SessionMetadata
+  permissions?: PermissionRuleset
+  revert?: SessionRevert
+}
+
+export type SessionCreated = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.created"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: {
+    sessionID: string
+    projectID: string
+    location: LocationRef
+    subpath?: string
+    parentID?: string
+    slug: string
+    title?: string
+    agent?: string
+    model?: ModelRef
+    metadata?: SessionMetadata
+    permissions?: PermissionRuleset
+    version: string
+  }
+}
+
 export type ConfigEntry =
  | {
      type: "document"
@@ -2084,8 +2096,6 @@ export type ConfigEntry =
  | { type: "agents"; path: string }
  | { type: "claude"; path: string }

-export type SessionsResponse = { data: Array<SessionInfo>; cursor: { previous?: string | null; next?: string | null } }
-
 export type SessionInboxUser = {
  id: string
  sessionID: string
@@ -2140,6 +2150,8 @@ export type FormFields = [FormField, ...Array<FormField>]

 export type FormFields2 = [FormField1, ...Array<FormField1>]

+export type SessionsResponse = { data: Array<SessionInfo>; cursor: { previous?: string | null; next?: string | null } }
+
 export type SessionInboxInfo = SessionInboxUser | SessionInboxSynthetic | SessionInboxCompaction | SessionInboxMove

 export type SessionInboxEnqueued = {
@@ -2233,6 +2245,7 @@ export type SessionEventDurable =
  | SessionModelSelected
  | SessionMoved
  | SessionRenamed
+  | SessionPermissionsUpdated
  | SessionViewed
  | SessionDeleted
  | SessionForked
@@ -2292,6 +2305,7 @@ export type V2Event =
  | SessionModelSelected
  | SessionMoved
  | SessionRenamed
+  | SessionPermissionsUpdated
  | SessionViewed
  | SessionUsageUpdated
  | SessionDeleted
@@ -2804,6 +2818,11 @@ export type SessionCreateInput = {
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
    readonly metadata?: { readonly [x: string]: JsonValue } | null
+    readonly permissions?: ReadonlyArray<{
+      readonly action: string
+      readonly resource: string
+      readonly effect: "allow" | "deny" | "ask"
+    }> | null
  }["id"]
  readonly title?: {
    readonly id?: string | null
@@ -2812,6 +2831,11 @@ export type SessionCreateInput = {
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
    readonly metadata?: { readonly [x: string]: JsonValue } | null
+    readonly permissions?: ReadonlyArray<{
+      readonly action: string
+      readonly resource: string
+      readonly effect: "allow" | "deny" | "ask"
+    }> | null
  }["title"]
  readonly agent?: {
    readonly id?: string | null
@@ -2820,6 +2844,11 @@ export type SessionCreateInput = {
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
    readonly metadata?: { readonly [x: string]: JsonValue } | null
+    readonly permissions?: ReadonlyArray<{
+      readonly action: string
+      readonly resource: string
+      readonly effect: "allow" | "deny" | "ask"
+    }> | null
  }["agent"]
  readonly model?: {
    readonly id?: string | null
@@ -2828,6 +2857,11 @@ export type SessionCreateInput = {
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
    readonly metadata?: { readonly [x: string]: JsonValue } | null
+    readonly permissions?: ReadonlyArray<{
+      readonly action: string
+      readonly resource: string
+      readonly effect: "allow" | "deny" | "ask"
+    }> | null
  }["model"]
  readonly location?: {
    readonly id?: string | null
@@ -2836,6 +2870,11 @@ export type SessionCreateInput = {
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
    readonly metadata?: { readonly [x: string]: JsonValue } | null
+    readonly permissions?: ReadonlyArray<{
+      readonly action: string
+      readonly resource: string
+      readonly effect: "allow" | "deny" | "ask"
+    }> | null
  }["location"]
  readonly metadata?: {
    readonly id?: string | null
@@ -2844,7 +2883,25 @@ export type SessionCreateInput = {
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
    readonly metadata?: { readonly [x: string]: JsonValue } | null
+    readonly permissions?: ReadonlyArray<{
+      readonly action: string
+      readonly resource: string
+      readonly effect: "allow" | "deny" | "ask"
+    }> | null
  }["metadata"]
+  readonly permissions?: {
+    readonly id?: string | null
+    readonly title?: string | null
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
+    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
+    readonly metadata?: { readonly [x: string]: JsonValue } | null
+    readonly permissions?: ReadonlyArray<{
+      readonly action: string
+      readonly resource: string
+      readonly effect: "allow" | "deny" | "ask"
+    }> | null
+  }["permissions"]
 }

 export type SessionCreateOutput = { data: SessionInfo }["data"]
@@ -2882,6 +2939,11 @@ export type SessionImportInput = {
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
      readonly metadata?: { readonly [x: string]: JsonValue }
+      readonly permissions?: ReadonlyArray<{
+        readonly action: string
+        readonly resource: string
+        readonly effect: "allow" | "deny" | "ask"
+      }>
      readonly revert?: {
        readonly messageID: string
        readonly partID?: string
@@ -3187,6 +3249,11 @@ export type SessionImportInput = {
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
      readonly metadata?: { readonly [x: string]: JsonValue }
+      readonly permissions?: ReadonlyArray<{
+        readonly action: string
+        readonly resource: string
+        readonly effect: "allow" | "deny" | "ask"
+      }>
      readonly revert?: {
        readonly messageID: string
        readonly partID?: string
@@ -3492,6 +3559,11 @@ export type SessionImportInput = {
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
      readonly metadata?: { readonly [x: string]: JsonValue }
+      readonly permissions?: ReadonlyArray<{
+        readonly action: string
+        readonly resource: string
+        readonly effect: "allow" | "deny" | "ask"
+      }>
      readonly revert?: {
        readonly messageID: string
        readonly partID?: string
@@ -5753,6 +5825,19 @@ export type PermissionReplyInput = {

 export type PermissionReplyOutput = void

+export type PermissionRulesInput = {
+  readonly sessionID: { readonly sessionID: string }["sessionID"]
+  readonly permissions: {
+    readonly permissions: ReadonlyArray<{
+      readonly action: string
+      readonly resource: string
+      readonly effect: "allow" | "deny" | "ask"
+    }>
+  }["permissions"]
+}
+
+export type PermissionRulesOutput = void
+
 export type FileReadInput = {
  readonly location?: {
    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
@@ -695,6 +695,10 @@ export function createData(config: CreateDataInput) {
        })
        return
      }
+      case "session.permissions.updated":
+        if (store.session.info[event.data.sessionID])
+          setStore("session", "info", event.data.sessionID, "permissions", event.data.permissions)
+        return
      case "session.moved": {
        const current = store.session.info[event.data.sessionID]
        if (current) {
@@ -9,7 +9,8 @@ standard-library surface that programs can use today, plus concrete gaps that ma
 - Intentional boundaries are not listed as compatibility work.

 When behavior changes, update this file and the tests in the same change. The implementation and tests remain the
-ultimate source of truth.
+ultimate source of truth. Upstream test262 files run verbatim from `test/test262`; a failing file is listed in
+`test/test262/skipped.txt` and its gap is an unchecked item here (see `test/test262/README.md`).

 ## Source and execution model

@@ -25,6 +26,10 @@ ultimate source of truth.
 - [x] The global `search(...)` built-in: synchronous tool discovery that counts as an admitted tool call and is
      shadowable by program declarations like other globals.
 - [x] Cooperative timeout, an optional total tool-call limit, output bounding, and unrestricted tool-call concurrency.
+- [ ] Strict-mode early errors: duplicate parameter names, `yield` as an identifier, and a trailing comma after a
+      rest parameter are accepted unless the program itself begins with `"use strict"`.
+- [ ] Valid JavaScript rejected by TypeScript transpilation before interpretation, such as `in` inside a destructuring
+      default in a `for...of` head and Unicode-escaped keywords.

 ## Values and literals

@@ -44,23 +49,31 @@ ultimate source of truth.

 ## Bindings and destructuring

- [x] `const`, `let`, and accepted `var` declarations.
+- [x] `const`, `let`, and `var` declarations.
 - [x] Object and array destructuring in declarations, parameters, assignment expressions, and `for...of` bindings.
 - [x] Nested patterns, defaults, elisions, and rest elements.
 - [x] Assignment to identifiers, plain-object fields, non-negative integer array indexes, and writable URL
      fields.
 - [x] Direct function declarations are hoisted in program and block statement lists.
 - [x] Parameter defaults observe a temporal dead zone for later parameters.
- [ ] JavaScript-correct function scoping, hoisting, and redeclaration for accepted `var` declarations.
+- [x] `var` is function-scoped and hoisted: names declared anywhere in a function or program body, including loop
+      heads, blocks, `switch` cases, and `try`/`catch`, read as `undefined` before their statement runs; redeclaration
+      assigns the one binding; a same-named parameter keeps its argument; closures in parameter defaults see outer
+      names rather than body `var`s.
 - [x] Predeclare `let` and `const` bindings in every lexical scope, including program/block bodies, switch bodies, and
      loop headers, so reads before initialization and self- or cross-referential initializers observe the JavaScript
      temporal dead zone.
- [ ] Hoist function declarations accepted directly in switch cases.
+- [x] Function declarations are hoisted across all cases of a `switch`, like any other statement list.
 - [x] Computed object destructuring keys such as `const { [field]: value } = record`.
 - [x] Object destructuring from arrays, such as `const { length } = values`.
 - [x] Array binding and assignment destructuring from strings, Maps, Sets, URLSearchParams, custom synchronous
      iterators, and synchronous generators, including stepwise elisions/rest and `IteratorClose` on early completion
      or binding/default failure.
+- [ ] Object destructuring from primitives follows ToObject (`const { length } = "abc"`, `const {} = 1`); non-object
+      sources are rejected.
+- [ ] Destructuring a key that member access resolves through the owning built-in, such as
+      `const { constructor } = error`, reads `undefined`.
+- [ ] Member expressions as `for...in` targets (`for (x.y in obj)`).

 ## Statements and control flow

@@ -108,6 +121,15 @@ ultimate source of truth.
 - [ ] User-defined constructor calls.
 - [ ] `Function.prototype.call`, `apply`, and `bind` for CodeMode functions.
 - [ ] Classes and private fields.
+- [x] Functions are objects: they hold own properties (`fn.count = 1`), enumerate them, and expose read-only `name`
+      and `length`. Names follow JavaScript's NamedEvaluation: declarations, named expressions, bindings,
+      assignments, object literal keys, and destructuring or parameter defaults.
+- [ ] `name` and `length` of built-in functions such as `Math.max` or `"a".includes`.
+- [ ] A named function expression's name is not bound inside its own body.
+- [ ] Redeclaring a function in the same scope is rejected; in JavaScript the last declaration wins.
+- [ ] A line terminator between `async function` and the function name.
+- [ ] Async generator functions evaluate parameter defaults and destructuring at the first `next()` rather than at the
+      call, so their errors are not thrown synchronously.
 - [x] Synchronous and async generator declarations/expressions, `yield`, and `yield*`, including lazy bodies,
      `next(value)`, `return(value)`, `throw(value)`, exhaustion, promise adoption, async request ordering,
      `try`/`catch`/`finally`, and sync/async iterator symbols. Async `yield*` awaits values while adapting a sync
@@ -151,6 +173,8 @@ ultimate source of truth.
 - [x] Plain, arithmetic, bitwise, and logical assignment operators.
 - [x] Property deletion on plain data objects and arrays, including computed and optional forms; deleting an array index
      creates a hole without changing its length.
+- [ ] Operators, `switch` discriminants, and coercion helpers such as `String` and `isNaN` applied to functions and
+      namespaces; JavaScript coerces them, the interpreter rejects non-data operands.

 ## Promises and tools

@@ -222,7 +246,8 @@ ultimate source of truth.
 - [x] Circular references are rejected when created (`o.self = o`, `array.push(array)`), not at serialization as in JS.
 - [x] `Object.is` for supported data values.
 - [x] `Object.groupBy` over finite collections and custom synchronous iterators/generators, with string-key coercion
-      and null-prototype results.
+      and plain-object results.
+- [ ] `Object.prototype` methods on values: `toString`, `toLocaleString`, `valueOf`, and `hasOwnProperty`.

 ## Arrays

@@ -242,20 +267,29 @@ ultimate source of truth.
 - [x] `length`, numeric indexing, index assignment, spread, and `for...of`.
 - [x] The `thisArg` argument of `Array.from` is accepted and ignored, like JS arrows.
 - [x] `Array.prototype.toSpliced`.
- [x] Canonical array/string index parsing: keys such as `"01"` remain non-index properties rather than aliasing index
-      `1`; arbitrary array-property assignment remains unsupported.
+- [x] Canonical array/string index parsing: keys such as `"01"` are ordinary properties rather than aliases of index
+      `1`.
 - [x] `Array.prototype.sort` preserves trailing holes, while `toSorted` densifies holes into `undefined` elements,
      like JavaScript.
+- [x] Assigning `length` to truncate or extend an array; invalid lengths throw `RangeError`.
+- [x] Non-index own properties on arrays (`arr.foo = 1`, `arr.constructor = null`). They are excluded from the JSON
+      form, like `JSON.stringify`.
+- [ ] Argument coercion for `indexOf`, `lastIndexOf`, `includes`, `fill`, `flat`, `copyWithin`, and the `join`
+      separator: JavaScript applies ToIntegerOrInfinity/ToString (including `valueOf`, strings, and `undefined`), the
+      interpreter requires numbers and strings; `includes()`/`indexOf()` with no argument should search for
+      `undefined`.
+- [ ] Iterator objects from `keys`, `values`, and `entries` with a live `next()`.

 ## Strings

 - [x] Case/normalization: `toLowerCase`, `toUpperCase`, `normalize`.
- [x] Trimming: `trim`, `trimStart`, and `trimEnd`.
+- [x] Trimming: `trim`, `trimStart`, and `trimEnd`, plus the Annex B `trimLeft` and `trimRight` aliases.
 - [x] Searching/tests: `includes`, `startsWith`, `endsWith`, `indexOf`, `lastIndexOf`, and `search`.
- [x] Slicing/access: `slice`, `substring`, `at`, `charAt`, `charCodeAt`, and `codePointAt`.
+- [x] Slicing/access: `slice`, `substring`, Annex B `substr`, `at`, `charAt`, `charCodeAt`, and `codePointAt`.
 - [x] Construction/transformation: `split`, `concat`, `repeat`, `padStart`, `padEnd`, `replace`, and `replaceAll`.
 - [x] Regular-expression integration: `match`, materialized `matchAll`, `replace`, `replaceAll`, `split`, and `search`.
 - [x] `localeCompare`; locale and options arguments are currently ignored.
+- [x] `isWellFormed` and `toWellFormed`.
 - [x] `toString`, `length`, numeric indexing, spread, and `for...of` by Unicode code point.
 - [x] Static `String.fromCharCode` and `String.fromCodePoint`.
 - [x] Native argument coercion for supported String methods; for example, `includes(1)` and `slice("1")` coerce like
@@ -316,6 +350,7 @@ ultimate source of truth.
 - [x] Local and UTC Date setters, including native argument coercion, mutation, rollover, invalid-Date recovery, and
      `TimeClip` behavior.
 - [x] `Date.prototype.toUTCString` and its `toGMTString` alias.
+- [x] `toDateString` and `toTimeString` in the host's local timezone.
 - [x] Native one-argument Date coercion for supported values, including booleans, null, arrays, and plain objects.
 - [x] Native Date loose-equality and default primitive-coercion semantics, using CodeMode's deterministic ISO string
      representation for the string primitive.
@@ -327,7 +362,7 @@ ultimate source of truth.
 - [x] `test`, `exec`, and `toString`.
 - [x] Readable `source`, `flags`, `lastIndex`, `hasIndices`, `global`, `ignoreCase`, `multiline`, `sticky`, `unicode`,
      `unicodeSets`, and `dotAll`.
- [x] Captures, named groups, match `.index`, and stateful global matching.
+- [x] Captures, named groups, match `.index` and `.input`, and stateful global matching.
 - [x] Integration with supported String methods, including function replacers.
 - [x] Writable `lastIndex`.
 - [x] Match `indices` metadata for the `d` flag, including named groups on `exec`, `match`, and `matchAll` results.
@@ -359,6 +394,14 @@ ultimate source of truth.
      `entries`, `toString`, and `size`.
 - [x] URL values serialize to their href; URLSearchParams serialize to `{}`.

+## Web platform helpers
+
+- [x] `atob` and `btoa` with forgiving-base64 decoding and WebIDL string conversion; invalid input throws an Error
+      named `InvalidCharacterError`, since there is no `DOMException`.
+- [x] `crypto.randomUUID()`.
+- [ ] `crypto.getRandomValues` and `crypto.subtle`, `TextEncoder`/`TextDecoder`, and `Blob`: these need a binary
+      value type, which the JSON-like data model does not have yet.
+
 ## Errors and diagnostics

 - [x] `Error`, `TypeError`, `RangeError`, `SyntaxError`, `ReferenceError`, `EvalError`, and `URIError`, callable with
@@ -375,6 +418,8 @@ ultimate source of truth.
      shift them. The diagnostic names the rejected node type and attaches a short orientation to the supported
      subset; this matrix is the full reference.
 - [x] Model-visible host failure messages and underlying causes, including output-validation errors.
- [ ] Distinguish user-thrown failures from interpreter defects and explicit tool refusals from internal tool
-      failures; preserve those categories in caught errors, promise rejection handlers, and `Promise.allSettled`
-      reasons.
+- [x] Caught errors do not distinguish user throws, interpreter failures, and tool failures; a program sees one
+      Error-shaped value with `name` and `message` in `catch`, rejection handlers, and `Promise.allSettled` reasons.
+      This is deliberate: the program should handle a failure the same way regardless of where it originated.
+- [ ] Failures raised by the interpreter itself carry the generic `Error` name where JavaScript throws a `TypeError`,
+      `RangeError`, or `ReferenceError`, so `e instanceof TypeError` and `e.constructor === TypeError` are false.
@@ -0,0 +1,62 @@
+// Copies the manifest's test262 directories from a local checkout into test/test262, verbatim.
+// Files needing unsupported flags, features, or harness includes, or whose code crosses one of the
+// interpreter's intentional boundaries, are not copied, so the vendored tree is exactly what
+// test/test262.test.ts runs.
+//
+// Usage: bun run script/sync-test262.ts /path/to/test262
+import path from "node:path"
+import { rm } from "node:fs/promises"
+
+type Frontmatter = { flags?: Array<string>; features?: Array<string>; includes?: Array<string> }
+
+const root = path.resolve(import.meta.dir, "../test/test262")
+const manifest = (await Bun.file(path.join(root, "manifest.json")).json()) as {
+  revision: string
+  directories: Array<string>
+  harness: Array<string>
+  flags: Array<string>
+  features: Array<string>
+  boundaries: Record<string, string>
+}
+const boundaries = Object.entries(manifest.boundaries).map(([name, pattern]) => [name, new RegExp(pattern)] as const)
+const checkout = process.argv[2]
+if (checkout === undefined) {
+  console.error("usage: bun run script/sync-test262.ts /path/to/test262")
+  process.exit(1)
+}
+const head = (await Bun.$`git -C ${checkout} rev-parse HEAD`.text()).trim()
+if (head !== manifest.revision) {
+  console.error(`checkout is at ${head}; manifest pins ${manifest.revision}`)
+  process.exit(1)
+}
+
+const excluded = new Map<string, number>()
+let copied = 0
+for (const dir of manifest.directories) {
+  await rm(path.join(root, dir), { recursive: true, force: true })
+  const from = path.join(checkout, "test", dir)
+  for await (const file of new Bun.Glob("**/*.js").scan({ cwd: from })) {
+    if (file.endsWith("_FIXTURE.js")) continue
+    const source = await Bun.file(path.join(from, file)).text()
+    const start = source.indexOf("/*---")
+    const end = source.indexOf("---*/", start)
+    const meta = start === -1 ? {} : (Bun.YAML.parse(source.slice(start + 5, end)) as Frontmatter)
+    const code = start === -1 ? source : source.slice(end + 5)
+    const reason =
+      meta.flags?.find((flag) => manifest.flags.includes(flag)) ??
+      meta.features?.find((feature) => manifest.features.includes(feature)) ??
+      meta.includes?.find((include) => !manifest.harness.includes(include)) ??
+      boundaries.find(([, pattern]) => pattern.test(code))?.[0]
+    if (reason !== undefined) {
+      excluded.set(reason, (excluded.get(reason) ?? 0) + 1)
+      continue
+    }
+    await Bun.write(path.join(root, dir, file), Bun.file(path.join(from, file)))
+    copied++
+  }
+}
+
+console.log(`copied ${copied} files`)
+for (const [reason, count] of [...excluded].sort((a, b) => b[1] - a[1])) {
+  console.log(`  excluded ${String(count).padStart(5)}  ${reason}`)
+}
@@ -0,0 +1,55 @@
+// Runs every vendored test262 file, including skipped ones, and groups failures by cause. Pass
+// --write to regenerate test/test262/skipped.txt from the current failures.
+//
+// Usage: bun run script/test262-report.ts [--write] [path-prefix]
+import path from "node:path"
+import { root, run, skipped } from "../test/test262/run.js"
+
+const write = process.argv.includes("--write")
+const prefix = process.argv.slice(2).find((arg) => !arg.startsWith("--")) ?? ""
+const files = [...new Bun.Glob("**/*.js").scanSync({ cwd: root })].filter((file) => file.startsWith(prefix)).sort()
+
+const failures: Array<{ file: string; reason: string }> = []
+const recovered: Array<string> = []
+for (const file of files) {
+  const outcome = await run(file)
+  if (outcome.status === "fail") failures.push({ file, reason: outcome.reason })
+  if (outcome.status === "pass" && skipped.has(file)) recovered.push(file)
+}
+
+// Collapse a reason to the part that identifies the cause rather than the test.
+const bucket = (reason: string) => {
+  const syntax = reason.match(/Syntax '([A-Za-z]+)' is not supported/)
+  if (syntax) return `unsupported syntax ${syntax[1]}`
+  if (reason.startsWith("expected ")) return reason.replace(/ but got .*/, " but the program ran")
+  return reason
+    .replace(/^(\$DONE: |ExecutionFailure: |InvalidDataValue: |ParseError: |Uncaught: |Test262Error: |Error: )+/, "")
+    .replace(/ \(line \d+, col \d+\)/, "")
+    .replace(/^[\w$]+\.(\w+) is not a function/, ".$1 is not a function")
+    .replace(/^[\w$]+ cannot be constructed/, "… cannot be constructed")
+    .replace(/'[^']*'/g, "'…'")
+    .slice(0, 100)
+}
+
+const buckets = new Map<string, Array<string>>()
+for (const failure of failures) {
+  const key = bucket(failure.reason)
+  buckets.set(key, [...(buckets.get(key) ?? []), failure.file])
+}
+
+console.log(`${files.length - failures.length} pass, ${failures.length} fail of ${files.length}\n`)
+for (const [key, list] of [...buckets].sort((a, b) => b[1].length - a[1].length)) {
+  console.log(`${String(list.length).padStart(5)}  ${key}`)
+  for (const file of list.slice(0, 3)) console.log(`         ${file}`)
+  if (list.length > 3) console.log(`         … ${list.length - 3} more`)
+}
+if (recovered.length > 0) {
+  console.log(`\n${recovered.length} skipped files pass now; remove them from skipped.txt:`)
+  for (const file of recovered) console.log(`         ${file}`)
+}
+
+if (write) {
+  const lines = failures.map((failure) => `${failure.file}  # ${bucket(failure.reason)}`)
+  await Bun.write(path.join(root, "skipped.txt"), `${lines.join("\n")}\n`)
+  console.log(`\nwrote ${lines.length} entries to skipped.txt`)
+}
@@ -105,7 +105,7 @@ export type Result = typeof Result.Type

 /** Reusable confined runtime over explicit tools. */
 export type Runtime<R = never> = {
-  readonly catalog: () => ReadonlyArray<ToolDescription>
+  readonly catalog: ReadonlyArray<ToolDescription>
  readonly execute: (code: string) => Effect.Effect<Result, never, R>
 }

@@ -134,7 +134,7 @@ export const make = <const Provided extends Record<string, unknown> = {}>(
  const prepared = ToolRuntime.prepare((options.tools ?? {}) as Tools<Services<Provided>>)
  const limits = resolveExecutionLimits(options.limits)
  return {
-    catalog: () => prepared.catalog,
+    catalog: prepared.catalog,
    execute: (code) => executeProgram(code, prepared, limits, options),
  }
 }
@@ -1,11 +1,16 @@
 export * as Data from "./data.js"

 import type { DiagnosticKind } from "./codemode.js"
+import {
+  ownEntries,
+  parseArrayIndex,
+  ProgramArray,
+  ProgramFunction,
+  ProgramObject,
+  set,
+} from "./interpreter/objects.js"
 import { Values } from "./values.js"

-/** A null-prototype object owned by the program. */
-export type SafeObject = Record<string, unknown>
-
 const MAX_VALUE_DEPTH = 32

 export class ToolRuntimeError extends Error {
@@ -23,15 +28,15 @@ export class ToolRuntimeError extends Error {
 }

 /**
- * Brings a host-produced runtime value into the program: runtime values pass through, their host
- * counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and objects become
- * null-prototype copies. Arrays keep extra enumerable properties such as `index` and `groups`.
+ * Brings a host-produced value into the program: program and runtime values pass through, their
+ * host counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and host objects
+ * and arrays are copied.
 */
 export const toProgram = (value: unknown, label: string): unknown => copy(value, label, "program", 0, new Set())

 /**
 * Brings host data into the program: Date and URL become strings, other host collections become
- * empty objects, and objects become null-prototype copies. Used for tool results and parsed JSON.
+ * empty objects, and objects become program copies. Used for tool results and parsed JSON.
 */
 export const fromData = (value: unknown, label: string): unknown => copy(value, label, "data", 0, new Set())

@@ -44,8 +49,7 @@ export const fromData = (value: unknown, label: string): unknown => copy(value,
 export const toData = (value: unknown, label: string, undefinedAs: "json" | "result" = "json"): unknown =>
  copy(value, label, undefinedAs, 0, new Set())

-// "program" and "data" build program-owned null-prototype objects; "json" and "result" build
-// ordinary objects for the host.
+// "program" and "data" build program objects; "json" and "result" build ordinary objects for the host.
 type Mode = "program" | "data" | "json" | "result"

 const copy = (value: unknown, label: string, mode: Mode, depth: number, seen: Set<object>): unknown => {
@@ -64,9 +68,13 @@ const copy = (value: unknown, label: string, mode: Mode, depth: number, seen: Se
      `${label} contains an un-awaited Promise; await tool calls (e.g. \`const result = await tools.ns.tool(...)\`) before using their results.`,
    )
  }
+  if (value instanceof ProgramFunction && mode !== "program") {
+    throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`)
+  }

+  const plain = mode === "program" || mode === "data"
  if (mode === "program") {
-    if (Values.isValue(value)) return value
+    if (value instanceof ProgramObject || Values.isValue(value)) return value
    if (value instanceof Date) return new Values.Date(value.getTime())
    if (value instanceof RegExp) return new Values.RegExp(value.source, value.flags)
    if (value instanceof Map) {
@@ -85,7 +93,6 @@ const copy = (value: unknown, label: string, mode: Mode, depth: number, seen: Se
    if (value instanceof URLSearchParams) return new Values.URLSearchParams(new URLSearchParams(value))
  }

-  const plain = mode === "program" || mode === "data"
  if (value instanceof Values.Date) return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null
  if (value instanceof Date) return Number.isFinite(value.getTime()) ? value.toISOString() : null
  if (value instanceof Values.URL) return value.url.href
@@ -98,7 +105,7 @@ const copy = (value: unknown, label: string, mode: Mode, depth: number, seen: Se
    value instanceof Set ||
    value instanceof URLSearchParams
  ) {
-    return plain ? (Object.create(null) as SafeObject) : {}
+    return plain ? new ProgramObject() : {}
  }

  if (seen.has(value)) {
@@ -106,27 +113,48 @@ const copy = (value: unknown, label: string, mode: Mode, depth: number, seen: Se
  }
  seen.add(value)

-  if (Array.isArray(value)) {
-    // Host output densifies holes to null like JSON; program copies keep them.
-    const copied = plain
-      ? value.map((item) => copy(item, label, mode, depth + 1, seen))
-      : Array.from(value, (item) => copy(item, label, mode, depth + 1, seen) ?? null)
-    if (mode === "program") {
-      for (const [key, item] of Object.entries(value)) {
-        if (Object.hasOwn(copied, key)) continue
-        define(copied, key, copy(item, label, mode, depth + 1, seen))
-      }
+  if (value instanceof ProgramArray) {
+    const copied = Array.from(value.items, (item) => copy(item, label, mode, depth + 1, seen) ?? null)
+    seen.delete(value)
+    return copied
+  }
+  if (value instanceof ProgramObject) {
+    const copied: Record<string, unknown> = {}
+    for (const [key, item] of ownEntries(value)) {
+      const next = copy(item, label, mode, depth + 1, seen)
+      if (next === undefined && mode === "json") continue
+      define(copied, key, next)
    }
    seen.delete(value)
    return copied
  }

+  if (Array.isArray(value)) {
+    if (plain) {
+      const copied = new ProgramArray(value.map((item) => copy(item, label, mode, depth + 1, seen)))
+      for (const [key, item] of Object.entries(value)) {
+        if (parseArrayIndex(key) === undefined) set(copied, key, copy(item, label, mode, depth + 1, seen))
+      }
+      seen.delete(value)
+      return copied
+    }
+    const copied = Array.from(value, (item) => copy(item, label, mode, depth + 1, seen) ?? null)
+    seen.delete(value)
+    return copied
+  }
+
  const prototype = Object.getPrototypeOf(value)
  if (prototype !== Object.prototype && prototype !== null) {
    throw new ToolRuntimeError("InvalidDataValue", `${label} must contain plain objects only.`)
  }

-  const copied: SafeObject = plain ? (Object.create(null) as SafeObject) : {}
+  if (plain) {
+    const copied = new ProgramObject()
+    for (const [key, item] of Object.entries(value)) set(copied, key, copy(item, label, mode, depth + 1, seen))
+    seen.delete(value)
+    return copied
+  }
+  const copied: Record<string, unknown> = {}
  for (const [key, item] of Object.entries(value)) {
    const next = copy(item, label, mode, depth + 1, seen)
    if (next === undefined && mode === "json") continue
@@ -136,8 +164,8 @@ const copy = (value: unknown, label: string, mode: Mode, depth: number, seen: Se
  return copied
 }

-// Own data property regardless of the target's prototype, so a "__proto__" key on a host object or
-// array never reaches the Object.prototype setter.
+// Own data property regardless of the target's prototype, so a "__proto__" key on a host object
+// never reaches the Object.prototype setter.
 const define = (target: object, key: string, value: unknown): void => {
  Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true })
 }
@@ -1,10 +1,11 @@
 import { Effect } from "effect"
 import type { Diagnostic } from "../codemode.js"
 import { ToolError } from "../tool-error.js"
-import { type SafeObject, toData, ToolRuntimeError } from "../data.js"
+import { toData, ToolRuntimeError } from "../data.js"
 import { type AstNode, formatLocation, InterpreterRuntimeError, ProgramThrow, sourceLocation } from "./model.js"
 import { containsRuntimeReference } from "./references.js"
 import { type HostCall, HostFunction } from "./host.js"
+import { get, ProgramError, ProgramObject } from "./objects.js"
 import { type Runner } from "./runner.js"
 import {
  coerceToString,
@@ -44,12 +45,8 @@ export const normalizeError = (error: unknown): Diagnostic => {
      message = "a non-data value"
    } else if (typeof value === "string") {
      message = value
-    } else if (
-      value !== null &&
-      typeof value === "object" &&
-      typeof (value as { message?: unknown }).message === "string"
-    ) {
-      message = (value as { message: string }).message
+    } else if (value instanceof ProgramObject && typeof get(value, "message") === "string") {
+      message = get(value, "message") as string
    } else {
      try {
        message = JSON.stringify(toData(value, "Thrown value")) ?? String(value)
@@ -87,14 +84,14 @@ export const caughtErrorValue = (thrown: unknown): unknown => {
  return createErrorValue(name, normalizeError(thrown).message)
 }

-const constructErrorValue = (name: string, args: Array<unknown>): SafeObject =>
+const constructErrorValue = (name: string, args: Array<unknown>): ProgramError =>
  createErrorValue(name, args[0] === undefined ? "" : coerceToString(args[0]))

 const constructAggregateErrorValue = <R>(
  runner: Runner<R>,
  args: Array<unknown>,
  node: AstNode,
-): Effect.Effect<SafeObject, unknown, R> =>
+): Effect.Effect<ProgramError, unknown, R> =>
  Effect.gen(function* () {
    const cursor = yield* runner.syncIterator(args[0], node)
    if (cursor === undefined) {
@@ -7,6 +7,7 @@ import type { DataValue, Diagnostic, ResolvedExecutionLimits, Result } from "../
 import { toData } from "../data.js"
 import { ToolRuntime } from "../tool-runtime.js"
 import { normalizeError } from "./errors.js"
+import type { Host } from "./globals.js"
 import { InterpreterRuntimeError } from "./model.js"
 import { PromiseRuntime } from "./promises.js"
 import { Runtime } from "./runtime.js"
@@ -16,6 +17,7 @@ export const executeProgram = <R>(
  prepared: ToolRuntime.Prepared<R>,
  limits: ResolvedExecutionLimits,
  hooks: ToolRuntime.ToolCallHooks<R>,
+  extraGlobals?: (host: Host<R>) => ReadonlyArray<readonly [string, unknown]>,
 ): Effect.Effect<Result, never, R> => {
  if (code.trim().length === 0) {
    return Effect.succeed({
@@ -39,7 +41,14 @@ export const executeProgram = <R>(
        Effect.gen(function* () {
          const program = parseProgram(code)
          const promises = new PromiseRuntime<R>(scope)
-          const value = yield* new Runtime<R>(tools.execute, tools.search, tools.keys, promises, logs).run(program)
+          const value = yield* new Runtime<R>(
+            tools.execute,
+            tools.search,
+            tools.keys,
+            promises,
+            logs,
+            extraGlobals,
+          ).run(program)
          const result = toData(value, "Execution result", "result") as DataValue
          returned = { value: result, promises }
          const warnings = yield* promises.interrupt()
@@ -11,6 +11,7 @@ import { regexpGlobal } from "../stdlib/regexp.js"
 import { stringGlobal } from "../stdlib/string.js"
 import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js"
 import { coercion, errorConstructors } from "../stdlib/value.js"
+import { atobGlobal, btoaGlobal, cryptoGlobal } from "../stdlib/web.js"
 import { ToolReference } from "../tool-runtime.js"
 import { errorGlobal } from "./errors.js"
 import { HostFunction } from "./host.js"
@@ -71,5 +72,8 @@ export const globals = <R>(host: Host<R>): ReadonlyArray<readonly [string, unkno
  ["encodeURIComponent", uriGlobal("encodeURIComponent")],
  ["decodeURI", uriGlobal("decodeURI")],
  ["decodeURIComponent", uriGlobal("decodeURIComponent")],
+  ["atob", atobGlobal],
+  ["btoa", btoaGlobal],
+  ["crypto", cryptoGlobal],
  ...[...errorConstructors].map((name) => [name, errorGlobal(name, host.runner)] as const),
 ]
@@ -1,13 +1,14 @@
 import { Effect } from "effect"
-import { type SafeObject, toProgram } from "../data.js"
+import { toProgram } from "../data.js"
 import { dateSetterArgumentCount, invokeDateMethod } from "../stdlib/date.js"
 import { invokeNumberMethod } from "../stdlib/number.js"
 import { invokeRegExpMethod, matchToValue, toHostRegex } from "../stdlib/regexp.js"
 import { invokeURLMethod, uriArgument } from "../stdlib/url.js"
-import { coerceToNumber, coerceToString, errorBrandName } from "../stdlib/value.js"
+import { coerceToNumber, coerceToString } from "../stdlib/value.js"
 import { compareText } from "../tool-runtime.js"
 import { Values } from "../values.js"
 import { type AstNode, IntrinsicReference, InterpreterRuntimeError } from "./model.js"
+import { get, ProgramArray, ProgramObject, record } from "./objects.js"
 import { containsOpaqueReference, rejectCircularInsertion, typeofValue } from "./references.js"
 import { applyCollectionCallback, isSupportedCallback, type Runner, toPrimitive } from "./runner.js"

@@ -16,6 +17,14 @@ export const invokeIntrinsic = <R>(
  ref: IntrinsicReference,
  args: Array<unknown>,
  node: AstNode,
+): Effect.Effect<unknown, unknown, R> =>
+  Effect.map(invoke(runner, ref, args, node), (result) => (Array.isArray(result) ? new ProgramArray(result) : result))
+
+const invoke = <R>(
+  runner: Runner<R>,
+  ref: IntrinsicReference,
+  args: Array<unknown>,
+  node: AstNode,
 ): Effect.Effect<unknown, unknown, R> => {
  if (typeof ref.receiver === "string") {
    if (ref.name === "replace" || ref.name === "replaceAll") {
@@ -32,7 +41,7 @@ export const invokeIntrinsic = <R>(
  if (typeof ref.receiver === "number") {
    return Effect.succeed(invokeNumberMethod(ref.receiver, ref.name, args, node))
  }
-  if (Array.isArray(ref.receiver)) {
+  if (ref.receiver instanceof ProgramArray) {
    return invokeArrayMethod(runner, ref.receiver, ref.name, args, node)
  }
  if (ref.receiver instanceof Values.Date) {
@@ -118,9 +127,11 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
      result = value.trim()
      break
    case "trimStart":
+    case "trimLeft":
      result = value.trimStart()
      break
    case "trimEnd":
+    case "trimRight":
      result = value.trimEnd()
      break
    // Locale/options are deliberately unsupported; comparison uses the host default locale.
@@ -213,7 +224,7 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
          node,
        )
      }
-      return Array.from(value.matchAll(pattern), matchToValue)
+      return new ProgramArray(Array.from(value.matchAll(pattern), matchToValue))
    }
    case "search": {
      result = value.search(toHostRegex(args[0], name, node))
@@ -241,6 +252,15 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
    case "substring":
      result = value.substring(optNum(0) ?? 0, optNum(1))
      break
+    case "substr":
+      result = value.substr(optNum(0) ?? 0, optNum(1))
+      break
+    case "isWellFormed":
+      result = value.isWellFormed()
+      break
+    case "toWellFormed":
+      result = value.toWellFormed()
+      break
    case "charCodeAt":
      result = value.charCodeAt(optNum(0) ?? 0)
      break
@@ -277,13 +297,7 @@ const invokeStringReplacer = <R>(
    if (typeof match !== "string" || typeof offset !== "number") {
      throw new InterpreterRuntimeError(`String.${name} produced an invalid replacement match.`, node)
    }
-    if (hasGroups) {
-      const safeGroups: SafeObject = Object.create(null) as SafeObject
-      for (const [key, group] of Object.entries(groups)) {
-        safeGroups[key] = group
-      }
-      callbackArgs[callbackArgs.length - 1] = safeGroups
-    }
+    if (hasGroups) callbackArgs[callbackArgs.length - 1] = record(groups as Record<string, unknown>)
    matches.push({ match, offset, args: callbackArgs })
    return match
  }
@@ -309,14 +323,11 @@ const invokeStringReplacer = <R>(
    let end = 0
    for (const match of matches) {
      const replacement = yield* apply(match.args)
-      // Error values are branded plain objects; toProgram would strip the brand before coercion.
      output.push(
        value.slice(end, match.offset),
        replacement instanceof Values.Promise
          ? "[object Promise]"
-          : errorBrandName(replacement)
-            ? coerceToString(replacement)
-            : coerceToString(toProgram(replacement, `String.${name} replacer result`)),
+          : coerceToString(toProgram(replacement, `String.${name} replacer result`)),
      )
      end = match.offset + match.match.length
    }
@@ -354,7 +365,7 @@ const invokeMapMethod = <R>(
    case "values":
      return Effect.sync(() => Array.from(target.map.values()))
    case "entries":
-      return Effect.sync(() => Array.from(target.map.entries(), ([key, item]): Array<unknown> => [key, item]))
+      return Effect.sync(() => Array.from(target.map.entries(), ([key, item]) => new ProgramArray([key, item])))
    case "forEach": {
      const apply = applyCollectionCallback(runner, args[0], "Map.forEach", node)
      return Effect.gen(function* () {
@@ -393,7 +404,7 @@ const invokeSetMethod = <R>(
    case "values":
      return Effect.sync(() => Array.from(target.set.values()))
    case "entries":
-      return Effect.sync(() => Array.from(target.set.values(), (item): Array<unknown> => [item, item]))
+      return Effect.sync(() => Array.from(target.set.values(), (item) => new ProgramArray([item, item])))
    case "forEach": {
      const apply = applyCollectionCallback(runner, args[0], "Set.forEach", node)
      return Effect.gen(function* () {
@@ -507,28 +518,27 @@ const loadSetRecord = <R>(runner: Runner<R>, source: unknown, name: string, node
      keys: () => Effect.succeed(source.map.keys()),
    })
  }
-  if (source === null || typeof source !== "object" || Values.isValue(source)) {
+  if (!(source instanceof ProgramObject)) {
    throw new InterpreterRuntimeError(`Set.${name} expects a Set-like object.`, node).as("TypeError")
  }
-  const object = source as Record<string, unknown>
  return Effect.gen(function* () {
-    const size = yield* coerceNumericArgument(runner, object.size, node)
+    const size = yield* coerceNumericArgument(runner, get(source, "size"), node)
    if (Number.isNaN(size)) {
      throw new InterpreterRuntimeError(`Set.${name} received a Set-like object with an invalid size.`, node).as(
        "TypeError",
      )
    }
-    if (!isSupportedCallback(object.has) || !isSupportedCallback(object.keys)) {
+    const has = get(source, "has")
+    const keys = get(source, "keys")
+    if (!isSupportedCallback(has) || !isSupportedCallback(keys)) {
      throw new InterpreterRuntimeError(`Set.${name} expects callable 'has' and 'keys' methods.`, node).as("TypeError")
    }
-    const has = object.has
-    const keys = object.keys
    return {
      size: Math.max(Math.trunc(size), 0),
      has: (item: unknown) => Effect.map(runner.invokeCallable(has, [item], node), Boolean),
      keys: () =>
        Effect.flatMap(runner.invokeCallable(keys, [], node), (result) => {
-          if (Array.isArray(result)) return Effect.succeed(result)
+          if (result instanceof ProgramArray) return Effect.succeed(result.items)
          throw new InterpreterRuntimeError(`Set.${name} expected 'keys' to return an iterator.`, node).as("TypeError")
        }),
    }
@@ -593,7 +603,7 @@ const invokeURLSearchParamsMethod = <R>(
    case "values":
      return Effect.sync(() => Array.from(target.params.values()))
    case "entries":
-      return Effect.sync(() => Array.from(target.params.entries(), ([key, value]): Array<unknown> => [key, value]))
+      return Effect.sync(() => Array.from(target.params.entries(), ([key, value]) => new ProgramArray([key, value])))
    case "toString":
      return Effect.sync(() => target.params.toString())
    case "forEach": {
@@ -611,11 +621,12 @@ const invokeURLSearchParamsMethod = <R>(

 const invokeArrayMethod = <R>(
  runner: Runner<R>,
-  target: Array<unknown>,
+  receiver: ProgramArray,
  name: string,
  args: Array<unknown>,
  node: AstNode,
 ): Effect.Effect<unknown, unknown, R> => {
+  const target = receiver.items
  const optNumber = (value: unknown, label: string): number | undefined => {
    if (value === undefined) return undefined
    if (typeof value !== "number")
@@ -627,9 +638,8 @@ const invokeArrayMethod = <R>(
      if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
        throw new InterpreterRuntimeError("Array.join expects zero arguments or one string separator.", node)
      }
-      const input = toProgram(target, "Array.join input") as Array<unknown>
      return Effect.succeed(
-        input.map((item) => coerceToString(item ?? "")).join(args.length === 0 ? "," : (args[0] as string)),
+        target.map((item) => coerceToString(item ?? "")).join(args.length === 0 ? "," : (args[0] as string)),
      )
    }
    case "includes":
@@ -649,11 +659,15 @@ const invokeArrayMethod = <R>(
    case "slice":
      return Effect.succeed(target.slice(optNumber(args[0], "start"), optNumber(args[1], "end")))
    case "concat":
-      return Effect.succeed(target.concat(...args))
-    case "flat":
-      return Effect.succeed(target.flat(optNumber(args[0], "depth") ?? 1))
+      return Effect.succeed(target.concat(...args.map((item) => (item instanceof ProgramArray ? item.items : item))))
+    case "flat": {
+      const flatten = (items: Array<unknown>, depth: number): Array<unknown> =>
+        items.flatMap((item) => (item instanceof ProgramArray && depth > 0 ? flatten(item.items, depth - 1) : [item]))
+      return Effect.succeed(flatten(target, optNumber(args[0], "depth") ?? 1))
+    }
    case "reverse":
-      return Effect.succeed(target.reverse())
+      target.reverse()
+      return Effect.succeed(receiver)
    case "sort": {
      const length = target.length
      const holeCount = Array.from({ length }, (_, index) => Object.hasOwn(target, index)).filter((own) => !own).length
@@ -665,7 +679,7 @@ const invokeArrayMethod = <R>(
        Array.from({ length: holeCount }, (_, index) => itemCount + index).forEach((index) => {
          Reflect.deleteProperty(target, index)
        })
-        return target
+        return receiver
      })
    }
    case "toSorted":
@@ -684,12 +698,12 @@ const invokeArrayMethod = <R>(
    }
    case "push": {
      // Validate all insertions before mutating to avoid partial cyclic updates.
-      for (const item of args) rejectCircularInsertion(target, item, "Array.push result", node)
+      for (const item of args) rejectCircularInsertion(receiver, item, "Array.push result", node)
      target.push(...args)
      return Effect.succeed(target.length)
    }
    case "unshift": {
-      for (const item of args) rejectCircularInsertion(target, item, "Array.unshift result", node)
+      for (const item of args) rejectCircularInsertion(receiver, item, "Array.unshift result", node)
      target.unshift(...args)
      return Effect.succeed(target.length)
    }
@@ -703,7 +717,7 @@ const invokeArrayMethod = <R>(
      if (args.length === 1) return Effect.succeed(target.splice(start))
      const deleteCount = optNumber(args[1], "delete count") ?? 0
      const inserted = args.slice(2)
-      for (const item of inserted) rejectCircularInsertion(target, item, "Array.splice result", node)
+      for (const item of inserted) rejectCircularInsertion(receiver, item, "Array.splice result", node)
      return Effect.succeed(target.splice(start, deleteCount, ...inserted))
    }
    case "toSpliced": {
@@ -720,23 +734,23 @@ const invokeArrayMethod = <R>(
      return Effect.succeed(copied)
    }
    case "fill": {
-      rejectCircularInsertion(target, args[0], "Array.fill result", node)
-      return Effect.succeed(target.fill(args[0], optNumber(args[1], "start"), optNumber(args[2], "end")))
+      rejectCircularInsertion(receiver, args[0], "Array.fill result", node)
+      target.fill(args[0], optNumber(args[1], "start"), optNumber(args[2], "end"))
+      return Effect.succeed(receiver)
    }
    case "copyWithin":
-      return Effect.succeed(
-        target.copyWithin(
-          optNumber(args[0], "target index") ?? 0,
-          optNumber(args[1], "start") ?? 0,
-          optNumber(args[2], "end"),
-        ),
+      target.copyWithin(
+        optNumber(args[0], "target index") ?? 0,
+        optNumber(args[1], "start") ?? 0,
+        optNumber(args[2], "end"),
      )
+      return Effect.succeed(receiver)
    case "keys":
      return Effect.succeed(Array.from(target.keys()))
    case "values":
      return Effect.succeed([...target])
    case "entries":
-      return Effect.succeed(Array.from(target.entries(), ([index, item]): Array<unknown> => [index, item]))
+      return Effect.succeed(Array.from(target.entries(), ([index, item]) => new ProgramArray([index, item])))
  }

  const apply = applyCollectionCallback(runner, args[0], `Array.${name}`, node)
@@ -749,7 +763,7 @@ const invokeArrayMethod = <R>(
        values.length = length
        for (let index = 0; index < length; index += 1) {
          if (!(index in target)) continue
-          values[index] = yield* apply([target[index], index, target])
+          values[index] = yield* apply([target[index], index, receiver])
        }
        return values
      }
@@ -757,8 +771,8 @@ const invokeArrayMethod = <R>(
        const values: Array<unknown> = []
        for (let index = 0; index < length; index += 1) {
          if (!(index in target)) continue
-          const mapped = yield* apply([target[index], index, target])
-          if (Array.isArray(mapped)) values.push(...mapped)
+          const mapped = yield* apply([target[index], index, receiver])
+          if (mapped instanceof ProgramArray) values.push(...mapped.items)
          else values.push(mapped)
        }
        return values
@@ -768,36 +782,36 @@ const invokeArrayMethod = <R>(
        for (let index = 0; index < length; index += 1) {
          if (!(index in target)) continue
          const item = target[index]
-          if (yield* apply([item, index, target])) values.push(item)
+          if (yield* apply([item, index, receiver])) values.push(item)
        }
        return values
      }
      case "find":
        for (let index = 0; index < length; index += 1) {
          const item = target[index]
-          if (yield* apply([item, index, target])) return item
+          if (yield* apply([item, index, receiver])) return item
        }
        return undefined
      case "findIndex":
        for (let index = 0; index < length; index += 1) {
-          if (yield* apply([target[index], index, target])) return index
+          if (yield* apply([target[index], index, receiver])) return index
        }
        return -1
      case "some":
        for (let index = 0; index < length; index += 1) {
          if (!(index in target)) continue
-          if (yield* apply([target[index], index, target])) return true
+          if (yield* apply([target[index], index, receiver])) return true
        }
        return false
      case "every":
        for (let index = 0; index < length; index += 1) {
          if (!(index in target)) continue
-          if (!(yield* apply([target[index], index, target]))) return false
+          if (!(yield* apply([target[index], index, receiver]))) return false
        }
        return true
      case "forEach":
        for (let index = 0; index < length; index += 1) {
-          if (index in target) yield* apply([target[index], index, target])
+          if (index in target) yield* apply([target[index], index, receiver])
        }
        return undefined
      case "reduce": {
@@ -814,7 +828,7 @@ const invokeArrayMethod = <R>(
        }
        for (let index = start; index < length; index += 1) {
          if (!(index in target)) continue
-          accumulator = yield* apply([accumulator, target[index], index, target])
+          accumulator = yield* apply([accumulator, target[index], index, receiver])
        }
        return accumulator
      }
@@ -832,19 +846,19 @@ const invokeArrayMethod = <R>(
        }
        for (let index = start; index >= 0; index -= 1) {
          if (!(index in target)) continue
-          accumulator = yield* apply([accumulator, target[index], index, target])
+          accumulator = yield* apply([accumulator, target[index], index, receiver])
        }
        return accumulator
      }
      case "findLast":
        for (let index = length - 1; index >= 0; index -= 1) {
          const item = target[index]
-          if (yield* apply([item, index, target])) return item
+          if (yield* apply([item, index, receiver])) return item
        }
        return undefined
      case "findLastIndex":
        for (let index = length - 1; index >= 0; index -= 1) {
-          if (yield* apply([target[index], index, target])) return index
+          if (yield* apply([target[index], index, receiver])) return index
        }
        return -1
    }
@@ -1,7 +1,7 @@
-import type { BlockStatement, Expression, Node, Pattern } from "acorn"
+import type { Node } from "acorn"
 import type { Effect } from "effect"
 import type { DiagnosticKind } from "../codemode.js"
-import type { SafeObject } from "../data.js"
+import type { ProgramObject } from "./objects.js"
 import type { Values } from "../values.js"

 /** Any parsed node; the interpreter narrows on `type` and reads `loc` for diagnostics. */
@@ -20,20 +20,10 @@ export type StatementResult =
  | { kind: "continue"; label?: string }

 export type MemberReference = {
-  target: SafeObject | Array<unknown> | Values.RegExp | Values.URL
+  target: ProgramObject | Values.RegExp | Values.URL
  key: PropertyKey
 }

-export class CodeModeFunction {
-  constructor(
-    readonly parameters: ReadonlyArray<Pattern>,
-    readonly body: BlockStatement | Expression,
-    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>,
-    readonly async: boolean,
-    readonly generator: boolean,
-  ) {}
-}
-
 export type GeneratorRequestKind = "next" | "return" | "throw"

 export class CodeModeGenerator {
@@ -0,0 +1,145 @@
+import type { BlockStatement, Expression, Pattern } from "acorn"
+import { AsyncIteratorSymbol, type Binding, IteratorSymbol } from "./model.js"
+
+/** An object owned by the program: own properties plus a prototype link. */
+export class ProgramObject {
+  readonly props = new Map<PropertyKey, unknown>()
+  constructor(public proto: ProgramObject | null = null) {}
+}
+
+export class ProgramArray extends ProgramObject {
+  constructor(readonly items: Array<unknown> = []) {
+    super()
+  }
+}
+
+export class ProgramError extends ProgramObject {
+  constructor(readonly errorName: string) {
+    super()
+  }
+}
+
+export class ProgramFunction extends ProgramObject {
+  readonly length: number
+  constructor(
+    readonly name: string,
+    readonly parameters: ReadonlyArray<Pattern>,
+    readonly body: BlockStatement | Expression,
+    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>,
+    readonly async: boolean,
+    readonly generator: boolean,
+  ) {
+    super()
+    const optional = parameters.findIndex((p) => p.type === "AssignmentPattern" || p.type === "RestElement")
+    this.length = optional === -1 ? parameters.length : optional
+  }
+}
+
+const MAX_ARRAY_LENGTH = 4_294_967_295
+
+export const parseArrayIndex = (key: string | number): number | undefined => {
+  const property = String(key)
+  if (!/^(0|[1-9]\d*)$/.test(property)) return undefined
+  const index = Number(property)
+  return index < MAX_ARRAY_LENGTH ? index : undefined
+}
+
+const canonical = (key: PropertyKey): string | symbol => (typeof key === "symbol" ? key : String(key))
+
+const index = (target: ProgramObject, key: string | symbol): number | undefined =>
+  target instanceof ProgramArray && typeof key === "string" ? parseArrayIndex(key) : undefined
+
+// Non-enumerable built-in properties: array length, function name and length.
+const builtin = (target: ProgramObject, name: string | symbol): boolean =>
+  (name === "length" && target instanceof ProgramArray) ||
+  ((name === "name" || name === "length") && target instanceof ProgramFunction)
+
+export const hasOwn = (target: ProgramObject, key: PropertyKey): boolean => {
+  const name = canonical(key)
+  const at = index(target, name)
+  if (at !== undefined) return at in (target as ProgramArray).items
+  return builtin(target, name) || target.props.has(name)
+}
+
+export const getOwn = (target: ProgramObject, key: PropertyKey): unknown => {
+  const name = canonical(key)
+  const at = index(target, name)
+  if (at !== undefined) return (target as ProgramArray).items[at]
+  if (target instanceof ProgramArray && name === "length") return target.items.length
+  if (target instanceof ProgramFunction && name === "name") return target.name
+  if (target instanceof ProgramFunction && name === "length") return target.length
+  return target.props.get(name)
+}
+
+export const get = (target: ProgramObject, key: PropertyKey): unknown => {
+  for (let current: ProgramObject | null = target; current !== null; current = current.proto) {
+    if (hasOwn(current, key)) return getOwn(current, key)
+  }
+  return undefined
+}
+
+export const has = (target: ProgramObject, key: PropertyKey): boolean => {
+  for (let current: ProgramObject | null = target; current !== null; current = current.proto) {
+    if (hasOwn(current, key)) return true
+  }
+  return false
+}
+
+export const set = (target: ProgramObject, key: PropertyKey, value: unknown): boolean => {
+  const name = canonical(key)
+  const at = index(target, name)
+  if (at !== undefined) {
+    ;(target as ProgramArray).items[at] = value
+    return true
+  }
+  if (name === "length" && target instanceof ProgramArray) {
+    const length = typeof value === "number" ? value : Number(value)
+    if (!Number.isInteger(length) || length < 0 || length > 4_294_967_295) return false
+    target.items.length = length
+    return true
+  }
+  if (builtin(target, name)) return false
+  target.props.set(name, value)
+  return true
+}
+
+export const remove = (target: ProgramObject, key: PropertyKey): boolean => {
+  const name = canonical(key)
+  const at = index(target, name)
+  if (at !== undefined) return delete (target as ProgramArray).items[at]
+  if (name === "length" && target instanceof ProgramArray) return false
+  if (builtin(target, name)) return true
+  target.props.delete(name)
+  return true
+}
+
+// JS order: array indexes, integer-like keys ascending, other strings, then symbols.
+export const ownKeys = (target: ProgramObject): Array<string | symbol> => {
+  const strings = [...target.props.keys()].filter((key): key is string => typeof key === "string")
+  const symbols = [...target.props.keys()].filter((key): key is symbol => typeof key === "symbol")
+  return [
+    ...(target instanceof ProgramArray ? Object.keys(target.items) : []),
+    ...strings.filter((key) => parseArrayIndex(key) !== undefined).sort((a, b) => Number(a) - Number(b)),
+    ...strings.filter((key) => parseArrayIndex(key) === undefined),
+    ...symbols,
+  ]
+}
+
+export const ownEntries = (target: ProgramObject): Array<[string, unknown]> =>
+  ownKeys(target)
+    .filter((key): key is string => typeof key === "string")
+    .map((key) => [key, getOwn(target, key)])
+
+export const record = (entries: Record<string, unknown>): ProgramObject => {
+  const target = new ProgramObject()
+  for (const [key, value] of Object.entries(entries)) set(target, key, value)
+  return target
+}
+
+export const assign = (target: ProgramObject, source: ProgramObject, skip?: ReadonlySet<PropertyKey>): void => {
+  for (const key of ownKeys(source)) {
+    if (skip?.has(key)) continue
+    if (typeof key === "symbol" && key !== IteratorSymbol && key !== AsyncIteratorSymbol) continue
+    set(target, key, getOwn(source, key))
+  }
+}
@@ -1,13 +1,7 @@
 import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect"
 import type { Diagnostic } from "../codemode.js"
-import type { SafeObject } from "../data.js"
-import {
-  type AstNode,
-  CodeModeFunction,
-  InterpreterRuntimeError,
-  ProgramThrow,
-  PromiseInstanceMethodReference,
-} from "./model.js"
+import { type AstNode, InterpreterRuntimeError, ProgramThrow, PromiseInstanceMethodReference } from "./model.js"
+import { get, ProgramArray, ProgramFunction, ProgramObject, record } from "./objects.js"
 import { HostFunction, requiresNew, sync } from "./host.js"
 import { caughtErrorValue, normalizeError } from "./errors.js"
 import { typeofValue } from "./references.js"
@@ -32,6 +26,17 @@ export class PromiseRuntime<R> {

  constructor(private readonly scope: Scope.Scope) {}

+  // Resolution bodies need the promise's own identity to reject `resolve(promise)` self-resolution.
+  createWithSelf(
+    body: (self: { promise?: Values.Promise }) => Effect.Effect<unknown, unknown, R>,
+  ): Effect.Effect<Values.Promise, never, R> {
+    const self: { promise?: Values.Promise } = {}
+    return Effect.map(this.create(body(self)), (promise) => {
+      self.promise = promise
+      return promise
+    })
+  }
+
  create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<Values.Promise, never, R> {
    return Effect.suspend(() => {
      // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
@@ -100,8 +105,8 @@ export const resolvePromiseValue = <R>(
 ): Effect.Effect<unknown, unknown, R> => {
  if (own?.promise !== undefined && value === own.promise) return Effect.fail(selfResolutionError(node))
  if (value instanceof Values.Promise) return runner.settlePromise(value)
-  if (value === null || typeof value !== "object" || !Object.hasOwn(value, "then")) return Effect.succeed(value)
-  const then = (value as SafeObject).then
+  if (!(value instanceof ProgramObject)) return Effect.succeed(value)
+  const then = get(value, "then")
  if (typeofValue(then) !== "function") return Effect.succeed(value)

  return Effect.gen(function* () {
@@ -126,11 +131,7 @@ export const resolvePromise = <R>(
  node: AstNode,
 ): Effect.Effect<Values.Promise, never, R> => {
  if (value instanceof Values.Promise) return Effect.succeed(value)
-  const box: { promise?: Values.Promise } = {}
-  return Effect.map(promises.create(resolvePromiseValue(runner, value, node, box)), (promise) => {
-    box.promise = promise
-    return promise
-  })
+  return promises.createWithSelf((self) => resolvePromiseValue(runner, value, node, self))
 }

 const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"] as const
@@ -167,10 +168,12 @@ const invokePromiseMethod = <R>(
      }

      if (name === "all") {
-        return yield* settleAfterTurn(
-          Effect.all(
-            items.map((item) => Effect.flatten(promises.await(item))),
-            { concurrency: "unbounded" },
+        return new ProgramArray(
+          yield* settleAfterTurn(
+            Effect.all(
+              items.map((item) => Effect.flatten(promises.await(item))),
+              { concurrency: "unbounded" },
+            ),
          ),
        )
      }
@@ -179,19 +182,14 @@ const invokePromiseMethod = <R>(
        for (const item of items) {
          const exit = yield* promises.await(item)
          if (Exit.isSuccess(exit)) {
-            outcomes.push(Object.assign(Object.create(null) as SafeObject, { status: "fulfilled", value: exit.value }))
+            outcomes.push(record({ status: "fulfilled", value: exit.value }))
            continue
          }
          if (Cause.hasInterruptsOnly(exit.cause)) return yield* Effect.failCause(exit.cause)
-          outcomes.push(
-            Object.assign(Object.create(null) as SafeObject, {
-              status: "rejected",
-              reason: caughtErrorValue(Cause.squash(exit.cause)),
-            }),
-          )
+          outcomes.push(record({ status: "rejected", reason: caughtErrorValue(Cause.squash(exit.cause)) }))
        }
        yield* Effect.yieldNow
-        return outcomes
+        return new ProgramArray(outcomes)
      }
      if (name === "race") {
        if (items.length === 0) {
@@ -246,7 +244,7 @@ const constructPromise = <R>(
  executor: unknown,
  node: AstNode,
 ): Effect.Effect<Values.Promise, unknown, R> => {
-  if (!(executor instanceof CodeModeFunction)) {
+  if (!(executor instanceof ProgramFunction)) {
    throw new InterpreterRuntimeError(
      "new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).",
      node,
@@ -254,11 +252,9 @@ const constructPromise = <R>(
  }
  return Effect.gen(function* () {
    const deferred = Deferred.makeUnsafe<unknown, unknown>()
-    const box: { promise?: Values.Promise } = {}
-    const promise = yield* promises.create(
-      Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, box)),
+    const promise = yield* promises.createWithSelf((self) =>
+      Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, self)),
    )
-    box.promise = promise
    const resolve = capability("resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)))
    const reject = capability("reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value))))
    const executed = yield* Effect.exit(runner.invokeFunction(executor, [resolve, reject]))
@@ -310,19 +306,16 @@ const chainReaction = <R>(
  method: string,
  node: AstNode,
 ): Effect.Effect<Values.Promise, never, R> => {
-  const box: { promise?: Values.Promise } = {}
-  const body = Effect.gen(function* () {
-    const exit = yield* reactionExit(promises, source)
-    const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected
-    if (handler === undefined) return yield* exit
-    const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(Cause.squash(exit.cause))
-    const result = yield* applyCollectionCallback(runner, handler, method, node)([input])
-    return yield* resolvePromiseValue(runner, result, node, box)
-  })
-  return Effect.map(promises.create(body), (derived) => {
-    box.promise = derived
-    return derived
-  })
+  return promises.createWithSelf((self) =>
+    Effect.gen(function* () {
+      const exit = yield* reactionExit(promises, source)
+      const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected
+      if (handler === undefined) return yield* exit
+      const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(Cause.squash(exit.cause))
+      const result = yield* applyCollectionCallback(runner, handler, method, node)([input])
+      return yield* resolvePromiseValue(runner, result, node, self)
+    }),
+  )
 }

 const chainFinally = <R>(
@@ -3,20 +3,18 @@ import { Values } from "../values.js"
 import { HostFunction, HostNamespace } from "./host.js"
 import {
  type AstNode,
-  AsyncIteratorSymbol,
-  CodeModeFunction,
  CodeModeGenerator,
  GeneratorMethodReference,
  InterpreterRuntimeError,
  IntrinsicReference,
-  IteratorSymbol,
  PromiseInstanceMethodReference,
 } from "./model.js"
+import { getOwn, ownKeys, ProgramArray, ProgramFunction, ProgramObject } from "./objects.js"

 export const isRuntimeReference = (value: unknown): boolean =>
  value instanceof HostFunction ||
  value instanceof HostNamespace ||
-  value instanceof CodeModeFunction ||
+  value instanceof ProgramFunction ||
  value instanceof CodeModeGenerator ||
  value instanceof GeneratorMethodReference ||
  value instanceof ToolReference ||
@@ -26,11 +24,8 @@ export const isRuntimeReference = (value: unknown): boolean =>
  Values.isValue(value)

 function* childValues(value: object): Generator {
-  for (const key of Reflect.ownKeys(value)) {
-    if (!Object.prototype.propertyIsEnumerable.call(value, key)) continue
-    if (typeof key === "symbol" && key !== AsyncIteratorSymbol && key !== IteratorSymbol) continue
-    yield Reflect.get(value, key)
-  }
+  if (!(value instanceof ProgramObject)) return
+  for (const key of ownKeys(value)) yield getOwn(value, key)
 }

 // Depth-first search over a value tree. `match` stops the walk; `skip` prunes a subtree without matching it.
@@ -79,7 +74,7 @@ export const rejectCircularInsertion = (

 export const describeValue = (value: unknown): string => {
  if (value === null) return "null"
-  if (Array.isArray(value)) return "an array"
+  if (value instanceof ProgramArray) return "an array"
  if (value instanceof Values.Promise) return "an un-awaited Promise"
  if (value instanceof ToolReference) return "a tool reference"
  if (value instanceof Values.Date) return "a Date"
@@ -97,7 +92,7 @@ export const describeValue = (value: unknown): string => {
 export const typeofValue = (value: unknown): string => {
  if (
    value instanceof HostFunction ||
-    value instanceof CodeModeFunction ||
+    value instanceof ProgramFunction ||
    value instanceof GeneratorMethodReference ||
    value instanceof IntrinsicReference ||
    value instanceof PromiseInstanceMethodReference
@@ -108,12 +103,3 @@ export const typeofValue = (value: unknown): string => {
  if (value instanceof ToolReference) return value.path.length > 0 ? "function" : "object"
  return typeof value
 }
-
-const MAX_ARRAY_LENGTH = 4_294_967_295
-
-export const parseArrayIndex = (key: string | number): number | undefined => {
-  const property = String(key)
-  if (!/^(0|[1-9]\d*)$/.test(property)) return undefined
-  const index = Number(property)
-  return index < MAX_ARRAY_LENGTH ? index : undefined
-}
@@ -2,7 +2,8 @@ import { Effect, Exit } from "effect"
 import { Values } from "../values.js"
 import { coerceToString } from "../stdlib/value.js"
 import { HostFunction } from "./host.js"
-import { type AstNode, CodeModeFunction, InterpreterRuntimeError, IntrinsicReference } from "./model.js"
+import { type AstNode, InterpreterRuntimeError, IntrinsicReference } from "./model.js"
+import { get, has, ProgramFunction, ProgramObject } from "./objects.js"
 import { typeofValue } from "./references.js"

 export type IteratorCursor<R> = {
@@ -12,7 +13,7 @@ export type IteratorCursor<R> = {

 /** Everything a host function needs to call back into the program. */
 export type Runner<R> = {
-  readonly invokeFunction: (fn: CodeModeFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>
+  readonly invokeFunction: (fn: ProgramFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>
  readonly invokeCallable: (
    callable: unknown,
    args: Array<unknown>,
@@ -42,13 +43,14 @@ export const toPrimitive = <R>(
  if (Values.isValue(value)) {
    return Effect.succeed(value instanceof Values.Date && hint === "number" ? value.time : coerceToString(value))
  }
-  const object = value as Record<string, unknown>
+  if (!(value instanceof ProgramObject)) return Effect.succeed(value)
  const order = hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"]
  return Effect.gen(function* () {
    for (const method of order) {
-      if (method === "toString" && !Object.hasOwn(object, "toString")) return coerceToString(value)
-      if (!Object.hasOwn(object, method) || typeofValue(object[method]) !== "function") continue
-      const result = yield* runner.invokeCallable(object[method], [], node)
+      if (method === "toString" && !has(value, "toString")) return coerceToString(value)
+      const callable = get(value, method)
+      if (typeofValue(callable) !== "function") continue
+      const result = yield* runner.invokeCallable(callable, [], node)
      if (result === null || (typeof result !== "object" && typeof result !== "function")) return result
    }
    throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError")
@@ -59,10 +61,10 @@ export const toPrimitive = <R>(
 // Array.from mappers, and promise reactions all admit exactly these callables.
 // Admission means dispatchable, not necessarily invocable: new-requiring
 // constructors pass the gate and throw a TypeError on call, like JS.
-export type SupportedCallback = CodeModeFunction | HostFunction<unknown> | IntrinsicReference
+export type SupportedCallback = ProgramFunction | HostFunction<unknown> | IntrinsicReference

 export const isSupportedCallback = (value: unknown): value is SupportedCallback =>
-  value instanceof CodeModeFunction ||
+  value instanceof ProgramFunction ||
  (value instanceof HostFunction && value.callback) ||
  value instanceof IntrinsicReference

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Aiden Cline	b8c48e7f7d	refactor(codemode): make functions program objects with name and length	2026-09-11 13:43:38 -05:00
Aiden Cline	a555f24ded	refactor: flatten provider settings across core and the AI package (#48429 )	2026-09-11 13:37:24 -05:00
Aiden Cline	10ae321bf3	refactor(codemode): give programs their own objects and arrays (#48527 )	2026-09-11 13:36:35 -05:00
Aiden Cline	6e8ff0c2b7	refactor(core): remove dead AISDK hooks (#48523 )	2026-09-11 12:41:20 -05:00
Aiden Cline	923bda07a2	feat(ai): always send interleaved thinking beta for Anthropic (#48521 )	2026-09-11 12:29:18 -05:00
Aiden Cline	4c34ee5eab	test(codemode): run test262 files verbatim from a local checkout (#48446 )	2026-09-11 10:40:02 -05:00
Shoubhit Dash	2df00955cb	fix(cli): preserve ACP reasoning boundaries and effort selections (#48493 )	2026-09-11 18:46:54 +05:30
opencode-agent[bot]andnexxeln	e0deffa083	docs(plugin): fix Effect system part example (#48492 ) Co-authored-by: nexxeln <95541290+nexxeln@users.noreply.github.com>	2026-09-11 18:12:11 +05:30
Wu Shuwen	4e97b78d98	docs: fix v2 plugin system example (#48452 )	2026-09-11 18:12:01 +05:30
Brendan Allan	6bb4b35399	fix(app): preserve loopback server host (#44296 )	2026-09-11 06:41:38 +00:00
Brendan Allan	0ce1383030	fix(app): preserve file search results while loading (#43832 )	2026-09-11 06:13:32 +00:00
Brendan AllanandBrendonovich	010cd6131e	fix(app): merge adjacent file-changing tools (#44977 ) Co-authored-by: Brendonovich <Brendonovich@users.noreply.github.com>	2026-09-11 05:58:02 +00:00
Brendan Allan	c2348f8f69	fix(app): coordinate notifications across windows (#44613 )	2026-09-11 05:28:13 +00:00
Aiden Cline	71317ec7c9	fix(core): report provider initialization failures (#48433 )	2026-09-11 00:26:55 -05:00
opencode-agent[bot]andBrendonovich	4261fe749d	fix(desktop): repair SSH server updates (#48442 ) Co-authored-by: Brendonovich <14191578+Brendonovich@users.noreply.github.com>	2026-09-11 13:24:38 +08:00
Aiden Cline	9dd7149e75	feat(core): append comment guidance to Anthropic system prompt (#48444 )	2026-09-11 00:05:05 -05:00
Brendan Allan	0c0a431c9f	fix(ui): make comment cancel action ghost (#46742 )	2026-09-11 13:03:49 +08:00
Brendan Allan	3368e049d2	fix(app): refine home row hover actions (#47270 )	2026-09-11 04:39:26 +00:00
Aiden Cline	f0b5da1c11	feat(ai): type provider configuration errors (#48440 )	2026-09-10 23:29:55 -05:00
Aiden Cline	15c525dcfb	fix(merman): support & node groups in flowchart statements (#48425 )	2026-09-10 22:24:59 -05:00
James Long	4d12e01824	refactor(tui): project production subgroups through tree engine (#48399 )	2026-09-10 23:15:58 -04:00
James Long	70afbac80c	docs(www): add core CLI theme concepts (#48426 )	2026-09-10 23:13:53 -04:00
James Long	1c723c56fa	feat(tui): add recursive grouping tree (#48394 )	2026-09-10 21:40:23 -04:00
Aiden Cline	181428a2f3	fix(codemode): use Bun's wording for the missing atob/btoa argument (#48381 )	2026-09-10 20:08:36 -05:00
Dax Raad	9b1891fb7e	docs(cli): expand provider connections	2026-09-10 20:43:17 -04:00
Dax Raad	d4bf78b348	docs: add websearch guides	2026-09-10 20:30:58 -04:00
Dax Raad	d4ceffe787	docs: refresh v2 guides	2026-09-10 20:12:08 -04:00
Aiden Cline	872e38055e	fix(ai): normalize flat Responses stream errors (#48376 )	2026-09-10 18:23:32 -05:00
James Long	0c1dfa9186	refactor(tui): extract shared session rendering primitives (#48393 )	2026-09-10 18:07:14 -04:00
Dax Raad	8f4d706647	feat(cli): add command docs and simplify session list	2026-09-10 16:27:12 -04:00
Aiden Cline	929374cdfd	feat(core): parse JSON text results from MCP tools without an output schema (#48357 )	2026-09-10 15:20:13 -05:00
opencode-agent[bot]	cfa5ba700e	fix(stats): canonicalize DeepSeek Flash usage (#48373 )	2026-09-10 13:58:51 -05:00
Shoubhit Dash	45a2ed9a97	feat(core): per-session permission rules (#48351 )	2026-09-10 22:30:53 +05:30
opencode-agent[bot]andnexxeln	f6333546f8	fix(tui): disambiguate plugin actions (#48354 ) Co-authored-by: nexxeln <95541290+nexxeln@users.noreply.github.com>	2026-09-10 22:10:01 +05:30
opencode-agent[bot]andnexxeln	9e153ce7b3	fix(core): raise instruction entry limit (#48350 ) Co-authored-by: nexxeln <nexxeln@users.noreply.github.com>	2026-09-10 20:59:38 +05:30
Simon Klee	eb357f17cf	fix(tui): strip NUL characters before clipboard writes (#48337 )	2026-09-10 15:47:03 +02:00
Shoubhit Dash	573d76933f	fix(ai): make xAI Responses websockets work and enable them (#48318 )	2026-09-10 17:27:43 +05:30
usrnk1andBrendonovich	bb8194395a	feat(desktop): respect follow-up behavior for slash commands (#48169 ) Co-authored-by: Brendonovich <14191578+Brendonovich@users.noreply.github.com>	2026-09-10 19:24:23 +08:00
opencode-agent[bot]andHona	2e8ed86658	fix(app): move compaction status below summary (#48262 ) Co-authored-by: Hona <10430890+Hona@users.noreply.github.com>	2026-09-10 18:27:08 +08:00
Brendan Allan	2695607fbc	fix(app): stabilize optimistic prompt position (#46723 )	2026-09-10 17:49:55 +08:00
Aiden Cline	f3ef84556a	feat(codemode): add atob, btoa, and crypto.randomUUID (#48290 )	2026-09-10 01:21:41 -05:00
Aiden Cline	08ff21179c	fix(codemode): hoist switch-case functions and memoize var names (#48287 )	2026-09-10 00:42:08 -05:00
Aiden Cline	98a36fb1a4	feat(codemode): hoist var to function scope (#48284 )	2026-09-10 00:27:58 -05:00
Aiden Cline	e22cd0a585	refactor(codemode): collapse repeated loop, promise, and Object shapes (#48283 )	2026-09-10 00:02:58 -05:00
Aiden Cline	8475783700	fix(tui): ignore parked synthetic inbox for tab busy (#48273 )	2026-09-09 23:31:16 -05:00
Aiden Cline	1452aadc87	feat(codemode): add substr, well-formed, and Date string methods (#48275 )	2026-09-09 23:29:34 -05:00
Aiden Cline	1417976257	fix(core): run compaction hooks before appending the summary prompt (#48276 )	2026-09-09 22:54:00 -05:00