fix(ai): handle remaining provider failures

fix(ai): handle retryable SDK failures
refactor(ai): remove SDK error diagnostics
2026-10-27 02:44:47 +08:00 · 2026-07-17 14:41:53 -05:00 · 2026-07-17 14:41:52 -05:00 · 2026-07-17 14:41:52 -05:00 · 2026-07-17 14:41:52 -05:00
77 changed files with 1316 additions and 2100 deletions
@@ -1,6 +1,6 @@
 # LLM Provider Parity Status

-Last reviewed: 2026-07-17
+Last reviewed: 2026-07-16

 This file tracks the gap between the native `@opencode-ai/ai` package and the AI SDK provider packages that opencode still depends on for many catalog/runtime paths.

@@ -20,7 +20,7 @@ This file tracks the gap between the native `@opencode-ai/ai` package and the AI
 | OpenAI Responses WebSocket         | `src/protocols/openai-responses.ts`, `src/route/transport/websocket.ts`                        | Present as `OpenAI.responsesWebSocket(...)`.                                                                                                                             | Runner/catalog support explicitly must not downgrade WebSocket routes; broader runtime selection is not complete.                                                                                                                                         |
 | OpenAI-compatible Chat             | `src/protocols/openai-compatible-chat.ts`, `src/providers/openai-compatible.ts`                | Usable for generic Chat and several profiles: Baseten, Cerebras, DeepInfra, DeepSeek, Fireworks, Groq, TogetherAI.                                                       | Family quirks are mostly endpoint defaults, not full typed behavior.                                                                                                                                                                                      |
 | OpenAI-compatible Responses        | `src/protocols/openai-compatible-responses.ts`, `src/providers/openai-compatible-responses.ts` | Usable for deployments that implement the OpenAI Responses wire protocol.                                                                                                | No named family profiles or recorded deployment coverage yet.                                                                                                                                                                                             |
-| Anthropic-compatible Messages      | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic-compatible.ts`                 | Usable for deployments that implement the Anthropic Messages wire protocol. Named Anthropic composes this base; MiniMax M3 has recorded text and tool-loop coverage.       | No named compatible family profiles yet.                                                                                                                                                                                                                  |
+| Anthropic-compatible Messages      | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic-compatible.ts`                 | Usable for deployments that implement the Anthropic Messages wire protocol. Named Anthropic composes this base.                                                          | No named compatible family profiles or recorded deployment coverage yet.                                                                                                                                                                                  |
 | Anthropic Messages                 | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic.ts`                            | Usable. Supports tools, thinking, cache control, images, server-hosted tool events, and usage.                                                                           | Provider option surface is small. Beta/header handling, metadata, and newer Messages fields need a typed parity pass.                                                                                                                                     |
 | Gemini Developer API               | `src/protocols/gemini.ts`, `src/providers/google.ts`                                           | Usable for Google API key flow. Supports text, images, tools, thinking signatures, and cache usage.                                                                      | This is not Vertex. Typed provider options are narrow; many Gemini request fields currently require raw `http.body` overlays.                                                                                                                             |
 | Vertex Gemini                      | `src/protocols/gemini.ts`, `src/providers/google-vertex.ts`                                    | Usable through API-key express mode, explicit OAuth tokens, or ADC with project/location endpoint derivation, including tuned `endpoints/...` deployments.               | Core runner/catalog mapping and recorded provider coverage are missing.                                                                                                                                                                                   |
@@ -161,18 +161,6 @@ const PROVIDERS: ReadonlyArray<Provider> = [
    vars: [{ name: "TOGETHER_AI_API_KEY" }],
    validate: (env) => validateBearer("https://api.together.xyz/v1/models", Redacted.make(env.TOGETHER_AI_API_KEY)),
  },
-  {
-    id: "minimax",
-    label: "MiniMax",
-    tier: "compatible",
-    note: "Anthropic-compatible Messages text/tool recorded tests",
-    vars: [{ name: "MINIMAX_API_KEY" }],
-    validate: (env) =>
-      HttpClientRequest.get("https://api.minimax.io/anthropic/v1/models").pipe(
-        HttpClientRequest.setHeader("x-api-key", Redacted.value(Redacted.make(env.MINIMAX_API_KEY))),
-        executeRequest,
-      ),
-  },
  {
    id: "mistral",
    label: "Mistral",
@@ -2,7 +2,8 @@ export { LLMClient } from "./route/client"
 export { Auth } from "./route/auth"
 export { Provider } from "./provider"
 export { ProviderPackage } from "./provider-package"
-export { isContextOverflow, isContextOverflowFailure } from "./provider-error"
+export { classifyProviderFailure, isContextOverflow, isContextOverflowFailure } from "./provider-error"
+export type { ProviderFailure } from "./provider-error"
 export type {
  RouteModelInput,
  RouteRoutedModelInput,
@@ -1,6 +1,6 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec"
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8"
-import { Effect, Stream } from "effect"
+import { Effect, Option, Schema, Stream } from "effect"
 import { Framing } from "../route/framing"
 import { ProviderShared } from "./shared"

@@ -53,8 +53,13 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
      })
      cursor = { buffer: cursor.buffer, offset: cursor.offset + totalLength }

-      if (decoded.headers[":message-type"]?.value !== "event") continue
-      const eventType = decoded.headers[":event-type"]?.value
+      const messageType = decoded.headers[":message-type"]?.value
+      const eventType =
+        messageType === "event"
+          ? decoded.headers[":event-type"]?.value
+          : messageType === "exception"
+            ? decoded.headers[":exception-type"]?.value
+            : undefined
      if (typeof eventType !== "string") continue
      const payload = utf8.decode(decoded.body)
      if (!payload) continue
@@ -84,4 +89,52 @@ export const framing = (route: string): Framing.Definition<object> => ({
  frame: (bytes) => bytes.pipe(Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
 })

+class StreamExceptionError extends Error {
+  constructor(
+    message: string,
+    readonly code: string,
+  ) {
+    super(message)
+  }
+}
+
+// The AI SDK Bedrock decoder ignores AWS exception frames before its language
+// model stream can expose them. Fail the byte stream first so the shared AI SDK
+// adapter can classify the transport error instead of accepting a false finish.
+export function monitorExceptions(response: Response) {
+  if (!response.body || !response.headers.get("content-type")?.includes("application/vnd.amazon.eventstream"))
+    return response
+  let state = initialFrameBuffer
+  const body = response.body.pipeThrough(
+    new TransformStream<Uint8Array, Uint8Array>({
+      transform(chunk, controller) {
+        state = appendChunk(state, chunk)
+        while (state.buffer.length - state.offset >= 4) {
+          const view = state.buffer.subarray(state.offset)
+          const totalLength = new DataView(view.buffer, view.byteOffset, view.byteLength).getUint32(0, false)
+          if (view.length < totalLength) break
+          const decoded = eventCodec.decode(view.subarray(0, totalLength))
+          state = { buffer: state.buffer, offset: state.offset + totalLength }
+          const exceptionType = decoded.headers[":exception-type"]?.value
+          if (decoded.headers[":message-type"]?.value === "exception" && typeof exceptionType === "string") {
+            const payload = Option.getOrUndefined(
+              Schema.decodeUnknownOption(Schema.UnknownFromJsonString)(utf8.decode(decoded.body)),
+            )
+            const message =
+              ProviderShared.isRecord(payload) && typeof payload.message === "string" ? payload.message : undefined
+            controller.error(new StreamExceptionError(message ?? `Bedrock ${exceptionType}`, exceptionType))
+            return
+          }
+        }
+        controller.enqueue(chunk)
+      },
+    }),
+  )
+  return new Response(body, {
+    headers: new Headers(response.headers),
+    status: response.status,
+    statusText: response.statusText,
+  })
+}
+
 export * as BedrockEventStream from "./bedrock-event-stream"
@@ -75,8 +75,6 @@ const OpenAIChatMessage = Schema.Union([
    content: Schema.NullOr(Schema.String),
    tool_calls: optionalArray(OpenAIChatAssistantToolCall),
    reasoning_content: Schema.optional(Schema.String),
-    reasoning: Schema.optional(Schema.String),
-    reasoning_text: Schema.optional(Schema.String),
  }),
  Schema.Struct({ role: Schema.Literal("tool"), tool_call_id: Schema.String, content: Schema.String }),
 ]).pipe(Schema.toTaggedUnion("role"))
@@ -147,8 +145,6 @@ type OpenAIChatToolCallDelta = Schema.Schema.Type<typeof OpenAIChatToolCallDelta
 const OpenAIChatDelta = Schema.Struct({
  content: optionalNull(Schema.String),
  reasoning_content: optionalNull(Schema.String),
-  reasoning: optionalNull(Schema.String),
-  reasoning_text: optionalNull(Schema.String),
  tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
 })

@@ -170,7 +166,6 @@ export interface ParserState {
  readonly usage?: Usage
  readonly finishReason?: FinishReason
  readonly lifecycle: Lifecycle.State
-  readonly reasoningField?: "reasoning" | "reasoning_content" | "reasoning_text"
 }

 // =============================================================================
@@ -213,12 +208,6 @@ const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part: MediaPart
 const openAICompatibleReasoningContent = (native: unknown) =>
  isRecord(native) && typeof native.reasoning_content === "string" ? native.reasoning_content : undefined

-const reasoningField = (part: ReasoningPart) => {
-  const field = part.providerMetadata?.openai?.reasoningField
-  if (field === "reasoning" || field === "reasoning_content" || field === "reasoning_text") return field
-  return "reasoning_content"
-}
-
 const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (message: OpenAIChatRequestMessage) {
  const content: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
  for (const part of message.content) {
@@ -259,20 +248,14 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
      continue
    }
  }
-  const text = reasoning.map((part) => part.text).join("")
-  const field = reasoning[0] ? reasoningField(reasoning[0]) : "reasoning_content"
  return {
    role: "assistant" as const,
    content: content.length === 0 ? null : ProviderShared.joinText(content),
    tool_calls: toolCalls.length === 0 ? undefined : toolCalls,
    reasoning_content:
-      reasoning.length === 0
-        ? openAICompatibleReasoningContent(message.native?.openaiCompatible)
-        : field === "reasoning_content"
-          ? text
-          : undefined,
-    reasoning: reasoning.length > 0 && field === "reasoning" ? text : undefined,
-    reasoning_text: reasoning.length > 0 && field === "reasoning_text" ? text : undefined,
+      reasoning.length > 0
+        ? reasoning.map((part) => part.text).join("")
+        : openAICompatibleReasoningContent(message.native?.openaiCompatible),
  }
 })

@@ -417,12 +400,6 @@ const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
  })
 }

-const reasoningDelta = (delta: Schema.Schema.Type<typeof OpenAIChatDelta> | null | undefined) => {
-  if (delta?.reasoning_content) return { field: "reasoning_content", text: delta.reasoning_content } as const
-  if (delta?.reasoning) return { field: "reasoning", text: delta.reasoning } as const
-  if (delta?.reasoning_text) return { field: "reasoning_text", text: delta.reasoning_text } as const
-}
-
 const step = (state: ParserState, event: OpenAIChatEvent) =>
  Effect.gen(function* () {
    const events: LLMEvent[] = []
@@ -435,12 +412,8 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>

    let lifecycle = state.lifecycle

-    const reasoning = reasoningDelta(delta)
-    const reasoningField = state.reasoningField ?? reasoning?.field
-    if (reasoning)
-      lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", reasoning.text, {
-        openai: { reasoningField: reasoningField ?? reasoning.field },
-      })
+    if (delta?.reasoning_content)
+      lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", delta.reasoning_content)

    if (delta?.content) {
      lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0")
@@ -477,7 +450,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
        usage,
        finishReason,
        lifecycle,
-        reasoningField,
      },
      events,
    ] as const
@@ -510,12 +482,7 @@ export const protocol = Protocol.make({
  },
  stream: {
    event: Protocol.jsonEvent(OpenAIChatEvent),
-    initial: () => ({
-      tools: ToolStream.empty<number>(),
-      toolCallEvents: [],
-      lifecycle: Lifecycle.initial(),
-      reasoningField: undefined,
-    }),
+    initial: () => ({ tools: ToolStream.empty<number>(), toolCallEvents: [], lifecycle: Lifecycle.initial() }),
    step,
    onHalt: finishEvents,
  },
@@ -46,24 +46,45 @@ export const isContextOverflowFailure = (failure: unknown) =>
    : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "context-overflow"

 const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
+const CONTENT_POLICY_CODES = new Set(["content_filter", "content_policy_violation", "safety"])
 const QUOTA_CODES = new Set(["insufficient_quota", "usage_not_included", "billing_error"])
+const RATE_LIMIT_CODES = new Set(["resource_exhausted", "throttlingexception", "too_many_requests"])
 const SERVER_CODES = new Set([
  "api_error",
+  "internal",
  "internal_error",
+  "internal_server_error",
  "internalserverexception",
  "modelstreamerrorexception",
+  "modeltimeoutexception",
  "overloaded_error",
+  "response_error",
  "server_error",
  "server_is_overloaded",
  "serviceunavailableexception",
 ])
-const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error", "validationexception"])
-const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i
+const INVALID_REQUEST_CODES = new Set([
+  "invalid_argument",
+  "invalid_prompt",
+  "invalid_request_error",
+  "model_not_found",
+  "not_found",
+  "not_found_error",
+  "resourcenotfoundexception",
+  "request_too_large",
+  "validationexception",
+])
+const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|throttl|too[_\s]?many[_\s]?requests/i
 const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded/i
-const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i
+const CONTENT_POLICY_TEXT =
+  /content[-_\s]?(?:filter|policy)|safety (?:filter|policy|rating)|blocked (?:by|due to) safety/i
+const INVALID_REQUEST_TEXT = /validation (?:error|exception)/i
+const SERVER_TEXT = /internal server error|service unavailable/i

 export interface ProviderFailure {
  readonly message: string
+  /** Provider text used only for classification and never retained on the resulting reason. */
+  readonly evidence?: string | undefined
  readonly status?: number | undefined
  readonly code?: string | undefined
  readonly retryAfterMs?: number | undefined
@@ -76,10 +97,11 @@ export interface ProviderFailure {
 // session retry policy never needs provider-specific string matching.
 export function classifyProviderFailure(input: ProviderFailure): LLMError["reason"] {
  const body = input.http?.body ?? ""
-  const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message)]
+  const evidence = input.evidence ?? ""
+  const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message), ...providerCodes(evidence)]
    .filter((code): code is string => code !== undefined)
    .map((code) => code.toLowerCase())
-  const text = body || input.message
+  const texts = [body, input.message, evidence]
  const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http }
  const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500)

@@ -87,32 +109,44 @@ export function classifyProviderFailure(input: ProviderFailure): LLMError["reaso
    clientScoped &&
    (codes.includes("context_length_exceeded") ||
      codes.includes("model_context_window_exceeded") ||
-      isContextOverflow(text))
+      texts.some(isContextOverflow))
  )
    return new InvalidRequestReason({ ...common, classification: "context-overflow" })
-  if (CONTENT_POLICY_TEXT.test(text)) return new ContentPolicyReason(common)
-  if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
+  if (codes.some((code) => CONTENT_POLICY_CODES.has(code)) || texts.some((text) => CONTENT_POLICY_TEXT.test(text)))
+    return new ContentPolicyReason(common)
+  if (
+    codes.some((code) => QUOTA_CODES.has(code)) ||
+    (input.status === 429 && texts.some((text) => QUOTA_TEXT.test(text)))
+  )
    return new QuotaExceededReason(common)
  if (input.status === 401) return new AuthenticationReason({ ...common, kind: "invalid" })
  if (input.status === 403) return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
-  if (codes.includes("authentication_error")) return new AuthenticationReason({ ...common, kind: "invalid" })
-  if (codes.includes("permission_error"))
-    return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
+  if (codes.some((code) => code === "authentication_error" || code === "unauthenticated"))
+    return new AuthenticationReason({ ...common, kind: "invalid" })
  if (
-    codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception")
+    codes.some(
+      (code) => code === "accessdeniedexception" || code === "permission_error" || code === "permission_denied",
+    )
  )
+    return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
+  if (codes.some((code) => code.includes("rate_limit") || RATE_LIMIT_CODES.has(code)))
    return new RateLimitReason({
      ...common,
      retryAfterMs: input.retryAfterMs,
      rateLimit: input.rateLimit,
    })
-  if (RATE_LIMIT_TEXT.test(text))
+  if (texts.some((text) => RATE_LIMIT_TEXT.test(text)))
    return new RateLimitReason({
      ...common,
      retryAfterMs: input.retryAfterMs,
      rateLimit: input.rateLimit,
    })
-  if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
+  if (codes.some((code) => INVALID_REQUEST_CODES.has(code)) || texts.some((text) => INVALID_REQUEST_TEXT.test(text)))
+    return new InvalidRequestReason(common)
+  if (
+    codes.some((code) => SERVER_CODES.has(code) || code.includes("unavailable")) ||
+    texts.some((text) => SERVER_TEXT.test(text))
+  )
    return new ProviderInternalReason({
      ...common,
      status: input.status,
@@ -131,7 +165,6 @@ export function classifyProviderFailure(input: ProviderFailure): LLMError["reaso
      status: input.status,
      retryAfterMs: input.retryAfterMs,
    })
-  if (codes.some((code) => INVALID_REQUEST_CODES.has(code))) return new InvalidRequestReason(common)
  if (
    input.status === 400 ||
    input.status === 404 ||
@@ -147,7 +180,17 @@ function providerCodes(value: string) {
  const decoded = Option.getOrUndefined(decodeJson(value))
  if (!isRecord(decoded)) return []
  const error = isRecord(decoded.error) ? decoded.error : undefined
-  return [decoded.code, error?.code, error?.type].filter((value): value is string => typeof value === "string")
+  const response = isRecord(decoded.response) ? decoded.response : undefined
+  const responseError = isRecord(response?.error) ? response.error : undefined
+  return [
+    decoded.code,
+    decoded.status,
+    error?.code,
+    error?.type,
+    error?.status,
+    responseError?.code,
+    responseError?.type,
+  ].filter((value): value is string => typeof value === "string")
 }

 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -240,7 +240,32 @@ const statusError =
      })
    })

-const toHttpError = (redactedNames: ReadonlyArray<string | RegExp>) => (error: unknown) => {
+const TIMEOUT_CODES = new Set([
+  "ETIMEDOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+])
+
+const errorCause = (error: unknown) => {
+  if (HttpClientError.isHttpClientError(error) && "cause" in error.reason) return error.reason.cause
+  return error instanceof Error ? error.cause : undefined
+}
+
+const errorCode = (error: unknown) => {
+  if (typeof error !== "object" || error === null) return undefined
+  const code = Reflect.get(error, "code")
+  return typeof code === "string" ? code.toUpperCase() : undefined
+}
+
+const errorMessage = (error: unknown, fallback: string) => {
+  const cause = errorCause(error)
+  if (cause instanceof Error) return cause.message
+  if (error instanceof Error) return error.message
+  return fallback
+}
+
+export const mapHttpClientError = (error: unknown, redactedNames: ReadonlyArray<string | RegExp>) => {
  const transportError = (input: {
    readonly message: string
    readonly kind?: string | undefined
@@ -257,23 +282,30 @@ const toHttpError = (redactedNames: ReadonlyArray<string | RegExp>) => (error: u
      }),
    })

-  if (Cause.isTimeoutError(error)) {
-    return transportError({ message: error.message, kind: "Timeout" })
-  }
+  const cause = errorCause(error)
+  const code = errorCode(cause) ?? errorCode(error)
+  const request = HttpClientError.isHttpClientError(error) ? error.request : undefined
+  if (
+    Cause.isTimeoutError(error) ||
+    Cause.isTimeoutError(cause) ||
+    (error instanceof Error && error.name === "TimeoutError") ||
+    (cause instanceof Error && cause.name === "TimeoutError") ||
+    (code !== undefined && TIMEOUT_CODES.has(code))
+  )
+    return transportError({ message: errorMessage(error, "HTTP transport timed out"), kind: code ?? "Timeout", request })
  if (!HttpClientError.isHttpClientError(error)) {
-    return transportError({ message: "HTTP transport failed" })
+    return transportError({ message: errorMessage(error, "HTTP transport failed"), kind: code })
  }
-  const request = "request" in error ? error.request : undefined
  if (error.reason._tag === "TransportError") {
    return transportError({
-      message: error.reason.description ?? "HTTP transport failed",
-      kind: error.reason._tag,
+      message: error.reason.description ?? errorMessage(error, "HTTP transport failed"),
+      kind: code ?? error.reason._tag,
      request,
    })
  }
  return transportError({
-    message: `HTTP transport failed: ${error.reason._tag}`,
-    kind: error.reason._tag,
+    message: errorMessage(error, `HTTP transport failed: ${error.reason._tag}`),
+    kind: code ?? error.reason._tag,
    request,
  })
 }
@@ -287,7 +319,10 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
        const redactedNames = yield* Headers.CurrentRedactedNames
        return yield* http
          .execute(request)
-          .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)))
+          .pipe(
+            Effect.mapError((error) => mapHttpClientError(error, redactedNames)),
+            Effect.flatMap(statusError(request, redactedNames)),
+          )
      })
    return Service.of({
      execute: executeOnce,
@@ -9,7 +9,8 @@ export type {
  Interface as LLMClientShape,
  Service as LLMClientService,
 } from "./client"
-export * from "./executor"
+export { RequestExecutor, Service, fetchLayer, layer } from "./executor"
+export type { Interface } from "./executor"
 export { Auth } from "./auth"
 export { AuthOptions } from "./auth-options"
 export { Endpoint } from "./endpoint"
@@ -6,6 +6,7 @@ import { Framing } from "../framing"
 import type { Transport, TransportPrepareInput } from "./index"
 import * as ProviderShared from "../../protocols/shared"
 import { mergeJsonRecords, type LLMRequest } from "../../schema"
+import { mapHttpClientError } from "../executor"

 export type JsonRequestInput<Body> = TransportPrepareInput<Body>

@@ -134,14 +135,10 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
        .execute(prepared.request)
        .pipe(
          Effect.map((response) =>
-            prepared.framing.frame(
-              response.stream.pipe(
-                Stream.mapError((error) =>
-                  ProviderShared.eventError(
-                    `${request.model.provider}/${request.model.route.id}`,
-                    `Failed to read ${request.model.provider}/${request.model.route.id} stream`,
-                    ProviderShared.errorText(error),
-                  ),
+            Stream.unwrap(
+              Effect.map(Headers.CurrentRedactedNames, (redactedNames) =>
+                prepared.framing.frame(
+                  response.stream.pipe(Stream.mapError((error) => mapHttpClientError(error, redactedNames))),
                ),
              ),
            ),
@@ -121,6 +121,7 @@ describe("RequestExecutor", () => {
      yield* classify("Request rate increased too quickly")
      yield* classify('{"type":"error","error":{"type":"too_many_requests"}}')
      yield* classify('{"type":"error","error":{"code":"rate_limit_exceeded"}}')
+      yield* classify('{"code":"resource_exhausted"}')
    }),
  )

@@ -135,7 +136,6 @@ describe("RequestExecutor", () => {
          expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
        }).pipe(Effect.provide(responsesLayer([new Response(body, { status: 400 })])))

-      yield* classify('{"code":"resource_exhausted"}')
      yield* classify('{"code":"service_unavailable"}')
    }),
  )
@@ -1,40 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "minimax",
-    "protocol": "anthropic-messages",
-    "route": "anthropic-messages",
-    "transport": "http",
-    "model": "MiniMax-M3",
-    "tags": [
-      "prefix:anthropic-compatible-messages",
-      "provider:minimax",
-      "protocol:anthropic-messages",
-      "text",
-      "golden"
-    ],
-    "name": "anthropic-compatible-messages/minimax-m3-anthropic-compatible-text",
-    "recordedAt": "2026-07-18T03:42:22.893Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"You are concise.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Reply exactly with: Hello!\"}]}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"1a0b363d0882af316faebcec4d4855a8\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":53,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"Hello\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"!\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\"},\"usage\":{\"input_tokens\":53,\"output_tokens\":2,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    }
-  ]
-}
@@ -1,41 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "minimax",
-    "protocol": "anthropic-messages",
-    "route": "anthropic-messages",
-    "transport": "http",
-    "model": "MiniMax-M3",
-    "tags": [
-      "prefix:anthropic-compatible-messages",
-      "provider:minimax",
-      "protocol:anthropic-messages",
-      "tool",
-      "tool-call",
-      "golden"
-    ],
-    "name": "anthropic-compatible-messages/minimax-m3-anthropic-compatible-tool-call",
-    "recordedAt": "2026-07-18T03:42:23.876Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"Call tools exactly as requested.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Call get_weather with city exactly Paris.\"}]}],\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"tool_choice\":{\"type\":\"tool\",\"name\":\"get_weather\"},\"stream\":true,\"max_tokens\":80,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"6731ecc323233459d1792df9a733dd98\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":0,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":404,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"call_function_vkxtif4epmvm_1\",\"name\":\"get_weather\",\"input\":{}}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"{\\\"city\\\": \\\"Paris\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"\\\"}\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\"},\"usage\":{\"input_tokens\":290,\"output_tokens\":27,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    }
-  ]
-}
@@ -1,60 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "minimax",
-    "protocol": "anthropic-messages",
-    "route": "anthropic-messages",
-    "transport": "http",
-    "model": "MiniMax-M3",
-    "tags": [
-      "prefix:anthropic-compatible-messages",
-      "provider:minimax",
-      "protocol:anthropic-messages",
-      "tool",
-      "tool-loop",
-      "golden"
-    ],
-    "name": "anthropic-compatible-messages/minimax-m3-anthropic-compatible-tool-loop",
-    "recordedAt": "2026-07-18T03:42:25.248Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"What is the weather in Paris?\"}]}],\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":80,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"3807fa12f9ecb9357df511e099da6da0\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":0,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":417,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"call_function_yr64rwmre4gr_1\",\"name\":\"get_weather\",\"input\":{}}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"{\\\"city\\\": \\\"Paris\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"\\\"}\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\"},\"usage\":{\"input_tokens\":303,\"output_tokens\":27,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    },
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"What is the weather in Paris?\"}]},{\"role\":\"assistant\",\"content\":[{\"type\":\"tool_use\",\"id\":\"call_function_yr64rwmre4gr_1\",\"name\":\"get_weather\",\"input\":{\"city\":\"Paris\"}}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"call_function_yr64rwmre4gr_1\",\"content\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}]}],\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":80,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"92f8a1e86f29946eb2699d40a088fc08\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":41,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":430,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"Paris\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\" is sunny.\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\"},\"usage\":{\"input_tokens\":41,\"output_tokens\":4,\"cache_read_input_tokens\":430,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    }
-  ]
-}
@@ -1,34 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "anthropic/claude-sonnet-4.6",
-    "tags": [
-      "prefix:openai-compatible-chat",
-      "provider:openrouter",
-      "protocol:openai-chat",
-      "reasoning"
-    ],
-    "name": "openrouter-reasoning",
-    "recordedAt": "2026-07-18T11:28:39.267Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://openrouter.ai/api/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Think through the arithmetic, then reply with only the final integer.\"},{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219?\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"max_tokens\":1536,\"temperature\":0,\"reasoning\":{\"max_tokens\":1024}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": ": OPENROUTER PROCESSING\n\n: OPENROUTER PROCESSING\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\"173\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\"173\",\"format\":\"anthropic-claude-v1\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\n: OPENROUTER PROCESSING\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\" × 219\\n\\n173 × 200 = 34,600\\n173 × 19 = 173 × 20 - 173 = 3,460 - 173 = 3,287\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\" × 219\\n\\n173 × 200 = 34,600\\n173 × 19 = 173 × 20 - 173 = 3,460 - 173 = 3,287\",\"format\":\"anthropic-claude-v1\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\"\\n\\n34,600 + 3,287 = 37,887\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\"\\n\\n34,600 + 3,287 = 37,887\",\"format\":\"anthropic-claude-v1\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"signature\":\"EtgCCosBCA8YAipA0W4viH3kgBs43Cl5ewwVBPXTQElvzfbA2TLF4iSbKy9ZZDCSDjjAlF3Bs4ELEnP3vrrTuTioC6OB380lXQdyIDIRY2xhdWRlLXNvbm5ldC00LTY4AEIIdGhpbmtpbmdaJDRjMGYwNDZmLTI1ZmQtNDVmYi1iZmIzLWEwOGE4ZTI0OWNhNxIMMiUlJC3x/5p5PuTwGgwlc8eipZyoM94BHwMiMO45uQx/ymeOjbugi7RDVPZ4jZXSIiEbVi2CD7zPjAK5fFQoVGP1HD55v9CER823JCp6Dg5Xb7Lrk6NUd1XN2KTKrttK7mATE+IBrDTFmor/1cNeg+9gjIbxM/jn/6L5HPmh3/esEVu24Q0IGLZVoE7cTgGgxsrceKMD71Jp2XQgIWD8ltsPfWw3gSc4p+z18UuPN6LuR0mHHENTnClHrAPnOrxbDIl4ZwZgMX8YAQ==\",\"format\":\"anthropic-claude-v1\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":null},\"finish_reason\":\"stop\",\"native_finish_reason\":\"end_turn\"}]}\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"service_tier\":\"default\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\"},\"finish_reason\":\"stop\",\"native_finish_reason\":\"end_turn\"}],\"usage\":{\"prompt_tokens\":61,\"completion_tokens\":80,\"total_tokens\":141,\"cost\":0.001383,\"is_byok\":false,\"prompt_tokens_details\":{\"cached_tokens\":0,\"cache_write_tokens\":0,\"audio_tokens\":0,\"video_tokens\":0},\"cache_creation\":{\"ephemeral_5m_input_tokens\":0,\"ephemeral_1h_input_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.001383,\"upstream_inference_prompt_cost\":0.000183,\"upstream_inference_completions_cost\":0.0012},\"completion_tokens_details\":{\"reasoning_tokens\":29,\"image_tokens\":0,\"audio_tokens\":0}}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}
@@ -63,14 +63,14 @@ export const dynamicResponse = (handler: Handler) => runtimeLayer(handlerLayer(h
 * Layer that emits the supplied SSE chunks and then aborts mid-stream. Used to
 * exercise transport errors that surface during parsing.
 */
-export const truncatedStream = (chunks: ReadonlyArray<string>) =>
+export const truncatedStream = (chunks: ReadonlyArray<string>, error: unknown = new Error("connection reset")) =>
  dynamicResponse((input) =>
    Effect.sync(() => {
      const encoder = new TextEncoder()
      const stream = new ReadableStream({
        start(controller) {
          for (const chunk of chunks) controller.enqueue(encoder.encode(chunk))
-          controller.error(new Error("connection reset"))
+          controller.error(error)
        },
      })
      return input.respond(stream, { headers: SSE_HEADERS })
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { isContextOverflow } from "../src"
+import { HttpContext, HttpRequestDetails, isContextOverflow } from "../src"
 import { classifyProviderFailure } from "../src/provider-error"

 describe("provider error classification", () => {
@@ -7,6 +7,33 @@ describe("provider error classification", () => {
    expect(isContextOverflow("tokens in request more than max tokens allowed")).toBe(true)
  })

+  test("checks overflow evidence in the message when the response body is uninformative", () => {
+    expect(
+      classifyProviderFailure({
+        message: "Input is too long for requested model",
+        status: 400,
+        http: new HttpContext({
+          request: new HttpRequestDetails({ method: "POST", url: "https://provider.test", headers: {} }),
+          body: "{}",
+        }),
+      }),
+    ).toMatchObject({ classification: "context-overflow" })
+  })
+
+  test("lets semantic invalid-request codes override server status", () => {
+    expect(classifyProviderFailure({ message: "too large", status: 500, code: "request_too_large" })._tag).toBe(
+      "InvalidRequest",
+    )
+  })
+
+  test("does not treat incidental safety text as a content-policy failure", () => {
+    expect(classifyProviderFailure({ message: "Internal safety check failed", status: 500 })._tag).toBe(
+      "ProviderInternal",
+    )
+    expect(classifyProviderFailure({ message: "Blocked by safety policy", status: 400 })._tag).toBe("ContentPolicy")
+    expect(classifyProviderFailure({ message: "Blocked", status: 400, code: "SAFETY" })._tag).toBe("ContentPolicy")
+  })
+
  test("classifies V1 plain-text rate limit fallbacks", () => {
    expect(
      [
@@ -28,12 +55,48 @@ describe("provider error classification", () => {
    ).toEqual(["RateLimit", "RateLimit", "RateLimit", "RateLimit"])
  })

-  test("classifies V1 overloaded provider codes", () => {
+  test("classifies canonical provider retry codes", () => {
    expect(
      ['{"code":"resource_exhausted"}', '{"code":"service_unavailable"}'].map(
        (message) => classifyProviderFailure({ message })._tag,
      ),
-    ).toEqual(["ProviderInternal", "ProviderInternal"])
+    ).toEqual(["RateLimit", "ProviderInternal"])
+  })
+
+  test("keeps temporary per-minute quota wording retryable", () => {
+    expect(classifyProviderFailure({ message: "You exceeded your per-minute quota", status: 429 })._tag).toBe(
+      "RateLimit",
+    )
+  })
+
+  test("classifies canonical Google error codes", () => {
+    expect(
+      ["UNAUTHENTICATED", "PERMISSION_DENIED", "INVALID_ARGUMENT", "NOT_FOUND", "INTERNAL"].map(
+        (code) => classifyProviderFailure({ message: "Provider failed", code })._tag,
+      ),
+    ).toEqual(["Authentication", "Authentication", "InvalidRequest", "InvalidRequest", "ProviderInternal"])
+  })
+
+  test("classifies stripped Bedrock stream errors from their messages", () => {
+    expect(
+      ["Internal server error", "Throttling exception", "Validation error: invalid input"].map(
+        (message) => classifyProviderFailure({ message })._tag,
+      ),
+    ).toEqual(["ProviderInternal", "RateLimit", "InvalidRequest"])
+  })
+
+  test("classifies documented Bedrock exception codes", () => {
+    expect(
+      ["accessDeniedException", "modelTimeoutException", "resourceNotFoundException"].map(
+        (code) => classifyProviderFailure({ message: "Bedrock failed", code })._tag,
+      ),
+    ).toEqual(["Authentication", "ProviderInternal", "InvalidRequest"])
+  })
+
+  test("classifies Anthropic not-found stream errors as invalid requests", () => {
+    expect(classifyProviderFailure({ message: "Model unavailable", code: "not_found_error" })._tag).toBe(
+      "InvalidRequest",
+    )
  })

  test("classifies nested provider codes when a top-level code is also present", () => {
@@ -42,8 +105,9 @@ describe("provider error classification", () => {
        '{"code":"bad_request","error":{"code":"usage_not_included"}}',
        '{"code":"bad_request","error":{"code":"server_error"}}',
        '{"code":"bad_request","error":{"type":"invalid_request_error"}}',
+        '{"type":"response.failed","response":{"error":{"code":"server_error"}}}',
      ].map((message) => classifyProviderFailure({ message })._tag),
-    ).toEqual(["QuotaExceeded", "ProviderInternal", "InvalidRequest"])
+    ).toEqual(["QuotaExceeded", "ProviderInternal", "InvalidRequest", "ProviderInternal"])
  })

  test("keeps unknown and malformed provider payloads non-retryable", () => {
@@ -6,6 +6,7 @@ import { CacheHint, LLM, Message, ToolCallPart, ToolChoice } from "../../src"
 import { LLMClient } from "../../src/route"
 import { AmazonBedrock } from "../../src/providers"
 import * as BedrockConverse from "../../src/protocols/bedrock-converse"
+import { BedrockEventStream } from "../../src/protocols/bedrock-event-stream"
 import { it } from "../lib/effect"
 import { fixedResponse } from "../lib/http"
 import {
@@ -34,6 +35,16 @@ const eventFrame = (type: string, payload: object) =>
    body: utf8Encoder.encode(JSON.stringify(payload)),
  })

+const exceptionFrame = (type: string, payload: object) =>
+  codec.encode({
+    headers: {
+      ":message-type": { type: "string", value: "exception" },
+      ":exception-type": { type: "string", value: type },
+      ":content-type": { type: "string", value: "application/json" },
+    },
+    body: utf8Encoder.encode(JSON.stringify(payload)),
+  })
+
 const concat = (frames: ReadonlyArray<Uint8Array>) => {
  const total = frames.reduce((sum, frame) => sum + frame.length, 0)
  const out = new Uint8Array(total)
@@ -48,6 +59,8 @@ const concat = (frames: ReadonlyArray<Uint8Array>) => {
 const eventStreamBody = (...payloads: ReadonlyArray<readonly [string, object]>) =>
  concat(payloads.map(([type, payload]) => eventFrame(type, payload)))

+const exceptionStreamBody = (type: string, payload: object) => exceptionFrame(type, payload)
+
 // Override the default SSE content-type with the binary event-stream type so
 // the cassette layer treats the body as bytes when recording.
 const fixedBytes = (bytes: Uint8Array) =>
@@ -357,10 +370,10 @@ describe("Bedrock Converse route", () => {

  it.effect("classifies throttlingException as a rate limit", () =>
    Effect.gen(function* () {
-      const body = eventStreamBody(
-        ["messageStart", { role: "assistant" }],
-        ["throttlingException", { message: "Slow down" }],
-      )
+      const body = concat([
+        eventStreamBody(["messageStart", { role: "assistant" }]),
+        exceptionStreamBody("throttlingException", { message: "Slow down" }),
+      ])
      const error = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)), Effect.flip)

      expect(error.reason).toMatchObject({ _tag: "RateLimit", message: "Slow down" })
@@ -371,7 +384,7 @@ describe("Bedrock Converse route", () => {
    Effect.gen(function* () {
      const error = yield* LLMClient.generate(baseRequest).pipe(
        Effect.provide(
-          fixedBytes(eventStreamBody(["validationException", { message: "Input is too long for requested model" }])),
+          fixedBytes(exceptionStreamBody("validationException", { message: "Input is too long for requested model" })),
        ),
        Effect.flip,
      )
@@ -384,6 +397,35 @@ describe("Bedrock Converse route", () => {
    }),
  )

+  it.effect("fails monitored AI SDK bodies on exception wire frames", () =>
+    Effect.gen(function* () {
+      const response = BedrockEventStream.monitorExceptions(
+        new Response(exceptionStreamBody("throttlingException", { message: "Slow down" }), {
+          headers: { "content-type": "application/vnd.amazon.eventstream" },
+        }),
+      )
+      const error = yield* Effect.tryPromise({
+        try: () => response.arrayBuffer(),
+        catch: (error) => error,
+      }).pipe(Effect.flip)
+
+      expect(error).toMatchObject({ code: "throttlingException", message: "Slow down" })
+    }),
+  )
+
+  it.effect("classifies serviceUnavailableException wire frames as provider failures", () =>
+    Effect.gen(function* () {
+      const error = yield* LLMClient.generate(baseRequest).pipe(
+        Effect.provide(
+          fixedBytes(exceptionStreamBody("serviceUnavailableException", { message: "Service unavailable" })),
+        ),
+        Effect.flip,
+      )
+
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "Service unavailable" })
+    }),
+  )
+
  it.effect("rejects requests with no auth path", () =>
    Effect.gen(function* () {
      const unsignedModel = AmazonBedrock.configure({
@@ -1,5 +1,4 @@
 import * as Anthropic from "../../src/providers/anthropic"
-import * as AnthropicCompatible from "../../src/providers/anthropic-compatible"
 import { CloudflareAIGateway, CloudflareWorkersAI } from "../../src/providers/cloudflare"
 import * as Google from "../../src/providers/google"
 import * as OpenAI from "../../src/providers/openai"
@@ -18,11 +17,6 @@ const anthropic = Anthropic.configure({
 })
 const anthropicHaiku = anthropic.model("claude-haiku-4-5-20251001")
 const anthropicOpus = anthropic.model("claude-opus-4-7")
-const minimax = AnthropicCompatible.configure({
-  apiKey: process.env.MINIMAX_API_KEY ?? "fixture",
-  baseURL: "https://api.minimax.io/anthropic/v1",
-  provider: "minimax",
-}).model("MiniMax-M3")
 const google = Google.configure({ apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY ?? "fixture" })
 const gemini = google.model("gemini-2.5-flash")
 const xai = XAI.configure({ apiKey: process.env.XAI_API_KEY ?? "fixture" })
@@ -114,15 +108,6 @@ describeRecordedGoldenScenarios([
      { id: "image-tool-result", temperature: false, maxTokens: 40 },
    ],
  },
-  {
-    name: "MiniMax M3 Anthropic-compatible",
-    prefix: "anthropic-compatible-messages",
-    protocol: "anthropic-messages",
-    model: minimax,
-    requires: ["MINIMAX_API_KEY"],
-    options: { redact: { allowRequestHeaders: ["anthropic-version"] } },
-    scenarios: ["text", "tool-call", "tool-loop"],
-  },
  {
    name: "Gemini 2.5 Flash",
    prefix: "gemini",
@@ -1,67 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM, LLMEvent } from "../../src"
-import * as OpenAICompatible from "../../src/providers/openai-compatible"
-import * as OpenRouter from "../../src/providers/openrouter"
-import { LLMClient } from "../../src/route"
-import { recordedTests } from "../recorded-test"
-
-const cases = [
-  {
-    name: "OpenRouter",
-    model: OpenRouter.configure({
-      apiKey: process.env.OPENROUTER_API_KEY ?? "fixture",
-      providerOptions: { openrouter: { reasoning: { max_tokens: 1024 } } },
-    }).model("anthropic/claude-sonnet-4.6"),
-    requires: ["OPENROUTER_API_KEY"],
-    cassette: "openrouter-reasoning",
-  },
-  {
-    name: "Vercel AI Gateway",
-    model: OpenAICompatible.configure({
-      provider: "vercel-ai-gateway",
-      baseURL: "https://ai-gateway.vercel.sh/v1",
-      apiKey: process.env.AI_GATEWAY_API_KEY ?? "fixture",
-      http: { body: { reasoning: { enabled: true, max_tokens: 1024 } } },
-    }).model("anthropic/claude-sonnet-4.6"),
-    requires: ["AI_GATEWAY_API_KEY"],
-    cassette: "vercel-ai-gateway-reasoning",
-  },
-] as const
-
-for (const item of cases) {
-  const recorded = recordedTests({
-    prefix: "openai-compatible-chat",
-    provider: item.model.provider,
-    protocol: "openai-chat",
-    requires: item.requires,
-    tags: ["reasoning"],
-    metadata: { model: item.model.id },
-  })
-
-  describe(`${item.name} reasoning recorded`, () => {
-    recorded.effect.with(
-      "streams scalar reasoning",
-      { cassette: item.cassette },
-      () =>
-        Effect.gen(function* () {
-          const response = yield* LLMClient.generate(
-            LLM.request({
-              model: item.model,
-              system: "Think through the arithmetic, then reply with only the final integer.",
-              prompt: "What is 173 multiplied by 219?",
-              generation: { maxTokens: 1536, temperature: 0 },
-            }),
-          )
-
-          expect(response.text.replaceAll(",", "").trim()).toBe("37887")
-          expect(response.reasoning.length).toBeGreaterThan(0)
-          expect(response.events.some(LLMEvent.is.reasoningDelta)).toBe(true)
-          expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-            openai: { reasoningField: "reasoning" },
-          })
-        }),
-      30_000,
-    )
-  })
-}
@@ -540,33 +540,29 @@ describe("OpenAI Chat route", () => {
    }),
  )

-  it.effect("parses and replays OpenAI-compatible reasoning fields", () =>
+  it.effect("parses OpenAI-compatible reasoning content deltas", () =>
    Effect.gen(function* () {
-      const fields = ["reasoning_content", "reasoning", "reasoning_text"] as const
-      for (const field of fields) {
-        const response = yield* LLMClient.generate(request).pipe(
-          Effect.provide(
-            fixedResponse(
-              sseEvents(
-                { choices: [{ delta: { [field]: "thinking" } }] },
-                { choices: [{ delta: { content: "Hello" } }] },
-                { choices: [{ delta: {}, finish_reason: "stop" }] },
-              ),
-            ),
-          ),
-        )
+      const body = sseEvents(
+        { choices: [{ delta: { reasoning_content: "thinking" } }] },
+        { choices: [{ delta: { content: "Hello" } }] },
+        { choices: [{ delta: {}, finish_reason: "stop" }] },
+      )

-        expect(response.reasoning).toBe("thinking")
-        expect(response.text).toBe("Hello")
-        expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-          openai: { reasoningField: field },
-        })
+      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))

-        const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-          LLM.request({ model, messages: [response.message] }),
-        )
-        expect(replay.body.messages).toEqual([{ role: "assistant", content: "Hello", [field]: "thinking" }])
-      }
+      expect(response.reasoning).toBe("thinking")
+      expect(response.text).toBe("Hello")
+      expect(response.events).toMatchObject([
+        { type: "step-start", index: 0 },
+        { type: "reasoning-start", id: "reasoning-0" },
+        { type: "reasoning-delta", id: "reasoning-0", text: "thinking" },
+        { type: "reasoning-end", id: "reasoning-0" },
+        { type: "text-start", id: "text-0" },
+        { type: "text-delta", id: "text-0", text: "Hello" },
+        { type: "text-end", id: "text-0" },
+        { type: "step-finish", index: 0, reason: "stop" },
+        { type: "finish", reason: "stop" },
+      ])
    }),
  )

@@ -655,7 +651,22 @@ describe("OpenAI Chat route", () => {
      ])
      const error = yield* LLMClient.generate(request).pipe(Effect.provide(layer), Effect.flip)

-      expect(error.message).toContain("Failed to read openai/openai-chat stream")
+      expect(error).toMatchObject({ reason: { _tag: "Transport", message: "connection reset" } })
+    }),
+  )
+
+  it.effect("classifies response body timeouts as transport timeouts", () =>
+    Effect.gen(function* () {
+      const error = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          truncatedStream([], Object.assign(new Error("body timed out"), { code: "UND_ERR_BODY_TIMEOUT" })),
+        ),
+        Effect.flip,
+      )
+
+      expect(error).toMatchObject({
+        reason: { _tag: "Transport", kind: "UND_ERR_BODY_TIMEOUT", message: "body timed out" },
+      })
    }),
  )

@@ -1,161 +0,0 @@
-#!/usr/bin/env node
-
-import childProcess from "node:child_process"
-import fs from "node:fs"
-import os from "node:os"
-import path from "node:path"
-import { createRequire } from "node:module"
-import { fileURLToPath } from "node:url"
-
-const directory = path.dirname(fileURLToPath(import.meta.url))
-const require = createRequire(import.meta.url)
-const packageJson = JSON.parse(fs.readFileSync(path.join(directory, "package.json"), "utf8"))
-const command = Object.keys(packageJson.bin ?? {})[0]
-if (!command) throw new Error("OpenCode package does not declare a binary")
-
-const platform = { darwin: "darwin", linux: "linux", win32: "windows" }[os.platform()] ?? os.platform()
-const arch = { x64: "x64", arm64: "arm64", arm: "arm" }[os.arch()] ?? os.arch()
-const sourceBinary = platform === "windows" ? `${command}.exe` : command
-const targetBinary = path.resolve(directory, packageJson.bin[command])
-const dependencies = packageJson.optionalDependencies ?? {}
-const base = Object.keys(dependencies).find((name) => name.endsWith(`-${platform}-${arch}`))
-if (!base) throw new Error(`OpenCode does not provide a binary for ${platform}-${arch}`)
-
-function supportsAvx2() {
-  if (arch !== "x64") return false
-  if (platform === "linux") {
-    try {
-      return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"))
-    } catch {
-      return false
-    }
-  }
-  if (platform === "darwin") {
-    try {
-      const result = childProcess.spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], {
-        encoding: "utf8",
-        timeout: 1500,
-      })
-      return result.status === 0 && (result.stdout || "").trim() === "1"
-    } catch {
-      return false
-    }
-  }
-  if (platform === "windows") {
-    const script =
-      '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)'
-    for (const executable of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
-      try {
-        const result = childProcess.spawnSync(executable, ["-NoProfile", "-NonInteractive", "-Command", script], {
-          encoding: "utf8",
-          timeout: 3000,
-          windowsHide: true,
-        })
-        if (result.status !== 0) continue
-        const output = (result.stdout || "").trim().toLowerCase()
-        if (output === "true" || output === "1") return true
-        if (output === "false" || output === "0") return false
-      } catch {
-        continue
-      }
-    }
-  }
-  return false
-}
-
-function isMusl() {
-  if (platform !== "linux") return false
-  try {
-    if (fs.existsSync("/etc/alpine-release")) return true
-    const result = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" })
-    return `${result.stdout || ""}${result.stderr || ""}`.toLowerCase().includes("musl")
-  } catch {
-    return false
-  }
-}
-
-function packageNames() {
-  const baseline = arch === "x64" && !supportsAvx2()
-  const names =
-    platform === "linux"
-      ? isMusl()
-        ? arch === "x64"
-          ? baseline
-            ? [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
-            : [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`]
-          : [`${base}-musl`, base]
-        : arch === "x64"
-          ? baseline
-            ? [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
-            : [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
-          : [base, `${base}-musl`]
-      : arch === "x64"
-        ? baseline
-          ? [`${base}-baseline`, base]
-          : [base, `${base}-baseline`]
-        : [base]
-  return names.filter((name) => dependencies[name])
-}
-
-function copyBinary(source) {
-  if (!fs.existsSync(source)) throw new Error(`Binary not found at ${source}`)
-  fs.mkdirSync(path.dirname(targetBinary), { recursive: true })
-  if (fs.existsSync(targetBinary)) fs.unlinkSync(targetBinary)
-  try {
-    fs.linkSync(source, targetBinary)
-  } catch {
-    fs.copyFileSync(source, targetBinary)
-  }
-  fs.chmodSync(targetBinary, 0o755)
-}
-
-function resolveBinary(name) {
-  const packagePath = require.resolve(`${name}/package.json`)
-  return path.join(path.dirname(packagePath), "bin", sourceBinary)
-}
-
-function installPackage(name) {
-  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "opencode-install-"))
-  try {
-    const result = childProcess.spawnSync(
-      "npm",
-      ["install", "--ignore-scripts", "--no-save", "--loglevel=error", "--prefix", temp, `${name}@${dependencies[name]}`],
-      { stdio: "inherit", windowsHide: true },
-    )
-    if (result.status !== 0) return false
-    copyBinary(path.join(temp, "node_modules", name, "bin", sourceBinary))
-    return true
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true })
-  }
-}
-
-function verifyBinary() {
-  return (
-    childProcess.spawnSync(targetBinary, ["--version"], {
-      stdio: "ignore",
-      windowsHide: true,
-    }).status === 0
-  )
-}
-
-function main() {
-  const names = packageNames()
-  for (const name of names) {
-    try {
-      copyBinary(resolveBinary(name))
-      if (verifyBinary()) return
-    } catch {
-      if (installPackage(name) && verifyBinary()) return
-    }
-  }
-
-  throw new Error(`Failed to install OpenCode. Try manually installing ${names.map((name) => JSON.stringify(name)).join(" or ")}.`)
-}
-
-try {
-  main()
-} catch (error) {
-  console.error(error instanceof Error ? error.message : String(error))
-  process.exit(1)
-}
@@ -32,23 +32,12 @@ async function publishDistribution(input: { root: string; name: string; binary:
  if (!version) throw new Error(`No binary packages found for ${input.name}`)

  await $`mkdir -p ${input.root}/${input.name}/bin`
-  await $`cp ./script/postinstall.mjs ${input.root}/${input.name}/postinstall.mjs`
-  await Bun.file(`${input.root}/${input.name}/bin/${input.binary}.exe`).write(
-    [
-      `echo "Error: ${input.name}'s postinstall script was not run." >&2`,
-      'echo "" >&2',
-      'echo "This occurs when installation scripts are disabled." >&2',
-      'echo "Run the package postinstall script or reinstall with scripts enabled." >&2',
-      "exit 1",
-      "",
-    ].join("\n"),
-  )
+  await $`cp ./bin/opencode2.cjs ${input.root}/${input.name}/bin/${input.binary}`
  await Bun.file(`${input.root}/${input.name}/package.json`).write(
    JSON.stringify(
      {
        name: input.name,
-        bin: { [input.binary]: `./bin/${input.binary}.exe` },
-        scripts: { postinstall: "node ./postinstall.mjs" },
+        bin: { [input.binary]: `./bin/${input.binary}` },
        version,
        license: pkg.license,
        repository: { type: "git", url: "git+https://github.com/anomalyco/opencode.git" },
@@ -1,4 +1,4 @@
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Global } from "@opencode-ai/core/global"
 import { run } from "@opencode-ai/tui"
 import { Commands } from "../commands"
@@ -75,6 +75,6 @@ export default Runtime.handler(Commands, (input) =>
                : Effect.logInfo(message, tags)
        runFork(effect)
      },
-    }).pipe(Effect.provide(LayerNode.compile(Global.node)))
+    }).pipe(Effect.provide(AppNodeBuilder.build(Global.node)))
  }),
 )
@@ -7,6 +7,7 @@ import { Runtime } from "./framework/runtime"
 import { Observability } from "@opencode-ai/core/observability"
 import { Updater } from "./services/updater"
 import { InstallationChannel, InstallationVersion, InstallationLocal } from "@opencode-ai/core/installation/version"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { Global } from "@opencode-ai/core/global"
 import { AppProcess } from "@opencode-ai/core/process"
@@ -60,7 +61,7 @@ Effect.logInfo("cli starting", {
  Effect.annotateLogs({ role: "cli" }),
  Effect.provide(Config.layer),
  Effect.provide(Updater.layer),
-  Effect.provide(LayerNode.compile(LayerNode.group([Global.node, AppProcess.node, Npm.node]))),
+  Effect.provide(AppNodeBuilder.build(LayerNode.group([Global.node, AppProcess.node, Npm.node]))),
  Effect.provide(Observability.layer),
  Effect.provide(NodeServices.layer),
  Effect.scoped,
@@ -7,8 +7,8 @@
 // none block each other.
 import { Context, Effect, Layer } from "effect"
 import { resolve } from "@opencode-ai/tui/config/v1"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { makeGlobalNode } from "@opencode-ai/core/effect/app-node"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { makeRuntime } from "@opencode-ai/core/effect/runtime"
 import { loadRunProviders } from "./catalog.shared"
 import { resolveCurrentSession, sessionHistory } from "./session.shared"
@@ -130,7 +130,7 @@ const layer = Layer.effect(
 )

 const node = makeGlobalNode({ service: Service, layer, deps: [] })
-const runtime = makeRuntime(Service, LayerNode.compile(node))
+const runtime = makeRuntime(Service, AppNodeBuilder.build(node))

 // Fetches available variants and context limits for every provider/model pair.
 export async function resolveModelInfo(
@@ -8,6 +8,7 @@
 // variant and the persisted file.
 import path from "path"
 import { FSUtil } from "@opencode-ai/core/fs-util"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Context, Effect, Layer } from "effect"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { makeGlobalNode } from "@opencode-ai/core/effect/app-node"
@@ -202,7 +203,7 @@ const node = makeGlobalNode({ service: Service, layer, deps: [FSUtil.node] })

 /** @internal Exported for testing. */
 export function createVariantRuntime(replacements?: readonly LayerNode.Replacement[]): VariantRuntime {
-  const runtime = makeRuntime(Service, LayerNode.compile(node, replacements))
+  const runtime = makeRuntime(Service, AppNodeBuilder.build(node, replacements))
  return {
    resolveSavedVariant: (model) => runtime.runPromise((svc) => svc.resolveSavedVariant(model)).catch(() => undefined),
    saveVariant: (model, variant) => runtime.runPromise((svc) => svc.saveVariant(model, variant)).catch(() => {}),
@@ -1,11 +1,13 @@
 export * as ServerProcess from "./server-process"

 import { NodeServices } from "@effect/platform-node"
-import { Service, type DiscoverOptions, type Info } from "@opencode-ai/client/effect/service"
+import { Service } from "@opencode-ai/client/effect/service"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { Global } from "@opencode-ai/core/global"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { AppProcess } from "@opencode-ai/core/process"
+import { ProcessLock } from "@opencode-ai/core/util/process-lock"
 import { randomBytes, randomUUID } from "node:crypto"
 import path from "node:path"
 import { Effect, FileSystem, Logger, Option, Redacted, Schedule, Schema } from "effect"
@@ -26,7 +28,7 @@ export type Options = {
 export const run = Effect.fnUntraced(function* (options: Options) {
  return yield* processEffect(options).pipe(
    Effect.provide(Updater.layer),
-    Effect.provide(LayerNode.compile(LayerNode.group([Global.node, AppProcess.node]))),
+    Effect.provide(AppNodeBuilder.build(LayerNode.group([Global.node, AppProcess.node]))),
    Effect.provide(NodeServices.layer),
  )
 })
@@ -36,15 +38,14 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
  return yield* Effect.scoped(
    Effect.gen(function* () {
      const serviceOptions = options.mode === "service" ? yield* ServiceConfig.options() : undefined
-      const config = options.mode === "service" ? yield* ServiceConfig.read() : {}
-      const hostname = options.hostname ?? config.hostname ?? "127.0.0.1"
-      const port = options.port ?? config.port ?? (options.mode === "service" ? ServiceConfig.defaultPort() : undefined)
-      if (
-        serviceOptions !== undefined &&
-        port !== undefined &&
-        (yield* Service.incumbent({ ...serviceOptions, url: serviceURL(hostname, port) })) !== undefined
-      )
-        return
+      if (serviceOptions !== undefined) {
+        const acquired = yield* ProcessLock.acquire(serviceOptions.file + ".lock").pipe(
+          Effect.as(true),
+          Effect.catchTag("ProcessLockHeldError", () => Effect.succeed(false)),
+        )
+        if (!acquired) return yield* Effect.void
+        if ((yield* Service.discover(serviceOptions)) !== undefined) return yield* Effect.void
+      }
      const { start } = yield* Effect.promise(() => import("@opencode-ai/server/process"))
      const environmentPassword = yield* Env.password
      // Keep the lease credential out of the environment inherited by tools.
@@ -52,49 +53,25 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
        delete process.env.OPENCODE_PASSWORD
        delete process.env.OPENCODE_SERVER_PASSWORD
      }
+      const config = options.mode === "service" ? yield* ServiceConfig.read() : {}
      const password =
        options.mode === "service"
-          ? config.password || randomBytes(32).toString("base64url")
+          ? yield* ServiceConfig.password()
          : environmentPassword
            ? Redacted.value(environmentPassword)
            : randomBytes(32).toString("base64url")
      if (!password) return yield* Effect.fail(new Error("Missing server password"))
      const instanceID = randomUUID()
      const server = yield* start({
-        hostname,
-        port: Option.fromNullishOr(port),
+        hostname: options.hostname ?? config.hostname ?? "127.0.0.1",
+        port: Option.fromNullishOr(options.port ?? config.port),
        password,
        instanceID,
        service:
          serviceOptions === undefined
            ? undefined
-            : {
-                onListen: (address, shutdown) =>
-                  Effect.gen(function* () {
-                    if (!config.password) yield* ServiceConfig.password(password)
-                    return yield* register(address, password, instanceID, serviceOptions.file, shutdown)
-                  }),
-              },
-      }).pipe(
-        Effect.provide(Logger.layer([], { mergeWithExisting: false })),
-        Effect.catch((error) => {
-          if (serviceOptions === undefined || port === undefined || !addressInUse(error)) return Effect.fail(error)
-          return recognizeIncumbent(serviceOptions, hostname, port).pipe(
-            Effect.flatMap((found) =>
-              found
-                ? Effect.void
-                : Effect.fail(
-                    new Error(
-                      `Managed service port ${port} on ${hostname} is already in use by another process. ` +
-                        "Configure another port with `opencode service set port <port>` and start the service again.",
-                      { cause: error },
-                    ),
-                  ),
-            ),
-          )
-        }),
-      )
-      if (server === undefined) return
+            : { onListen: (address) => register(address, password, instanceID, serviceOptions.file) },
+      }).pipe(Effect.provide(Logger.layer([], { mergeWithExisting: false })))
      const url = HttpServer.formatAddress(server.address)
      console.log(options.mode === "stdio" ? JSON.stringify({ url }) : `server listening on ${url}`)
      if (options.mode === "default" && !environmentPassword) console.log(`server password ${password}`)
@@ -118,7 +95,6 @@ const register = Effect.fnUntraced(function* (
  password: string,
  id: string,
  file: string,
-  shutdown: Effect.Effect<void>,
 ) {
  const fs = yield* FileSystem.FileSystem
  const temp = file + "." + id + ".tmp"
@@ -131,49 +107,38 @@ const register = Effect.fnUntraced(function* (
    password,
  }
  const encoded = yield* encodeInfo(info)
+  const publish = fs.writeFileString(temp, encoded, { mode: 0o600 }).pipe(Effect.andThen(fs.rename(temp, file)))
+  yield* publish
  const current = fs.readFileString(file).pipe(
    Effect.flatMap(decodeInfo),
    Effect.orElseSucceed(() => undefined),
  )
-  const owns = (found: Info | undefined) =>
-    found?.id === info.id &&
-    found.version === info.version &&
-    found.url === info.url &&
-    found.pid === info.pid &&
-    found.password === info.password
-  yield* fs.writeFileString(temp, encoded, { mode: 0o600 }).pipe(Effect.andThen(fs.rename(temp, file)))
-  yield* current.pipe(
-    Effect.filterOrFail(owns),
+  const assertRegistration = Effect.gen(function* () {
+    const found = yield* current
+    if (
+      found !== undefined &&
+      found.id === info.id &&
+      found.version === info.version &&
+      found.url === info.url &&
+      found.pid === info.pid &&
+      found.password === info.password
+    )
+      return
+    yield* publish
+  })
+  yield* Effect.addFinalizer(() =>
+    current.pipe(
+      Effect.flatMap((current) => (current?.id === id ? fs.remove(file) : Effect.void)),
+      Effect.ignore,
+    ),
+  )
+  yield* assertRegistration.pipe(
+    Effect.catchCause((cause) => Effect.logWarning("failed to reassert service registration", { cause })),
    Effect.repeat(Schedule.spaced("5 seconds")),
-    Effect.ignore,
-    Effect.andThen(shutdown),
    Effect.forkScoped,
  )
-  return current.pipe(
-    Effect.flatMap((found) => (owns(found) ? fs.remove(file) : Effect.void)),
-    Effect.ignore,
-  )
 })

-const recognizeIncumbent = Effect.fnUntraced(function* (options: DiscoverOptions, hostname: string, port: number) {
-  const found = yield* Service.incumbent({ ...options, url: serviceURL(hostname, port) }).pipe(
-    Effect.filterOrFail((value) => value !== undefined),
-    Effect.retry(Schedule.spaced("100 millis")),
-    Effect.timeoutOption("15 seconds"),
-  )
-  return Option.isSome(found)
-})
-
-function serviceURL(hostname: string, port: number) {
-  return `http://${hostname.includes(":") ? `[${hostname}]` : hostname}:${port}`
-}
-
-function addressInUse(error: unknown): boolean {
-  if (typeof error !== "object" || error === null) return false
-  if ("code" in error && error.code === "EADDRINUSE") return true
-  return "cause" in error && addressInUse(error.cause)
-}
-
 function waitForStdinClose() {
  return Effect.callback<void>((resume) => {
    const close = () => resume(Effect.void)
@@ -30,12 +30,6 @@ export function filename(channel = InstallationChannel) {
  return `service-${Hash.fast(channel)}.json`
 }

-export function defaultPort(channel = InstallationChannel) {
-  if (channel === "latest") return 0xc0de
-  if (channel === "local") return 0xc0df
-  return 10_000 + (Number.parseInt(Hash.fast(channel).slice(0, 8), 16) % 50_000)
-}
-
 export function versionBelongsToChannel(
  version: string | undefined,
  channel = InstallationChannel,
@@ -1,6 +1,6 @@
 import { Service, type Endpoint } from "@opencode-ai/client/effect/service"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Deferred, Effect, Schema, Stream } from "effect"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import { randomBytes } from "node:crypto"
@@ -53,7 +53,7 @@ const makeEndpoint = Effect.fn("cli.standalone.endpoint")(
      pid: proc.pid,
    } satisfies Endpoint & { readonly pid: number }
  },
-  Effect.provide(LayerNode.compile(CrossSpawnSpawner.node)),
+  Effect.provide(AppNodeBuilder.build(CrossSpawnSpawner.node)),
 )

 export function start(options: Options = {}) {
@@ -1,10 +1,9 @@
 import { NodeFileSystem } from "@effect/platform-node"
-import { Service, type Info } from "@opencode-ai/client/effect/service"
+import { Service } from "@opencode-ai/client/effect/service"
 import { Database } from "@opencode-ai/core/database/database"
 import { EventV2 } from "@opencode-ai/core/event"
 import { EventTable } from "@opencode-ai/core/event/sql"
 import { Global } from "@opencode-ai/core/global"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -18,13 +17,6 @@ import os from "node:os"
 import path from "node:path"
 import { ServiceConfig } from "../src/services/service-config"

-test("managed service ports are stable per installation channel", () => {
-  expect(ServiceConfig.defaultPort("latest")).toBe(0xc0de)
-  expect(ServiceConfig.defaultPort("local")).toBe(0xc0df)
-  expect(ServiceConfig.defaultPort("preview-a")).toBe(ServiceConfig.defaultPort("preview-a"))
-  expect(ServiceConfig.defaultPort("preview-a")).not.toBe(ServiceConfig.defaultPort("preview-b"))
-})
-
 test("local channel stores service config with the local service filename", async () => {
  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-"))
  try {
@@ -98,80 +90,6 @@ test("preview registration migration never moves stable discovery", async () =>
  }
 })

-test("managed service writes its registration once", async () => {
-  const service = await startManagedService("opencode-service-once-")
-  try {
-    const before = await fs.stat(service.registration)
-    await Bun.sleep(6_000)
-    const after = await fs.stat(service.registration)
-    expect(after.ino).toBe(before.ino)
-    expect(after.mtimeMs).toBe(before.mtimeMs)
-    expect(await Bun.file(service.registration).json()).toEqual(service.info)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
-test("deleting a managed service registration stops its owner", async () => {
-  const service = await startManagedService("opencode-service-delete-")
-  try {
-    await fs.rm(service.registration)
-    expect(await waitForExit(service.owner)).toBe(true)
-    expect(await Bun.file(service.registration).exists()).toBe(false)
-    await expectPortAvailable(service.port)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
-test("deleting a failed service registration stops its owner", async () => {
-  const service = await startManagedService("opencode-service-failed-delete-", true)
-  try {
-    await waitForFailed(service.info)
-    await fs.rm(service.registration)
-    expect(await waitForExit(service.owner)).toBe(true)
-    await expectPortAvailable(service.port)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
-test("corrupting a managed service registration stops its owner", async () => {
-  const service = await startManagedService("opencode-service-corrupt-")
-  try {
-    await fs.writeFile(service.registration, "not-json")
-    expect(await waitForExit(service.owner)).toBe(true)
-    expect(await Bun.file(service.registration).text()).toBe("not-json")
-    await expectPortAvailable(service.port)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
-test("replacing a managed service registration stops its owner and preserves the foreign owner", async () => {
-  const service = await startManagedService("opencode-service-foreign-")
-  const foreign = { ...service.info, id: "foreign-owner", pid: process.pid }
-  try {
-    await fs.writeFile(service.registration, JSON.stringify(foreign))
-    expect(await waitForExit(service.owner)).toBe(true)
-    expect(await Bun.file(service.registration).json()).toEqual(foreign)
-    await expectPortAvailable(service.port)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
-test("clean managed service shutdown removes its registration", async () => {
-  const service = await startManagedService("opencode-service-clean-")
-  try {
-    await Effect.runPromise(Service.stop({ file: service.registration }).pipe(Effect.provide(NodeFileSystem.layer)))
-    expect(await waitForExit(service.owner)).toBe(true)
-    expect(await Bun.file(service.registration).exists()).toBe(false)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
 test("concurrent service processes elect one server", async () => {
  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-election-"))
  const database = path.join(root, "opencode.db")
@@ -212,34 +130,18 @@ test("concurrent service processes elect one server", async () => {
  )
  const command = [process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"]
  const registration = path.join(root, "state", "opencode", "service-local.json")
-  const port = await availablePort()
-  const config = path.join(root, "config", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  await fs.writeFile(config, JSON.stringify({ port }))
-  const processes = Array.from({ length: 10 }, () => Bun.spawn(command, { env, stderr: "pipe", stdout: "pipe" }))
+  const processes = Array.from({ length: 10 }, () => Bun.spawn(command, { env, stderr: "pipe", stdout: "ignore" }))

  try {
    const info = await waitForInfo(registration)
    const winner = processes.find((process) => process.pid === info.pid)
    const losers = processes.filter((process) => process.pid !== info.pid)
    const exited = await Promise.all(
-      losers.map((process) => Promise.race([process.exited.then(() => true), Bun.sleep(60_000).then(() => false)])),
+      losers.map((process) => Promise.race([process.exited.then(() => true), Bun.sleep(10_000).then(() => false)])),
    )

    expect(exited).toEqual(losers.map(() => true))
-    const errors = await Promise.all(
-      losers.map(
-        async (process) => (await new Response(process.stdout).text()) + (await new Response(process.stderr).text()),
-      ),
-    )
-    expect(
-      losers.map((process) => process.exitCode),
-      errors.filter(Boolean).join("\n"),
-    ).toEqual(losers.map(() => 0))
    expect(winner?.exitCode).toBe(null)
-    expect(new URL(info.url).port).toBe(String(port))
-    expect((await Bun.file(config).json()).password).toBe(info.password)
-    expect(await Bun.file(registration + ".lock").exists()).toBe(false)
    expect(
      await fetch(new URL("/api/health", info.url), {
        headers: { authorization: "Basic " + btoa(`opencode:${info.password}`) },
@@ -249,6 +151,20 @@ test("concurrent service processes elect one server", async () => {
      version: info.version,
      pid: info.pid,
    })
+    const blockedTemp = registration + "." + info.id + ".tmp"
+    await fs.mkdir(blockedTemp)
+    await fs.rm(registration)
+    await Bun.sleep(6_000)
+    expect(await Bun.file(registration).exists()).toBe(false)
+    await fs.rm(blockedTemp, { recursive: true })
+    const restored = await waitForInfo(registration)
+    expect(restored.id).toBe(info.id)
+    expect(restored.pid).toBe(info.pid)
+    await fs.writeFile(registration, "not-json")
+    const repaired = await waitForInfo(registration)
+    expect(repaired.id).toBe(info.id)
+    expect(repaired.pid).toBe(info.pid)
+
    const contender = Bun.spawn(command, { env, stderr: "pipe", stdout: "ignore" })
    try {
      const contenderExited = await Promise.race([
@@ -256,7 +172,6 @@ test("concurrent service processes elect one server", async () => {
        Bun.sleep(10_000).then(() => false),
      ])
      expect(contenderExited).toBe(true)
-      expect(contender.exitCode).toBe(0)
      expect((await waitForInfo(registration)).id).toBe(info.id)
    } finally {
      contender.kill("SIGTERM")
@@ -278,200 +193,18 @@ test("concurrent service processes elect one server", async () => {
    expect(await waitForExecutionStart(database, sessionID)).toBe(1)
    await Effect.runPromise(Service.stop({ file: registration }).pipe(Effect.provide(NodeFileSystem.layer)))
    await winner?.exited
-    expect(await Bun.file(registration).exists()).toBe(false)
  } finally {
    processes.forEach((process) => process.kill("SIGTERM"))
    await Promise.all(processes.map((process) => process.exited))
-    await fs.rm(root, { recursive: true, force: true })
-  }
-}, 120_000)
-
-test("configured managed service port overrides the channel default", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-port-"))
-  const port = await availablePort()
-  const env = serviceEnv(root)
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  const config = path.join(root, "config", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  await fs.writeFile(config, JSON.stringify({ port, password: "" }))
-  const owner = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env,
-    stderr: "pipe",
-    stdout: "ignore",
-  })
-  try {
-    const info = await waitForInfo(registration)
-    expect(new URL(info.url).port).toBe(String(port))
-    expect(info.password).not.toBe("")
-    expect((await Bun.file(config).json()).password).toBe(info.password)
-    await Effect.runPromise(Service.stop({ file: registration }).pipe(Effect.provide(NodeFileSystem.layer)))
-    await owner.exited
-  } finally {
-    owner.kill("SIGTERM")
-    await owner.exited
-    await fs.rm(root, { recursive: true, force: true })
-  }
-}, 30_000)
-
-test("unrelated managed port occupancy reports an actionable conflict", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-conflict-"))
-  const listener = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response("unrelated") })
-  const port = listener.port
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  await fs.writeFile(path.join(root, "config", "opencode", "service-local.json"), JSON.stringify({ port }))
-  const contender = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env: serviceEnv(root),
-    stderr: "pipe",
-    stdout: "pipe",
-  })
-  try {
-    expect(await contender.exited).not.toBe(0)
-    const output = (await new Response(contender.stdout).text()) + (await new Response(contender.stderr).text())
-    expect(output).toContain(`Managed service port ${port} on 127.0.0.1 is already in use by another process`)
-    expect(output).toContain("opencode service set port <port>")
-    expect(await Bun.file(registration).exists()).toBe(false)
-  } finally {
-    listener.stop(true)
-    contender.kill("SIGTERM")
-    await contender.exited
-    await fs.rm(root, { recursive: true, force: true })
-  }
-}, 30_000)
-
-test("unresponsive managed port occupancy reports a bounded conflict", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-unresponsive-conflict-"))
-  const recognizing = Promise.withResolvers<void>()
-  const requests = { count: 0 }
-  using listener = Bun.serve({
-    hostname: "127.0.0.1",
-    port: 0,
-    fetch() {
-      requests.count += 1
-      if (requests.count === 2) recognizing.resolve()
-      return new Promise<Response>(() => {})
-    },
-  })
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  await fs.mkdir(path.dirname(registration), { recursive: true })
-  await fs.writeFile(
-    path.join(root, "config", "opencode", "service-local.json"),
-    JSON.stringify({ port: listener.port }),
-  )
-  const stale = {
-    id: "stale",
-    version: InstallationVersion,
-    url: "http://127.0.0.1:1",
-    pid: process.pid,
-    password: "stale",
-  }
-  await fs.writeFile(registration, JSON.stringify(stale))
-  const contender = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env: serviceEnv(root),
-    stderr: "pipe",
-    stdout: "pipe",
-  })
-
-  try {
-    expect(await Promise.race([recognizing.promise.then(() => true), Bun.sleep(20_000).then(() => false)])).toBe(true)
-    const exitCode = await Promise.race([contender.exited, Bun.sleep(20_000).then(() => undefined)])
-    expect(exitCode).toBe(1)
-    const output = (await new Response(contender.stdout).text()) + (await new Response(contender.stderr).text())
-    expect(output).toContain(`Managed service port ${listener.port} on 127.0.0.1 is already in use by another process`)
-    expect(await Bun.file(registration).json()).toEqual(stale)
-  } finally {
-    contender.kill("SIGTERM")
-    await contender.exited
-    await fs.rm(root, { recursive: true, force: true })
-  }
-}, 45_000)
-
-test("port contender recognizes an incumbent registered during the bind race", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-bind-race-"))
-  const recognizing = Promise.withResolvers<void>()
-  const requests = { count: 0 }
-  using listener = Bun.serve({
-    hostname: "127.0.0.1",
-    port: 0,
-    fetch() {
-      requests.count += 1
-      if (requests.count === 2) recognizing.resolve()
-      return Response.json({ healthy: true, version: InstallationVersion, pid: process.pid }, { status: 503 })
-    },
-  })
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  const config = path.join(root, "config", "opencode", "service-local.json")
-  await fs.mkdir(path.dirname(config), { recursive: true })
-  await fs.writeFile(config, JSON.stringify({ port: listener.port }))
-  await fs.mkdir(path.dirname(registration), { recursive: true })
-  await fs.writeFile(
-    registration,
-    JSON.stringify({
-      id: "stale",
-      version: InstallationVersion,
-      url: "http://127.0.0.1:1",
-      pid: 2_147_483_647,
-      password: "stale",
-    }),
-  )
-  const contender = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env: serviceEnv(root),
-    stderr: "pipe",
-    stdout: "ignore",
-  })
-
-  try {
-    expect(await Promise.race([recognizing.promise.then(() => true), Bun.sleep(20_000).then(() => false)])).toBe(true)
-    await Bun.sleep(8_000)
-    const info = {
-      id: "incumbent",
-      version: InstallationVersion,
-      url: `http://127.0.0.1:${listener.port}`,
-      pid: process.pid,
-      password: "incumbent",
+    try {
+      expect(await Bun.file(registration).exists()).toBe(false)
+    } finally {
+      await fs.rm(root, { recursive: true, force: true })
    }
-    await fs.writeFile(registration, JSON.stringify(info))
-
-    expect(await Promise.race([contender.exited, Bun.sleep(20_000).then(() => undefined)])).toBe(0)
-    expect(await Bun.file(registration).json()).toEqual(info)
-  } finally {
-    contender.kill("SIGTERM")
-    await contender.exited
-    await fs.rm(root, { recursive: true, force: true })
  }
-}, 45_000)
+}, 60_000)

-test("stale dead registration is replaced after binding the selected port", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-stale-"))
-  const port = await availablePort()
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  await fs.mkdir(path.dirname(registration), { recursive: true })
-  await fs.writeFile(path.join(root, "config", "opencode", "service-local.json"), JSON.stringify({ port }))
-  await fs.writeFile(
-    registration,
-    JSON.stringify({ id: "dead", version: "dead", url: `http://127.0.0.1:${port}`, pid: 2_147_483_647 }),
-  )
-  const owner = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env: serviceEnv(root),
-    stderr: "pipe",
-    stdout: "ignore",
-  })
-  try {
-    const info = await waitForInfo(registration, (value) => value.id !== "dead")
-    expect(new URL(info.url).port).toBe(String(port))
-    expect(info.pid).toBe(owner.pid)
-    await Effect.runPromise(Service.stop({ file: registration }).pipe(Effect.provide(NodeFileSystem.layer)))
-    await owner.exited
-  } finally {
-    owner.kill("SIGTERM")
-    await owner.exited
-    await fs.rm(root, { recursive: true, force: true })
-  }
-}, 30_000)
-
-test("a failed service stays registered and owns the selected port until stopped", async () => {
+test("a failed service stays registered and owns the lock until stopped", async () => {
  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-failed-"))
  const database = path.join(root, "database")
  await fs.mkdir(database)
@@ -491,12 +224,10 @@ test("a failed service stays registered and owns the selected port until stopped

  try {
    const info = await waitForInfo(registration)
-    await waitForFailed(info)
    expect(owner.exitCode).toBe(null)

    const contender = Bun.spawn(command, { env, stderr: "pipe", stdout: "ignore" })
    expect(await Promise.race([contender.exited.then(() => true), Bun.sleep(10_000).then(() => false)])).toBe(true)
-    expect(contender.exitCode).toBe(0)
    expect((await waitForInfo(registration)).id).toBe(info.id)
    expect(owner.exitCode).toBe(null)

@@ -544,86 +275,13 @@ function waitForExecutionStart(file: string, sessionID: SessionV2.ID) {
  )
 }

-async function waitForInfo(file: string, accept: (info: Info) => boolean = () => true) {
+async function waitForInfo(file: string) {
  for (let attempt = 0; attempt < 400; attempt++) {
    const value = await Bun.file(file)
      .json()
      .catch(() => undefined)
-    if (value !== undefined) {
-      const info = await Schema.decodeUnknownPromise(Service.Info)(value)
-      if (accept(info)) return info
-    }
+    if (value !== undefined) return Schema.decodeUnknownPromise(Service.Info)(value)
    await Bun.sleep(50)
  }
  throw new Error("Timed out waiting for service registration")
 }
-
-async function waitForFailed(info: Info) {
-  for (let attempt = 0; attempt < 400; attempt++) {
-    const status = await fetch(new URL("/api/health", info.url), {
-      headers: { authorization: "Basic " + btoa(`opencode:${info.password}`) },
-    })
-      .then((response) => response.status)
-      .catch(() => undefined)
-    if (status === 500) return
-    await Bun.sleep(50)
-  }
-  throw new Error("Timed out waiting for service boot failure")
-}
-
-async function availablePort() {
-  const server = Bun.serve({ port: 0, fetch: () => new Response() })
-  const port = server.port
-  await server.stop(true)
-  if (port === undefined) throw new Error("Server did not bind a port")
-  return port
-}
-
-function serviceEnv(root: string) {
-  return {
-    ...process.env,
-    HOME: root,
-    OPENCODE_DB: path.join(root, "opencode.db"),
-    OPENCODE_TEST_HOME: root,
-    XDG_CACHE_HOME: path.join(root, "cache"),
-    XDG_CONFIG_HOME: path.join(root, "config"),
-    XDG_DATA_HOME: path.join(root, "data"),
-    XDG_STATE_HOME: path.join(root, "state"),
-  }
-}
-
-async function startManagedService(prefix: string, failBoot = false) {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), prefix))
-  const port = await availablePort()
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  if (failBoot) await fs.mkdir(path.join(root, "database"))
-  await fs.writeFile(path.join(root, "config", "opencode", "service-local.json"), JSON.stringify({ port }))
-  const owner = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env: failBoot ? { ...serviceEnv(root), OPENCODE_DB: path.join(root, "database") } : serviceEnv(root),
-    stderr: "pipe",
-    stdout: "ignore",
-  })
-  const info = await waitForInfo(registration).catch(async (cause) => {
-    owner.kill("SIGTERM")
-    await owner.exited
-    await fs.rm(root, { recursive: true, force: true })
-    throw cause
-  })
-  return { root, port, registration, owner, info }
-}
-
-async function stopManagedService(service: Awaited<ReturnType<typeof startManagedService>>) {
-  service.owner.kill("SIGTERM")
-  await service.owner.exited
-  await fs.rm(service.root, { recursive: true, force: true })
-}
-
-function waitForExit(process: Bun.Subprocess, timeout = 10_000) {
-  return Promise.race([process.exited.then(() => true), Bun.sleep(timeout).then(() => false)])
-}
-
-async function expectPortAvailable(port: number) {
-  const server = Bun.serve({ hostname: "127.0.0.1", port, fetch: () => new Response() })
-  await server.stop(true)
-}
@@ -29,17 +29,6 @@ export const discover = Effect.fn("service.discover")(function* (options: Discov
  return (yield* discoverLocal(options))?.endpoint
 })

-/** Recognize an authenticated compatible service bound to an expected URL, including while it starts or fails. */
-export const incumbent = Effect.fn("service.incumbent")(function* (
-  options: DiscoverOptions & { readonly url: string },
-) {
-  const info = yield* read(options.file)
-  const found = info === undefined ? undefined : yield* probe({ ...info, url: options.url })
-  if (found === undefined || found.legacy) return undefined
-  if (options.version !== undefined && found.version !== options.version) return undefined
-  return { endpoint: found.endpoint, state: found.state }
-})
-
 const discoverLocal = Effect.fnUntraced(function* (options: DiscoverOptions) {
  const found = (yield* registered(options.file)).service
  if (found?.state !== "ready") return undefined
@@ -112,15 +101,8 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
      lastSpawn = Date.now()
    }
    return Option.none<LocalService>()
-  }).pipe(
-    Effect.repeat({
-      until: Option.isSome,
-      schedule: Schedule.max([Schedule.spaced("1 second"), Schedule.recurs(120)]),
-    }),
-  )
-  if (Option.isNone(found))
-    return yield* Effect.fail(new Error("Timed out waiting for the background service to start"))
-  return found.value.endpoint
+  }).pipe(Effect.repeat({ until: Option.isSome, schedule: Schedule.spaced("1 second") }))
+  return Option.getOrThrow(found).endpoint
 })

 function contenderFailure(contender: Contender) {
@@ -291,4 +273,4 @@ const requestStop = Effect.fnUntraced(function* (service: LocalService) {
 })

 /** Effect-based local service lifecycle operations. */
-export const Service = { discover, incumbent, ensure, stop, headers, Info }
+export const Service = { discover, ensure, stop, headers, Info }
@@ -2,7 +2,13 @@ import { readFile } from "node:fs/promises"
 import { spawn, type ChildProcess } from "node:child_process"
 import { homedir } from "node:os"
 import { join } from "node:path"
-import type { DiscoverOptions, Endpoint, Info, EnsureOptions, StopOptions } from "../service.js"
+import type {
+  DiscoverOptions,
+  Endpoint,
+  Info,
+  EnsureOptions,
+  StopOptions,
+} from "../service.js"
 import type { ServiceHealth, ServiceStopResponse } from "./generated/types.js"

 export * from "../service.js"
@@ -32,7 +38,6 @@ async function discoverLocal(options: DiscoverOptions) {

 /** Ensure a healthy, compatible local service is running. */
 export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
-  const deadline = Date.now() + 120_000
  const contenders = new Set<Contender>()
  let announced = false
  let lastSpawn = 0
@@ -61,7 +66,6 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
  }

  while (true) {
-    if (Date.now() >= deadline) throw new Error("Timed out waiting for the background service to start")
    const registration = await registered(options.file, true)

    if (registration.service !== undefined) {
@@ -124,9 +128,7 @@ function fallback() {
 /** Create HTTP authentication headers for a service endpoint. */
 export function headers(endpoint: Endpoint) {
  if (endpoint.auth === undefined) return undefined
-  return {
-    authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64"),
-  }
+  return { authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64") }
 }

 async function read(file?: string) {
@@ -225,8 +227,7 @@ async function kill(service: LocalService, options: { readonly file?: string })
  const latest = await find(options)
  if (latest === undefined || !same(latest.info, service.info)) return
  signal(service.info.pid, "SIGKILL")
-  if (!(await waitUntilStopped(service.info.pid)))
-    throw new Error(`Server process ${service.info.pid} is still running`)
+  if (!(await waitUntilStopped(service.info.pid))) throw new Error(`Server process ${service.info.pid} is still running`)
 }

 async function requestStop(service: LocalService) {
@@ -19,7 +19,7 @@ ultimate source of truth.
 - [x] Top-level `await` and `return` through the program's implicit async-function scope.
 - [x] Explicit `return`, final top-level expression as a REPL-style result, and `null` when no value is produced.
 - [x] Program results use JSON-like boundaries, with `undefined` and non-finite numbers normalized to `null`. Tool
-      arguments follow JSON serialization semantics before their schema applies (see the tools section).
+      arguments remain subject to their schema and the outbound-handling gap listed below.
 - [x] Live Date, RegExp, Map, Set, URL, and URLSearchParams values inside CodeMode.
 - [x] Tool calls through the host-provided `tools` tree only.
 - [x] The global `search(...)` built-in: synchronous tool discovery that counts as an admitted tool call and is
@@ -80,7 +80,7 @@ ultimate source of truth.
 - [x] Expression and block function bodies.
 - [x] User callbacks for the supported Array, Map, Set, URLSearchParams, sort, string-replacement, and `Array.from`
      mapper APIs, with one shared acceptance rule everywhere including promise reactions.
- [x] `Boolean`, `Number`, `String`, `parseInt`, `parseFloat`, `isFinite`, `isNaN`, and URI helpers as callbacks.
+- [x] `Boolean`, `Number`, `String`, `parseInt`, `parseFloat`, and URI helpers as callbacks.
 - [x] Built-in method references as callbacks, such as `values.map(Math.abs)`, `records.map(JSON.stringify)`,
      `items.forEach(console.log)`, and `Promise.resolve(-1).then(Math.abs)`. Extra callback arguments a built-in
      does not consume are ignored, like JS; consumed arguments stay strictly validated (`Math.floor` still rejects a
@@ -157,11 +157,8 @@ ultimate source of truth.
 - [x] Dotted tool names are canonicalized into namespace paths; a path can be both callable and a namespace, and the
      last definition supplied for a canonical path wins.
 - [x] Tool path segments may be named `constructor`, `prototype`, or `__proto__` because paths use inert Map keys.
- [x] Outbound tool arguments follow JSON serialization semantics, like `JSON.stringify`: object properties with
-      `undefined` values are dropped, `undefined` array elements and non-finite numbers become `null`, and sparse
-      arrays densify. Tools never receive `undefined` inside their input object, though a bare `tools.t(undefined)`
-      argument still reaches schema decoding as `undefined`. Program results keep the stricter
-      normalization where every `undefined` becomes `null`.
+- [ ] Reject `undefined` and non-finite numbers in outbound tool arguments before render-only and OpenAPI tools run;
+      retain null normalization for program results and JSON serialization.
 - [ ] Tokenize and case-fold non-ASCII tool paths, descriptions, and queries for tool search.

 ## Objects and properties
@@ -213,12 +210,9 @@ ultimate source of truth.
 - [x] `localeCompare`; locale and options arguments are currently ignored.
 - [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
-      native JS, `split(undefined)` returns the whole string, and `includes`/`startsWith`/`endsWith` reject regular
-      expressions with a native-style `TypeError`. Opaque runtime references still reject as data errors, and
-      `repeat` still requires a finite non-negative count.
- [x] Native no-argument parity for `match()`, `matchAll()`, and `search()`; all behave as an empty pattern. Present
-      arguments must still be a regular expression or string pattern.
+- [ ] Native argument coercion for supported String methods; for example, `includes(1)` and `slice("1")` currently
+      reject instead of coercing.
+- [ ] Native no-argument parity for `match()` and `search()`.

 ## Numbers and Math

@@ -232,16 +226,13 @@ ultimate source of truth.
 - [x] Math methods: `random`, `max`, `min`, `abs`, `acos`, `acosh`, `asin`, `asinh`, `atan`, `atan2`, `atanh`,
      `floor`, `ceil`, `round`, `trunc`, `sign`, `sqrt`, `cbrt`, `pow`, `hypot`, `cos`, `cosh`, `sin`, `sinh`,
      `tan`, `tanh`, `log`, `log2`, `log10`, `log1p`, `exp`, `expm1`, `f16round`, `fround`, `clz32`, and `imul`.
- [x] Native zero-argument behavior for `Number()` and `String()`: they produce `0` and `""`, while
-      `Number(undefined)` stays `NaN` and `String(undefined)` stays `"undefined"`.
- [x] `++` and `--` use CodeMode numeric coercion (numeric strings increment, plain data objects become `NaN`, Dates
-      use their epoch time) and reject opaque runtime references as data errors.
- [x] Unknown static members on global namespaces and on `Number`/`String`/the coercion functions read as `undefined`
-      for feature detection. Calling any undefined value reports a native-style `TypeError` naming the callee, for
-      example `Math.sumPrecise is not a function.` Blocked members (`constructor`, `__proto__`, ...) still throw,
-      and unknown `Promise` statics keep their descriptive error.
+- [ ] Native zero-argument behavior for `Number()` and `String()`; they currently do not produce `0` and `""`.
+- [ ] `++` and `--` must use CodeMode numeric coercion and reject opaque runtime references; they currently call host
+      `Number(...)` directly.
+- [ ] Unknown static members must read as `undefined` for feature detection; some currently appear callable or throw
+      during property access.
 - [ ] `Math.sumPrecise`.
- [x] Global coercing `isFinite` and `isNaN`; opaque runtime references reject as data errors, like `Number(...)`.
+- [ ] Global coercing `isFinite` and `isNaN`.

 ## JSON and console

@@ -44,7 +44,7 @@ export const normalizeError = (error: unknown): Diagnostic => {
      message = (value as { message: string }).message
    } else {
      try {
-        message = JSON.stringify(copyOut(value, "json")) ?? String(value)
+        message = JSON.stringify(copyOut(value)) ?? String(value)
      } catch {
        message = String(value)
      }
@@ -52,7 +52,7 @@ export const executeWithLimits = <const Provided extends Record<string, unknown>
            logs,
          )
          const value = yield* interpreter.run(program)
-          const result = copyOut(copyIn(value, "Execution result"), "nullify") as DataValue
+          const result = copyOut(copyIn(value, "Execution result"), true) as DataValue
          returned = { value: result, promises }
          const warnings = yield* promises.interrupt()
          return {
@@ -12,7 +12,7 @@ import {
  PromiseNamespace,
  UriFunction,
 } from "./model.js"
-import { containsOpaqueReference, rejectCircularInsertion, typeofValue } from "./references.js"
+import { rejectCircularInsertion, typeofValue } from "./references.js"
 import { isBlockedMember, type SafeObject } from "../tool-runtime.js"
 import {
  CodeModeDate,
@@ -137,31 +137,21 @@ export const invokeGlobalMethod = (ref: GlobalMethodReference, args: Array<unkno
  return invokeJsonMethod(ref.name, args, node)
 }

-const requireDataArgument = (name: string, index: number, arg: unknown, node: AstNode): unknown => {
-  if (containsOpaqueReference(arg)) {
-    throw new InterpreterRuntimeError(
-      `String.${name} expects argument ${index + 1} to be a data value.`,
-      node,
-      "InvalidDataValue",
-    )
-  }
-  return arg
-}
-
 const invokeStringMethod = (value: string, name: string, args: Array<unknown>, node: AstNode): unknown => {
-  // Coerce arguments like native JS; opaque runtime references still reject.
-  const str = (index: number): string => coerceToString(requireDataArgument(name, index, args[index], node))
-  const num = (index: number): number => coerceToNumber(requireDataArgument(name, index, args[index], node))
+  const str = (index: number): string => {
+    const arg = args[index]
+    if (typeof arg !== "string")
+      throw new InterpreterRuntimeError(`String.${name} expects argument ${index + 1} to be a string.`, node)
+    return arg
+  }
+  const num = (index: number): number => {
+    const arg = args[index]
+    if (typeof arg !== "number")
+      throw new InterpreterRuntimeError(`String.${name} expects argument ${index + 1} to be a number.`, node)
+    return arg
+  }
  const optNum = (index: number): number | undefined => (args[index] === undefined ? undefined : num(index))
  const optStr = (index: number): string | undefined => (args[index] === undefined ? undefined : str(index))
-  const rejectRegex = (): void => {
-    if (args[0] instanceof CodeModeRegExp) {
-      throw new InterpreterRuntimeError(
-        `String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`,
-        node,
-      ).as("TypeError")
-    }
-  }

  let result: unknown
  switch (name) {
@@ -197,11 +187,8 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
      break
    }
    case "split": {
-      // Native: an undefined separator returns the whole string, not a split on "undefined",
-      // unless the limit truncates to zero.
-      if (args[0] === undefined) {
-        const requestedLimit = optNum(1)
-        result = requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value]
+      if (args.length === 0) {
+        result = [value]
        break
      }
      if (args[0] instanceof CodeModeRegExp) {
@@ -216,15 +203,12 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
      result = value.slice(optNum(0), optNum(1))
      break
    case "includes":
-      rejectRegex()
      result = value.includes(str(0), optNum(1))
      break
    case "startsWith":
-      rejectRegex()
      result = value.startsWith(str(0), optNum(1))
      break
    case "endsWith":
-      rejectRegex()
      result = value.endsWith(str(0), optNum(1))
      break
    case "indexOf":
@@ -279,7 +263,7 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
    case "repeat": {
      const count = num(0)
      if (!Number.isFinite(count) || count < 0)
-        throw new InterpreterRuntimeError("String.repeat expects a finite non-negative count.", node).as("RangeError")
+        throw new InterpreterRuntimeError("String.repeat expects a finite non-negative count.", node)
      result = value.repeat(count)
      break
    }
@@ -317,8 +301,6 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
  return boundedData(result, `String.${name} result`)
 }

-export const arrayStatics = new Set(["isArray", "of", "from"])
-
 const invokeArrayStatic = (name: string, args: Array<unknown>, node: AstNode): unknown => {
  switch (name) {
    case "isArray":
@@ -418,9 +400,11 @@ const invokeStringReplacer = <R>(
    if (name === "replace") value.replace(pattern.regex, collect)
    else value.replaceAll(pattern.regex, collect)
  } else {
-    const search = coerceToString(requireDataArgument(name, 0, pattern, node))
-    if (name === "replace") value.replace(search, collect)
-    else value.replaceAll(search, collect)
+    if (typeof pattern !== "string") {
+      throw new InterpreterRuntimeError(`String.${name} expects argument 1 to be a string.`, node)
+    }
+    if (name === "replace") value.replace(pattern, collect)
+    else value.replaceAll(pattern, collect)
  }

  return Effect.gen(function* () {
@@ -105,7 +105,7 @@ export class GlobalMethodReference {
 }

 export class CoercionFunction {
-  constructor(readonly name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN") {}
+  constructor(readonly name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat") {}
 }

 export class UriFunction {
@@ -10,7 +10,6 @@ import {
  ErrorConstructorReference,
  GlobalMethodReference,
  GlobalNamespace,
-  type GlobalNamespaceName,
  getArray,
  getBoolean,
  getNode,
@@ -35,7 +34,7 @@ import {
  UriFunction,
 } from "./model.js"
 import { caughtErrorValue, constructErrorValue } from "./errors.js"
-import { arrayStatics, type CallbackRunner, invokeArrayFrom, invokeGlobalMethod, invokeIntrinsic } from "./methods.js"
+import { type CallbackRunner, invokeArrayFrom, invokeGlobalMethod, invokeIntrinsic } from "./methods.js"
 import {
  constructPromise,
  invokePromiseInstanceMethod,
@@ -47,11 +46,10 @@ import { containsOpaqueReference, isRuntimeReference, rejectCircularInsertion, t
 import { ScopeStack } from "./scope.js"
 import { arrayMethods, mapMethods, setMethods, spreadItems } from "../stdlib/collections.js"
 import { consoleMethods, formatConsoleMessage } from "../stdlib/console.js"
-import { dateMethods, dateStatics } from "../stdlib/date.js"
-import { jsonStatics } from "../stdlib/json.js"
-import { mathConstants, mathMethods } from "../stdlib/math.js"
+import { dateMethods } from "../stdlib/date.js"
+import { mathConstants } from "../stdlib/math.js"
 import { numberConstants, numberMethods, numberStatics } from "../stdlib/number.js"
-import { objectMethodsPreservingIdentity, objectStatics } from "../stdlib/object.js"
+import { objectMethodsPreservingIdentity } from "../stdlib/object.js"
 import { promiseStatics } from "../stdlib/promise.js"
 import { escapeRegexHint, regexpMethods, regexpProperties, regexFailureReason } from "../stdlib/regexp.js"
 import { stringMethods, stringStatics } from "../stdlib/string.js"
@@ -59,7 +57,6 @@ import {
  urlMethods,
  urlProperties,
  urlSearchParamsMethods,
-  urlStatics,
  urlWritableProperties,
  invokeUriFunction,
  uriArgument,
@@ -86,32 +83,6 @@ import {
  CodeModeURLSearchParams,
 } from "../values.js"

-const globalStaticMembers: Partial<Record<GlobalNamespaceName, Set<string>>> = {
-  Object: objectStatics,
-  Math: mathMethods,
-  JSON: jsonStatics,
-  Array: arrayStatics,
-  console: consoleMethods,
-  Date: dateStatics,
-  URL: urlStatics,
-}
-
-const calleeDescription = (callee: AstNode): string => {
-  if (callee.type === "Identifier") return getString(callee, "name")
-  if (callee.type === "MemberExpression") {
-    const object = getNode(callee, "object")
-    const property = getNode(callee, "property")
-    const key =
-      callee.computed !== true && property.type === "Identifier"
-        ? getString(property, "name")
-        : property.type === "Literal" && typeof property.value === "string"
-          ? property.value
-          : undefined
-    if (object.type === "Identifier" && key !== undefined) return `${getString(object, "name")}.${key}`
-  }
-  return "The called value"
-}
-
 const instanceofValue = (lhs: unknown, rhs: unknown, node: AstNode): boolean => {
  if (rhs instanceof ErrorConstructorReference) {
    const brand = errorBrandName(lhs)
@@ -228,8 +199,6 @@ export class Interpreter<R> {
    globalScope.set("console", { mutable: false, value: new GlobalNamespace("console") })
    globalScope.set("parseInt", { mutable: false, value: new CoercionFunction("parseInt") })
    globalScope.set("parseFloat", { mutable: false, value: new CoercionFunction("parseFloat") })
-    globalScope.set("isFinite", { mutable: false, value: new CoercionFunction("isFinite") })
-    globalScope.set("isNaN", { mutable: false, value: new CoercionFunction("isNaN") })
    globalScope.set("Date", { mutable: false, value: new GlobalNamespace("Date") })
    globalScope.set("RegExp", { mutable: false, value: new GlobalNamespace("RegExp") })
    globalScope.set("Map", { mutable: false, value: new GlobalNamespace("Map") })
@@ -1485,23 +1454,10 @@ export class Interpreter<R> {
      throw new InterpreterRuntimeError(`Unsupported update operator '${operator}'.`, node)
    }

-    // CodeMode numeric coercion, not host Number(): null-prototype data objects would make
-    // the host throw during ToPrimitive, and opaque runtime references must reject clearly.
-    const operand = (current: unknown): number => {
-      if (containsOpaqueReference(current)) {
-        throw new InterpreterRuntimeError(
-          `'${operator}' requires a data value in CodeMode.`,
-          argument,
-          "InvalidDataValue",
-        )
-      }
-      return coerceToNumber(current)
-    }
-
    if (argument.type === "Identifier") {
      return Effect.sync(() => {
        const name = getString(argument, "name")
-        const current = operand(this.scopes.get(name, argument))
+        const current = Number(this.scopes.get(name, argument))
        const next = current + increment
        this.scopes.set(name, next, argument)
        return prefix ? next : current
@@ -1510,7 +1466,7 @@ export class Interpreter<R> {

    if (argument.type === "MemberExpression") {
      return this.modifyMember(argument, (current) => {
-        const value = operand(current)
+        const value = Number(current)
        const next = value + increment
        return Effect.succeed({ write: true, next, result: prefix ? next : value })
      })
@@ -1607,9 +1563,6 @@ export class Interpreter<R> {
        callable.settle(args[0])
        return undefined
      }
-      if (callable === undefined || callable === null) {
-        throw new InterpreterRuntimeError(`${calleeDescription(callee)} is not a function.`, callee).as("TypeError")
-      }
      throw new InterpreterRuntimeError("Only tools are callable in CodeMode.", callee)
    })
  }
@@ -1880,18 +1833,16 @@ export class Interpreter<R> {
      }

      if (objectValue instanceof GlobalNamespace) {
-        if (typeof key === "string" && isBlockedMember(key)) {
-          throw new InterpreterRuntimeError(`${objectValue.name}.${key} is not available in CodeMode.`, propertyNode)
+        if (typeof key !== "string" || isBlockedMember(key)) {
+          throw new InterpreterRuntimeError(
+            `${objectValue.name}.${String(key)} is not available in CodeMode.`,
+            propertyNode,
+          )
        }
-        if (typeof key !== "string") return new ComputedValue(undefined)
        if (objectValue.name === "Math" && mathConstants.has(key)) {
          return new ComputedValue((Math as unknown as Record<string, number>)[key])
        }
-        if (globalStaticMembers[objectValue.name]?.has(key)) {
-          return new GlobalMethodReference(objectValue.name, key)
-        }
-        // Unknown static members read as undefined so feature detection works like native JS.
-        return new ComputedValue(undefined)
+        return new GlobalMethodReference(objectValue.name, key)
      }

      if (typeof objectValue === "string") {
@@ -1907,21 +1858,12 @@ export class Interpreter<R> {
        return new ComputedValue(undefined)
      }

-      if (objectValue instanceof CoercionFunction) {
-        if (typeof key === "string" && isBlockedMember(key)) {
-          throw new InterpreterRuntimeError(`${objectValue.name}.${key} is not available in CodeMode.`, propertyNode)
-        }
-        if (typeof key !== "string") return new ComputedValue(undefined)
+      if (objectValue instanceof CoercionFunction && typeof key === "string" && !isBlockedMember(key)) {
        if (objectValue.name === "Number" && numberConstants.has(key)) {
          return new ComputedValue((Number as unknown as Record<string, number>)[key])
        }
-        if (objectValue.name === "Number" && numberStatics.has(key)) {
-          return new GlobalMethodReference("Number", key)
-        }
-        if (objectValue.name === "String" && stringStatics.has(key)) {
-          return new GlobalMethodReference("String", key)
-        }
-        return new ComputedValue(undefined)
+        if (objectValue.name === "Number" && numberStatics.has(key)) return new GlobalMethodReference("Number", key)
+        if (objectValue.name === "String" && stringStatics.has(key)) return new GlobalMethodReference("String", key)
      }

      if (objectValue instanceof CodeModeDate) {
@@ -89,7 +89,7 @@ const formatConsoleTable = (value: unknown, columnsArgument: unknown): string =>
 const consoleTableColumns = (value: unknown): ReadonlyArray<string> | undefined => {
  if (value === undefined) return undefined
  if (containsRuntimeReference(value)) return undefined
-  const columns = copyOut(copyIn(value, "console.table columns"), "nullify")
+  const columns = copyOut(copyIn(value, "console.table columns"), true)
  return Array.isArray(columns) ? columns.map((column) => String(column)) : undefined
 }

@@ -23,8 +23,6 @@ export const dateMethods = new Set([
  "getTimezoneOffset",
 ])

-export const dateStatics = new Set(["now", "parse", "UTC"])
-
 export const invokeDateStatic = (name: string, args: Array<unknown>, node: AstNode): number => {
  switch (name) {
    case "now":
@@ -2,8 +2,6 @@ import { type AstNode, InterpreterRuntimeError, supportedSyntaxMessage } from ".
 import { typeofValue } from "../interpreter/references.js"
 import { copyIn, copyOut } from "../tool-runtime.js"

-export const jsonStatics = new Set(["parse", "stringify"])
-
 export const invokeJsonMethod = (name: string, args: Array<unknown>, node: AstNode): unknown => {
  switch (name) {
    case "stringify": {
@@ -18,7 +16,7 @@ export const invokeJsonMethod = (name: string, args: Array<unknown>, node: AstNo
      }
      const space = args[2]
      const indent = typeof space === "number" || typeof space === "string" ? space : undefined
-      return JSON.stringify(copyOut(copyIn(args[0], "JSON.stringify value"), "json"), null, indent)
+      return JSON.stringify(copyOut(copyIn(args[0], "JSON.stringify value")), null, indent)
    }
    case "parse": {
      const text = args[0]
@@ -6,8 +6,6 @@ import { boundedData, coerceToString } from "./value.js"

 export const objectMethodsPreservingIdentity = new Set(["assign", "values", "entries", "fromEntries"])

-export const objectStatics = new Set(["keys", "values", "entries", "hasOwn", "is", "assign", "fromEntries"])
-
 export const invokeObjectMethod = (name: string, args: Array<unknown>, node: AstNode): unknown => {
  const requireObject = (): Record<string, unknown> => {
    const input = args[0]
@@ -19,8 +19,6 @@ export const escapeRegexHint =
  'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.'

 export const toHostRegex = (arg: unknown, method: string, node: AstNode, extraFlags = ""): RegExp => {
-  // Native parity: an undefined pattern behaves as an empty pattern.
-  if (arg === undefined) return new RegExp("", extraFlags)
  if (arg instanceof CodeModeRegExp) return arg.regex
  if (typeof arg === "string") {
    try {
@@ -61,19 +61,10 @@ export const coerceToString = (value: unknown): string => {
 export const coerceToNumber = (value: unknown): number => {
  if (value instanceof CodeModeDate) return value.time
  if (isCodeModeValue(value)) return Number.NaN
-  // Arrays coerce through our own string coercion: host Number(array) joins with host
-  // ToPrimitive, which throws on the null-prototype objects the interpreter produces.
-  if (Array.isArray(value)) return Number(coerceToString(value))
-  return value !== null && typeof value === "object" ? Number.NaN : Number(value)
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? Number.NaN : Number(value)
 }

 export const invokeCoercion = (ref: CoercionFunction, args: Array<unknown>, node: AstNode): unknown => {
-  // Native: Number() is 0 and String() is "", unlike their undefined-argument forms; the
-  // other coercers match native through the undefined-argument path below.
-  if (args.length === 0) {
-    if (ref.name === "Number") return 0
-    if (ref.name === "String") return ""
-  }
  const raw = args[0]
  // Error values are plain SafeObjects; the boundedData path below would strip their brand.
  if (ref.name === "String" && errorBrandName(raw) !== undefined) return coerceToString(raw)
@@ -81,16 +72,12 @@ export const invokeCoercion = (ref: CoercionFunction, args: Array<unknown>, node
    if (ref.name === "Boolean") return true
    if (ref.name === "Number") return coerceToNumber(raw)
    if (ref.name === "String") return coerceToString(raw)
-    if (ref.name === "isFinite") return Number.isFinite(coerceToNumber(raw))
-    if (ref.name === "isNaN") return Number.isNaN(coerceToNumber(raw))
    if (ref.name === "parseInt") return parseInt(coerceToString(raw))
    return parseFloat(coerceToString(raw))
  }
  const value = boundedData(raw, `${ref.name} input`)
  if (ref.name === "Number") return coerceToNumber(value)
  if (ref.name === "Boolean") return Boolean(value)
-  if (ref.name === "isFinite") return Number.isFinite(coerceToNumber(value))
-  if (ref.name === "isNaN") return Number.isNaN(coerceToNumber(value))
  if (ref.name === "parseInt") {
    const radix = args[1]
    if (radix !== undefined && typeof radix !== "number") {
@@ -118,7 +118,8 @@ export class ToolRuntimeError extends Error {
  }
 }

-const isDefinition = <R>(value: Definition<R> | Tools<R>): value is Definition<R> => isToolDefinition<R>(value)
+const isDefinition = <R>(value: Definition<R> | Tools<R>): value is Definition<R> =>
+  isToolDefinition<R>(value)

 const runHost = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, ToolError, R> =>
  effect.pipe(
@@ -256,31 +257,18 @@ const copyBounded = (
  return copied
 }

-// "json" mirrors JSON.stringify (undefined object values drop, undefined array elements become
-// null, a bare undefined passes through): use it wherever data leaves as JSON, like tool
-// arguments and stringify-style formatting. "nullify" turns every undefined, including a bare
-// one, into null: use it for program results, where the consumer must never see undefined.
-export type CopyOutMode = "json" | "nullify"
-
-export const copyOut = (value: unknown, mode: CopyOutMode): unknown => {
-  if (value === undefined && mode === "nullify") return null
+export const copyOut = (value: unknown, undefinedAsNull = false): unknown => {
+  if (value === undefined && undefinedAsNull) return null
  if (typeof value === "number" && !Number.isFinite(value)) {
    return null
  }
  if (Array.isArray(value)) {
    // Array.from densifies holes so sparse arrays normalize at the boundary like JSON does.
-    return Array.from(value, (item) => {
-      const copied = copyOut(item, mode)
-      return copied === undefined && mode === "json" ? null : copied
-    })
+    return Array.from(value, (item) => copyOut(item, undefinedAsNull))
  }

  if (value !== null && typeof value === "object" && !(value instanceof ToolReference)) {
-    return Object.fromEntries(
-      Object.entries(value)
-        .map(([key, item]) => [key, copyOut(item, mode)] as const)
-        .filter(([, item]) => !(item === undefined && mode === "json")),
-    )
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, copyOut(item, undefinedAsNull)]))
  }

  return value
@@ -708,13 +696,13 @@ export const make = <R>(
        invokeDefinition(
          "search",
          searchTool,
-          args.map((arg) => copyOut(copyIn(arg, "Arguments for tool 'search'"), "json")),
+          args.map((arg) => copyOut(copyIn(arg, "Arguments for tool 'search'"))),
        ),
      ),
    invoke: (path, args) =>
      Effect.gen(function* () {
        const name = canonicalSegments(path).join(".")
-        const externalArgs = args.map((arg) => copyOut(copyIn(arg, `Arguments for tool '${name}'`), "json"))
+        const externalArgs = args.map((arg) => copyOut(copyIn(arg, `Arguments for tool '${name}'`)))
        const tool = resolve(root, path)
        return yield* invokeDefinition(name, tool, externalArgs)
      }),
@@ -453,56 +453,6 @@ describe("CodeMode schema flexibility", () => {
    expect(observed).toStrictEqual([{ id: 42 }])
  })

-  test("outbound tool arguments follow JSON serialization semantics", async () => {
-    const observed: Array<unknown> = []
-    const call = Tool.make({
-      description: "Observe raw input",
-      input: { type: "object" },
-      run: (input) =>
-        Effect.sync(() => {
-          observed.push(input)
-          return "ok"
-        }),
-    })
-    const runtime = CodeMode.make({ tools: { adapter: { call } } })
-
-    const result = await Effect.runPromise(
-      runtime.execute(
-        `return await tools.adapter.call({ q: undefined, limit: 0 / 0, rate: 1 / 0, items: [1, undefined, 2], holes: [1, , 3] })`,
-      ),
-    )
-    expect(result.ok).toBe(true)
-    const received = observed[0] as Record<string, unknown>
-    expect(received).toStrictEqual({ limit: null, rate: null, items: [1, null, 2], holes: [1, null, 3] })
-    // The undefined-valued property is dropped like JSON.stringify, not delivered as undefined.
-    expect(Object.hasOwn(received, "q")).toBe(false)
-  })
-
-  test("dropping undefined values lets optionalKey schemas accept conditional arguments", async () => {
-    const observed: Array<unknown> = []
-    const find = Tool.make({
-      description: "Find things",
-      input: Schema.Struct({ query: Schema.optionalKey(Schema.String), limit: Schema.optionalKey(Schema.Number) }),
-      run: (input) =>
-        Effect.sync(() => {
-          observed.push(input)
-          return "ok"
-        }),
-    })
-    const runtime = CodeMode.make({ tools: { things: { find } } })
-
-    // The `cond ? value : undefined` idiom: optionalKey rejects a present undefined, so the
-    // JSON boundary must drop the key before the schema decodes.
-    const result = await Effect.runPromise(
-      runtime.execute(`return await tools.things.find({ query: undefined, limit: 5 })`),
-    )
-    expect(result.ok).toBe(true)
-    expect(observed).toStrictEqual([{ limit: 5 }])
-
-    const search = await Effect.runPromise(runtime.execute(`return (await search({ query: undefined })).items.length`))
-    expect(search.ok).toBe(true)
-  })
-
  test("renders JSON Schema outputs and $defs references", async () => {
    const lookup = Tool.make({
      description: "Look up a user",
@@ -258,23 +258,11 @@ describe("H1: NaN/Infinity flow as intermediates and normalize to null at the bo

  test("copyOut normalizes non-finite numbers to null (the shared return + tool-arg boundary)", () => {
    // Tool-call arguments funnel through copyOut too, so this one function pins both boundaries.
-    expect(ToolRuntime.copyOut(NaN, "json")).toBeNull()
-    expect(ToolRuntime.copyOut(Infinity, "json")).toBeNull()
-    expect(ToolRuntime.copyOut(-Infinity, "nullify")).toBeNull()
-    expect(ToolRuntime.copyOut(42, "json")).toBe(42)
-    expect(ToolRuntime.copyOut({ a: NaN, b: [Infinity, 1] }, "json")).toEqual({ a: null, b: [null, 1] })
-  })
-})
-
-describe("copyOut undefined handling per boundary mode", () => {
-  test("json mode mirrors JSON.stringify for undefined", () => {
-    expect(ToolRuntime.copyOut({ q: undefined, keep: 1 }, "json")).toStrictEqual({ keep: 1 })
-    expect(ToolRuntime.copyOut([1, undefined, 2], "json")).toStrictEqual([1, null, 2])
-    expect(ToolRuntime.copyOut({ nested: { a: undefined, b: [undefined] } }, "json")).toStrictEqual({
-      nested: { b: [null] },
-    })
-    expect(ToolRuntime.copyOut(undefined, "json")).toBeUndefined()
-    expect(ToolRuntime.copyOut({ a: undefined }, "nullify")).toStrictEqual({ a: null })
+    expect(ToolRuntime.copyOut(NaN)).toBeNull()
+    expect(ToolRuntime.copyOut(Infinity)).toBeNull()
+    expect(ToolRuntime.copyOut(-Infinity)).toBeNull()
+    expect(ToolRuntime.copyOut(42)).toBe(42)
+    expect(ToolRuntime.copyOut({ a: NaN, b: [Infinity, 1] })).toEqual({ a: null, b: [null, 1] })
  })
 })

@@ -681,177 +669,3 @@ describe("destructuring assignment", () => {
    expect(err.message).toContain("Property key must be a string or number")
  })
 })
-
-describe("coercion parity: zero-argument coercion functions", () => {
-  test("Number() is 0 and String() is empty, unlike their undefined-argument forms", async () => {
-    expect(await value(`return Number()`)).toBe(0)
-    expect(await value(`return String()`)).toBe("")
-    expect(await value(`return Boolean()`)).toBe(false)
-    expect(await value(`return Number.isNaN(Number(undefined))`)).toBe(true)
-    expect(await value(`return String(undefined)`)).toBe("undefined")
-  })
-
-  test("parseInt() and parseFloat() stay NaN with no argument", async () => {
-    expect(await value(`return Number.isNaN(parseInt())`)).toBe(true)
-    expect(await value(`return Number.isNaN(parseFloat())`)).toBe(true)
-  })
-})
-
-describe("coercion parity: global isFinite and isNaN", () => {
-  test("coerce their argument like native JS, unlike the Number statics", async () => {
-    expect(await value(`return isFinite("42")`)).toBe(true)
-    expect(await value(`return Number.isFinite("42")`)).toBe(false)
-    expect(await value(`return isNaN("oops")`)).toBe(true)
-    expect(await value(`return isNaN("42")`)).toBe(false)
-    expect(await value(`return isFinite(Infinity)`)).toBe(false)
-    expect(await value(`return isNaN(null)`)).toBe(false)
-  })
-
-  test("zero-argument forms match native", async () => {
-    expect(await value(`return isFinite()`)).toBe(false)
-    expect(await value(`return isNaN()`)).toBe(true)
-  })
-
-  test("read as functions", async () => {
-    expect(await value(`return typeof isFinite`)).toBe("function")
-    expect(await value(`return typeof isNaN`)).toBe("function")
-  })
-
-  test("work as array callbacks", async () => {
-    expect(await value(`return [1, "2", "x", Infinity].filter(isFinite)`)).toEqual([1, "2"])
-    expect(await value(`return ["1", "x"].map(isNaN)`)).toEqual([false, true])
-  })
-})
-
-describe("coercion parity: arrays coerce to numbers through their string form", () => {
-  test("arrays with objects become NaN instead of crashing on host ToPrimitive", async () => {
-    expect(await value(`let x = [{}]; x++; return Number.isNaN(x)`)).toBe(true)
-    expect(await value(`return isFinite([{}])`)).toBe(false)
-    expect(await value(`return "abc".slice([{}])`)).toBe("abc")
-  })
-
-  test("single-element and empty arrays match native Number()", async () => {
-    expect(await value(`return Number([5])`)).toBe(5)
-    expect(await value(`return Number([])`)).toBe(0)
-    expect(await value(`return Number.isNaN(Number([1, 2]))`)).toBe(true)
-  })
-})
-
-describe("coercion parity: String method arguments coerce like native JS", () => {
-  test("includes and indexOf coerce numbers", async () => {
-    expect(await value(`return "v1.2".includes(1)`)).toBe(true)
-    expect(await value(`return "a2b".indexOf(2)`)).toBe(1)
-    expect(await value(`return "abc".includes("d")`)).toBe(false)
-  })
-
-  test("slice, repeat, and padStart coerce numeric strings", async () => {
-    expect(await value(`return "abc".slice("1")`)).toBe("bc")
-    expect(await value(`return "ab".repeat("2")`)).toBe("abab")
-    expect(await value(`return "7".padStart("3", 0)`)).toBe("007")
-  })
-
-  test("split coerces separators but treats undefined as absent", async () => {
-    expect(await value(`return "a1b".split(1)`)).toEqual(["a", "b"])
-    expect(await value(`return "a,b".split(undefined)`)).toEqual(["a,b"])
-    expect(await value(`return "a,b".split()`)).toEqual(["a,b"])
-    expect(await value(`return "a,b".split(undefined, 0)`)).toEqual([])
-    expect(await value(`return "a,b".split(undefined, 1)`)).toEqual(["a,b"])
-  })
-
-  test("replace coerces search and replacement values", async () => {
-    expect(await value(`return "a1b".replace(1, 2)`)).toBe("a2b")
-    expect(await value(`return "a1b".replace(1, () => "x")`)).toBe("axb")
-  })
-
-  test("repeat rejections carry the native RangeError name", async () => {
-    expect(await value(`try { "a".repeat(-1) } catch (e) { return e.name }`)).toBe("RangeError")
-  })
-
-  test("includes, startsWith, and endsWith reject regular expressions with a TypeError", async () => {
-    expect(await value(`try { "abc".includes(/a/) } catch (e) { return e.name }`)).toBe("TypeError")
-    expect(await value(`try { "abc".startsWith(/a/) } catch (e) { return e.name }`)).toBe("TypeError")
-    expect(await value(`try { "abc".endsWith(/a/) } catch (e) { return e.name }`)).toBe("TypeError")
-  })
-
-  test("opaque runtime references still reject as data errors", async () => {
-    const err = await error(`const f = () => 1; return "abc".includes(f)`)
-    expect(err.message).toContain("data value")
-    const replacerErr = await error(`const f = () => 1; return "a".replace(f, () => "x")`)
-    expect(replacerErr.message).toContain("data value")
-  })
-})
-
-describe("coercion parity: match() and search() with no argument", () => {
-  test("behave as an empty pattern like native JS", async () => {
-    expect(await value(`return "abc".search()`)).toBe(0)
-    expect(await value(`const m = "abc".match(); return { first: m[0], index: m.index }`)).toEqual({
-      first: "",
-      index: 0,
-    })
-  })
-})
-
-describe("coercion parity: ++ and -- use CodeMode numeric coercion", () => {
-  test("numeric strings increment like native JS", async () => {
-    expect(await value(`let x = "5"; x++; return x`)).toBe(6)
-    expect(await value(`let x = "5"; return ++x`)).toBe(6)
-    expect(await value(`const o = { n: "2" }; o.n--; return o.n`)).toBe(1)
-  })
-
-  test("dates increment through their epoch time", async () => {
-    expect(await value(`let d = new Date(5); d++; return d`)).toBe(6)
-  })
-
-  test("plain data objects become NaN instead of crashing", async () => {
-    expect(await value(`let x = {}; x++; return Number.isNaN(x)`)).toBe(true)
-    expect(await value(`const o = { a: {} }; o.a++; return Number.isNaN(o.a)`)).toBe(true)
-  })
-
-  test("opaque runtime references reject with a clear error", async () => {
-    const err = await error(`let f = () => 1; f++`)
-    expect(err.message).toContain("data value")
-  })
-})
-
-describe("coercion parity: unknown static members read as undefined", () => {
-  test("feature detection on missing statics works like native JS", async () => {
-    expect(await value(`return typeof Math.sumPrecise`)).toBe("undefined")
-    expect(await value(`return Object.groupBy === undefined`)).toBe(true)
-    expect(await value(`return RegExp.escape === undefined`)).toBe(true)
-    expect(await value(`return Number.range === undefined`)).toBe(true)
-    expect(await value(`return String.raw === undefined`)).toBe(true)
-    expect(await value(`return isFinite.something === undefined`)).toBe(true)
-    expect(await value(`return console.group === undefined`)).toBe(true)
-    expect(await value(`return Date.moment === undefined`)).toBe(true)
-    expect(await value(`return JSON.rawJSON === undefined`)).toBe(true)
-    expect(await value(`return URL.createObjectURL === undefined`)).toBe(true)
-    expect(await value(`return Map.groupBy === undefined`)).toBe(true)
-    expect(await value(`return Math.sumPrecise?.([1]) ?? "fallback"`)).toBe("fallback")
-  })
-
-  test("known statics still resolve and run", async () => {
-    expect(await value(`return typeof Math.max`)).toBe("function")
-    expect(await value(`return typeof console.log`)).toBe("function")
-    expect(await value(`return typeof Date.now`)).toBe("function")
-    expect(await value(`return Math.max(1, 2)`)).toBe(2)
-    expect(await value(`return URL.canParse("https://example.com")`)).toBe(true)
-    expect(await value(`return Number.isInteger(3)`)).toBe(true)
-    expect(await value(`return Number.MAX_SAFE_INTEGER`)).toBe(Number.MAX_SAFE_INTEGER)
-  })
-
-  test("calling an unknown static reports a native-style TypeError", async () => {
-    expect(await value(`try { Math.sumPrecise([1]) } catch (e) { return e.name + ": " + e.message }`)).toBe(
-      "TypeError: Math.sumPrecise is not a function.",
-    )
-    expect(await value(`try { Math["sumPrecise"]([1]) } catch (e) { return e.message }`)).toBe(
-      "Math.sumPrecise is not a function.",
-    )
-  })
-
-  test("blocked members still throw instead of reading as undefined", async () => {
-    const err = await error(`return Math.constructor`)
-    expect(err.message).toContain("not available")
-    const coercionErr = await error(`return Number.constructor`)
-    expect(coercionErr.message).toContain("Number.constructor is not available")
-  })
-})
@@ -1,28 +1,45 @@
 export * as AISDK from "./aisdk"

 import { makeLocationNode } from "./effect/app-node"
-import type {
-  JSONSchema7,
-  JSONValue,
-  LanguageModelV3,
-  LanguageModelV3CallOptions,
-  LanguageModelV3FinishReason,
-  LanguageModelV3FunctionTool,
-  LanguageModelV3Message,
-  LanguageModelV3Prompt,
-  LanguageModelV3StreamPart,
-  LanguageModelV3ToolChoice,
-  SharedV3ProviderOptions,
+import {
+  APICallError,
+  EmptyResponseBodyError,
+  InvalidArgumentError,
+  InvalidPromptError,
+  InvalidResponseDataError,
+  JSONParseError,
+  LoadAPIKeyError,
+  LoadSettingError,
+  NoContentGeneratedError,
+  NoSuchModelError,
+  TypeValidationError,
+  UnsupportedFunctionalityError,
+  type JSONSchema7,
+  type JSONValue,
+  type LanguageModelV3,
+  type LanguageModelV3CallOptions,
+  type LanguageModelV3FinishReason,
+  type LanguageModelV3FunctionTool,
+  type LanguageModelV3Message,
+  type LanguageModelV3Prompt,
+  type LanguageModelV3StreamPart,
+  type LanguageModelV3ToolChoice,
+  type SharedV3ProviderOptions,
 } from "@ai-sdk/provider"
 import {
+  AuthenticationReason,
+  classifyProviderFailure,
  FinishReason,
+  InvalidRequestReason,
  InvalidProviderOutputReason,
  LLMEvent,
  LLMError,
  Model,
  ProviderID,
+  ProviderInternalReason,
  ProviderMetadata,
  ToolResultValue,
+  TransportReason,
  UnknownProviderReason,
  type ContentPart,
  type LLMRequest,
@@ -30,6 +47,7 @@ import {
  type UsageInput,
 } from "@opencode-ai/ai"
 import { Auth, Endpoint, type AnyRoute } from "@opencode-ai/ai/route"
+import { BedrockEventStream } from "@opencode-ai/ai/protocols/bedrock-event-stream"
 import { Cause, Context, Effect, Layer, Option, Schema, Scope, Stream } from "effect"
 import { ModelV2 } from "./model"
 import { ProviderV2 } from "./provider"
@@ -40,6 +58,8 @@ type UserContent = Extract<LanguageModelV3Message, { role: "user" }>["content"]
 type AssistantContent = Extract<LanguageModelV3Message, { role: "assistant" }>["content"]
 type ToolResultContent = Extract<AssistantContent[number], { type: "tool-result" }>

+class ChunkTimeoutError extends Error {}
+
 export interface SDKEvent {
  readonly model: ModelV2.Info
  readonly package: string
@@ -64,7 +84,7 @@ function wrapSSE(res: Response, ms: number, ctl: AbortController) {
    async pull(ctrl) {
      const part = await new Promise<Awaited<ReturnType<typeof reader.read>>>((resolve, reject) => {
        const id = setTimeout(() => {
-          const err = new Error("SSE read timed out")
+          const err = new ChunkTimeoutError("SSE read timed out")
          ctl.abort(err)
          void reader.cancel(err)
          reject(err)
@@ -153,8 +173,9 @@ function prepareOptions(model: ModelV2.Info, pkg: string) {
      ...opts,
      timeout: false,
    })
-    if (!chunkAbortCtl || typeof chunkTimeout !== "number") return res
-    return wrapSSE(res, chunkTimeout, chunkAbortCtl)
+    const response = pkg === "@ai-sdk/amazon-bedrock" ? BedrockEventStream.monitorExceptions(res) : res
+    if (!chunkAbortCtl || typeof chunkTimeout !== "number") return response
+    return wrapSSE(response, chunkTimeout, chunkAbortCtl)
  }

  return options
@@ -716,10 +737,41 @@ function messageValue(input: unknown) {
 }

 function llmError(method: string, error: unknown) {
-  const reason =
-    error instanceof LLMError
-      ? new InvalidProviderOutputReason({ message: error.message })
-      : new UnknownProviderReason({ message: error instanceof Error ? error.message : String(error) })
+  if (error instanceof LLMError) return error
+  const cause = error instanceof Error ? error.cause : undefined
+  const failures = [error, cause]
+  const code = failures.map(machineCode).find((value) => value !== undefined)
+  const providerCode = apiFailureCode(error)?.toLowerCase()
+  const reason = (() => {
+    if (
+      error instanceof ChunkTimeoutError ||
+      failures.some((failure) => failure instanceof Error && failure.name === "TimeoutError") ||
+      providerCode === "timeout_error" ||
+      (code !== undefined && TRANSPORT_TIMEOUT_CODES.has(code))
+    )
+      return new TransportReason({ message: errorMessage(error), kind: code ?? "Timeout" })
+    if (APICallError.isInstance(error)) return apiCallReason(error)
+    if (code !== undefined && TRANSPORT_CONNECTION_CODES.has(code))
+      return new TransportReason({ message: errorMessage(error), kind: code })
+    const malformed = failures.find(isMalformedError)
+    if (malformed) return new InvalidProviderOutputReason({ message: malformed.message })
+    if (LoadAPIKeyError.isInstance(error)) return new AuthenticationReason({ message: error.message, kind: "missing" })
+    if (NoSuchModelError.isInstance(error)) return new InvalidRequestReason({ message: error.message })
+    if (
+      LoadSettingError.isInstance(error) ||
+      InvalidPromptError.isInstance(error) ||
+      InvalidArgumentError.isInstance(error) ||
+      UnsupportedFunctionalityError.isInstance(error)
+    )
+      return new InvalidRequestReason({ message: error.message })
+    const providerReason = classifyProviderFailure({
+      message: apiFailureMessage(error),
+      code: apiFailureCode(error),
+      status: apiFailureStatus(error),
+    })
+    if (providerReason._tag !== "UnknownProvider") return providerReason
+    return new UnknownProviderReason({ message: errorMessage(error) })
+  })()
  return new LLMError({
    module: "AISDK",
    method,
@@ -727,4 +779,133 @@ function llmError(method: string, error: unknown) {
  })
 }

+function apiCallReason(error: APICallError) {
+  const malformed = isMalformedError(error.cause) ? error.cause : undefined
+  if (error.statusCode !== undefined && error.statusCode < 400 && malformed)
+    return new InvalidProviderOutputReason({ message: malformed.message })
+  const evidence = apiFailureEvidence(error.responseBody)
+  const code = apiFailureCode(error.data) ?? apiFailureCode(evidence)
+  if (error.statusCode === undefined) {
+    const reason =
+      code === undefined && evidence === undefined
+        ? undefined
+        : classifyProviderFailure({ message: error.message, code, evidence })
+    if (reason && reason._tag !== "UnknownProvider") return reason
+    if (error.isRetryable) return new TransportReason({ message: error.message })
+    return reason ?? new UnknownProviderReason({ message: error.message })
+  }
+  const retryAfter = retryAfterMs(error.responseHeaders)
+  const reason = classifyProviderFailure({
+    message: error.message,
+    evidence,
+    status: error.statusCode,
+    code,
+    retryAfterMs: retryAfter,
+  })
+  if (!error.isRetryable || (reason._tag !== "UnknownProvider" && reason._tag !== "InvalidRequest")) return reason
+  if (classifyProviderFailure({ message: error.message, evidence, code })._tag !== "UnknownProvider") return reason
+  return new ProviderInternalReason({ message: error.message, status: error.statusCode, retryAfterMs: retryAfter })
+}
+
+const TRANSPORT_TIMEOUT_CODES = new Set([
+  "ETIMEDOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+])
+const TRANSPORT_CONNECTION_CODES = new Set([
+  "CONNECTIONCLOSED",
+  "CONNECTIONREFUSED",
+  "EAI_AGAIN",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "ENOTFOUND",
+  "EPIPE",
+  "FAILEDTOOPENSOCKET",
+  "UND_ERR_SOCKET",
+])
+const FAILURE_EVIDENCE_LIMIT = 65_536
+
+function field(error: unknown, name: string) {
+  return typeof error === "object" && error !== null ? Reflect.get(error, name) : undefined
+}
+
+function machineCode(error: unknown) {
+  const code = field(error, "code")
+  return typeof code === "string" ? code.toUpperCase() : undefined
+}
+
+function apiFailureCode(error: unknown): string | undefined {
+  if (typeof error === "string") {
+    const decoded = Option.getOrUndefined(Schema.decodeUnknownOption(Schema.UnknownFromJsonString)(error))
+    return apiFailureCode(decoded)
+  }
+  const nested = field(error, "error") ?? field(field(error, "response"), "error")
+  const nestedCode = nested === undefined || nested === error ? undefined : apiFailureCode(nested)
+  if (nestedCode) return nestedCode
+  if (typeof field(error, "originalMessage") === "string" && typeof field(error, "originalStatusCode") === "number")
+    return "modelstreamerrorexception"
+  const code = field(error, "code")
+  if (typeof code === "string" || typeof code === "number") return String(code)
+  const status = field(error, "status")
+  if (typeof status === "string") return status
+  const type = field(error, "type")
+  if (typeof type === "string" && type !== "error") return type
+}
+
+function apiFailureMessage(error: unknown): string {
+  const message = field(error, "message")
+  if (typeof message === "string") return message
+  const originalMessage = field(error, "originalMessage")
+  if (typeof originalMessage === "string") return originalMessage
+  const nested = field(error, "error") ?? field(field(error, "response"), "error")
+  return nested === undefined || nested === error ? String(error) : apiFailureMessage(nested)
+}
+
+function apiFailureStatus(error: unknown): number | undefined {
+  const status = field(error, "status")
+  const statusCode = field(error, "statusCode")
+  const originalStatusCode = field(error, "originalStatusCode")
+  const code = field(error, "code")
+  const value = [status, statusCode, originalStatusCode, code]
+    .map((value) => (typeof value === "number" ? value : typeof value === "string" ? Number(value) : undefined))
+    .find((value) => value !== undefined && Number.isInteger(value) && value >= 400 && value < 600)
+  if (value !== undefined) return value
+  const nested = field(error, "error") ?? field(field(error, "response"), "error")
+  return nested === undefined || nested === error ? undefined : apiFailureStatus(nested)
+}
+
+function apiFailureEvidence(error: string | undefined) {
+  return error === undefined ? undefined : error.slice(0, FAILURE_EVIDENCE_LIMIT)
+}
+
+function retryAfterMs(headers: Record<string, string> | undefined) {
+  if (!headers) return undefined
+  const normalized = Object.fromEntries(Object.entries(headers).map(([name, value]) => [name.toLowerCase(), value]))
+  const millis = Number(normalized["retry-after-ms"])
+  if (Number.isFinite(millis)) return Math.max(0, millis)
+  const value = normalized["retry-after"]
+  if (!value) return undefined
+  const seconds = Number(value)
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000)
+  const date = Date.parse(value)
+  return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now())
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error)
+}
+
+function isMalformedError(error: unknown): error is Error {
+  return (
+    InvalidResponseDataError.isInstance(error) ||
+    JSONParseError.isInstance(error) ||
+    TypeValidationError.isInstance(error) ||
+    EmptyResponseBodyError.isInstance(error) ||
+    NoContentGeneratedError.isInstance(error)
+  )
+}
+
 export const node = makeLocationNode({ service: Service, layer: locationLayer, deps: [] })
@@ -70,7 +70,6 @@ export type Inputs = Integration.Inputs
 export type OAuthAuthorization = {
  readonly url: string
  readonly instructions: string
-  readonly expiresAt?: number
 } & (
  | {
      readonly mode: "auto"
@@ -561,7 +560,7 @@ const layer = Layer.effect(
      )
      const id = AttemptID.create()
      const created = yield* Clock.currentTimeMillis
-      const time = { created, expires: authorization.expiresAt ?? created + attemptLifetime }
+      const time = { created, expires: created + attemptLifetime }
      yield* SynchronizedRef.update(attempts, (current) =>
        new Map(current).set(id, {
          status: "pending",
@@ -13,10 +13,8 @@ import { EventV2 } from "../event"
 import { Form } from "../form"
 import { Integration } from "../integration"
 import { IntegrationConnection } from "../integration/connection"
-import { KeyedMutex } from "../effect/keyed-mutex"
 import { Location } from "../location"
 import { waitForAbort } from "../process"
-import { State } from "../state"
 import { MCPClient } from "./client"
 import { MCPOAuth } from "./oauth"

@@ -120,7 +118,6 @@ type ServerEntry = {
  prompts?: ReadonlyArray<Prompt>
  // Set when a remote server is registered as an OAuth integration; the credential lives in the global store.
  integrationID?: Integration.ID
-  registration?: State.Registration
 }

 // MCP elicitations are Location-scoped, not Session-scoped: the server cannot attribute them to a
@@ -130,10 +127,6 @@ const URL_ELICITATION_FIELD_KEY = "elicitation"

 export interface Interface {
  readonly servers: () => Effect.Effect<ServerInfo[]>
-  readonly add: (server: ServerName | string, config: typeof ConfigMCP.Server.Type) => Effect.Effect<void>
-  readonly connect: (server: ServerName | string) => Effect.Effect<void, NotFoundError>
-  readonly disconnect: (server: ServerName | string) => Effect.Effect<void, NotFoundError>
-  readonly remove: (server: ServerName | string) => Effect.Effect<void, NotFoundError>
  readonly tools: () => Effect.Effect<Tool[]>
  readonly callTool: (input: {
    readonly server: ServerName | string
@@ -177,9 +170,6 @@ export const layer = Layer.effect(
    )
    // Later config files win for duplicate server names; per-server timeout overrides globals.
    const runtime = new Map<ServerName, ServerEntry>()
-    // Serializes lifecycle operations per server. Anything taking this lock from a connection
-    // callback must stay forked: lifecycle operations close scopes while holding it, firing onClose.
-    const locks = KeyedMutex.makeUnsafe<ServerName>()
    const urlElicitations = new Map<string, Form.ID>()
    for (const entry of documents) {
      for (const [name, server] of Object.entries(entry.info.mcp?.servers ?? {})) {
@@ -193,9 +183,14 @@ export const layer = Layer.effect(

    // Register every remote server as an OAuth integration so credentials live in the global store
    // rather than in committed config. Servers that connect anonymously simply never use the method.
-    const owned = new Set<Integration.ID>()
-    const register = Effect.fnUntraced(function* (name: ServerName, entry: ServerEntry) {
-      if (entry.config.type !== "remote" || entry.config.oauth === false) return
+    const registrations: Array<{
+      readonly name: ServerName
+      readonly remote: typeof ConfigMCP.Remote.Type
+      readonly integrationID: Integration.ID
+      readonly methodID: Integration.MethodID
+    }> = []
+    for (const [name, entry] of runtime) {
+      if (entry.config.type !== "remote" || entry.config.oauth === false) continue
      const remote = entry.config
      // Key identity on name + url, not url alone: two configs for the same url under different names are
      // distinct logical servers that may hold different accounts, so they must not share a credential row.
@@ -205,24 +200,27 @@ export const layer = Layer.effect(
          .update(name + "\u0000" + remote.url)
          .digest("hex")
          .slice(0, 16)
-      const integrationID = Integration.ID.make(suffix)
-      entry.integrationID = integrationID
-      owned.add(integrationID)
-      const methodID = Integration.MethodID.make(suffix)
-      entry.registration = yield* integration
-        .transform((draft) => {
-          draft.update(integrationID, (ref) => {
-            ref.name = name
+      entry.integrationID = Integration.ID.make(suffix)
+      registrations.push({
+        name,
+        remote,
+        integrationID: entry.integrationID,
+        methodID: Integration.MethodID.make(suffix),
+      })
+    }
+    if (registrations.length > 0)
+      yield* integration.transform((draft) => {
+        for (const reg of registrations) {
+          draft.update(reg.integrationID, (ref) => {
+            ref.name = reg.name
          })
          draft.method.update({
-            integrationID,
-            method: { id: methodID, type: "oauth", label: name },
-            authorize: () => MCPOAuth.authorize({ name, config: remote, methodID }),
+            integrationID: reg.integrationID,
+            method: { id: reg.methodID, type: "oauth", label: reg.name },
+            authorize: () => MCPOAuth.authorize({ name: reg.name, config: reg.remote, methodID: reg.methodID }),
          })
-        })
-        .pipe(Scope.provide(root))
-    })
-    yield* Effect.forEach(runtime, ([name, entry]) => register(name, entry), { discard: true })
+        }
+      })

    const requireServer = Effect.fnUntraced(function* (server: ServerName | string) {
      const name = ServerName.make(server)
@@ -422,44 +420,36 @@ export const layer = Layer.effect(
        ),
      )

-    // Runs a connection callback under the server lock, dropping it if the connection is no longer
-    // the entry's live client, so late SDK callbacks cannot commit obsolete state.
-    const whenLive =
-      (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) =>
-      <E>(effect: Effect.Effect<void, E>) =>
+    const watch = (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) => {
+      connection.onClose(() => {
+        // A reconnect closes the previous scope, but the SDK may fire this onclose after the new
+        // connection is already assigned; ignore the stale close so it can't null out the live client.
+        if (entry.client !== connection) return
+        entry.client = undefined
+        entry.tools = undefined
+        entry.prompts = undefined
+        entry.status = { status: "failed", error: "Connection closed" }
+        fork(events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore))
+        fork(events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore))
+        fork(events.publish(Command.Event.Updated, {}).pipe(Effect.ignore))
+        fork(events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore))
+      })
+      connection.onLog((message) => fork(serverLog(name, message).pipe(Effect.ignore)))
+      connection.onToolsChanged(() => {
        fork(
-          Effect.suspend(() => (entry.client === connection ? effect : Effect.void)).pipe(
-            locks.withLock(name),
+          refreshTools(name, entry, connection).pipe(
+            Effect.andThen(events.publish(McpEvent.ToolsChanged, { server: name })),
            Effect.ignore,
          ),
        )
-
-    const watch = (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) => {
-      const live = whenLive(name, entry, connection)
-      connection.onClose(() =>
-        live(
-          Effect.gen(function* () {
-            entry.client = undefined
-            entry.tools = undefined
-            entry.prompts = undefined
-            entry.status = { status: "failed", error: "Connection closed" }
-            yield* events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore)
-            yield* events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore)
-            yield* events.publish(Command.Event.Updated, {}).pipe(Effect.ignore)
-            yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
-          }),
-        ),
-      )
-      connection.onLog((message) => fork(serverLog(name, message).pipe(Effect.ignore)))
-      connection.onToolsChanged(() =>
-        live(
-          refreshTools(name, entry, connection).pipe(
-            Effect.andThen(events.publish(McpEvent.ToolsChanged, { server: name })),
-          ),
-        ),
-      )
-      connection.onPromptsChanged(() => live(refreshPrompts(name, entry, connection)))
-      connection.onResourcesChanged(() => live(events.publish(McpEvent.ResourcesChanged, { server: name })))
+      })
+      connection.onPromptsChanged(() => {
+        fork(refreshPrompts(name, entry, connection).pipe(Effect.ignore))
+      })
+      connection.onResourcesChanged(() => {
+        if (entry.client !== connection) return
+        fork(events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore))
+      })
    }

    const serverLog = (server: ServerName, message: MCPClient.LogMessage) => {
@@ -482,10 +472,6 @@ export const layer = Layer.effect(

    const startServer = (name: ServerName, entry: ServerEntry) =>
      Effect.gen(function* () {
-        // Announce the handshake so connect() and credential reconnects don't show a stale
-        // disabled/failed status for the duration of the connection attempt.
-        entry.status = { status: "pending" }
-        yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
        const scope = yield* Scope.fork(root)
        entry.scope = scope
        const authProvider = yield* connectProvider(entry)
@@ -509,7 +495,7 @@ export const layer = Layer.effect(
          yield* events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore)
          yield* events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore)
          yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
-          whenLive(name, entry, result.value.connection)(refreshPrompts(name, entry, result.value.connection))
+          fork(refreshPrompts(name, entry, result.value.connection).pipe(Effect.ignore))
          return
        }
        yield* Scope.close(scope, Exit.void)
@@ -523,19 +509,6 @@ export const layer = Layer.effect(
        yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
      }).pipe(Effect.ensuring(Deferred.succeed(entry.startup, undefined)))

-    const stopServer = Effect.fnUntraced(function* (name: ServerName, entry: ServerEntry) {
-      const scope = entry.scope
-      if (!scope) return
-      entry.scope = undefined
-      entry.client = undefined
-      entry.tools = undefined
-      entry.prompts = undefined
-      yield* Scope.close(scope, Exit.void)
-      yield* events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore)
-      yield* events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore)
-      yield* events.publish(Command.Event.Updated, {}).pipe(Effect.ignore)
-    })
-
    // Disabled servers settle their startup immediately so queries never block on them.
    for (const [name, entry] of runtime) {
      if (entry.config.disabled) {
@@ -543,24 +516,27 @@ export const layer = Layer.effect(
        Deferred.doneUnsafe(entry.startup, Exit.void)
        continue
      }
-      fork(startServer(name, entry).pipe(locks.withLock(name)))
+      fork(startServer(name, entry))
    }

    // Bring a server online (or back to needs_auth) when its integration's credential changes, so an
    // OAuth login takes effect without a restart. Only fires for the integrations we registered.
+    const owned = new Set(registrations.map((reg) => reg.integrationID))
    const reconnect = (integrationID: Integration.ID) =>
      Effect.gen(function* () {
        const match = Array.from(runtime).find(([, entry]) => entry.integrationID === integrationID)
        if (!match) return
-        const name = match[0]
-        yield* Effect.gen(function* () {
-          // add() or remove() may have replaced or deleted the entry while we waited for the lock.
-          const entry = runtime.get(name)
-          if (!entry || entry.integrationID !== integrationID) return
-          if (entry.status.status === "disabled") return
-          yield* stopServer(name, entry)
-          yield* startServer(name, entry)
-        }).pipe(locks.withLock(name))
+        const [name, entry] = match
+        if (entry.config.disabled) return
+        if (entry.scope) {
+          yield* Scope.close(entry.scope, Exit.void)
+          entry.scope = undefined
+          entry.client = undefined
+          entry.tools = undefined
+          entry.prompts = undefined
+          yield* events.publish(Command.Event.Updated, {}).pipe(Effect.ignore)
+        }
+        yield* startServer(name, entry)
      })
    fork(
      events.subscribe(Integration.Event.ConnectionUpdated).pipe(
@@ -570,13 +546,10 @@ export const layer = Layer.effect(
      ),
    )

-    // Suspend so each await sees current entries; a bare Map iterator is exhausted after one run.
-    const whenAllReady = Effect.suspend(() =>
-      Effect.forEach(Array.from(runtime.values()), (entry) => Deferred.await(entry.startup), {
-        concurrency: "unbounded",
-        discard: true,
-      }),
-    )
+    const whenAllReady = Effect.forEach(runtime.values(), (entry) => Deferred.await(entry.startup), {
+      concurrency: "unbounded",
+      discard: true,
+    })
    return Service.of({
      servers: Effect.fn("MCP.servers")(function* () {
        const entries = Array.from(runtime).toSorted(([a], [b]) => a.localeCompare(b))
@@ -589,66 +562,6 @@ export const layer = Layer.effect(
          }),
        )
      }),
-      add: Effect.fn("MCP.add")(function* (server, config) {
-        const name = ServerName.make(server)
-        yield* Effect.gen(function* () {
-          const previous = runtime.get(name)
-          if (previous) {
-            yield* stopServer(name, previous)
-            if (previous.integrationID) owned.delete(previous.integrationID)
-            if (previous.registration) yield* previous.registration.dispose
-          }
-          const entry: ServerEntry = {
-            config: { ...config, timeout: { ...timeout, ...config.timeout } },
-            status: { status: "pending" },
-            startup: Deferred.makeUnsafe<void>(),
-          }
-          runtime.set(name, entry)
-          yield* Effect.gen(function* () {
-            yield* register(name, entry)
-            if (config.disabled) {
-              entry.status = { status: "disabled" }
-              yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
-              return
-            }
-            yield* startServer(name, entry)
-          }).pipe(
-            // Settle startup even when register fails or add is interrupted, so an entry that made it
-            // into runtime can never hang readers awaiting its startup.
-            Effect.ensuring(Effect.sync(() => Deferred.doneUnsafe(entry.startup, Exit.void))),
-          )
-        }).pipe(locks.withLock(name))
-      }),
-      connect: Effect.fn("MCP.connect")(function* (server) {
-        const name = ServerName.make(server)
-        yield* Effect.gen(function* () {
-          const target = yield* requireServer(name)
-          yield* stopServer(name, target.entry)
-          yield* startServer(name, target.entry)
-        }).pipe(locks.withLock(name))
-      }),
-      disconnect: Effect.fn("MCP.disconnect")(function* (server) {
-        const name = ServerName.make(server)
-        yield* Effect.gen(function* () {
-          const target = yield* requireServer(name)
-          yield* stopServer(name, target.entry)
-          target.entry.status = { status: "disabled" }
-          yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
-        }).pipe(locks.withLock(name))
-      }),
-      remove: Effect.fn("MCP.remove")(function* (server) {
-        const name = ServerName.make(server)
-        yield* Effect.gen(function* () {
-          const target = yield* requireServer(name)
-          yield* stopServer(name, target.entry)
-          if (target.entry.integrationID) owned.delete(target.entry.integrationID)
-          if (target.entry.registration) yield* target.entry.registration.dispose
-          // Credentials are kept: they are keyed by name + url, so re-adding the same server
-          // reuses them without forcing re-auth, matching add()'s replacement semantics.
-          runtime.delete(name)
-          yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
-        }).pipe(locks.withLock(name))
-      }),
      tools: Effect.fn("MCP.tools")(function* () {
        yield* whenAllReady
        return Array.from(runtime.values())
@@ -6,8 +6,7 @@ import { Permission } from "@opencode-ai/schema/permission"
 import { EventV2 } from "./event"
 import { Location } from "./location"
 import { AgentV2 } from "./agent"
-import { SessionErrors } from "./session/error"
-import { SessionSchema } from "./session/schema"
+import { SessionV2 } from "./session"
 import { SessionStore } from "./session/store"
 import { Wildcard } from "./util/wildcard"
 import { PermissionSaved } from "./permission/saved"
@@ -99,11 +98,11 @@ export function merge(...rulesets: Permission.Ruleset[]): Permission.Ruleset {
 }

 export interface Interface {
-  readonly ask: (input: AssertInput) => Effect.Effect<AskResult, SessionErrors.NotFoundError>
-  readonly assert: (input: AssertInput) => Effect.Effect<void, Error | SessionErrors.NotFoundError>
+  readonly ask: (input: AssertInput) => Effect.Effect<AskResult, SessionV2.NotFoundError>
+  readonly assert: (input: AssertInput) => Effect.Effect<void, Error | SessionV2.NotFoundError>
  readonly reply: (input: ReplyInput) => Effect.Effect<void, NotFoundError>
  readonly get: (id: ID) => Effect.Effect<Request | undefined>
-  readonly forSession: (sessionID: SessionSchema.ID) => Effect.Effect<ReadonlyArray<Request>>
+  readonly forSession: (sessionID: SessionV2.ID) => Effect.Effect<ReadonlyArray<Request>>
  readonly list: () => Effect.Effect<ReadonlyArray<Request>>
 }

@@ -143,12 +142,9 @@ const layer = Layer.effect(
      )
    })

-    const configured = Effect.fn("PermissionV2.configured")(function* (
-      sessionID: SessionSchema.ID,
-      agentID?: AgentV2.ID,
-    ) {
+    const configured = Effect.fn("PermissionV2.configured")(function* (sessionID: SessionV2.ID, agentID?: AgentV2.ID) {
      const session = yield* sessions.get(sessionID)
-      if (!session) return yield* new SessionErrors.NotFoundError({ sessionID })
+      if (!session) return yield* new SessionV2.NotFoundError({ sessionID })
      const agent = yield* agents.resolve(agentID ?? session.agent)
      return agent?.permissions ?? missingAgentPermissions
    })
@@ -305,7 +301,7 @@ const layer = Layer.effect(
      return pending.get(id)?.request
    })

-    const forSession = Effect.fn("PermissionV2.forSession")(function* (sessionID: SessionSchema.ID) {
+    const forSession = Effect.fn("PermissionV2.forSession")(function* (sessionID: SessionV2.ID) {
      return Array.from(pending.values(), (item) => item.request).filter((request) => request.sessionID === sessionID)
    })

@@ -133,20 +133,12 @@ const device = {
      },
      Device,
    ).pipe(
-      Effect.flatMap((value) =>
-        Clock.currentTimeMillis.pipe(
-          Effect.map((created) => {
-            const lifetime = positiveSeconds(value.expires_in, 0)
-            return {
-              mode: "auto" as const,
-              url: value.verification_uri_complete ?? value.verification_uri,
-              instructions: `Open ${value.verification_uri} on any device and enter code: ${value.user_code}`,
-              ...(lifetime ? { expiresAt: created + lifetime * 1000 } : {}),
-              callback: poll(value).pipe(Effect.flatMap((tokens) => credential(deviceMethodID, tokens))),
-            }
-          }),
-        ),
-      ),
+      Effect.map((value) => ({
+        mode: "auto" as const,
+        url: value.verification_uri_complete ?? value.verification_uri,
+        instructions: `Open ${value.verification_uri} on any device and enter code: ${value.user_code}`,
+        callback: poll(value).pipe(Effect.flatMap((tokens) => credential(deviceMethodID, tokens))),
+      })),
    ),
  refresh: (value) => refresh(deviceMethodID, Credential.OAuth.make({ ...value, methodID: deviceMethodID })),
 } satisfies IntegrationOAuthMethodRegistration
@@ -28,9 +28,9 @@ import { fromRow } from "./session/info"
 import { SessionRunner } from "./session/runner/index"
 import { SessionStore } from "./session/store"
 import { SessionExecution } from "./session/execution"
-import { MessageDecodeError, NotFoundError } from "./session/error"
 import { makeGlobalNode } from "./effect/app-node"
 import { LocationServiceMap } from "./location-service-map"
+import { MessageDecodeError } from "./session/error"
 import { SessionEvent } from "./session/event"
 import { SessionPending } from "./session/pending"
 import { SessionGenerate } from "./session/generate"
@@ -108,6 +108,10 @@ type ForkInput = {
  messageID?: SessionMessage.ID
 }

+export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Session.NotFoundError", {
+  sessionID: SessionSchema.ID,
+}) {}
+
 export class OperationUnavailableError extends Schema.TaggedErrorClass<OperationUnavailableError>()(
  "Session.OperationUnavailableError",
  {
@@ -115,7 +119,7 @@ export class OperationUnavailableError extends Schema.TaggedErrorClass<Operation
  },
 ) {}

-export { MessageDecodeError, NotFoundError }
+export { MessageDecodeError } from "./session/error"

 export class PromptConflictError extends Schema.TaggedErrorClass<PromptConflictError>()("Session.PromptConflictError", {
  sessionID: SessionSchema.ID,
@@ -1,15 +1,9 @@
-export * as SessionErrors from "./error"
-
 import { Schema } from "effect"
 import { Agent } from "@opencode-ai/schema/agent"
 import { SessionMessage } from "./message"
 import { SessionSchema } from "./schema"
 import { SessionError } from "@opencode-ai/schema/session-error"

-export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Session.NotFoundError", {
-  sessionID: SessionSchema.ID,
-}) {}
-
 export class MessageDecodeError extends Schema.TaggedErrorClass<MessageDecodeError>()("Session.MessageDecodeError", {
  sessionID: SessionSchema.ID,
  messageID: SessionMessage.ID,
@@ -410,9 +410,7 @@ const layer = Layer.effect(
              yield* events.publish(SessionEvent.Compaction.Failed, {
                sessionID,
                reason: "manual",
-                error: Cause.hasInterruptsOnly(compacted.cause)
-                  ? { type: "aborted", message: "Compaction cancelled" }
-                  : { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
+                error: { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
                inputID: unsettled.id,
              })
            return yield* Effect.failCause(compacted.cause)
@@ -1,11 +1,19 @@
-import type { LanguageModelV3CallOptions } from "@ai-sdk/provider"
+import {
+  APICallError,
+  InvalidPromptError,
+  InvalidResponseDataError,
+  LoadAPIKeyError,
+  type LanguageModelV3,
+  type LanguageModelV3CallOptions,
+  type LanguageModelV3StreamPart,
+} from "@ai-sdk/provider"
 import { AISDK } from "@opencode-ai/core/aisdk"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { LLM, Message } from "@opencode-ai/ai"
+import { InvalidRequestReason, LLM, LLMError, Message } from "@opencode-ai/ai"
 import { LLMClient } from "@opencode-ai/ai/route"
 import { expect } from "bun:test"
-import { Effect } from "effect"
+import { Effect, Stream } from "effect"
 import { testEffect } from "./lib/effect"

 const it = testEffect(AISDK.locationLayer)
@@ -19,6 +27,49 @@ const model = (packageName: string, settings: Record<string, unknown> = {}) =>
    limit: { context: 100, output: 20 },
  })

+const failingLanguage = (error: unknown): LanguageModelV3 => ({
+  specificationVersion: "v3",
+  provider: "test-provider",
+  modelId: "api-model",
+  supportedUrls: {},
+  doGenerate: async () => {
+    throw error
+  },
+  doStream: async () => {
+    throw error
+  },
+})
+
+const streamingLanguage = (...events: LanguageModelV3StreamPart[]): LanguageModelV3 => ({
+  ...failingLanguage(new Error("unused")),
+  doStream: async () => ({
+    stream: new ReadableStream<LanguageModelV3StreamPart>({
+      start(controller) {
+        events.forEach((event) => controller.enqueue(event))
+        controller.close()
+      },
+    }),
+    request: { body: {} },
+  }),
+})
+
+const streamFailure = (language: LanguageModelV3) =>
+  Effect.gen(function* () {
+    const aisdk = yield* AISDK.Service
+    yield* aisdk.hook.sdk((event) => {
+      event.sdk = {}
+    })
+    yield* aisdk.hook.language((event) => {
+      event.language = language
+    })
+    const resolved = yield* aisdk.model(model("@ai-sdk/openai"))
+    const request = LLM.request({ model: resolved, prompt: "Hello" })
+    const prepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(request)
+    return yield* resolved.route
+      .streamPrepared(prepared.body, request, { http: { execute: () => Effect.die("unused") } })
+      .pipe(Stream.runDrain, Effect.flip)
+  })
+
 it.effect("keys language models by package and flattened overlays", () =>
  Effect.gen(function* () {
    const aisdk = yield* AISDK.Service
@@ -238,3 +289,403 @@ it.effect("projects replay metadata onto AI SDK prompt parts", () =>
    ])
  }),
 )
+
+it.effect("classifies AI SDK API failures", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Bad Request",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 400,
+          responseBody: '{"error":{"code":"insufficient_quota","detail":"quota-body-secret"}}',
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "QuotaExceeded" } })
+    expect("http" in error.reason ? error.reason.http : undefined).toBeUndefined()
+    expect(JSON.stringify(error)).not.toContain("quota-body-secret")
+  }),
+)
+
+it.effect("keeps retryable quota responses terminal", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Quota exceeded",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 429,
+          responseBody: '{"error":{"code":"insufficient_quota"}}',
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "QuotaExceeded" } })
+  }),
+)
+
+it.effect("uses response bodies as transient classification evidence", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Bad Request",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 400,
+          responseBody: "Input is too long for requested model overflow-body-secret",
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "InvalidRequest", classification: "context-overflow" } })
+    expect("http" in error.reason ? error.reason.http : undefined).toBeUndefined()
+    expect(JSON.stringify(error)).not.toContain("overflow-body-secret")
+  }),
+)
+
+it.effect("honors retryable AI SDK request timeouts", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "HTTP 408",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 408,
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 408 } })
+  }),
+)
+
+it.effect("honors retryable AI SDK conflicts", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "HTTP 409",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 409,
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 409 } })
+  }),
+)
+
+it.effect("keeps semantic invalid requests terminal on retryable statuses", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Conflict",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 409,
+          responseBody: '{"error":{"code":"request_too_large"}}',
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" } })
+  }),
+)
+
+it.effect("retries unknown coded conflicts", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Conflict",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 409,
+          responseBody: '{"error":{"code":"conflict"}}',
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 409 } })
+  }),
+)
+
+it.effect("preserves AI SDK retry delays without HTTP diagnostics", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Too Many Requests",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 429,
+          responseHeaders: { "Retry-After-Ms": "250" },
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "RateLimit", retryAfterMs: 250 } })
+    expect("http" in error.reason ? error.reason.http : undefined).toBeUndefined()
+  }),
+)
+
+it.effect("classifies statusless retryable API failures as transport failures", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Cannot connect to API",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          isRetryable: true,
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "Transport" } })
+  }),
+)
+
+it.effect("classifies AI SDK timeouts", () =>
+  Effect.gen(function* () {
+    const timeout = yield* streamFailure(failingLanguage(new DOMException("timed out", "TimeoutError")))
+
+    expect(timeout).toMatchObject({ reason: { _tag: "Transport", kind: "Timeout" } })
+  }),
+)
+
+it.effect("classifies AI SDK connection failures", () =>
+  Effect.gen(function* () {
+    const reset = yield* streamFailure(
+      failingLanguage(Object.assign(new Error("connection reset"), { code: "ECONNRESET" })),
+    )
+
+    expect(reset).toMatchObject({ reason: { _tag: "Transport", kind: "ECONNRESET" } })
+  }),
+)
+
+it.effect("classifies Bun connection failures", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(Object.assign(new Error("connection refused"), { code: "ConnectionRefused" })),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "Transport", kind: "CONNECTIONREFUSED" } })
+  }),
+)
+
+it.effect("classifies structured AI SDK stream errors", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({ type: "error", error: { type: "overloaded_error", message: "Overloaded" } }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", message: "Overloaded" } })
+  }),
+)
+
+it.effect("classifies AI Gateway errors with statusCode", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({
+        type: "error",
+        error: { type: "internal_server_error", message: "Gateway failed", statusCode: 503 },
+      }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 503 } })
+  }),
+)
+
+it.effect("classifies AI Gateway timeouts as retryable", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({
+        type: "error",
+        error: { type: "timeout_error", message: "Gateway timed out", statusCode: 408 },
+      }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "Transport", kind: "Timeout" } })
+  }),
+)
+
+it.effect("classifies stripped Bedrock model stream errors", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({
+        type: "error",
+        error: {
+          message: "The model stream failed",
+          originalMessage: "Upstream provider failed",
+          originalStatusCode: 424,
+        },
+      }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 424 } })
+  }),
+)
+
+it.effect("classifies structured stream messages without codes", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(streamingLanguage({ type: "error", error: { message: "Rate limit exceeded" } }))
+
+    expect(error).toMatchObject({ reason: { _tag: "RateLimit" } })
+  }),
+)
+
+it.effect("classifies nested OpenAI Responses stream errors", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({
+        type: "error",
+        error: {
+          type: "response.failed",
+          response: { error: { code: "server_error", message: "Provider failed" } },
+        },
+      }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", message: "Provider failed" } })
+  }),
+)
+
+it.effect("classifies numeric string stream statuses", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({ type: "error", error: { code: "503", message: "Unavailable" } }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 503 } })
+  }),
+)
+
+it.effect("classifies readable stream failures", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure({
+      ...failingLanguage(new Error("unused")),
+      doStream: async () => ({
+        stream: new ReadableStream<LanguageModelV3StreamPart>({
+          start(controller) {
+            controller.error(Object.assign(new Error("connection reset"), { code: "ECONNRESET" }))
+          },
+        }),
+        request: { body: {} },
+      }),
+    })
+
+    expect(error).toMatchObject({ method: "readStream", reason: { _tag: "Transport", kind: "ECONNRESET" } })
+  }),
+)
+
+it.live("times out stalled SSE chunks", () =>
+  Effect.acquireUseRelease(
+    Effect.sync(() =>
+      Bun.serve({
+        port: 0,
+        fetch: () =>
+          new Response(
+            new ReadableStream<Uint8Array>({
+              start(controller) {
+                controller.enqueue(new TextEncoder().encode(": connected\n\n"))
+              },
+            }),
+            { headers: { "content-type": "text/event-stream" } },
+          ),
+      }),
+    ),
+    (server) =>
+      Effect.gen(function* () {
+        const aisdk = yield* AISDK.Service
+        let wrappedFetch: typeof fetch | undefined
+        yield* aisdk.hook.sdk((event) => {
+          wrappedFetch = event.options.fetch
+          event.sdk = {}
+        })
+        yield* aisdk.hook.language((event) => {
+          event.language = {
+            ...failingLanguage(new Error("unused")),
+            doStream: async () => {
+              const fetcher = wrappedFetch
+              if (!fetcher) throw new Error("AI SDK fetch was not configured")
+              const response = await fetcher(server.url, { method: "POST" })
+              if (!response.body) throw new Error("AI SDK response body was missing")
+              return {
+                stream: response.body.pipeThrough(
+                  new TransformStream<Uint8Array, LanguageModelV3StreamPart>({ transform() {} }),
+                ),
+                request: { body: {} },
+              }
+            },
+          }
+        })
+        const resolved = yield* aisdk.model(model("@ai-sdk/openai", { chunkTimeout: 10 }))
+        const request = LLM.request({ model: resolved, prompt: "Hello" })
+        const prepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(request)
+        const error = yield* resolved.route
+          .streamPrepared(prepared.body, request, { http: { execute: () => Effect.die("unused") } })
+          .pipe(Stream.runDrain, Effect.flip)
+
+        expect(error).toMatchObject({ method: "readStream", reason: { _tag: "Transport", kind: "Timeout" } })
+      }),
+    (server) => Effect.promise(() => server.stop(true)),
+  ),
+)
+
+it.effect("classifies missing AI SDK API keys", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(failingLanguage(new LoadAPIKeyError({ message: "API key is missing" })))
+
+    expect(error).toMatchObject({ reason: { _tag: "Authentication", kind: "missing" } })
+  }),
+)
+
+it.effect("classifies invalid AI SDK prompts", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(new InvalidPromptError({ prompt: [], message: "unsupported prompt" })),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" } })
+  }),
+)
+
+it.effect("preserves existing LLM errors", () =>
+  Effect.gen(function* () {
+    const original = new LLMError({
+      module: "test",
+      method: "run",
+      reason: new InvalidRequestReason({ message: "invalid" }),
+    })
+    const error = yield* streamFailure(failingLanguage(original))
+
+    expect(error).toBe(original)
+  }),
+)
+
+it.effect("classifies malformed AI SDK response causes", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Failed to process response",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 200,
+          cause: new InvalidResponseDataError({ data: { invalid: true } }),
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "InvalidProviderOutput" } })
+  }),
+)
@@ -9,10 +9,6 @@ export const emptyMcpLayer = Layer.succeed(
  MCP.Service,
  MCP.Service.of({
    servers: () => Effect.succeed([]),
-    add: () => Effect.die("unused mcp.add"),
-    connect: () => Effect.die("unused mcp.connect"),
-    disconnect: () => Effect.die("unused mcp.disconnect"),
-    remove: () => Effect.die("unused mcp.remove"),
    tools: () => Effect.succeed([]),
    callTool: () => Effect.die("unused mcp.callTool"),
    instructions: () => Effect.succeed([]),
@@ -1,5 +1,5 @@
 import { describe, expect } from "bun:test"
-import { Cause, Clock, Duration, Effect, Exit, Fiber, Layer, Scope, Stream } from "effect"
+import { Cause, Duration, Effect, Exit, Fiber, Layer, Scope, Stream } from "effect"
 import * as TestClock from "effect/testing/TestClock"
 import { Credential } from "@opencode-ai/core/credential"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -414,41 +414,6 @@ describe("Integration", () => {
    }),
  )

-  it.effect("uses provider-defined OAuth attempt expirations", () =>
-    Effect.gen(function* () {
-      const integrations = yield* Integration.Service
-      const integrationID = Integration.ID.make("openai")
-      const created = yield* Clock.currentTimeMillis
-      const expirations = [
-        created + Duration.toMillis(Duration.minutes(5)),
-        created + Duration.toMillis(Duration.minutes(20)),
-      ]
-
-      yield* Effect.forEach(expirations, (expiresAt, index) => {
-        const methodID = Integration.MethodID.make(`browser-${index}`)
-        return Effect.gen(function* () {
-          yield* integrations.transform((editor) =>
-            editor.method.update({
-              integrationID,
-              method: { id: methodID, type: "oauth", label: "Browser" },
-              authorize: () =>
-                Effect.succeed({
-                  mode: "auto" as const,
-                  url: "https://example.com/authorize",
-                  instructions: "Sign in",
-                  expiresAt,
-                  callback: Effect.never,
-                }),
-            }),
-          )
-
-          const attempt = yield* integrations.oauth.connect({ integrationID, methodID, inputs: {} })
-          expect(attempt.time).toEqual({ created, expires: expiresAt })
-        })
-      })
-    }),
-  )
-
  it.effect("projects credential and env connections", () => {
    const integrationID = Integration.ID.make("acme")
    return Effect.acquireUseRelease(
@@ -148,10 +148,7 @@ function resourceServer(
  )
 }

-function resourceMcpLayer(
-  server: string | typeof ConfigMCP.Server.Type,
-  onFormCreated?: (form: Form.Info) => Effect.Effect<void>,
-) {
+function resourceMcpLayer(url: string, onFormCreated?: (form: Form.Info) => Effect.Effect<void>) {
  const directory = AbsolutePath.make(import.meta.dir)
  const unusedIntegration = () => Effect.die("unused integration service")
  return MCP.layer.pipe(
@@ -167,12 +164,7 @@ function resourceMcpLayer(
                  type: "document",
                  info: new Config.Info({
                    mcp: new ConfigMCP.Info({
-                      servers: {
-                        resources:
-                          typeof server === "string"
-                            ? new ConfigMCP.Remote({ type: "remote", url: server, oauth: false })
-                            : server,
-                      },
+                      servers: { resources: new ConfigMCP.Remote({ type: "remote", url, oauth: false }) },
                    }),
                  }),
                }),
@@ -642,120 +634,6 @@ test("loads and reads MCP resources", async () => {
  )
 })

-test("adds, disconnects, and reconnects MCP servers at runtime", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        yield* Effect.gen(function* () {
-          const service = yield* MCP.Service
-
-          expect((yield* service.servers())[0]?.status).toEqual({ status: "disabled" })
-          expect(yield* service.connect("missing").pipe(Effect.flip)).toBeInstanceOf(MCP.NotFoundError)
-          expect(yield* service.disconnect("missing").pipe(Effect.flip)).toBeInstanceOf(MCP.NotFoundError)
-          yield* service.add(
-            "dynamic",
-            new ConfigMCP.Local({
-              type: "local",
-              command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-output-schema.ts")],
-            }),
-          )
-          expect((yield* service.servers()).find((server) => server.name === "dynamic")?.status).toEqual({
-            status: "connected",
-          })
-
-          yield* service.add(
-            "dynamic",
-            new ConfigMCP.Local({
-              type: "local",
-              command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-output-schema.ts")],
-              disabled: true,
-            }),
-          )
-          expect((yield* service.servers()).find((server) => server.name === "dynamic")?.status).toEqual({
-            status: "disabled",
-          })
-          expect(yield* service.tools()).toEqual([])
-
-          yield* service.connect("dynamic")
-          expect((yield* service.servers()).find((server) => server.name === "dynamic")?.status).toEqual({
-            status: "connected",
-          })
-          yield* service.disconnect("dynamic")
-          expect((yield* service.servers()).find((server) => server.name === "dynamic")?.status).toEqual({
-            status: "disabled",
-          })
-          expect(yield* service.tools()).toEqual([])
-
-          yield* service.connect("dynamic")
-          expect((yield* service.servers()).find((server) => server.name === "dynamic")?.status).toEqual({
-            status: "connected",
-          })
-
-          yield* service.remove("dynamic")
-          expect((yield* service.servers()).some((server) => server.name === "dynamic")).toBe(false)
-          expect(yield* service.tools()).toEqual([])
-          expect(yield* service.remove("dynamic").pipe(Effect.flip)).toBeInstanceOf(MCP.NotFoundError)
-        }).pipe(
-          Effect.provide(
-            resourceMcpLayer(
-              new ConfigMCP.Local({
-                type: "local",
-                command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-output-schema.ts")],
-                disabled: true,
-              }),
-            ),
-          ),
-        )
-      }),
-    ),
-  )
-})
-
-test("serializes concurrent MCP lifecycle operations", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        yield* Effect.gen(function* () {
-          const service = yield* MCP.Service
-
-          // Whatever order the racing operations land in, the resulting state must be consistent.
-          yield* Effect.all(
-            [
-              service.connect("resources"),
-              service.connect("resources"),
-              service.disconnect("resources"),
-              service.connect("resources"),
-            ],
-            { concurrency: "unbounded", discard: true },
-          )
-          const status = (yield* service.servers()).find((server) => server.name === "resources")?.status
-          const tools = yield* service.tools()
-          expect(status?.status === "connected" || status?.status === "disabled").toBe(true)
-          if (status?.status === "disabled") expect(tools).toEqual([])
-          if (status?.status === "connected") expect(tools.length).toBeGreaterThan(0)
-
-          yield* service.disconnect("resources")
-          expect((yield* service.servers())[0]?.status).toEqual({ status: "disabled" })
-          expect(yield* service.tools()).toEqual([])
-          yield* service.connect("resources")
-          expect((yield* service.servers())[0]?.status).toEqual({ status: "connected" })
-          expect((yield* service.tools()).length).toBeGreaterThan(0)
-        }).pipe(
-          Effect.provide(
-            resourceMcpLayer(
-              new ConfigMCP.Local({
-                type: "local",
-                command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-output-schema.ts")],
-                disabled: true,
-              }),
-            ),
-          ),
-        )
-      }),
-    ),
-  )
-})
-
 it.effect("advertises MCP output schemas to Code Mode", () =>
  Effect.gen(function* () {
    const registry = yield* ToolRegistry.Service
@@ -1892,35 +1892,6 @@ describe("SessionRunnerLLM", () => {
    }),
  )

-  it.effect("records cancelled manual compaction without surfacing an internal failure", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      response = reply.text("Earlier answer", "text-manual-interrupt-history")
-      yield* admit(session, "Earlier question")
-      yield* session.resume(sessionID)
-
-      const streamed = yield* Deferred.make<void>()
-      const partial = fragmentFixture("text", "text-manual-interrupt-summary", ["Partial summary"])
-      responseStream = Stream.concat(
-        Stream.fromIterable(partial.partialEvents),
-        Stream.fromEffect(Deferred.succeed(streamed, undefined)).pipe(Stream.flatMap(() => Stream.never)),
-      )
-      const compaction = yield* session.compact({ sessionID })
-      const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
-      yield* Deferred.await(streamed)
-      yield* session.interrupt(sessionID)
-
-      yield* Fiber.await(run)
-      expect(yield* SessionPending.compaction((yield* Database.Service).db, sessionID)).toBeUndefined()
-      expect((yield* session.messages({ sessionID })).find((message) => message.id === compaction.id)).toMatchObject({
-        type: "compaction",
-        status: "failed",
-        reason: "manual",
-        error: { type: "aborted", message: "Compaction cancelled" },
-      })
-    }),
-  )
-
  it.effect("settles an admitted manual compaction when pre-start resolution throws", () =>
    Effect.gen(function* () {
      const session = yield* setup
@@ -2,7 +2,7 @@ import fs from "fs/promises"
 import { realpathSync } from "node:fs"
 import path from "path"
 import { describe, expect, test } from "bun:test"
-import { DateTime, Deferred, Duration, Effect, Fiber, Layer, Scope, Stream } from "effect"
+import { DateTime, Duration, Effect, Fiber, Layer, Scope, Stream } from "effect"
 import { Money } from "@opencode-ai/schema/money"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
@@ -166,10 +166,10 @@ const overflowCommand = (bytes: number) =>
  isWindows
    ? `[Console]::Out.Write(('x' * ${bytes})); Start-Sleep -Milliseconds 100`
    : `head -c ${bytes} /dev/zero | tr '\\0' 'x'`
-const progressOverflowCommand = (bytes: number, release: string) =>
+const progressOverflowCommand = (bytes: number) =>
  isWindows
-    ? `[Console]::Out.Write(('x' * ${bytes})); while (!(Test-Path -LiteralPath '${release}')) { Start-Sleep -Milliseconds 50 }`
-    : `head -c ${bytes} /dev/zero | tr '\\0' 'x'; while [ ! -e '${release}' ]; do sleep 0.05; done`
+    ? `[Console]::Out.Write(('x' * ${bytes})); Start-Sleep -Milliseconds 1500`
+    : `head -c ${bytes} /dev/zero | tr '\\0' 'x'; sleep 1.5`

 const withSession = <A, E, R>(directory: string, body: (registry: ToolRegistry.Interface) => Effect.Effect<A, E, R>) =>
  Effect.gen(function* () {
@@ -417,49 +417,33 @@ describe("ShellTool", () => {
    ),
  )

-  it.live(
-    "reports bounded output progress for a running command",
-    () =>
-      Effect.acquireUseRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) => {
-          reset()
-          const release = "shell-progress-release"
-          const releasePath = path.join(tmp.path, release)
-          return withSession(tmp.path, (registry) =>
-            Effect.gen(function* () {
-              const observed = yield* Deferred.make<ToolRegistry.Progress>()
-              yield* settleTool(registry, {
-                ...call(
-                  { command: progressOverflowCommand(ShellTool.MAX_CAPTURE_BYTES + 1024, release) },
-                  "call-progress",
-                ),
-                progress: (update) =>
-                  Effect.gen(function* () {
-                    if (update.structured.truncated !== true) return
-                    const content = update.content[0]
-                    if (content?.type !== "text") return
-                    if (content.text.indexOf("\n\n[output truncated; full output saved to:") !== ShellTool.MAX_CAPTURE_BYTES)
-                      return
-                    yield* Deferred.succeed(observed, update)
-                    yield* Effect.promise(() => fs.writeFile(releasePath, ""))
-                  }),
-              })
+  it.live("reports bounded output progress for a running command", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => {
+        reset()
+        const bytes = ShellTool.MAX_CAPTURE_BYTES + 1024
+        return withSession(tmp.path, (registry) =>
+          Effect.gen(function* () {
+            const progress: ToolRegistry.Progress[] = []
+            yield* settleTool(registry, {
+              ...call({ command: progressOverflowCommand(bytes) }, "call-progress"),
+              progress: (update) => Effect.sync(() => progress.push(update)),
+            })

-              const progress = yield* Deferred.await(observed)
-              expect(progress.structured).toEqual({ truncated: true })
-              const content = progress.content[0]
-              expect(content?.type).toBe("text")
-              if (content?.type !== "text") return
-              expect(content.text.indexOf("\n\n[output truncated; full output saved to:")).toBe(
-                ShellTool.MAX_CAPTURE_BYTES,
-              )
-            }).pipe(Effect.ensuring(Effect.promise(() => fs.writeFile(releasePath, "")).pipe(Effect.ignore))),
-          )
-        },
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
-      ),
-    { timeout: 15_000 },
+            expect(progress).toHaveLength(1)
+            expect(progress[0]?.structured).toEqual({ truncated: true })
+            const content = progress[0]?.content[0]
+            expect(content?.type).toBe("text")
+            if (content?.type !== "text") return
+            expect(content.text.indexOf("\n\n[output truncated; full output saved to:")).toBe(
+              ShellTool.MAX_CAPTURE_BYTES,
+            )
+          }),
+        )
+      },
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
+    ),
  )

  it.live("returns a useful timeout settlement", () =>
@@ -22,12 +22,12 @@ You can also install it with the following package managers.
  </Tab>
  <Tab title="bun">
    ```bash
-    bun install -g --trust @opencode-ai/cli@next
+    bun install -g @opencode-ai/cli@next
    ```
  </Tab>
  <Tab title="pnpm">
    ```bash
-    pnpm add -g --allow-build=@opencode-ai/cli @opencode-ai/cli@next
+    pnpm install -g @opencode-ai/cli@next
    ```
  </Tab>
  <Tab title="Yarn">
@@ -37,9 +37,6 @@ You can also install it with the following package managers.
  </Tab>
 </Tabs>

-The package uses a trusted postinstall script to select the native binary for your platform. The Bun and pnpm commands
-above explicitly allow that script to run.
-
 <Note>During beta, the binary is called `opencode2`.</Note>

 ### Homebrew
@@ -17,7 +17,6 @@ import type { Transform } from "./registration.js"
 export type IntegrationOAuthAuthorization = {
  readonly url: string
  readonly instructions: string
-  readonly expiresAt?: number
 } & (
  | {
      readonly mode: "auto"
@@ -21,10 +21,7 @@ export type Options<E = never, R = never> = {
  readonly password: string
  readonly instanceID: string
  readonly service?: {
-    readonly onListen: (
-      address: HttpServer.Address,
-      shutdown: Effect.Effect<void>,
-    ) => Effect.Effect<Effect.Effect<void>, E, R>
+    readonly onListen: (address: HttpServer.Address) => Effect.Effect<void, E, R>
  }
 }

@@ -47,21 +44,17 @@ export const start = Effect.fn("ServerProcess.start")(function* <E, R>(options:
  yield* bound.http
    .serve(dispatch(options.password, status, application, shutdown), HttpMiddleware.logger)
    .pipe(withoutParentSpan)
-  if (options.service)
-    yield* options.service.onListen(bound.http.address, Deferred.succeed(shutdown, undefined).pipe(Effect.asVoid)).pipe(
-      Effect.flatMap((cleanup) =>
-        Effect.addFinalizer(() => Scope.close(bound.scope, Exit.void).pipe(Effect.andThen(cleanup))),
-      ),
-      Effect.uninterruptible,
-    )
+  if (options.service) yield* options.service.onListen(bound.http.address)

  const parentScope = yield* Scope.Scope
  const applicationScope = yield* Scope.fork(parentScope)
  yield* Effect.addFinalizer(() =>
-    status.beginStopping.pipe(
-      Effect.andThen(Ref.set(application, Option.none())),
-      Effect.andThen(Effect.sync(() => bound.server.closeAllConnections())),
-    ),
+    status
+      .beginStopping
+      .pipe(
+        Effect.andThen(Ref.set(application, Option.none())),
+        Effect.andThen(Effect.sync(() => bound.server.closeAllConnections())),
+      ),
  )

  const boot = Effect.gen(function* () {
@@ -119,7 +112,7 @@ function bind(hostname: string, port: number) {
    return yield* Effect.gen(function* () {
      const http = yield* NodeHttpServer.make(() => server, { port, host: hostname })
      yield* Effect.addFinalizer(() => Effect.sync(() => server.closeAllConnections()))
-      return { http, server, scope: serverScope }
+      return { http, server }
    }).pipe(
      Effect.provideService(Scope.Scope, serverScope),
      Effect.onError((cause) => Scope.close(serverScope, Exit.failCause(cause))),
@@ -197,13 +190,10 @@ const control = Effect.fnUntraced(function* (

 const healthResponse = Effect.fnUntraced(function* (status: Status.Interface) {
  const state = yield* status.current
-  return HttpServerResponse.jsonUnsafe(
-    { healthy: true, version: InstallationVersion, pid: process.pid },
-    {
-      status: state.type === "ready" ? 200 : state.type === "failed" ? 500 : 503,
-      headers: state.type === "starting" || state.type === "stopping" ? { "retry-after": "1" } : undefined,
-    },
-  )
+  return HttpServerResponse.jsonUnsafe({ healthy: true, version: InstallationVersion, pid: process.pid }, {
+    status: state.type === "ready" ? 200 : state.type === "failed" ? 500 : 503,
+    headers: state.type === "starting" || state.type === "stopping" ? { "retry-after": "1" } : undefined,
+  })
 })

 function unavailable(status: Status.State) {
@@ -22,7 +22,6 @@ interface Tab {
 const ComposerContext = createContext<{
  register: (tab: Tab) => () => void
  active: (id: string) => boolean
-  close: () => void
 }>()

 export function useComposerTab() {
@@ -74,7 +73,6 @@ export function Composer(props: ComposerProps) {
    active(id: string) {
      return props.open && store.active === id
    },
-    close,
  }

  const keymap = Keymap.use()
@@ -59,11 +59,9 @@ export function ShellTab(props: { sessionID: string }) {
        group: "Composer",
        bind: "up",
        run() {
-          if (store.selected === 0) {
-            composer.close()
-            return
-          }
-          setStore("selected", (prev) => prev - 1)
+          const list = entries()
+          if (list.length === 0) return
+          setStore("selected", (prev) => (prev - 1 + list.length) % list.length)
        },
      },
      {
@@ -160,11 +160,9 @@ export function SubagentsTab(props: { sessionID: string }) {
        group: "Composer",
        bind: "up",
        run() {
-          if (store.selected === 0) {
-            composer.close()
-            return
-          }
-          moveTo(store.selected - 1, true)
+          const list = entries()
+          if (list.length === 0) return
+          moveTo((store.selected - 1 + list.length) % list.length, true)
        },
      },
      {
@@ -1440,10 +1440,9 @@ function CompactionMessage(props: { message: Extract<SessionMessageInfo, { type:
  const ctx = use()
  const { themeV2, syntax } = useTheme()
  const status = () => props.message.status
-  const cancelled = () => props.message.status === "failed" && props.message.error.type === "aborted"
-  const text = () => (props.message.status === "failed" ? (cancelled() ? "" : props.message.error.message) : props.message.summary)
+  const text = () => (props.message.status === "failed" ? props.message.error.message : props.message.summary)
  const content = createMemo(() => text().trim())
-  const color = () => (status() === "failed" && !cancelled() ? themeV2.text.feedback.error() : themeV2.text.subdued())
+  const color = () => (status() === "failed" ? themeV2.text.feedback.error() : themeV2.text.subdued())
  return (
    <box>
      <box flexDirection="row" alignItems="center">
@@ -1455,14 +1454,11 @@ function CompactionMessage(props: { message: Extract<SessionMessageInfo, { type:
                <spinner frames={SPINNER_FRAMES} interval={80} color={color()} />
              </Show>
            </Match>
-            <Match when={status() === "failed" && !cancelled()}>
+            <Match when={status() === "failed"}>
              <text fg={color()}>✗</text>
            </Match>
          </Switch>
          <text fg={color()}>Compaction</text>
-          <Show when={cancelled()}>
-            <text fg={color()}>· cancelled</text>
-          </Show>
        </box>
        <box border={["top"]} borderColor={color()} flexGrow={1} />
      </box>
@@ -77,7 +77,6 @@ export function createComponentTheme(current: Accessor<ResolvedThemeView>, mode:

  return {
    hue,
-    source: (color: RGBA) => current().source(color),
    increase: (color: RGBA, amount = 1) => current().increase(color, amount),
    decrease: (color: RGBA, amount = 1) => current().decrease(color, amount),
    raise: (color: RGBA) => (mode() === "light" ? current().increase(color) : current().decrease(color)),
@@ -32,7 +32,6 @@ export {
 export type {
  FormfieldColor,
  Hue,
-  HueSource,
  HueScale,
  ResolvedActionState,
  ResolvedFormfieldState,
@@ -141,36 +141,35 @@ function contextualActions(
 function resolveView(
  definition: ThemeTokensDefinition,
  hue: ResolvedThemeView["hue"],
-  hueSteps: Pick<ResolvedThemeView, "source" | "increase" | "decrease">,
+  hueSteps: Pick<ResolvedThemeView, "increase" | "decrease">,
 ): ResolvedThemeView {
  const source: Record<string, unknown> = { hue, ...definition }
  return { ...(createResolver(source)(source, "theme") as ResolvedThemeView), hue, ...hueSteps }
 }

-function compileHueSteps(
-  hue: ResolvedThemeView["hue"],
-): Pick<ResolvedThemeView, "source" | "increase" | "decrease"> {
-  const index = new WeakMap<RGBA, { hue: keyof typeof hue; step: HueStep; position: number }>()
-  for (const [name, scale] of Object.entries(hue) as [keyof typeof hue, HueScale][]) {
-    HueStep.literals.forEach((step, position) => index.set(scale[step], { hue: name, step, position }))
-  }
+function compileHueSteps(hue: ResolvedThemeView["hue"]): Pick<ResolvedThemeView, "increase" | "decrease"> {
+  const index = new Map(
+    Object.values(hue).flatMap((scale) =>
+      HueStep.literals.map((step, position) => [colorKey(scale[step]), { position, scale }] as const),
+    ),
+  )
  const shift = (color: RGBA, amount: number) => {
-    const match = index.get(color)
+    const match = index.get(colorKey(color))
    if (!match) return color
    const offset = Number.isFinite(amount) ? Math.trunc(amount) : 0
    const position = Math.max(0, Math.min(HueStep.literals.length - 1, match.position + offset))
-    return hue[match.hue][HueStep.literals[position]]
+    return match.scale[HueStep.literals[position]]
  }
  return {
-    source: (color) => {
-      const match = index.get(color)
-      return match ? { hue: match.hue, step: match.step } : undefined
-    },
    increase: (color, amount = 1) => shift(color, amount),
    decrease: (color, amount = 1) => shift(color, -amount),
  }
 }

+function colorKey(color: RGBA) {
+  return color.toInts().join(":")
+}
+
 function resolveHue(definition: HueDefinition) {
  const source = definition as Record<string, unknown>
  const cache = new Map<string, HueScale>()
@@ -187,8 +186,7 @@ function resolveHue(definition: HueDefinition) {
    if (typeof value === "string") {
      const match = /^\$hue\.([^.]+)$/.exec(value)
      if (!match?.[1]) throw new Error(`Hue alias "${value}" must reference a hue scale`)
-      const target = resolve(match[1], [...stack, name])
-      const result = Object.fromEntries(HueStep.literals.map((step) => [step, RGBA.clone(target[step])])) as HueScale
+      const result = resolve(match[1], [...stack, name])
      cache.set(name, result)
      return result
    }
@@ -15,13 +15,11 @@ export type ResolvedActionState = "default" | ActionState
 export type ResolvedFormfieldState = ResolvedActionState
 export type HueScale = Readonly<Record<HueStep, RGBA>>
 export type Hue = Readonly<Record<BaseHue | HueAlias, HueScale>>
-export type HueSource = Readonly<{ hue: BaseHue | HueAlias; step: HueStep }>
 export type StatefulColor = Readonly<Record<ResolvedActionState, RGBA>>
 export type FormfieldColor = StatefulColor

 export type ResolvedThemeView = {
  readonly hue: Hue
-  readonly source: (color: RGBA) => HueSource | undefined
  readonly increase: (color: RGBA, amount?: number) => RGBA
  readonly decrease: (color: RGBA, amount?: number) => RGBA
  readonly text: {
@@ -283,7 +283,7 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
      setTimeout(() => {
        if (filter.length > 0) {
          moveTo(0, true, false)
-        } else if (current && props.focusCurrent !== false && store.input !== "mouse") {
+        } else if (current && props.focusCurrent !== false) {
          const currentIndex = flat().findIndex((opt) => isDeepEqual(opt.value, current))
          if (currentIndex >= 0) {
            moveTo(currentIndex, true)
@@ -79,7 +79,7 @@ async function renderSelect(
  return app
 }

-async function mountSelect(root: string, initial: DialogSelectOption<string>[], trackCurrent = false) {
+async function mountSelect(root: string, initial: DialogSelectOption<string>[]) {
  const state = path.join(root, "state")
  await mkdir(state, { recursive: true })
  const config = createTuiResolvedConfig()
@@ -105,7 +105,6 @@ async function mountSelect(root: string, initial: DialogSelectOption<string>[],

  function Harness() {
    const [options, setOptions] = createSignal(initial)
-    const [current, setCurrent] = createSignal(initial[0]?.value)
    replaceOptions = setOptions

    function Fixture() {
@@ -115,11 +114,7 @@ async function mountSelect(root: string, initial: DialogSelectOption<string>[],
          <DialogSelect
            title="Mutable options"
            options={options()}
-            current={trackCurrent ? current() : undefined}
-            onMove={(option) => {
-              moved.push(option.value)
-              if (trackCurrent) setCurrent(option.value)
-            }}
+            onMove={(option) => moved.push(option.value)}
            onSelect={(option) => selected.push(option.value)}
          />
        )),
@@ -277,30 +272,3 @@ test("selects a repopulated option after removing the only option", async () =>
    select.app.renderer.destroy()
  }
 })
-
-test("hover stays on the row when current follows selection", async () => {
-  await using tmp = await tmpdir()
-  const select = await mountSelect(
-    tmp.path,
-    ["first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth"].map((value) => ({
-      title: value,
-      value,
-    })),
-    true,
-  )
-
-  try {
-    await select.app.mockMouse.moveTo(20, 11)
-    await select.app.flush()
-    await select.app.mockMouse.moveTo(20, 12)
-    await select.app.waitFor(() => select.moved.includes("second"))
-    select.moved.length = 0
-    await select.app.mockMouse.moveTo(20, 14)
-    await select.app.waitFor(() => select.moved.length > 0)
-    await select.app.waitForVisualIdle()
-
-    expect(select.moved).toEqual(["fourth"])
-  } finally {
-    select.app.renderer.destroy()
-  }
-})
@@ -25,10 +25,8 @@ test("provides reactive property, variant, state, and context accessors", () =>
  expect(theme.decrease(theme.hue.red(300), 2)).toBe(resolved().hue.red[100])
  expect(theme.increase(theme.hue.red(900), 3)).toBe(resolved().hue.red[900])
  expect(theme.decrease(theme.hue.red(100), 3)).toBe(resolved().hue.red[100])
-  expect(theme.source(theme.background.surface.offset())).toEqual({ hue: "neutral", step: 200 })
  const equivalent = RGBA.fromInts(...resolved().hue.green[500].toInts())
-  expect(theme.source(equivalent)).toBeUndefined()
-  expect(theme.increase(equivalent, 1)).toBe(equivalent)
+  expect(theme.increase(equivalent, 1)).toBe(resolved().hue.green[600])
  const unmatched = RGBA.fromInts(1, 2, 3)
  expect(theme.increase(unmatched, 1)).toBe(unmatched)
  expect(theme.text.subdued()).toBe(resolved().text.subdued)
@@ -12,15 +12,9 @@ test("resolves independent definitions and hue aliases", () => {
  const lightTheme = resolveTheme(light)
  const darkTheme = resolveTheme(dark)

-  expect(lightTheme.hue.accent).not.toBe(lightTheme.hue.blue)
-  expect(lightTheme.hue.accent[500].equals(lightTheme.hue.blue[500])).toBeTrue()
-  expect(lightTheme.hue.interactive).not.toBe(lightTheme.hue.blue)
-  expect(lightTheme.hue.interactive[500].equals(lightTheme.hue.blue[500])).toBeTrue()
-  expect(lightTheme.hue.neutral).not.toBe(lightTheme.hue.gray)
-  expect(lightTheme.hue.neutral[500].equals(lightTheme.hue.gray[500])).toBeTrue()
-  expect(lightTheme.source(lightTheme.hue.blue[500])).toEqual({ hue: "blue", step: 500 })
-  expect(lightTheme.source(lightTheme.hue.neutral[200])).toEqual({ hue: "neutral", step: 200 })
-  expect(lightTheme.source(lightTheme.background.surface.offset)).toEqual({ hue: "neutral", step: 200 })
+  expect(lightTheme.hue.accent).toBe(lightTheme.hue.blue)
+  expect(lightTheme.hue.interactive).toBe(lightTheme.hue.blue)
+  expect(lightTheme.hue.neutral).toBe(lightTheme.hue.gray)
  expect(lightTheme.increase(lightTheme.hue.red[100])).toBe(lightTheme.hue.red[200])
  expect(lightTheme.decrease(lightTheme.hue.red[200])).toBe(lightTheme.hue.red[100])
  expect(lightTheme.contexts["@context:elevated"]?.increase(lightTheme.hue.red[100])).toBe(
@@ -70,15 +64,9 @@ test("resolves base hue aliases and rejects circular hue aliases", () => {
    "light",
  )

-  expect(aliased.hue.blue).not.toBe(aliased.hue.red)
-  expect(aliased.hue.blue[500].equals(aliased.hue.red[500])).toBeTrue()
-  expect(aliased.hue.purple).not.toBe(aliased.hue.blue)
-  expect(aliased.hue.purple[500].equals(aliased.hue.red[500])).toBeTrue()
-  expect(overridden.hue.blue).not.toBe(overridden.hue.red)
-  expect(overridden.hue.blue[500].equals(overridden.hue.red[500])).toBeTrue()
-  expect(aliased.source(aliased.hue.red[500])).toEqual({ hue: "red", step: 500 })
-  expect(aliased.source(aliased.hue.blue[500])).toEqual({ hue: "blue", step: 500 })
-  expect(aliased.source(aliased.hue.purple[500])).toEqual({ hue: "purple", step: 500 })
+  expect(aliased.hue.blue).toBe(aliased.hue.red)
+  expect(aliased.hue.purple).toBe(aliased.hue.red)
+  expect(overridden.hue.blue).toBe(overridden.hue.red)
  expect(() =>
    resolveTheme({
      ...light,
@@ -87,25 +75,6 @@ test("resolves base hue aliases and rejects circular hue aliases", () => {
  ).toThrow("Circular hue reference: red -> blue -> red")
 })

-test("steps by hue source when adjacent colors have equal values", () => {
-  if (typeof light.hue.gray !== "object") throw new Error("Expected a concrete gray scale")
-  const theme = resolveTheme({
-    ...light,
-    hue: {
-      ...light.hue,
-      gray: { ...light.hue.gray, 200: "#eee8d5", 300: "#eee8d5", 400: "#d3d7c6" },
-      neutral: "$hue.gray",
-    },
-  })
-
-  expect(theme.hue.neutral[200]).not.toBe(theme.hue.neutral[300])
-  expect(theme.hue.neutral[200].equals(theme.hue.neutral[300])).toBeTrue()
-  expect(theme.source(theme.hue.neutral[200])).toEqual({ hue: "neutral", step: 200 })
-  expect(theme.source(theme.hue.neutral[300])).toEqual({ hue: "neutral", step: 300 })
-  expect(theme.increase(theme.hue.neutral[200])).toBe(theme.hue.neutral[300])
-  expect(theme.increase(theme.hue.neutral[300])).toBe(theme.hue.neutral[400])
-})
-
 test("merges partial files with the selected OpenCode defaults", () => {
  const theme = resolveThemeFile(
    {
Author	SHA1	Message	Date
Aiden Cline	0eacf8d736	fix(ai): handle remaining provider failures	2026-07-17 14:41:53 -05:00
Aiden Cline	7c655f6a61	fix(ai): handle retryable SDK failures	2026-07-17 14:41:52 -05:00
Aiden Cline	7236eb106b	refactor(ai): remove SDK error diagnostics	2026-07-17 14:41:52 -05:00
Aiden Cline	0960ef48fd	fix(ai): classify provider failures consistently	2026-07-17 14:41:52 -05:00