fix(session-ui): count patched files in tool summaries

Grouped tool summaries used the raw tool-call count, so repeated patch calls reported the number of invocations instead of the distinct files changed. Derive the count from successful patch metadata while keeping the existing fallback for other tools.

packages/ai/AGENTS.md

@@ -165,10 +165,6 @@ Native chronological system messages are route/model-specific. Open Responses lo
 
 The wrapped-user fallback preserves ordering while visibly lowering authority. Never silently pass a raw chronological `role: "system"` through a route that might reject it. Do not insert raw retrieved documents, tool output, or web content into privileged chronological system updates; keep untrusted content in ordinary user/tool channels.
 
-### Effort Updates
-
-`Message.effort({ effort, previous })` is a chronological "reasoning effort changed here" marker (`undefined` means the model default). Changing a top-level effort invalidates the whole provider prompt cache, so protocols with a native per-message update (`Protocol.supportsEffortUpdates`) keep the top-level effort at the first marker's `previous` and lower each marker in place: Anthropic Messages emits an empty `role: "system"` message with `output_config.effort` plus the `mid-conversation-output-config-2026-07-01` beta, and OpenAI Responses emits `configuration_update` items. `applyEffortUpdates` runs in `prepareRequest` and strips the markers for every other route, so a protocol without support keeps today's plain top-level behaviour. When the last marker disagrees with the effort the request asks for (reverted or forked history), `resolveEffortUpdates` strips the markers and falls back to a plain top-level change.
-
 ### Tools
 
 Tool loops are represented in common messages and events:

packages/ai/src/cache-policy.ts

@@ -12,7 +12,6 @@
 // count against the four-breakpoint budget; auto only fills remaining slots.
 import { CacheHint, type CachePolicy, type CachePolicyObject } from "./schema/options.js"
 import { LLMRequest, Message, ToolDefinition, type ContentPart, type ToolEntry } from "./schema/messages.js"
-import { effortUpdate } from "./effort-updates.js"
 
 const AUTO: CachePolicyObject = {
   tools: true,
@@ -122,15 +121,9 @@ const markMessages = (
     return markMessageAt(messages, lastIndexOfRole(messages, "user"), hint, budget)
   if (strategy === "latest-assistant")
     return markMessageAt(messages, lastIndexOfRole(messages, "assistant"), hint, budget)
-  let start = messages.length
-  let remaining = strategy.tail
-  while (remaining > 0 && start > 0) {
-    start -= 1
-    if (effortUpdate(messages[start]!) === undefined) remaining -= 1
-  }
+  const start = Math.max(0, messages.length - strategy.tail)
   let next = messages
-  for (let i = start; i < messages.length; i++)
-    if (effortUpdate(messages[i]!) === undefined) next = markMessageAt(next, i, hint, budget)
+  for (let i = start; i < messages.length; i++) next = markMessageAt(next, i, hint, budget)
   return next
 }
 

packages/ai/src/effort-updates.ts

@@ -1,27 +0,0 @@
-// A top-level reasoning effort change invalidates the whole provider prompt cache, so a
-// mid-conversation switch travels as a `Message.effort(...)` marker: protocols with a native
-// per-message update freeze the top-level effort and lower the markers; every other route strips them.
-import { LLMRequest, type EffortPart, type Message } from "./schema/messages.js"
-
-export const effortUpdate = (message: Message): EffortPart | undefined => {
-  if (message.role !== "system" || message.content.length !== 1) return undefined
-  const part = message.content[0]
-  return part.type === "effort" ? part : undefined
-}
-
-export const stripEffortUpdates = (request: LLMRequest) => {
-  const messages = request.messages.filter((message) => effortUpdate(message) === undefined)
-  return messages.length === request.messages.length ? request : LLMRequest.update(request, { messages })
-}
-
-export const applyEffortUpdates = (request: LLMRequest): LLMRequest =>
-  request.model.route.supportsEffortUpdates?.(request) ? request : stripEffortUpdates(request)
-
-// The markers must end at `current`: `revert.ts` never touches `session.model` and forks may select
-// another variant, so on disagreement fall back to a plain top-level change instead of misreporting effort.
-export const resolveEffortUpdates = (request: LLMRequest, current: string | undefined) => {
-  const updates = request.messages.flatMap((message) => effortUpdate(message) ?? [])
-  if (updates.length === 0) return { request, effort: current }
-  if (updates.at(-1)?.effort !== current) return { request: stripEffortUpdates(request), effort: current }
-  return { request, effort: updates[0]?.previous }
-}

packages/ai/src/protocols/anthropic-messages.ts

@@ -27,7 +27,6 @@ import {
 } from "../schema/index.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { classifyProviderFailure } from "../provider-error.js"
-import { effortUpdate, resolveEffortUpdates } from "../effort-updates.js"
 import * as Cache from "./utils/cache.js"
 import { Lifecycle } from "./utils/lifecycle.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
@@ -37,7 +36,6 @@ const ADAPTER = "anthropic-messages"
 export const DEFAULT_BASE_URL = "https://api.anthropic.com/v1"
 export const PATH = "/messages"
 export const DEFAULT_MAX_TOKENS = 32_000
-const DEFAULT_EFFORT = "high"
 
 const SSE_EVENTS = new Set([
   "message",
@@ -288,11 +286,7 @@ type AnthropicToolResultBlock = Schema.Schema.Type<typeof AnthropicToolResultBlo
 const AnthropicMessage = Schema.Union([
   Schema.Struct({ role: Schema.Literal("user"), content: Schema.Array(AnthropicUserBlock) }),
   Schema.Struct({ role: Schema.Literal("assistant"), content: Schema.Array(AnthropicAssistantBlock) }),
-  Schema.Struct({
-    role: Schema.Literal("system"),
-    content: Schema.Array(AnthropicTextBlock),
-    output_config: Schema.optional(Schema.Struct({ effort: Schema.String })),
-  }),
+  Schema.Struct({ role: Schema.Literal("system"), content: Schema.Array(AnthropicTextBlock) }),
 ]).pipe(Schema.toTaggedUnion("role"))
 type AnthropicMessage = Schema.Schema.Type<typeof AnthropicMessage>
 
@@ -883,12 +877,6 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
 
   for (const [index, message] of request.messages.entries()) {
     if (message.role === "system") {
-      const update = effortUpdate(message)
-      if (update) {
-        // Accepted at any position, so the text-update placement rules do not apply.
-        messages.push({ role: "system", content: [], output_config: { effort: update.effort ?? DEFAULT_EFFORT } })
-        continue
-      }
       if (splitsLocalToolResults(request.messages, index))
         return yield* invalid("Anthropic Messages system updates cannot split a local tool call from its tool result")
       if (supportsNativeSystemUpdates(request) && canUseNativeSystemUpdate(request, index)) {
@@ -1046,11 +1034,18 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
     ProviderShared.isRecord(rawOutputConfig) && ProviderShared.isRecord(rawOutputConfig.format)
       ? (rawOutputConfig.format as { type: "json_schema"; schema: Record<string, unknown> })
       : undefined
+  const output_config =
+    outputConfigEffort === undefined && outputConfigFormat === undefined
+      ? undefined
+      : {
+          ...(outputConfigEffort === undefined ? {} : { effort: outputConfigEffort }),
+          ...(outputConfigFormat === undefined ? {} : { format: outputConfigFormat }),
+        }
   const thinking = yield* resolveThinking(input?.thinking)
   return {
     thinking: applyThinkingBindingDefault(request.model, thinking),
     effort: outputConfigEffort,
-    format: outputConfigFormat,
+    output_config,
     service_tier,
     metadata,
     container,
@@ -1059,30 +1054,15 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
   }
 })
 
-// Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
-const claudeVersion = (id: string) => {
-  const match = /(?:^|[./])claude-(?<family>[a-z]+)-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/.exec(
-    id.toLowerCase(),
-  )?.groups
-  if (!match) return undefined
-  return { family: match.family, major: Number(match.major), minor: Number(match.minor ?? 0) }
-}
-
 const supportsThinkingBlockBinding = (model: LLMRequest["model"]) => {
   const override = model.compatibility?.supportsThinkingBlockBinding
   if (override !== undefined) return override
-  const version = claudeVersion(model.id)
-  return version !== undefined && (version.major > 5 || (version.major === 5 && version.minor >= 1))
-}
-
-const supportsEffortUpdates = (model: LLMRequest["model"]) => {
-  const override = model.compatibility?.supportsEffortUpdates
-  if (override !== undefined) return override
-  const version = claudeVersion(model.id)
-  if (version === undefined) return false
-  if (version.family === "opus") return version.major >= 5
-  if (version.family !== "fable" && version.family !== "mythos") return false
-  return version.major > 5 || (version.major === 5 && version.minor >= 1)
+  // Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
+  const version = /(?:^|[./])claude-[a-z]+-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/i.exec(model.id)?.groups
+  if (!version) return false
+  const major = Number(version.major)
+  const minor = Number(version.minor ?? 0)
+  return major > 5 || (major === 5 && minor >= 1)
 }
 
 const applyThinkingBindingDefault = (model: LLMRequest["model"], thinking: AnthropicThinking | undefined) => {
@@ -1124,15 +1104,13 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
   const management = yield* ProviderShared.validateWith(
     Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)),
   )(request.providerOptions?.contextManagement)
-  const options = yield* resolveOptions(request)
-  const updates = resolveEffortUpdates(request, options.effort)
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   // Allocate the 4-breakpoint budget in invalidation order: tools → system →
   // messages. Tools live highest in the cache hierarchy, so when callers
   // over-mark we keep their tool hints and shed the message-tail ones first.
   const breakpoints = Cache.newBreakpoints(ANTHROPIC_BREAKPOINT_CAP)
-  const flattened = ProviderShared.flattenToolRequest(updates.request)
+  const flattened = ProviderShared.flattenToolRequest(request)
   const tools =
     flattened.tools.length === 0
       ? undefined
@@ -1160,13 +1138,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
       `Anthropic Messages: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${ANTHROPIC_BREAKPOINT_CAP} per request.`,
     )
   }
-  const output_config =
-    updates.effort === undefined && options.format === undefined
-      ? undefined
-      : {
-          ...(updates.effort === undefined ? {} : { effort: updates.effort }),
-          ...(options.format === undefined ? {} : { format: options.format }),
-        }
+  const options = yield* resolveOptions(request)
   const body = {
     model: request.model.id,
     system,
@@ -1180,7 +1152,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     top_k: generation?.topK,
     stop_sequences: generation?.stop,
     thinking: options.thinking,
-    output_config,
+    output_config: options.output_config,
     // top-level passthrough per SDK MessageCreateParamsBase:4638,4643,4649,4654,4670
     cache_control: options.cache_control,
     container: options.container,
@@ -1705,7 +1677,6 @@ export const protocol = Protocol.make({
     }),
     step,
   },
-  supportsEffortUpdates: (request) => supportsEffortUpdates(request.model),
 })
 
 export const transport = <
@@ -1744,9 +1715,6 @@ function requiredBetaHeaders(body: Pick<AnthropicMessagesBody, "messages" | "con
   )
   if (requestsCompaction || replaysCompaction) betas.push("compact-2026-01-12")
 
-  if (body.messages.some((message) => message.role === "system" && message.output_config !== undefined))
-    betas.push("mid-conversation-output-config-2026-07-01")
-
   const thinking = body.thinking
   if (thinking && thinking.type !== "disabled" && thinking.block_binding)
     betas.push("thinking-binding-controls-2026-08-01")

packages/ai/src/protocols/open-responses-channel.ts

@@ -18,6 +18,7 @@ const WebSocketResponseCreate = Schema.StructWithRest(Schema.Struct({ type: Sche
 ])
 const decodeMessage = ProviderShared.validateWith(Schema.decodeUnknownEffect(WebSocketResponseCreate))
 const encodeMessage = Schema.encodeSync(Schema.fromJsonString(WebSocketResponseCreate))
+const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)
 
 export interface Options {
   readonly id: string
@@ -26,7 +27,6 @@ export interface Options {
   readonly enabled?: (url: string) => boolean
   readonly url?: (url: string) => string
   readonly headers?: (headers: Headers.Headers) => Headers.Headers
-  readonly continuation?: OpenResponsesContinuation.Shape
 }
 
 export interface Prepared {
@@ -60,7 +60,7 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
       }),
     observe: (_create, frame) =>
       Effect.gen(function* () {
-        const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(
+        const event = yield* decodeEvent(frame).pipe(
           Effect.mapError((cause) =>
             ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause),
           ),
@@ -163,7 +163,6 @@ export const transport = <Body>(options: Options): Transport<Body, Prepared, str
                     request: create.request,
                     message: create.message,
                     base,
-                    continuation: options.continuation,
                   }),
                 }
               })

packages/ai/src/protocols/open-responses-continuation.ts

@@ -6,6 +6,7 @@ import { OpenResponses } from "./open-responses.js"
 
 const PROTOCOL = "open-responses.websocket.v1"
 const VERSION = 1
+const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)
 
 interface CheckpointValue {
   readonly version: typeof VERSION
@@ -14,19 +15,12 @@ interface CheckpointValue {
   readonly output: ReadonlyArray<unknown>
 }
 
-/**
- * Fields to send next to `previous_response_id` on an incremental step, or undefined to send the step in full.
- * Whether omitted fields carry over from the continued response is provider behavior the route must know.
- */
-export type Shape = (request: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>> | undefined
-
 export interface DriverInput {
   readonly id: string
   readonly name: string
   readonly request: Readonly<Record<string, unknown>>
   readonly message: string
   readonly base: WebSocketChannelDriver
-  readonly continuation?: Shape
 }
 
 const checkpointValue = (checkpoint: ChannelCheckpoint | undefined): CheckpointValue | undefined => {
@@ -133,26 +127,22 @@ const rejected = (
 
 export const driver = (input: DriverInput): WebSocketChannelDriver => {
   const { previous_response_id: _previousResponseID, ...request } = input.request
-  const shape = input.continuation ?? ((fields: Readonly<Record<string, unknown>>) => fields)
   let output: OpenResponses.StreamItem[] = []
   return {
     create: (checkpoint) =>
       Effect.sync(() => {
         output = []
         const previous = checkpointValue(checkpoint)
-        // Ask the route first: diffing the whole history is wasted when it declines the continuation.
-        const fields = previous ? shape(request) : undefined
-        const delta = previous && fields ? incremental(request, previous) : undefined
-        if (!previous || !fields || !delta)
-          return { message: ProviderShared.encodeJson(request), mode: "full" as const }
+        const delta = previous ? incremental(request, previous) : undefined
+        if (!previous || !delta) return { message: ProviderShared.encodeJson(request), mode: "full" as const }
         return {
-          message: ProviderShared.encodeJson({ ...fields, input: delta, previous_response_id: previous.responseID }),
+          message: ProviderShared.encodeJson({ ...request, input: delta, previous_response_id: previous.responseID }),
           mode: "incremental" as const,
         }
       }),
     observe: (create, frame) =>
       Effect.gen(function* () {
-        const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(
+        const event = yield* decodeEvent(frame).pipe(
           Effect.mapError((cause) =>
             ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause),
           ),
@@ -191,7 +181,7 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
               responseID,
               request,
               // Completion can re-encrypt reasoning. Callers replay the item already emitted by output_item.done.
-              output: event.response?.output?.length
+              output: event.response?.output
                 ? event.response.output.map((item) =>
                     item.type === "reasoning" && item.id !== undefined
                       ? (output.find((done) => done.type === item.type && done.id === item.id) ?? item)
@@ -205,4 +195,4 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
   }
 }
 
-export * as OpenResponsesContinuation from "./open-responses-continuation.js"
+export const OpenResponsesContinuation = { driver } as const

packages/ai/src/protocols/open-responses.ts

@@ -1,4 +1,4 @@
-import { Effect, Option, Schema, SchemaGetter } from "effect"
+import { Effect, Option, Schema } from "effect"
 import type { Content } from "@opencode/schema/tool"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
@@ -20,7 +20,6 @@ import {
 } from "../schema/index.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { classifyProviderFailure } from "../provider-error.js"
-import { effortUpdate } from "../effort-updates.js"
 import { OpenResponsesOptions } from "./utils/open-responses-options.js"
 import { Lifecycle } from "./utils/lifecycle.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
@@ -165,13 +164,6 @@ export const CompactionItem = Schema.Struct({
   encrypted_content: Schema.String,
 })
 
-// Kept out of the baseline `InputItem` union: only the OpenAI extension accepts it.
-export const ConfigurationUpdate = Schema.Struct({
-  type: Schema.Literal("configuration_update"),
-  reasoning: Schema.Struct({ effort: OpenResponsesOptions.ReasoningEffort }),
-})
-type ConfigurationUpdate = Schema.Schema.Type<typeof ConfigurationUpdate>
-
 export const InputItem = Schema.Union([
   CompactionItem,
   Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
@@ -216,7 +208,6 @@ export type HostedToolReplayItem = {
 type LoweredInputItem =
   | OpenResponsesInputItem
   | HostedToolReplayItem
-  | ConfigurationUpdate
   | {
       readonly type: "message"
       readonly id?: string
@@ -334,8 +325,9 @@ export const StreamItem = Schema.StructWithRest(
 export type StreamItem = Schema.Schema.Type<typeof StreamItem>
 export type OutputItem = StreamItem & { readonly id: string }
 
-// Responses-compatible providers put streaming error details at the top level or
-// under `error`, and response failures under `response.error`. Accept all three shapes.
+// The Responses schema puts streaming error details at the top level and
+// response failures under `response.error`. WebSocket failures use an
+// event-level `error` envelope, so accept all three shapes here.
 // https://www.openresponses.org/specification
 const OpenResponsesErrorPayload = Schema.Struct({
   type: optionalNull(Schema.String),
@@ -409,39 +401,10 @@ export const Event = Schema.StructWithRest(
     headers: Schema.optional(Schema.Unknown),
   }),
   [Schema.Record(Schema.String, Schema.Unknown)],
-).pipe(
-  Schema.decode({
-    decode: SchemaGetter.transform((event) => {
-      if (event.type !== "error" || event.error != null) return event
-      const { code, message, param, ...rest } = event
-      if (code === undefined && message === undefined && param === undefined) return event
-      // Flat errors (for example, Meta's) can also arrive through generic Responses endpoints.
-      return { ...rest, error: { code, message, param } }
-    }),
-    encode: SchemaGetter.passthrough(),
-  }),
 )
 export type Event = Schema.Schema.Type<typeof Event>
 export type NormalizedEvent = Event & { readonly item?: OutputItem | null }
 
-const decodeEventValue = Schema.decodeUnknownEffect(Event)
-const decodeFrame = Schema.decodeUnknownEffect(ProviderShared.Json)
-
-/**
- * Decodes one WebSocket frame. xAI answers a rejected `response.create` with `{ "error": { "message", "type" } }` and no
- * event type; that envelope reads as an error event so the failure classifies instead of failing decoding.
- */
-export const decodeChannelEvent = (frame: string) =>
-  decodeFrame(frame).pipe(
-    Effect.flatMap((value) =>
-      decodeEventValue(
-        ProviderShared.isRecord(value) && value.type === undefined && ProviderShared.isRecord(value.error)
-          ? { ...value, type: "error" }
-          : value,
-      ),
-    ),
-  )
-
 export interface ProviderAdapter {
   readonly id: string
   readonly name: string
@@ -643,8 +606,6 @@ const lowerToolResultOutput = Effect.fnUntraced(function* (
   return yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request, adapter))
 })
 
-const DEFAULT_EFFORT = "medium"
-
 const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
   request: LLMRequest,
   adapter: ProviderAdapter,
@@ -657,14 +618,6 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
       Schema.decodeUnknownEffect(Schema.UndefinedOr(MessageMetadata)),
     )(message.providerMetadata?.[providerMetadataKey])
     if (message.role === "system") {
-      const update = effortUpdate(message)
-      if (update) {
-        // Consecutive updates are rejected, so a newer one replaces its predecessor.
-        const last = input.at(-1)
-        if (last !== undefined && "type" in last && last.type === "configuration_update") input.pop()
-        input.push({ type: "configuration_update", reasoning: { effort: update.effort ?? DEFAULT_EFFORT } })
-        continue
-      }
       input.push({
         role: "developer",
         content: ProviderShared.joinText(yield* ProviderShared.systemUpdateText(adapter.name, message)),
@@ -808,7 +761,8 @@ export const lowerConversation = Effect.fn("OpenResponses.lowerConversation")(fu
   }
 })
 
-export const lowerGeneration = (request: LLMRequest, options = OpenResponsesOptions.resolve(request)) => {
+export const lowerGeneration = (request: LLMRequest) => {
+  const options = OpenResponsesOptions.resolve(request)
   const generation = request.generation
   const cacheKey = ProviderShared.promptCacheKey(request)
   const parallelToolCalls = resolveParallelToolCalls(request)

packages/ai/src/protocols/openai-responses.ts

@@ -6,9 +6,7 @@ import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { HttpTransport } from "../route/transport/index.js"
 import { LLMRequest, mergeJsonRecords, type JsonSchema, type ToolDefinition, type ToolEntry } from "../schema/index.js"
-import { resolveEffortUpdates } from "../effort-updates.js"
 import { OpenResponses } from "./open-responses.js"
-import { OpenResponsesOptions } from "./utils/open-responses-options.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { OpenAIImage } from "./utils/openai-image.js"
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
@@ -96,15 +94,9 @@ const OpenAIResponsesToolChoice = Schema.Union([
   Schema.Struct({ type: Schema.tag("image_generation") }),
 ])
 
-const OpenAIResponsesInputItem = Schema.Union([
-  OpenResponses.InputItem,
-  OpenAIResponsesHostedToolItem,
-  OpenResponses.ConfigurationUpdate,
-])
-
 const OpenAIResponsesCoreFields = {
   ...OpenResponses.coreFields,
-  input: Schema.Array(OpenAIResponsesInputItem),
+  input: Schema.Array(Schema.Union([OpenResponses.InputItem, OpenAIResponsesHostedToolItem])),
   tools: optionalArray(OpenAIResponsesTools),
   tool_choice: Schema.optional(OpenAIResponsesToolChoice),
   context_management: Schema.optional(
@@ -127,7 +119,7 @@ export type OpenAIResponsesBody = Schema.Schema.Type<typeof OpenAIResponsesBody>
 export const CompactionTrigger = Schema.Struct({ type: Schema.Literal("compaction_trigger") })
 const CheckpointBody = Schema.Struct({
   ...OpenAIResponsesBody.fields,
-  input: Schema.Array(Schema.Union([OpenAIResponsesInputItem, CompactionTrigger])),
+  input: Schema.Array(Schema.Union([OpenResponses.InputItem, OpenAIResponsesHostedToolItem, CompactionTrigger])),
   store: Schema.Literal(false),
   prompt_cache_retention: optionalNull(Schema.String),
   prompt_cache_options: optionalNull(
@@ -141,14 +133,6 @@ const adapter = {
   restoreHostedToolItem: (item: unknown) => (Schema.is(OpenAIResponsesHostedToolItem)(item) ? item : undefined),
 } satisfies OpenResponses.ProviderAdapter
 
-// Only GPT-6 Astra accepts `configuration_update`, and never alongside automatic `context_management` compaction.
-const supportsEffortUpdates = (request: LLMRequest) => {
-  if (request.providerOptions?.contextManagement !== undefined) return false
-  const override = request.model.compatibility?.supportsEffortUpdates
-  if (override !== undefined) return override
-  return /(?:^|\/)gpt-6-astra$/i.test(request.model.id)
-}
-
 const nativeImageToolInput = (tool: ToolDefinition) => {
   const native = tool.native?.openai
   return ProviderShared.isRecord(native) && native.type === "image_generation" ? native : undefined
@@ -205,12 +189,10 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
   const management = yield* ProviderShared.validateWith(
     Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)),
   )(request.providerOptions?.contextManagement)
-  const options = OpenResponsesOptions.resolve(request)
-  const updates = resolveEffortUpdates(request, options.reasoningEffort)
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   return yield* decodeBody({
-    ...(yield* OpenResponses.lowerConversation(updates.request, adapter)),
-    ...OpenResponses.lowerGeneration(request, { ...options, reasoningEffort: updates.effort }),
+    ...(yield* OpenResponses.lowerConversation(request, adapter)),
+    ...OpenResponses.lowerGeneration(request),
     context_management: management?.map((edit) => ({ type: edit.type, compact_threshold: edit.compactThreshold })),
     tools:
       request.tools.length === 0
@@ -313,7 +295,6 @@ export const protocol = Protocol.make({
     step,
     terminal: OpenResponses.terminal,
   },
-  supportsEffortUpdates,
 })
 
 const endpoint = Endpoint.path<OpenAIResponsesBody>(PATH, { baseURL: DEFAULT_BASE_URL })

packages/ai/src/protocols/utils/open-responses-options.ts

@@ -1,7 +1,12 @@
 import { Option, Schema } from "effect"
-import { ReasoningEffort, ReasoningEfforts, type LLMRequest } from "../../schema/index.js"
+import type { LLMRequest } from "../../schema/index.js"
 
-export { ReasoningEffort, ReasoningEfforts }
+export const ReasoningEfforts = ["none", "minimal", "low", "medium", "high", "xhigh", "max"] as const
+export type ReasoningEffort = (typeof ReasoningEfforts)[number] | (string & {})
+export const ReasoningEffort = Schema.declare<ReasoningEffort>(
+  (value): value is ReasoningEffort => typeof value === "string",
+  { title: "ReasoningEffort" },
+)
 
 export const TextVerbosities = ["low", "medium", "high"] as const
 export type TextVerbosity = (typeof TextVerbosities)[number] | (string & {})

packages/ai/src/protocols/utils/responses-compaction.ts

@@ -11,7 +11,6 @@ import {
   mergeJsonRecords,
 } from "../../schema/index.js"
 import type { CompactOperation } from "../../route/client.js"
-import { stripEffortUpdates } from "../../effort-updates.js"
 import { Endpoint } from "../../route/endpoint.js"
 import { RequestExecutor } from "../../route/executor.js"
 import { HttpTransport } from "../../route/transport/index.js"
@@ -76,8 +75,7 @@ const Response = Schema.Struct({
 export const make = (adapter: OpenResponses.ProviderAdapter): CompactOperation =>
   Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
     const route = request.model.route
-    // The standalone compaction endpoint rejects histories containing configuration updates.
-    const native = yield* OpenResponses.lowerConversation(stripEffortUpdates(request), adapter)
+    const native = yield* OpenResponses.lowerConversation(request, adapter)
     const body = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(
       mergeJsonRecords(
         {

packages/ai/src/providers/alibaba.ts

@@ -6,7 +6,7 @@ import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
-import { ProviderConfigurationError, ProviderID, ToolDefinition, type ModelID } from "../schema/index.js"
+import { ProviderID, ToolDefinition, type ModelID } from "../schema/index.js"
 
 export const id = ProviderID.make("alibaba")
 
@@ -82,13 +82,8 @@ export const configure = (input: Config) => {
         ? hosts.get(region)
         : `${workspaceID}.${region}.maas.aliyuncs.com`
   if (baseURL === undefined) {
-    if (region === undefined)
-      throw new ProviderConfigurationError({ provider: id, message: "Alibaba requires region or baseURL" })
-    if (host === undefined)
-      throw new ProviderConfigurationError({
-        provider: id,
-        message: `Alibaba region ${region} requires workspaceID or baseURL`,
-      })
+    if (region === undefined) throw new Error("Alibaba requires region or baseURL")
+    if (host === undefined) throw new Error(`Alibaba region ${region} requires workspaceID or baseURL`)
   }
   const opts = { ...rest, auth: AuthOptions.bearer(input, ["DASHSCOPE_API_KEY", "ALIBABA_API_KEY"]) }
   const common = { ...opts, endpoint: { baseURL: baseURL ?? `https://${host}/compatible-mode/v1` } }

packages/ai/src/providers/amazon-bedrock-mantle.ts

@@ -1,10 +1,9 @@
 import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
-import { OpenResponses } from "../protocols/open-responses.js"
+import { OpenAIResponses } from "../protocols/openai-responses.js"
 import { BedrockAuth, type Credentials } from "../protocols/utils/bedrock-auth.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("amazon-bedrock")
@@ -38,10 +37,11 @@ const responsesRoute = Route.make({
   id: "bedrock-mantle-responses",
   provider: id,
   providerMetadataKey: "mantle",
-  protocol: OpenResponses.protocol,
-  endpoint: Endpoint.path(OpenResponses.PATH),
-  transport: OpenResponses.httpTransport,
-  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
+  protocol: OpenAIResponses.protocol,
+  endpoint: OpenAIResponses.route.endpoint,
+  auth: OpenAIResponses.route.auth,
+  transport: OpenAIResponses.httpTransport,
+  defaults: OpenAIResponses.route.defaults,
 })
 
 const chatRoute = OpenAIChat.route.with({
@@ -79,12 +79,9 @@ const defaults = (input: Config) => {
 
 export const configure = (input: Config = {}) => {
   if (input.auth === "bearer" && input.apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock Mantle bearer auth requires apiKey" })
+    throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey")
   if (input.auth === "sigv4" && input.apiKey !== undefined)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "Amazon Bedrock Mantle SigV4 auth does not accept apiKey",
-    })
+    throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey")
   const configuredResponsesRoute = configuredRoute(responsesRoute, input)
   const configuredChatRoute = configuredRoute(chatRoute, input)
   const modelDefaults = defaults(input)

packages/ai/src/providers/amazon-bedrock.ts

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

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

@@ -3,7 +3,7 @@ import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
 import type { RouteDefaultsInput } from "../route/client.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
 export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
@@ -36,12 +36,8 @@ const auth = (input: ProviderAuthOption<"optional">) => {
 }
 
 export const configure = (input: Config) => {
+  if (!input.baseURL) throw new Error("Anthropic-compatible providers require a baseURL")
   const provider = input.provider ?? "anthropic-compatible"
-  if (!input.baseURL)
-    throw new ProviderConfigurationError({
-      provider: ProviderID.make(provider),
-      message: "Anthropic-compatible providers require a baseURL",
-    })
   const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
   const route = AnthropicMessages.route.with({
     ...rest,
@@ -65,13 +61,8 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
   modelID,
   settings,
 ) => {
-  // Read before the exclusivity check narrows a conflicting settings object to `never`.
-  const provider = ProviderID.make(settings.provider ?? id)
   if (settings.apiKey !== undefined && settings.authToken !== undefined)
-    throw new ProviderConfigurationError({
-      provider,
-      message: "Anthropic-compatible apiKey cannot be combined with authToken",
-    })
+    throw new Error("Anthropic-compatible apiKey cannot be combined with authToken")
   return configure({
     ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
     baseURL: settings.baseURL,

packages/ai/src/providers/anthropic.ts

@@ -2,7 +2,7 @@ import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { AnthropicCompatible } from "./anthropic-compatible.js"
 
@@ -57,10 +57,7 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
   settings,
 ) => {
   if (settings.apiKey !== undefined && settings.authToken !== undefined)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "Anthropic apiKey cannot be combined with authToken",
-    })
+    throw new Error("Anthropic apiKey cannot be combined with authToken")
   return configure({
     ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
     baseURL: settings.baseURL,

packages/ai/src/providers/azure.ts

@@ -3,7 +3,7 @@ import { Auth } from "../route/auth.js"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
 import type { Route, RouteDefaultsInput, CompactionOperations } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import * as OpenAIResponses from "../protocols/openai-responses.js"
 import { ProviderShared } from "../protocols/shared.js"
@@ -163,7 +163,7 @@ const config = (settings: Settings): Config => {
   }
   if (settings.baseURL !== undefined) return { ...common, baseURL: settings.baseURL }
   if (settings.resourceName !== undefined) return { ...common, resourceName: settings.resourceName }
-  throw new ProviderConfigurationError({ provider: id, message: "Azure requires resourceName or baseURL" })
+  throw new Error("Azure requires resourceName or baseURL")
 }
 
 export const responsesModel: ProviderPackage.Definition<

packages/ai/src/providers/cloudflare-ai-gateway.ts

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js"
 import type { AtLeastOne, ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("cloudflare-ai-gateway")
@@ -35,11 +35,7 @@ export type Settings = ProviderPackage.Settings &
 
 export const baseURL = (input: GatewayURL) => {
   if (input.baseURL) return input.baseURL
-  if (!input.accountId)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "CloudflareAIGateway.configure requires accountId unless baseURL is supplied",
-    })
+  if (!input.accountId) throw new Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied")
   return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`
 }
 

packages/ai/src/providers/cloudflare-workers-ai.ts

@@ -3,7 +3,7 @@ import { OpenAIChat } from "../protocols/openai-chat.js"
 import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("cloudflare-workers-ai")
@@ -28,11 +28,7 @@ export type Settings = ProviderPackage.Settings &
 
 export const baseURL = (input: WorkersAIURL) => {
   if (input.baseURL) return input.baseURL
-  if (!input.accountId)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "CloudflareWorkersAI.configure requires accountId unless baseURL is supplied",
-    })
+  if (!input.accountId) throw new Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied")
   return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(input.accountId)}/ai/v1`
 }
 

packages/ai/src/providers/google-vertex-chat.ts

@@ -2,7 +2,7 @@ import type { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
@@ -37,8 +37,7 @@ const route = Route.make({
 export const routes = [route]
 
 const configuredRoute = (input: Config) => {
-  if ("apiKey" in input && input.apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Chat does not support API keys" })
+  if ("apiKey" in input && input.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
   const {
     accessToken: _accessToken,
     auth: _auth,
@@ -75,8 +74,7 @@ export const provider = {
 }
 
 export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
-  if (settings.apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Chat does not support API keys" })
+  if (settings.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
   return configure({
     accessToken: settings.accessToken,
     baseURL: settings.baseURL,

packages/ai/src/providers/google-vertex-messages.ts

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
@@ -67,7 +67,7 @@ export const routes = [route]
 
 const configuredRoute = (input: Config) => {
   if ("apiKey" in input && input.apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Messages does not support API keys" })
+    throw new Error("Google Vertex Messages does not support API keys")
   const {
     accessToken: _accessToken,
     auth: _auth,
@@ -107,8 +107,7 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
   modelID,
   settings,
 ) => {
-  if (settings.apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Messages does not support API keys" })
+  if (settings.apiKey !== undefined) throw new Error("Google Vertex Messages does not support API keys")
   return configure({
     accessToken: settings.accessToken,
     baseURL: settings.baseURL,

packages/ai/src/providers/google-vertex-responses.ts

@@ -2,7 +2,7 @@ import type { ProviderPackage } from "../provider-package.js"
 import { OpenResponses } from "../protocols/open-responses.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
 
@@ -39,7 +39,7 @@ export const routes = [route]
 
 const configuredRoute = (input: Config) => {
   if ("apiKey" in input && input.apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Responses does not support API keys" })
+    throw new Error("Google Vertex Responses does not support API keys")
   const {
     accessToken: _accessToken,
     auth: _auth,
@@ -79,8 +79,7 @@ export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOp
   modelID,
   settings,
 ) => {
-  if (settings.apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Responses does not support API keys" })
+  if (settings.apiKey !== undefined) throw new Error("Google Vertex Responses does not support API keys")
   return configure({
     accessToken: settings.accessToken,
     baseURL: settings.baseURL,

packages/ai/src/providers/google-vertex-shared.ts

@@ -1,10 +1,8 @@
 import type { AnyAuthClient } from "google-auth-library"
 import { Effect, Redacted } from "effect"
 import { Auth, MissingCredentialError } from "../route/auth.js"
-import { ProviderConfigurationError, ProviderID } from "../schema/index.js"
 
 const SCOPE = "https://www.googleapis.com/auth/cloud-platform"
-const id = ProviderID.make("google-vertex")
 
 export type OAuthOptions =
   | { readonly accessToken?: string; readonly auth?: never }
@@ -37,18 +35,12 @@ export const host = (location: string) => {
 
 export const requireProject = (value: string | undefined) => {
   if (value) return value
-  throw new ProviderConfigurationError({
-    provider: id,
-    message: "Google Vertex requires a project when baseURL is not configured",
-  })
+  throw new Error("Google Vertex requires a project when baseURL is not configured")
 }
 
 export const apiKey = (input: ApiKeyOptions) => {
   if (input.apiKey !== undefined && (input.accessToken !== undefined || input.auth !== undefined))
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "Google Vertex apiKey cannot be combined with accessToken or auth",
-    })
+    throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth")
   if (input.accessToken !== undefined || input.auth !== undefined) return undefined
   return input.apiKey ?? process.env.GOOGLE_VERTEX_API_KEY
 }
@@ -76,10 +68,7 @@ const adc = (project?: string) => {
 
 export const oauth = (input: OAuthOptions, project?: string) => {
   if (input.accessToken !== undefined && input.auth !== undefined)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "Google Vertex accessToken cannot be combined with auth",
-    })
+    throw new Error("Google Vertex accessToken cannot be combined with auth")
   if (input.auth) return input.auth
   if (input.accessToken !== undefined) return Auth.bearer(input.accessToken)
   return adc(project)

packages/ai/src/providers/google-vertex.ts

@@ -6,7 +6,7 @@ import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
-import { ProviderConfigurationError, ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
+import { ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 
 export interface GeminiOptionsInput extends Gemini.OptionsInput {
@@ -93,10 +93,7 @@ const configuredRoute = (input: Config, modelID: string | ModelID) => {
   const apiKey = GoogleVertexShared.apiKey(input)
   const endpointModel = String(modelID).startsWith("endpoints/")
   if (apiKey !== undefined && endpointModel)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "Google Vertex tuned models do not support Express Mode API keys",
-    })
+    throw new Error("Google Vertex tuned models do not support Express Mode API keys")
   const location = GoogleVertexShared.location(inputLocation, "us-central1")
   const project = GoogleVertexShared.project(inputProject)
   const endpoint =
@@ -126,10 +123,7 @@ export const provider = {
 }
 export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"] = (modelID, settings) => {
   if (settings.apiKey !== undefined && settings.accessToken !== undefined)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "Google Vertex apiKey cannot be combined with accessToken or auth",
-    })
+    throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth")
   return configure({
     ...(settings.apiKey === undefined ? { accessToken: settings.accessToken } : { apiKey: settings.apiKey }),
     baseURL: settings.baseURL,

packages/ai/src/providers/xai.ts

@@ -41,10 +41,6 @@ const responsesRoute = Route.make({
     id: "openai-responses",
     name: "xAI Responses",
     rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
-    // xAI continues a chain only from stored responses: with `store: false` (the route default) `previous_response_id`
-    // fails with "Response with id=… not found", so those steps are sent in full over the reused connection. It also
-    // rejects `instructions` next to `previous_response_id` and keeps the instructions of the response it continues.
-    continuation: ({ instructions: _instructions, ...request }) => (request.store === false ? undefined : request),
   }),
   defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 })

packages/ai/src/route/client.ts

@@ -7,7 +7,6 @@ import { HttpTransport } from "./transport/index.js"
 import type { HttpMiddleware, Transport, TransportRuntime, WebSocketChannelExecutor } from "./transport/index.js"
 import type { Protocol } from "./protocol.js"
 import { applyCachePolicy } from "../cache-policy.js"
-import { applyEffortUpdates } from "../effort-updates.js"
 import { normalizeToolHistory } from "../tool-history.js"
 import { sanitizeSurrogates } from "../utils/sanitize.js"
 import * as ProviderShared from "../protocols/shared.js"
@@ -24,7 +23,6 @@ import {
   LanguageModel,
   LLMEvent,
   InvalidProviderOutputError,
-  ProviderConfigurationError,
   ProviderID,
   mergeGenerationOptions,
   mergeHttpOptions,
@@ -56,7 +54,6 @@ export interface Route<
   readonly transport: Transport<Body, Prepared, unknown>
   readonly defaults: RouteDefaults
   readonly body: RouteBody<Body>
-  readonly supportsEffortUpdates?: (request: LLMRequest) => boolean
   readonly with: {
     <Next extends CompactionOperations | undefined>(
       patch: RoutePatch<Body, Prepared> & { readonly compact: Next },
@@ -131,10 +128,7 @@ const makeRouteLanguageModel = <Options extends ProviderOptions, Compact extends
   const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
   if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
   if (!endpointBaseURL(route.endpoint))
-    throw new ProviderConfigurationError({
-      provider: ProviderID.make(provider),
-      message: `Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`,
-    })
+    throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`)
   return LanguageModel.make<Options, Compact>({
     ...mapped,
     provider,
@@ -390,7 +384,6 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
       transport: routeInput.transport,
       defaults: routeInput.defaults ?? {},
       body: protocol.body,
-      supportsEffortUpdates: protocol.supportsEffortUpdates,
       with: (patch: RoutePatch<Body, Prepared>) => {
         const { compact, id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch
         return build({
@@ -561,9 +554,7 @@ const prepareRequest = (request: LLMRequest) => {
     [...new Map(tools.map((tool) => [`${tool.type}:${tool.name}`, tool])).values()].map((tool) =>
       tool.type === "tool" ? tool : { ...tool, tools: dedupe(tool.tools) },
     )
-  const resolved = applyCachePolicy(
-    applyEffortUpdates(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) })),
-  )
+  const resolved = applyCachePolicy(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) }))
   const headers = resolved.model.route.headers?.({ request: resolved })
   return headers === undefined
     ? resolved

packages/ai/src/route/protocol.ts

@@ -41,8 +41,6 @@ export interface Protocol<Body, Frame, Event, State> {
   readonly body: ProtocolBody<Body>
   /** Response side: streaming state machine. */
   readonly stream: ProtocolStream<Frame, Event, State>
-  /** Whether `body.from` lowers `Message.effort(...)` markers; wrappers around another `body.from` must forward it. */
-  readonly supportsEffortUpdates?: (request: LLMRequest) => boolean
 }
 
 export interface ProtocolBody<Body> {

packages/ai/src/schema/errors.ts

@@ -50,19 +50,6 @@ export class UnsupportedOperationError extends Schema.TaggedError<UnsupportedOpe
   route: Schema.optional(RouteID),
 }) {}
 
-/**
- * Provider settings that are missing, conflicting, or unsupported, such as
- * Azure without `resourceName` or `baseURL`. Thrown synchronously while a
- * provider facade or package entrypoint configures a model, before any
- * request exists, so it is not an `AIError` reason.
- */
-export class ProviderConfigurationError extends Schema.TaggedError<ProviderConfigurationError>(
-  "AI.Error.ProviderConfiguration",
-)("ProviderConfiguration", {
-  provider: ProviderID,
-  message: Schema.String,
-}) {}
-
 export class NoRouteError extends Schema.TaggedError<NoRouteError>("AI.Error.NoRoute")("NoRoute", {
   ...ReasonFields,
   route: RouteID,

packages/ai/src/schema/messages.ts

@@ -9,7 +9,6 @@ import {
   LanguageModelSchema,
   type LanguageModel,
   ProviderOptions,
-  ReasoningEffort,
 } from "./options.js"
 import { ProviderID } from "./ids.js"
 
@@ -218,14 +217,6 @@ export const CompactionPart = Object.assign(compactionPartSchema, {
     Schema.decodeUnknownSync(compactionPartSchema)({ type: "compaction", ...input }),
 })
 
-/** Reasoning effort changed here, from `previous` to `effort`; `undefined` is the model default. */
-export const EffortPart = Schema.Struct({
-  type: Schema.Literal("effort"),
-  effort: Schema.optional(ReasoningEffort),
-  previous: Schema.optional(ReasoningEffort),
-}).annotate({ identifier: "LLM.Content.Effort" })
-export type EffortPart = Schema.Schema.Type<typeof EffortPart>
-
 export const ContentPart = Schema.Union([
   TextPart,
   MediaPart,
@@ -233,7 +224,6 @@ export const ContentPart = Schema.Union([
   ToolResultPart,
   ReasoningPart,
   CompactionPart,
-  EffortPart,
 ]).pipe(Schema.toTaggedUnion("type"))
 export type ContentPart = Schema.Schema.Type<typeof ContentPart>
 
@@ -275,9 +265,6 @@ export namespace Message {
    */
   export const system = (content: SystemContentInput) => make({ role: "system", content })
 
-  export const effort = (input: { readonly effort?: ReasoningEffort; readonly previous?: ReasoningEffort }) =>
-    make({ role: "system", content: [{ type: "effort", effort: input.effort, previous: input.previous }] })
-
   export const tool = (result: ToolResultPart | Parameters<typeof ToolResultPart.make>[0]) =>
     make({ role: "tool", content: ["type" in result ? result : ToolResultPart.make(result)] })
 }

packages/ai/src/schema/options.ts

@@ -140,14 +140,6 @@ export namespace LanguageModelDefaults {
   }
 }
 
-/** Ordered lowest to highest. */
-export const ReasoningEfforts = ["none", "minimal", "low", "medium", "high", "xhigh", "max"] as const
-export type ReasoningEffort = (typeof ReasoningEfforts)[number] | (string & {})
-export const ReasoningEffort = Schema.declare<ReasoningEffort>(
-  (value): value is ReasoningEffort => typeof value === "string",
-  { title: "ReasoningEffort" },
-)
-
 export const LanguageModelToolSchemaCompatibility = Schema.Literals(["gemini", "moonshot"])
 export type LanguageModelToolSchemaCompatibility = Schema.Schema.Type<typeof LanguageModelToolSchemaCompatibility>
 
@@ -173,8 +165,6 @@ export class LanguageModelCompatibility extends Schema.Class<LanguageModelCompat
   requireSignature: Schema.optional(Schema.Boolean),
   /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
   supportsThinkingBlockBinding: Schema.optional(Schema.Boolean),
-  /** Supports per-message effort updates. Overrides model-ID detection. */
-  supportsEffortUpdates: Schema.optional(Schema.Boolean),
 }) {}
 
 export namespace LanguageModelCompatibility {

packages/ai/test/effort-updates.test.ts

@@ -1,439 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { LLM, LLMRequest, Message, ToolCallPart } from "../src/index.js"
-import { Auth, LLMClient } from "../src/route.js"
-import { compileRequest } from "../src/route/client.js"
-import { AnthropicMessages } from "../src/protocols/anthropic-messages.js"
-import { OpenAIResponses } from "../src/protocols/openai-responses.js"
-import { Gemini } from "../src/protocols/gemini.js"
-import { GoogleVertexMessages, OpenAI } from "../src/providers.js"
-import { applyCachePolicy } from "../src/cache-policy.js"
-import { applyEffortUpdates } from "../src/effort-updates.js"
-import { it, testEffect } from "./lib/effect.js"
-import { dynamicResponse } from "./lib/http.js"
-import { sseEvents } from "./lib/sse.js"
-
-const anthropic = (id: string, compatibility?: { readonly supportsEffortUpdates?: boolean }) =>
-  AnthropicMessages.route
-    .with({ endpoint: { baseURL: "https://api.anthropic.test/v1/" }, auth: Auth.header("x-api-key", "test") })
-    .model({ id, compatibility })
-
-const openai = (id: string, compatibility?: { readonly supportsEffortUpdates?: boolean }) =>
-  OpenAIResponses.route
-    .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
-    .model({ id, compatibility })
-
-const opus5 = anthropic("claude-opus-5")
-const astra = openai("gpt-6-astra")
-
-const lowFromHigh = Message.effort({ effort: "low", previous: "high" })
-const conversation = [Message.user("Before."), lowFromHigh, Message.user("After.")]
-
-const systemMessages = (body: AnthropicMessages.AnthropicMessagesBody) =>
-  body.messages.filter((message) => message.role === "system")
-
-const updates = (body: OpenAIResponses.OpenAIResponsesBody) =>
-  body.input.filter((item) => "type" in item && item.type === "configuration_update")
-
-describe("applyEffortUpdates", () => {
-  test("keeps the request identity without markers and for protocols that lower them", () => {
-    const plain = LLM.request({ model: opus5, prompt: "hi" })
-    expect(applyEffortUpdates(plain)).toBe(plain)
-
-    const supported = LLM.request({ model: opus5, messages: conversation, providerOptions: { effort: "low" } })
-    expect(applyEffortUpdates(supported)).toBe(supported)
-  })
-
-  it.effect("compiles markers away for protocols without per-message effort", () =>
-    Effect.gen(function* () {
-      const model = Gemini.route
-        .with({
-          endpoint: { baseURL: "https://generativelanguage.test/v1beta/" },
-          auth: Auth.header("x-goog-api-key", "test"),
-        })
-        .model({ id: "gemini-3.5-flash" })
-      const withMarkers = yield* compileRequest(LLM.request({ model, messages: conversation }))
-      const withoutMarkers = yield* compileRequest(
-        LLM.request({ model, messages: [Message.user("Before."), Message.user("After.")] }),
-      )
-
-      expect(withMarkers.body).toEqual(withoutMarkers.body)
-    }),
-  )
-})
-
-describe("cache policy", () => {
-  it.effect("walks the tail breakpoint back past a trailing effort marker", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: opus5,
-          messages: [Message.user("first"), Message.assistant("reply"), Message.user("latest"), lowFromHigh],
-          providerOptions: { effort: "low" },
-          cache: "auto",
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        { role: "user", content: [{ type: "text", text: "first" }] },
-        { role: "assistant", content: [{ type: "text", text: "reply" }] },
-        { role: "user", content: [{ type: "text", text: "latest", cache_control: { type: "ephemeral" } }] },
-        { role: "system", content: [], output_config: { effort: "low" } },
-      ])
-    }),
-  )
-})
-
-describe("Anthropic Messages effort updates", () => {
-  it.effect("lowers markers to per-turn system messages and freezes the top-level effort", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({ model: opus5, messages: conversation, providerOptions: { effort: "low" }, cache: "none" }),
-      )
-
-      expect(prepared.body.output_config).toEqual({ effort: "high" })
-      expect(prepared.body.messages).toEqual([
-        { role: "user", content: [{ type: "text", text: "Before." }] },
-        { role: "system", content: [], output_config: { effort: "low" } },
-        { role: "user", content: [{ type: "text", text: "After." }] },
-      ])
-    }),
-  )
-
-  it.effect("omits the frozen effort for the model default and sends `high` for a switch back to it", () =>
-    Effect.gen(function* () {
-      const format = { type: "json_schema" as const, schema: { type: "object" } }
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: opus5,
-          messages: [
-            Message.user("One."),
-            Message.effort({ effort: "low" }),
-            Message.user("Two."),
-            Message.effort({ previous: "low" }),
-            Message.user("Three."),
-          ],
-          providerOptions: { output_config: { format } },
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.output_config).toEqual({ format })
-      expect(systemMessages(prepared.body)).toEqual([
-        { role: "system", content: [], output_config: { effort: "low" } },
-        { role: "system", content: [], output_config: { effort: "high" } },
-      ])
-    }),
-  )
-
-  it.effect("requests the mid-conversation output config beta only when markers are sent", () =>
-    Effect.gen(function* () {
-      for (const [model, betas] of [
-        [opus5, "existing-beta,mid-conversation-output-config-2026-07-01"],
-        [anthropic("claude-sonnet-5"), "existing-beta"],
-      ] as const) {
-        const request = LLM.request({
-          model,
-          messages: conversation,
-          providerOptions: { effort: "low" },
-          http: { headers: { "anthropic-beta": "existing-beta" } },
-        })
-        const compiled = yield* compileRequest(request)
-        const prepared = yield* AnthropicMessages.route.prepareTransport(compiled.body, request)
-        expect(prepared.request.headers["anthropic-beta"]).toBe(betas)
-      }
-    }),
-  )
-
-  it.effect("accepts a marker between a tool call and its result", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: opus5,
-          messages: [
-            Message.user("Weather?"),
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "lookup", input: {} })]),
-            lowFromHigh,
-            Message.tool({ id: "call_1", name: "lookup", result: { temp: 72 } }),
-          ],
-          providerOptions: { effort: "low" },
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        { role: "user", content: [{ type: "text", text: "Weather?" }] },
-        { role: "assistant", content: [{ type: "tool_use", id: "call_1", name: "lookup", input: {} }] },
-        { role: "system", content: [], output_config: { effort: "low" } },
-        { role: "user", content: [{ type: "tool_result", tool_use_id: "call_1", content: '{"temp":72}' }] },
-      ])
-    }),
-  )
-
-  it.effect("falls back to a plain top-level effort when history drifted from the current effort", () =>
-    Effect.gen(function* () {
-      const drifted = yield* compileRequest(
-        LLM.request({ model: opus5, messages: conversation, providerOptions: { effort: "medium" }, cache: "none" }),
-      )
-      const plain = yield* compileRequest(
-        LLM.request({
-          model: opus5,
-          messages: [Message.user("Before."), Message.user("After.")],
-          providerOptions: { effort: "medium" },
-          cache: "none",
-        }),
-      )
-
-      expect(drifted.body).toEqual(plain.body)
-      expect(drifted.body.output_config).toEqual({ effort: "medium" })
-    }),
-  )
-
-  for (const [id, supported] of [
-    ["claude-opus-5", true],
-    ["claude-opus-5-20260901", true],
-    ["anthropic/claude-opus-5", true],
-    ["claude-fable-5-1", true],
-    ["claude-mythos-5-1", true],
-    ["claude-fable-5", false],
-    ["claude-opus-4-8", false],
-    ["claude-sonnet-5", false],
-    ["kimi-k2.5", false],
-  ] as const) {
-    it.effect(`${supported ? "lowers" : "strips"} markers for ${id}`, () =>
-      Effect.gen(function* () {
-        const prepared = yield* compileRequest(
-          LLM.request({ model: anthropic(id), messages: conversation, providerOptions: { effort: "low" } }),
-        )
-
-        expect(systemMessages(prepared.body)).toHaveLength(supported ? 1 : 0)
-        expect(prepared.body.output_config).toEqual({ effort: supported ? "high" : "low" })
-      }),
-    )
-  }
-
-  it.effect("honors the compatibility override in both directions", () =>
-    Effect.gen(function* () {
-      const enabled = yield* compileRequest(
-        LLM.request({
-          model: anthropic("claude-sonnet-5", { supportsEffortUpdates: true }),
-          messages: conversation,
-          providerOptions: { effort: "low" },
-        }),
-      )
-      const disabled = yield* compileRequest(
-        LLM.request({
-          model: anthropic("claude-opus-5", { supportsEffortUpdates: false }),
-          messages: conversation,
-          providerOptions: { effort: "low" },
-        }),
-      )
-
-      expect(systemMessages(enabled.body)).toHaveLength(1)
-      expect(systemMessages(disabled.body)).toHaveLength(0)
-    }),
-  )
-
-  it.effect("strips markers on the Vertex Anthropic route, whose protocol wrapper does not forward support", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: GoogleVertexMessages.configure({ accessToken: "test", location: "global", project: "test" }).model(
-            "claude-opus-5",
-          ),
-          messages: conversation,
-          providerOptions: { effort: "low" },
-        }),
-      )
-
-      expect(systemMessages(prepared.body)).toHaveLength(0)
-      expect(prepared.body.output_config).toEqual({ effort: "low" })
-    }),
-  )
-})
-
-describe("OpenAI Responses effort updates", () => {
-  it.effect("lowers markers to configuration_update items and freezes reasoning.effort", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({ model: astra, messages: conversation, providerOptions: { reasoningEffort: "low" } }),
-      )
-
-      expect(prepared.body.reasoning).toEqual({ effort: "high" })
-      expect(prepared.body.input).toEqual([
-        { role: "user", content: [{ type: "input_text", text: "Before." }] },
-        { type: "configuration_update", reasoning: { effort: "low" } },
-        { role: "user", content: [{ type: "input_text", text: "After." }] },
-      ])
-    }),
-  )
-
-  it.effect("coalesces consecutive updates so the newest wins", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: astra,
-          messages: [
-            Message.user("Before."),
-            Message.effort({ effort: "low", previous: "medium" }),
-            Message.effort({ effort: "xhigh", previous: "low" }),
-            Message.user("After."),
-          ],
-          providerOptions: { reasoningEffort: "xhigh" },
-        }),
-      )
-
-      expect(prepared.body.reasoning).toEqual({ effort: "medium" })
-      expect(prepared.body.input).toEqual([
-        { role: "user", content: [{ type: "input_text", text: "Before." }] },
-        { type: "configuration_update", reasoning: { effort: "xhigh" } },
-        { role: "user", content: [{ type: "input_text", text: "After." }] },
-      ])
-    }),
-  )
-
-  it.effect("omits reasoning.effort for the model default and sends `medium` for a switch back to it", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: astra,
-          messages: [
-            Message.user("One."),
-            Message.effort({ effort: "low" }),
-            Message.user("Two."),
-            Message.effort({ previous: "low" }),
-            Message.user("Three."),
-          ],
-        }),
-      )
-
-      expect(prepared.body.reasoning).toBeUndefined()
-      expect(updates(prepared.body)).toEqual([
-        { type: "configuration_update", reasoning: { effort: "low" } },
-        { type: "configuration_update", reasoning: { effort: "medium" } },
-      ])
-    }),
-  )
-
-  it.effect("falls back to a plain top-level effort when history drifted from the current effort", () =>
-    Effect.gen(function* () {
-      const drifted = yield* compileRequest(
-        LLM.request({ model: astra, messages: conversation, providerOptions: { reasoningEffort: "xhigh" } }),
-      )
-      const plain = yield* compileRequest(
-        LLM.request({
-          model: astra,
-          messages: [Message.user("Before."), Message.user("After.")],
-          providerOptions: { reasoningEffort: "xhigh" },
-        }),
-      )
-
-      expect(drifted.body).toEqual(plain.body)
-      expect(drifted.body.reasoning).toEqual({ effort: "xhigh" })
-    }),
-  )
-
-  it.effect("strips markers when automatic context management is enabled", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: astra,
-          messages: conversation,
-          providerOptions: { reasoningEffort: "low", contextManagement: [{ type: "compaction" }] },
-        }),
-      )
-
-      expect(updates(prepared.body)).toEqual([])
-      expect(prepared.body.reasoning).toEqual({ effort: "low" })
-      expect(prepared.body.context_management).toEqual([{ type: "compaction" }])
-    }),
-  )
-
-  for (const [id, supported] of [
-    ["gpt-6-astra", true],
-    ["openai/gpt-6-astra", true],
-    ["gpt-6-astra-2026-09-01", false],
-    ["gpt-5.6-sol", false],
-  ] as const) {
-    it.effect(`${supported ? "lowers" : "strips"} markers for ${id}`, () =>
-      Effect.gen(function* () {
-        const prepared = yield* compileRequest(
-          LLM.request({ model: openai(id), messages: conversation, providerOptions: { reasoningEffort: "low" } }),
-        )
-
-        expect(updates(prepared.body)).toHaveLength(supported ? 1 : 0)
-        expect(prepared.body.reasoning).toEqual({ effort: supported ? "high" : "low" })
-      }),
-    )
-  }
-
-  it.effect("honors the compatibility override in both directions", () =>
-    Effect.gen(function* () {
-      const enabled = yield* compileRequest(
-        LLM.request({
-          model: openai("gpt-5.5", { supportsEffortUpdates: true }),
-          messages: conversation,
-          providerOptions: { reasoningEffort: "low" },
-        }),
-      )
-      const disabled = yield* compileRequest(
-        LLM.request({
-          model: openai("gpt-6-astra", { supportsEffortUpdates: false }),
-          messages: conversation,
-          providerOptions: { reasoningEffort: "low" },
-        }),
-      )
-
-      expect(updates(enabled.body)).toHaveLength(1)
-      expect(updates(disabled.body)).toHaveLength(0)
-    }),
-  )
-
-  const checkpoint = { type: "compaction", id: "cmp_1", encrypted_content: "opaque" }
-  const compactRequest = LLM.request({
-    model: OpenAI.configure({ apiKey: "fixture" }).responses("gpt-6-astra"),
-    messages: conversation,
-    providerOptions: { reasoningEffort: "low" },
-  })
-
-  testEffect(
-    dynamicResponse(({ text, respond }) =>
-      Effect.sync(() => {
-        const body = JSON.parse(text)
-        expect(body.reasoning).toEqual({ effort: "high" })
-        expect(body.input).toEqual([
-          { role: "user", content: [{ type: "input_text", text: "Before." }] },
-          { type: "configuration_update", reasoning: { effort: "low" } },
-          { role: "user", content: [{ type: "input_text", text: "After." }] },
-          { type: "compaction_trigger" },
-        ])
-        return respond(sseEvents({ type: "response.completed", response: { id: "resp_1", output: [checkpoint] } }), {
-          headers: { "content-type": "text/event-stream" },
-        })
-      }),
-    ),
-  ).effect("keeps configuration updates in the checkpoint body", () =>
-    Effect.gen(function* () {
-      const result = yield* LLMClient.compact(compactRequest, { mechanism: "trigger" })
-      expect(result.checkpoint.encrypted).toBe("opaque")
-    }),
-  )
-
-  testEffect(
-    dynamicResponse(({ request, text, respond }) =>
-      Effect.sync(() => {
-        expect(new URL(request.url).pathname).toEndWith("/responses/compact")
-        expect(JSON.parse(text).input).toEqual([
-          { role: "user", content: [{ type: "input_text", text: "Before." }] },
-          { role: "user", content: [{ type: "input_text", text: "After." }] },
-        ])
-        return respond(JSON.stringify({ object: "response.compaction", output: [checkpoint] }))
-      }),
-    ),
-  ).effect("drops markers from the compaction endpoint body", () =>
-    Effect.gen(function* () {
-      const result = yield* LLMClient.compact(compactRequest, { mechanism: "endpoint" })
-      expect(result.replacement.map((message) => message.content[0]?.type)).toEqual(["compaction"])
-    }),
-  )
-})

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

@@ -3,9 +3,6 @@ import { model } from "@opencode/ai/providers/openai"
 import { LLM } from "../src/index.js"
 import { Endpoint } from "../src/route/endpoint.js"
 
-const configuration = (provider: string, message: string) =>
-  expect.objectContaining({ _tag: "ProviderConfiguration", provider, message })
-
 describe("provider package entrypoints", () => {
   test("semantic API aliases expose the same contract", async () => {
     const modules = await Promise.all([
@@ -325,7 +322,7 @@ describe("provider package entrypoints", () => {
     const AnthropicCompatible = await import("@opencode/ai/providers/anthropic-compatible")
     expect(() =>
       Reflect.apply(AnthropicCompatible.model, undefined, ["compatible-model", { apiKey: "fixture" }]),
-    ).toThrow(configuration("anthropic-compatible", "Anthropic-compatible providers require a baseURL"))
+    ).toThrow("Anthropic-compatible providers require a baseURL")
   })
 
   test("rejects conflicting Anthropic-compatible auth settings at runtime", async () => {
@@ -340,10 +337,10 @@ describe("provider package entrypoints", () => {
           baseURL: "https://messages.example.test/v1",
         },
       ]),
-    ).toThrow(configuration("anthropic-compatible", "Anthropic-compatible apiKey cannot be combined with authToken"))
+    ).toThrow("Anthropic-compatible apiKey cannot be combined with authToken")
     expect(() =>
       Reflect.apply(Anthropic.model, undefined, ["claude-sonnet-4-6", { apiKey: "fixture", authToken: "token" }]),
-    ).toThrow(configuration("anthropic", "Anthropic apiKey cannot be combined with authToken"))
+    ).toThrow("Anthropic apiKey cannot be combined with authToken")
   })
 
   test("maps legacy OpenAI organization and project settings to headers", () => {
@@ -493,45 +490,43 @@ describe("provider package entrypoints", () => {
         "gemini-3.5-flash",
         { accessToken: "token", apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow(configuration("google-vertex", "Google Vertex apiKey cannot be combined with accessToken or auth"))
+    ).toThrow("Google Vertex apiKey cannot be combined with accessToken or auth")
     const configured = Reflect.apply(GoogleVertex.configure, undefined, [
       { accessToken: "token", auth: {}, project: "vertex-project" },
     ])
-    expect(() => configured.model("gemini-3.5-flash")).toThrow(
-      configuration("google-vertex", "Google Vertex accessToken cannot be combined with auth"),
-    )
+    expect(() => configured.model("gemini-3.5-flash")).toThrow("Google Vertex accessToken cannot be combined with auth")
     expect(() =>
       Reflect.apply(GoogleVertexMessages.model, undefined, [
         "claude-sonnet-4-6",
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow(configuration("google-vertex", "Google Vertex Messages does not support API keys"))
+    ).toThrow("Google Vertex Messages does not support API keys")
     expect(() =>
       Reflect.apply(Providers.GoogleVertexMessages.configure, undefined, [
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow(configuration("google-vertex", "Google Vertex Messages does not support API keys"))
+    ).toThrow("Google Vertex Messages does not support API keys")
     expect(() =>
       Reflect.apply(GoogleVertexChat.model, undefined, [
         "deepseek-ai/deepseek-v3.2-maas",
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow(configuration("google-vertex", "Google Vertex Chat does not support API keys"))
+    ).toThrow("Google Vertex Chat does not support API keys")
     expect(() =>
       Reflect.apply(Providers.GoogleVertexChat.configure, undefined, [
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow(configuration("google-vertex", "Google Vertex Chat does not support API keys"))
+    ).toThrow("Google Vertex Chat does not support API keys")
     expect(() =>
       Reflect.apply(GoogleVertexResponses.model, undefined, [
         "xai/grok-4.20-reasoning",
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow(configuration("google-vertex", "Google Vertex Responses does not support API keys"))
+    ).toThrow("Google Vertex Responses does not support API keys")
     expect(() =>
       Reflect.apply(Providers.GoogleVertexResponses.configure, undefined, [
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow(configuration("google-vertex", "Google Vertex Responses does not support API keys"))
+    ).toThrow("Google Vertex Responses does not support API keys")
   })
 })

packages/ai/test/provider/alibaba.test.ts

@@ -76,13 +76,7 @@ it.effect("Alibaba owns regional shared and workspace-specific endpoints", () =>
 
 test("Alibaba requires explicit placement and supports complete base URL overrides", () => {
   for (const region of ["eu-central-1", "ap-northeast-1", "future-region"])
-    expect(() => Alibaba.configure({ region })).toThrow(
-      expect.objectContaining({
-        _tag: "ProviderConfiguration",
-        provider: "alibaba",
-        message: `Alibaba region ${region} requires workspaceID or baseURL`,
-      }),
-    )
+    expect(() => Alibaba.configure({ region })).toThrow("requires workspaceID or baseURL")
   for (const config of [
     { baseURL: "https://gateway.example/prefix" },
     { region: "future-region", workspaceID: "ignored", baseURL: "https://gateway.example/prefix" },

packages/ai/test/provider/bedrock-converse.test.ts

@@ -1458,13 +1458,7 @@ describe("Bedrock Converse route", () => {
         expect(headers.get("authorization")).toContain("Credential=AKIACHAINEXAMPLE/")
         expect(headers.get("authorization")).toContain("/ap-southeast-2/bedrock/aws4_request")
       }
-      expect(() => AmazonBedrock.configure({ auth: "sigv4", apiKey: "k" })).toThrow(
-        expect.objectContaining({
-          _tag: "ProviderConfiguration",
-          provider: "amazon-bedrock",
-          message: "Amazon Bedrock SigV4 auth does not accept apiKey",
-        }),
-      )
+      expect(() => AmazonBedrock.configure({ auth: "sigv4", apiKey: "k" })).toThrow("does not accept apiKey")
     }).pipe(
       withProcessEnv({
         ...noAmbientAWS,

packages/ai/test/provider/bedrock-mantle.test.ts

@@ -4,7 +4,7 @@ import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, Message } from "../../src/index.js"
 import { AmazonBedrockMantle } from "../../src/providers.js"
 import { model } from "../../src/providers/amazon-bedrock/mantle.js"
-import { OpenResponses } from "../../src/protocols/open-responses.js"
+import { OpenAIResponses } from "../../src/protocols/openai-responses.js"
 import { compileRequest, LLMClient } from "../../src/route/client.js"
 import { it } from "../lib/effect.js"
 import { withProcessEnv } from "../lib/env.js"
@@ -25,7 +25,7 @@ describe("Amazon Bedrock Mantle provider", () => {
       expect(provider.model).toBe(provider.responses)
       expect(AmazonBedrockMantle.model).toBe(AmazonBedrockMantle.responsesModel)
       expect(model).toBe(AmazonBedrockMantle.responsesModel)
-      expect(provider.model("openai.gpt-oss-120b").route.transport).toBe(OpenResponses.httpTransport)
+      expect(provider.model("openai.gpt-oss-120b").route.transport).toBe(OpenAIResponses.httpTransport)
       const chat = yield* compileRequest(LLM.request({ model: provider.chat("openai.gpt-oss-120b"), prompt: "Hi" }))
       const responses = yield* compileRequest(
         LLM.request({ model: provider.model("openai.gpt-oss-120b"), prompt: "Hi" }),
@@ -38,7 +38,7 @@ describe("Amazon Bedrock Mantle provider", () => {
       })
       expect(responses).toMatchObject({
         route: "bedrock-mantle-responses",
-        protocol: "open-responses",
+        protocol: "openai-responses",
         body: { model: "openai.gpt-oss-120b", store: false },
       })
       expect(provider.model("openai.gpt-oss-120b").route.providerMetadataKey).toBe("mantle")
@@ -178,7 +178,7 @@ describe("Amazon Bedrock Mantle provider", () => {
 const recorded = recordedTests({
   prefix: "bedrock-mantle",
   provider: "amazon-bedrock",
-  protocol: "open-responses",
+  protocol: "openai-responses",
   requires: ["AWS_BEARER_TOKEN_BEDROCK"],
   metadata: { model: "openai.gpt-oss-120b" },
 })

packages/ai/test/provider/google-vertex.test.ts

@@ -378,11 +378,7 @@ describe("Google Vertex providers", () => {
 
   test("rejects tuned Gemini models in express mode", () => {
     expect(() => GoogleVertex.configure({ apiKey: "fixture" }).model("endpoints/1234567890")).toThrow(
-      expect.objectContaining({
-        _tag: "ProviderConfiguration",
-        provider: "google-vertex",
-        message: "Google Vertex tuned models do not support Express Mode API keys",
-      }),
+      "Google Vertex tuned models do not support Express Mode API keys",
     )
   })
 })

packages/ai/test/provider/open-responses-errors.test.ts

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

packages/ai/test/provider/openai-responses.test.ts

@@ -90,11 +90,7 @@ const classifyingChannelDriver = (message: string): WebSocketChannelDriver => {
   }
 }
 
-const continuationDriver = (
-  request: Readonly<Record<string, unknown>>,
-  base = baseChannelDriver,
-  continuation?: OpenResponsesContinuation.Shape,
-) => {
+const continuationDriver = (request: Readonly<Record<string, unknown>>, base = baseChannelDriver) => {
   const message = ProviderShared.encodeJson(request)
   return OpenResponsesContinuation.driver({
     id: "openai-responses",
@@ -102,7 +98,6 @@ const continuationDriver = (
     request,
     message,
     base: base(message),
-    continuation,
   })
 }
 
@@ -586,54 +581,52 @@ describe("OpenAI Responses route", () => {
   )
 
   it.effect("continues a streamed tool call with only the new tool output", () =>
-    Effect.forEach([undefined, []], (output) =>
-      Effect.gen(function* () {
-        const firstRequest = {
-          type: "response.create",
-          model: "gpt-5.2",
-          store: false,
-          input: [{ role: "user", content: [{ type: "input_text", text: "Weather?" }] }],
-        }
-        const first = continuationDriver(firstRequest)
-        const firstCreate = yield* first.create(undefined)
+    Effect.gen(function* () {
+      const firstRequest = {
+        type: "response.create",
+        model: "gpt-5.2",
+        store: false,
+        input: [{ role: "user", content: [{ type: "input_text", text: "Weather?" }] }],
+      }
+      const first = continuationDriver(firstRequest)
+      const firstCreate = yield* first.create(undefined)
+      yield* first.observe(
+        firstCreate,
+        ProviderShared.encodeJson({
+          type: "response.output_item.done",
+          item: {
+            type: "function_call",
+            id: "fc_1",
+            status: "completed",
+            call_id: "call_1",
+            name: "weather",
+            arguments: '{ "city": "Paris" }',
+          },
+        }),
+      )
+      const saved = checkpoint(
         yield* first.observe(
           firstCreate,
-          ProviderShared.encodeJson({
-            type: "response.output_item.done",
-            item: {
-              type: "function_call",
-              id: "fc_1",
-              status: "completed",
-              call_id: "call_1",
-              name: "weather",
-              arguments: '{ "city": "Paris" }',
-            },
-          }),
-        )
-        const saved = checkpoint(
-          yield* first.observe(
-            firstCreate,
-            ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_1", output } }),
-          ),
-        )
-        const second = continuationDriver({
-          ...firstRequest,
-          input: [
-            ...firstRequest.input,
-            { type: "function_call", call_id: "call_1", name: "weather", arguments: '{"city":"Paris"}' },
-            { type: "function_call_output", call_id: "call_1", output: '{"temperature":22}' },
-          ],
-        })
+          ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_1" } }),
+        ),
+      )
+      const second = continuationDriver({
+        ...firstRequest,
+        input: [
+          ...firstRequest.input,
+          { type: "function_call", call_id: "call_1", name: "weather", arguments: '{"city":"Paris"}' },
+          { type: "function_call_output", call_id: "call_1", output: '{"temperature":22}' },
+        ],
+      })
 
-        const create = yield* second.create(saved)
+      const create = yield* second.create(saved)
 
-        expect(create.mode).toBe("incremental")
-        expect(ProviderShared.decodeJson(create.message)).toMatchObject({
-          previous_response_id: "resp_1",
-          input: [{ type: "function_call_output", call_id: "call_1", output: '{"temperature":22}' }],
-        })
-      }),
-    ),
+      expect(create.mode).toBe("incremental")
+      expect(ProviderShared.decodeJson(create.message)).toMatchObject({
+        previous_response_id: "resp_1",
+        input: [{ type: "function_call_output", call_id: "call_1", output: '{"temperature":22}' }],
+      })
+    }),
   )
 
   it.effect("continues a tool call from authoritative completed response output", () =>
@@ -687,47 +680,45 @@ describe("OpenAI Responses route", () => {
   )
 
   it.effect("continues a promoted steer after assistant output with response-only text metadata", () =>
-    Effect.forEach([undefined, []], (output) =>
-      Effect.gen(function* () {
-        const firstInput = [{ role: "user", content: [{ type: "input_text", text: "First" }] }]
-        const first = continuationDriver({ type: "response.create", model: "gpt-5.2", store: false, input: firstInput })
-        const create = yield* first.create(undefined)
+    Effect.gen(function* () {
+      const firstInput = [{ role: "user", content: [{ type: "input_text", text: "First" }] }]
+      const first = continuationDriver({ type: "response.create", model: "gpt-5.2", store: false, input: firstInput })
+      const create = yield* first.create(undefined)
+      yield* first.observe(
+        create,
+        ProviderShared.encodeJson({
+          type: "response.output_item.done",
+          item: {
+            type: "message",
+            id: "msg_1",
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text: "Hello", annotations: [], logprobs: [] }],
+          },
+        }),
+      )
+      const saved = checkpoint(
         yield* first.observe(
           create,
-          ProviderShared.encodeJson({
-            type: "response.output_item.done",
-            item: {
-              type: "message",
-              id: "msg_1",
-              status: "completed",
-              role: "assistant",
-              content: [{ type: "output_text", text: "Hello", annotations: [], logprobs: [] }],
-            },
-          }),
-        )
-        const saved = checkpoint(
-          yield* first.observe(
-            create,
-            ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_1", output } }),
-          ),
-        )
-        const steer = { role: "user", content: [{ type: "input_text", text: "Actually, be brief" }] }
-        const next = continuationDriver({
-          type: "response.create",
-          model: "gpt-5.2",
-          store: false,
-          input: [...firstInput, { role: "assistant", content: [{ type: "output_text", text: "Hello" }] }, steer],
-        })
+          ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_1" } }),
+        ),
+      )
+      const steer = { role: "user", content: [{ type: "input_text", text: "Actually, be brief" }] }
+      const next = continuationDriver({
+        type: "response.create",
+        model: "gpt-5.2",
+        store: false,
+        input: [...firstInput, { role: "assistant", content: [{ type: "output_text", text: "Hello" }] }, steer],
+      })
 
-        const continued = yield* next.create(saved)
+      const continued = yield* next.create(saved)
 
-        expect(continued.mode).toBe("incremental")
-        expect(ProviderShared.decodeJson(continued.message)).toMatchObject({
-          previous_response_id: "resp_1",
-          input: [steer],
-        })
-      }),
-    ),
+      expect(continued.mode).toBe("incremental")
+      expect(ProviderShared.decodeJson(continued.message)).toMatchObject({
+        previous_response_id: "resp_1",
+        input: [steer],
+      })
+    }),
   )
 
   it.effect("continues streamed reasoning when completion re-encrypts the same item", () =>
@@ -926,58 +917,6 @@ describe("OpenAI Responses route", () => {
         type: "provider-failure",
         error: { reason: { _tag: "InvalidRequest", classification: "context-overflow" } },
       })
-
-      // A retryable failure stays one: the runner retries it, and the transport has already dropped the
-      // checkpoint, so that retry is a full send. xAI reports every rejection this way.
-      const internal = ProviderShared.encodeJson({
-        type: "error",
-        error: { type: "api_error", message: "gRPC error: Response with id=resp_1 not found" },
-      })
-      expect(yield* second.observe(yield* second.create(saved), internal)).toMatchObject({
-        type: "provider-failure",
-        error: { reason: { _tag: "ProviderInternal" } },
-      })
-    }),
-  )
-
-  it.effect("shapes the incremental send with the route continuation", () =>
-    Effect.gen(function* () {
-      const firstRequest = {
-        type: "response.create",
-        model: "grok-4.6",
-        store: true,
-        instructions: "You are terse.",
-        input: [{ role: "user", content: [{ type: "input_text", text: "First" }] }],
-      }
-      const secondRequest = {
-        ...firstRequest,
-        input: [...firstRequest.input, { role: "user", content: [{ type: "input_text", text: "Second" }] }],
-      }
-      const saved = checkpoint(
-        yield* continuationDriver(firstRequest).observe(
-          yield* continuationDriver(firstRequest).create(undefined),
-          ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_1" } }),
-        ),
-      )
-
-      const trimmed = yield* continuationDriver(
-        secondRequest,
-        baseChannelDriver,
-        ({ instructions: _, ...rest }) => rest,
-      ).create(saved)
-      expect(trimmed.mode).toBe("incremental")
-      expect(JSON.parse(trimmed.message)).toEqual({
-        type: "response.create",
-        model: "grok-4.6",
-        store: true,
-        previous_response_id: "resp_1",
-        input: [{ role: "user", content: [{ type: "input_text", text: "Second" }] }],
-      })
-
-      // Declining the continuation sends the step in full and never sends a previous_response_id.
-      const declined = yield* continuationDriver(secondRequest, baseChannelDriver, () => undefined).create(saved)
-      expect(declined.mode).toBe("full")
-      expect(JSON.parse(declined.message)).toEqual(secondRequest)
     }),
   )
 

packages/ai/test/provider/xai-responses.test.ts

@@ -1,18 +1,11 @@
 import { describe, expect } from "bun:test"
-import { Effect, Layer, Stream } from "effect"
+import { Effect } from "effect"
 import { LLM, LLMEvent, Message } from "../../src/index.js"
 import { XAI } from "../../src/providers.js"
 import { OpenResponses } from "../../src/protocols/open-responses.js"
 import { OpenAIResponses } from "../../src/protocols/openai-responses.js"
-import * as ProviderShared from "../../src/protocols/shared.js"
 import { XAIResponses } from "../../src/protocols/xai-responses.js"
-import {
-  LLMClient,
-  RequestExecutor,
-  WebSocketTransport,
-  type ChannelCheckpoint,
-  type WebSocketChannelDriver,
-} from "../../src/route.js"
+import { LLMClient } from "../../src/route.js"
 import { compileRequest } from "../../src/route/client.js"
 import { it } from "../lib/effect.js"
 import { fixedResponse } from "../lib/http.js"
@@ -20,35 +13,6 @@ import { sseEvents } from "../lib/sse.js"
 
 const model = XAI.configure({ apiKey: "test", baseURL: "https://api.x.ai/v1" }).responses("grok-4.6")
 
-/** Runs a request through the WebSocket transport and hands back its channel driver; the HTTP fallback answers. */
-const channelDriver = (request: ReturnType<typeof LLM.request>) =>
-  Effect.gen(function* () {
-    let driver: WebSocketChannelDriver | undefined
-    yield* LLMClient.generate(request, {
-      webSocket: {
-        execute: (exchange) =>
-          Effect.sync(() => {
-            driver = exchange.driver
-            return { frames: exchange.fallback(), complete: Effect.void }
-          }),
-      },
-    }).pipe(Effect.provide(fixedResponse(sseEvents({ type: "response.completed", response: { id: "http" } }))))
-    if (!driver) throw new Error("Expected a WebSocket channel driver")
-    return driver
-  })
-
-const completed = (driver: WebSocketChannelDriver, id: string) =>
-  Effect.gen(function* () {
-    const create = yield* driver.create(undefined)
-    yield* driver.observe(create, ProviderShared.encodeJson({ type: "response.created", response: { id } }))
-    const observation = yield* driver.observe(
-      create,
-      ProviderShared.encodeJson({ type: "response.completed", response: { id } }),
-    )
-    if (observation.type !== "completed" || !observation.checkpoint) throw new Error("Expected a checkpoint")
-    return observation.checkpoint
-  })
-
 describe("xAI Responses route", () => {
   it.effect("composes the Open Responses baseline with xAI extensions", () =>
     Effect.gen(function* () {
@@ -198,78 +162,6 @@ describe("xAI Responses route", () => {
     }),
   )
 
-  it.effect("classifies xAI's untyped WebSocket error envelope", () =>
-    Effect.gen(function* () {
-      // xAI answers a rejected response.create with an error envelope that carries no event type.
-      const envelope = ProviderShared.encodeJson({
-        error: {
-          message:
-            'Request validation error: {"code":"400","error":"Argument not supported: instructions and previous_response_id together"}',
-          type: "api_error",
-        },
-      })
-      const webSocket = WebSocketTransport.makeDirect({
-        open: () =>
-          Effect.succeed({ sendText: () => Effect.void, messages: Stream.make(envelope), close: Effect.void }),
-      })
-      const error = yield* LLMClient.generate(LLM.request({ model, prompt: "Hello" }), { webSocket }).pipe(
-        Effect.provide(
-          LLMClient.layer.pipe(
-            Layer.provide(
-              Layer.succeed(
-                RequestExecutor.Service,
-                RequestExecutor.Service.of({ execute: () => Effect.die("unexpected HTTP request") }),
-              ),
-            ),
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("ProviderInternal")
-      expect(error.message).toContain("Argument not supported: instructions and previous_response_id together")
-      expect(error.reason.body).toBe(envelope)
-    }),
-  )
-
-  it.effect("continues stored responses without instructions and sends unstored steps in full", () =>
-    Effect.gen(function* () {
-      const step = (store: boolean, ...prompts: string[]) =>
-        LLM.request({
-          model,
-          system: "You are terse.",
-          messages: prompts.map((prompt) => Message.user(prompt)),
-          providerOptions: { store },
-        })
-      const send = (store: boolean, checkpoint: ChannelCheckpoint) =>
-        channelDriver(step(store, "First", "Second")).pipe(Effect.flatMap((driver) => driver.create(checkpoint)))
-
-      const stored = yield* send(true, yield* completed(yield* channelDriver(step(true, "First")), "resp_1"))
-      expect(stored.mode).toBe("incremental")
-      expect(JSON.parse(stored.message)).toEqual({
-        type: "response.create",
-        model: "grok-4.6",
-        store: true,
-        include: ["reasoning.encrypted_content"],
-        previous_response_id: "resp_1",
-        input: [{ role: "user", content: [{ type: "input_text", text: "Second" }] }],
-      })
-
-      // The connection cache only serves stored responses, so the default store: false never chains.
-      const unstored = yield* send(false, yield* completed(yield* channelDriver(step(false, "First")), "resp_1"))
-      expect(unstored.mode).toBe("full")
-      expect(JSON.parse(unstored.message)).toMatchObject({
-        instructions: "You are terse.",
-        store: false,
-        input: [
-          { role: "user", content: [{ type: "input_text", text: "First" }] },
-          { role: "user", content: [{ type: "input_text", text: "Second" }] },
-        ],
-      })
-      expect(JSON.parse(unstored.message).previous_response_id).toBeUndefined()
-    }),
-  )
-
   it.effect("parses xAI hosted tool items", () =>
     Effect.gen(function* () {
       const item = { type: "x_search_call", id: "x_search_1", status: "completed", action: { query: "news" } }

packages/app/component-tests/ssh-reconnect.spec.ts

@@ -19,13 +19,11 @@ story("cancelling a version mismatch permits reconnecting again", async ({ mount
   const component = await mount("app-dialog-ssh--incompatible-session")
   await component.getByRole("button", { name: "Reconnect", exact: true }).click()
   const dialog = page.getByRole("dialog")
-  await expect(dialog.getByRole("status")).toContainText("Server update required")
-  await expect(dialog.getByRole("textbox")).toHaveCount(0)
+  await expect(dialog.getByRole("alert")).toBeVisible()
   await dialog.getByRole("button", { name: "Cancel", exact: true }).click()
   await expect(dialog).toHaveCount(0)
   await component.getByRole("button", { name: "Reconnect", exact: true }).click()
-  await expect(dialog.getByRole("status")).toContainText("Server update required")
-  await expect(dialog.getByRole("textbox")).toHaveCount(0)
+  await expect(dialog.getByRole("alert")).toBeVisible()
   await dialog.getByRole("button", { name: "Cancel", exact: true }).click()
   await expect(dialog).toHaveCount(0)
 })
@@ -45,17 +43,6 @@ story("adding a server keeps all SSH challenges in the original connection dialo
   await expect(dialog).toHaveCount(0)
 })
 
-story("adding an incompatible server advances to a dedicated update step", async ({ mount, page }) => {
-  await mount("app-dialog-ssh--incompatible-host")
-  const dialog = page.getByRole("dialog")
-  await dialog.getByRole("textbox", { name: "Host or SSH command" }).fill("ssh devbox")
-  await dialog.getByRole("button", { name: "Add server", exact: true }).click()
-  await expect(dialog.getByRole("status")).toContainText("Server update required")
-  await expect(dialog.getByRole("textbox")).toHaveCount(0)
-  await expect(dialog.getByRole("alert")).toHaveCount(0)
-  await expect(dialog.getByRole("button", { name: "Update and reconnect", exact: true })).toBeVisible()
-})
-
 story("updating an incompatible connection continues authentication in the same dialog", async ({ mount, page }) => {
   const component = await mount("app-dialog-ssh--incompatible-session")
   await component.getByRole("button", { name: "Reconnect", exact: true }).click()

packages/app/e2e/regression/session-prompt-spacing.spec.ts

@@ -1,74 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { sessionID, setupTimeline, userMessage } from "../performance/timeline-stability/fixture"
-
-test("keeps a submitted prompt in place while its optimistic rows are measured", async ({ page }) => {
-  await setupTimeline(page, { messages: [userMessage()], seedHistory: true })
-  const release = Promise.withResolvers<void>()
-  await page.route(`**/api/session/${sessionID}/prompt`, async (route) => {
-    if (route.request().method() !== "POST") return route.fallback()
-    await release.promise
-    return route.fallback()
-  })
-
-  const editor = page.locator('[data-component="composer"]').getByRole("textbox")
-  await expect(editor).toBeEditable()
-  await editor.fill("Observe optimistic prompt spacing.")
-  await expect
-    .poll(() =>
-      page.locator("[data-timeline-virtual-content]").evaluate((element) => {
-        const root = element.parentElement!
-        return root.scrollHeight - root.clientHeight - root.scrollTop
-      }),
-    )
-    .toBe(0)
-
-  const observation = await page.evaluateHandle(() => {
-    const frames: { prompt?: number; working: boolean }[] = []
-    let frame = 0
-    const sample = () => {
-      const prompt = [...document.querySelectorAll<HTMLElement>('[data-timeline-row="UserMessage"]')].find((row) =>
-        row.textContent?.includes("Observe optimistic prompt spacing."),
-      )
-      frames.push({
-        ...(prompt ? { prompt: prompt.getBoundingClientRect().y } : {}),
-        working: !!document.querySelector('[data-component="session-working"]'),
-      })
-      frame = requestAnimationFrame(sample)
-    }
-    frame = requestAnimationFrame(sample)
-    return {
-      stop: () => {
-        cancelAnimationFrame(frame)
-        return frames
-      },
-    }
-  })
-  const requested = page.waitForRequest(
-    (request) => request.method() === "POST" && new URL(request.url()).pathname === `/api/session/${sessionID}/prompt`,
-  )
-  try {
-    await editor.press("Enter")
-    await requested
-    const prompt = page
-      .locator('[data-timeline-row="UserMessage"]')
-      .filter({ hasText: "Observe optimistic prompt spacing." })
-    await expect(prompt).toBeInViewport()
-    await expect(page.locator('[data-component="session-working"]')).toBeVisible()
-    await expect
-      .poll(() =>
-        page.locator("[data-timeline-virtual-content]").evaluate((element) => {
-          const root = element.parentElement!
-          return root.scrollHeight - root.clientHeight - root.scrollTop
-        }),
-      )
-      .toBe(0)
-    const frames = await observation.evaluate((value) => value.stop())
-    expect(frames.some((frame) => frame.working && frame.prompt === undefined)).toBe(false)
-    const positions = frames.flatMap((frame) => (frame.prompt === undefined ? [] : [frame.prompt]))
-    expect(positions.length).toBeGreaterThan(0)
-    expect(new Set(positions).size).toBe(1)
-  } finally {
-    release.resolve()
-    await observation.dispose()
-  }
-})

packages/app/e2e/regression/session-timeline-notices.spec.ts

@@ -122,15 +122,7 @@ test("renders compaction progress, summary, and outcome in order", async ({ page
   )
   await expect(compaction.getByRole("heading", { name: "Checkpoint" })).toBeVisible()
   await expect(compaction).toContainText("Streamed implementation details.")
-  const running = compaction.getByRole("status").getByLabel("Compacting", { exact: true })
-  await expect(running).toBeVisible()
-  await expect
-    .poll(async () => {
-      const summary = await compaction.locator('[data-component="text-part"]').boundingBox()
-      const status = await running.boundingBox()
-      return !!summary && !!status && status.y >= summary.y + summary.height
-    })
-    .toBe(true)
+  await expect(compaction.getByRole("status").getByLabel("Compacting", { exact: true })).toBeVisible()
   await expect(compaction.getByText("Session compacted", { exact: true })).toHaveCount(0)
 
   await timeline.send(

packages/app/e2e/regression/session-timeline-reducer-projection.spec.ts

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

packages/app/e2e/regression/session-workspace-tab-cycle.spec.ts

@@ -1,68 +0,0 @@
-import { expect, test } from "@playwright/test"
-import type { OpenCodeEvent, SessionMessageInfo } from "@opencode/client/promise"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { fixture } from "../performance/timeline/session-timeline-stress.fixture"
-import { installStressSessionTabs, stressSessionHref } from "../performance/timeline/timeline-test-helpers"
-
-test.use({ viewport: { width: 1440, height: 900 }, serviceWorkers: "block" })
-
-test("keeps five loaded workspace tabs visible and reactive through repeated switches", async ({ page }, info) => {
-  const sessions = Array.from({ length: 5 }, (_, index) => ({
-    ...fixture.sessions[0]!,
-    id: `ses_workspace_cycle_${index}`,
-    directory: `${fixture.directory}/worktree-${index}`,
-    title: `Workspace session ${index}`,
-  }))
-  const events: OpenCodeEvent[] = []
-  await mockOpenCodeServer(page, {
-    ...fixture,
-    sessions,
-    pageMessages: (id) => ({
-      items: [
-        { id: `msg_user_${id}`, type: "user", text: `Prompt for ${id}`, time: { created: 1 } },
-        {
-          id: `msg_assistant_${id}`,
-          type: "assistant",
-          agent: "build",
-          model: { id: "claude-opus-4-6", providerID: "opencode" },
-          time: { created: 2, completed: 3 },
-          content: [{ type: "text", text: `Answer for ${id}` }],
-        },
-      ] satisfies SessionMessageInfo[],
-    }),
-    events: () => events.splice(0),
-  })
-  await page.route("**/api/location?*", (route) =>
-    route.fulfill({
-      json: {
-        directory: new URL(route.request().url()).searchParams.get("location[directory]"),
-        project: { id: fixture.project.id, directory: fixture.directory, canonical: fixture.directory },
-      },
-    }),
-  )
-  await installStressSessionTabs(page, { sessionIDs: sessions.map((session) => session.id) })
-  await page.goto(stressSessionHref(sessions[0]!.id))
-  await expect(page.getByText(`Answer for ${sessions[0]!.id}`, { exact: true })).toBeVisible()
-
-  for (const session of [...sessions.slice(1), ...sessions, ...sessions.toReversed()]) {
-    await page.locator(`[data-titlebar-tab-link][href="${stressSessionHref(session.id)}"]`).click()
-    await expect(page.locator(`[data-timeline-part-id="msg_assistant_${session.id}:text:0"]`)).toBeVisible()
-    await expect(page.locator("[data-timeline-virtual-content]")).toHaveCSS("visibility", "visible")
-  }
-  const active = sessions[0]!
-  events.push({
-    id: "evt_workspace_cycle_update",
-    created: 4,
-    type: "session.text.ended",
-    location: { directory: active.directory },
-    durable: { aggregateID: active.id, seq: 0, version: 1 },
-    data: {
-      sessionID: active.id,
-      assistantMessageID: `msg_assistant_${active.id}`,
-      ordinal: 0,
-      text: "Still receiving updates",
-    },
-  })
-  await expect(page.getByText("Still receiving updates", { exact: true })).toBeVisible()
-  await page.screenshot({ path: info.outputPath("workspace-tabs.png") })
-})

packages/app/src/composer/submit.ts

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

packages/app/src/runtime/platform/web.ts

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

packages/app/src/runtime/server/runtime.tsx

@@ -10,7 +10,6 @@ import { createData } from "@opencode/client/solid"
 import type { ServerScope } from "@/runtime/server/scope"
 import { createPermissionAutoApprover } from "@/session/requests/auto-approve"
 import { createServerNotificationState } from "@/shell/notifications/notification"
-import { createNotificationCoordinator } from "@/shell/notifications/coordinator"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import { createDesktopData } from "./data"
 import { ModelState } from "./persistence"
@@ -34,7 +33,6 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
       },
     })
     const models = createGlobalModels()
-    const notificationCoordinator = createNotificationCoordinator()
 
     const settingsServer = createMemo(() => {
       const list = server.list
@@ -59,7 +57,7 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
       if (existing) return existing
       const serverCtx = createRoot((dispose) => {
         serverCtxDisposers.set(key, dispose)
-        return createServerController(conn, server.scope(key), server.projects.forServer(key), notificationCoordinator)
+        return createServerController(conn, server.scope(key), server.projects.forServer(key))
       }, owner)
       serverCtxs.set(key, serverCtx)
       return serverCtx
@@ -133,7 +131,6 @@ function createServerController(
   conn: ServerConnection.Any,
   scope: ServerScope,
   projects: ReturnType<typeof createServerProjects>,
-  notificationCoordinator: ReturnType<typeof createNotificationCoordinator>,
 ) {
   const language = useLanguage()
   const settings = useSettings()
@@ -162,7 +159,7 @@ function createServerController(
   })
   const sync = createServerSyncContext(sdk, data)
   createPermissionAutoApprover({ sdk, data })
-  const notification = createServerNotificationState({ sdk, data, key: connKey, coordinator: notificationCoordinator })
+  const notification = createServerNotificationState({ sdk, data, key: connKey })
 
   function enrich(project: { worktree: string; expanded: boolean }) {
     const [childStore] = sync.child(project.worktree, { bootstrap: false })

packages/app/src/servers/ssh/dialog.stories.tsx

@@ -278,7 +278,6 @@ function Open(props: { initial?: string }) {
 export default { title: "App/Dialogs/SSH", id: "app-dialog-ssh" }
 export const AuthenticationRequired = { render: () => <Fixture initial="required" /> }
 export const SettingsReconnect = { render: () => <Fixture initial="required" settings connectionDelay={200} /> }
-export const IncompatibleHost = { render: () => <Fixture incompatible /> }
 export const IncompatibleSession = { render: () => <Fixture initial="required" session incompatible /> }
 export const InactiveSession = { render: () => <Fixture initial="required" session connectionDelay={3000} /> }
 export const KeyReconnect = { render: () => <Fixture initial="required" session keyOnly connectionDelay={3000} /> }

packages/app/src/servers/ssh/dialog.tsx

@@ -120,13 +120,7 @@ export function DialogSsh(props: {
       <Divider />
       <DialogBody class="flex w-full min-w-0 flex-1 flex-col px-4 pt-4 pb-2">
         <div class="flex w-full min-w-0 flex-col gap-6">
-          <Show
-            when={
-              !props.promptOnly &&
-              item()?.stage !== "incompatible" &&
-              (!state.prompted || (!!error() && !prompt()))
-            }
-          >
+          <Show when={!props.promptOnly && (!state.prompted || (!!error() && !prompt()))}>
             <div class="flex w-full min-w-0 flex-col gap-2">
               <label class="settings-server-dialog-label" for="ssh-target">
                 {language.t("ssh.target")}
@@ -166,12 +160,6 @@ export function DialogSsh(props: {
               />
             </div>
           </Show>
-          <Show when={item()?.stage === "incompatible"}>
-            <div class="flex w-full min-w-0 flex-col gap-2" role="status" aria-live="polite">
-              <span class="text-14-medium text-v2-text-text-base">{language.t("ssh.stage.incompatible")}</span>
-              <span class="text-13-regular text-v2-text-text-muted">{language.t("ssh.error.version")}</span>
-            </div>
-          </Show>
           <Show when={prompt()} keyed>
             {(prompt) => (
               <div class="flex w-full min-w-0 flex-col gap-2">
@@ -207,7 +195,7 @@ export function DialogSsh(props: {
               </div>
             )}
           </Show>
-          <Show when={item()?.stage !== "incompatible" && error()}>
+          <Show when={error()}>
             {(error) => (
               <span class="settings-server-dialog-error !leading-[var(--line-height-compact)]" role="alert">
                 {error()}

packages/app/src/session/files/session-file-browser-tab.tsx

@@ -1,6 +1,6 @@
 import { createMemo, createUniqueId, Show } from "solid-js"
 import { createStore } from "solid-js/store"
-import { createQuery, keepPreviousData } from "@tanstack/solid-query"
+import { createQuery } from "@tanstack/solid-query"
 import { Icon } from "@opencode/ui/icon"
 import { SessionFilePanelV2, SessionFilePanelV2Empty } from "@opencode/session-ui/v2/session-file-panel-v2"
 import { SessionReviewV2Sidebar } from "@opencode/session-ui/v2/session-review-v2"
@@ -56,7 +56,6 @@ export function SessionFileBrowserTab(props: {
       queryKey: [serverSDK.scope, "session-open-file", workspaceKey(), value] as const,
       enabled: serverSDK.connection.status() === "connected" && value.length > 0,
       queryFn: ({ signal }) => file.searchFiles(value, { limit: 200, signal }),
-      placeholderData: keepPreviousData,
     }
   })
   const files = createMemo(() => {

packages/app/src/session/timeline/cache.ts

@@ -18,7 +18,6 @@ export function createTimelineCache(
   visible: Accessor<boolean>,
 ) {
   const owner = getOwner()
-  let workspace = untrack(session.identity.workspaceKey)
   const cache = createScopedCache(
     (key) =>
       createRoot((dispose) => {
@@ -52,18 +51,8 @@ export function createTimelineCache(
     { maxEntries: 16, dispose: (entry) => entry.dispose() },
   )
   onCleanup(cache.clear)
-  const syncWorkspace = (key: string) => {
-    if (workspace === key) return
-    workspace = key
-    cache.clear()
-  }
   // Providers follow the selected Location even while its history is loading.
   // Dispose detached views before their effects can read the new Location.
-  createComputed(on(session.identity.workspaceKey, syncWorkspace, { defer: true }))
-  return () => {
-    // A tab's render can run before the workspace watcher in the same batch.
-    // Clear the old workspace here, and let that later watcher keep this view.
-    syncWorkspace(session.identity.workspaceKey())
-    return cache.get(session.identity.sessionKey()).value
-  }
+  createComputed(on(session.identity.workspaceKey, cache.clear, { defer: true }))
+  return () => cache.get(session.identity.sessionKey()).value
 }

packages/app/src/session/timeline/virtualizer.tsx

@@ -515,19 +515,6 @@ export function createTimelineVirtualizer(input: Input) {
           <div
             ref={(value) => {
               element = value
-              if (row()._tag !== "UserMessage" || !addedKeys.has(rowProps.rowKey) || !input.pinned() || coldPending)
-                return
-              // The optimistic row can paint before ResizeObserver corrects the tail estimates.
-              // Measure the mounted tail and pin it in this render's microtask instead.
-              queueMicrotask(() => {
-                if (!input.pinned() || !virtualContent?.isConnected) return
-                virtualizer.elementsCache.forEach((item) => {
-                  if (item.isConnected) virtualizer.resizeItem(virtualizer.indexFromElement(item), item.offsetHeight)
-                })
-                virtualizer.resizeItem(item().index, element.offsetHeight)
-                virtualContent.style.height = `${virtualizer.getTotalSize()}px`
-                virtualizer.scrollToEnd()
-              })
             }}
             data-index={item().index}
             style={{ "min-height": ready() ? undefined : `${initialItem.size}px` }}

packages/app/src/shell/notifications/coordinator.ts

@@ -1,93 +0,0 @@
-import { onCleanup } from "solid-js"
-
-const FOCUS_LOCK = "opencode:notification-focus"
-const MAX_CLAIMED = 500
-
-export function createNotificationCoordinator() {
-  const locks = typeof navigator === "undefined" ? undefined : navigator.locks
-  const claimed = new Set<string>()
-  const focus = { pending: false, release: undefined as (() => void) | undefined }
-
-  const updateFocus = () => {
-    if (typeof document === "undefined" || !document.hasFocus()) {
-      focus.release?.()
-      return
-    }
-    if (!locks || focus.pending || focus.release) return
-
-    focus.pending = true
-    void locks
-      .request(FOCUS_LOCK, { mode: "shared" }, async () => {
-        focus.pending = false
-        if (!document.hasFocus()) return
-        await new Promise<void>((resolve) => {
-          focus.release = resolve
-        })
-        focus.release = undefined
-      })
-      .catch(() => {
-        focus.pending = false
-      })
-  }
-
-  if (typeof window !== "undefined") {
-    window.addEventListener("focus", updateFocus)
-    window.addEventListener("blur", updateFocus)
-    document.addEventListener("visibilitychange", updateFocus)
-    updateFocus()
-    onCleanup(() => {
-      window.removeEventListener("focus", updateFocus)
-      window.removeEventListener("blur", updateFocus)
-      document.removeEventListener("visibilitychange", updateFocus)
-      focus.release?.()
-    })
-  }
-
-  const once = async (kind: "sound" | "system", eventID: string, run: () => Promise<unknown> | void) => {
-    const key = `${kind}:${eventID}`
-    const execute = async () => {
-      if (!claim(kind, key, claimed)) return
-      await run()
-    }
-    if (!locks) return execute()
-    await locks.request(`opencode:notification:${key}`, execute)
-  }
-
-  return {
-    sound(eventID: string, run: () => Promise<unknown> | void) {
-      return once("sound", eventID, run)
-    },
-    system(eventID: string, run: () => Promise<unknown> | void) {
-      return once("system", eventID, async () => {
-        if (typeof document !== "undefined" && document.hasFocus()) return
-        if (!locks) return run()
-        await locks.request(FOCUS_LOCK, { mode: "exclusive", ifAvailable: true }, async (lock) => {
-          if (!lock) return
-          await run()
-        })
-      })
-    },
-  }
-}
-
-function claim(kind: "sound" | "system", eventID: string, claimed: Set<string>) {
-  if (claimed.has(eventID)) return false
-
-  if (typeof localStorage !== "undefined") {
-    try {
-      const storageKey = `opencode:notification-${kind}`
-      const value: unknown = JSON.parse(localStorage.getItem(storageKey) ?? "[]")
-      const events = Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
-      if (events.includes(eventID)) {
-        claimed.add(eventID)
-        return false
-      }
-      localStorage.setItem(storageKey, JSON.stringify([...events, eventID].slice(-MAX_CLAIMED)))
-    } catch {
-      // The in-memory claim still prevents duplicates in this renderer when storage is unavailable.
-    }
-  }
-
-  claimed.add(eventID)
-  return true
-}

packages/app/src/shell/notifications/notification.tsx

@@ -11,8 +11,7 @@ import { useSettings } from "@/settings/model"
 import { decode64 } from "@/runtime/persistence/base64"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import { Persistence } from "@/runtime/persistence/schema"
-import { playSoundById } from "@/shell/notifications/sound"
-import type { createNotificationCoordinator } from "@/shell/notifications/coordinator"
+import { playSoundByIdOnce } from "@/shell/notifications/sound"
 import { useGlobal } from "@/runtime/server/runtime"
 import { ServerConnection, useServers } from "@/runtime/server/registry"
 import { sessionIDHasOpenTab, useTabs } from "@/shell/tabs/tabs"
@@ -115,12 +114,7 @@ function buildNotificationIndex(list: Notification[]) {
   return index
 }
 
-export function createServerNotificationState(input: {
-  sdk: ServerSDK
-  data: Data
-  key: ServerConnection.Key
-  coordinator: ReturnType<typeof createNotificationCoordinator>
-}) {
+export function createServerNotificationState(input: { sdk: ServerSDK; data: Data; key: ServerConnection.Key }) {
   const platform = usePlatform()
   const settings = useSettings()
   const language = useLanguage()
@@ -229,7 +223,7 @@ export function createServerNotificationState(input: {
       if (session.parentID) return
 
       if (sessionIDHasOpenTab(tabs.store, input.key, sessionID) && settings.sounds.agentEnabled()) {
-        void input.coordinator.sound(`${input.key}\0${eventID}`, () => playSoundById(settings.sounds.agent()))
+        void playSoundByIdOnce(settings.sounds.agent(), `${input.key}\0${eventID}`)
       }
 
       append({
@@ -241,10 +235,8 @@ export function createServerNotificationState(input: {
       })
 
       if (settings.notifications.agent()) {
-        void input.coordinator.system(`${input.key}\0${eventID}`, () =>
-          platform.notify(language.t("notification.session.responseReady.title"), session.title ?? sessionID, () =>
-            openNotificationSession(tabs, input.key, sessionID),
-          ),
+        void platform.notify(language.t("notification.session.responseReady.title"), session.title ?? sessionID, () =>
+          openNotificationSession(tabs, input.key, sessionID),
         )
       }
     })
@@ -256,7 +248,7 @@ export function createServerNotificationState(input: {
       if (session?.parentID) return
 
       if (sessionIDHasOpenTab(tabs.store, input.key, sessionID) && settings.sounds.errorsEnabled()) {
-        void input.coordinator.sound(`${input.key}\0${eventID}`, () => playSoundById(settings.sounds.errors()))
+        void playSoundByIdOnce(settings.sounds.errors(), `${input.key}\0${eventID}`)
       }
 
       append({
@@ -271,10 +263,8 @@ export function createServerNotificationState(input: {
         session?.title ??
         (typeof error === "string" ? error : language.t("notification.session.error.fallbackDescription"))
       if (settings.notifications.errors()) {
-        void input.coordinator.system(`${input.key}\0${eventID}`, () =>
-          platform.notify(language.t("notification.session.error.title"), description, () =>
-            openNotificationSession(tabs, input.key, sessionID),
-          ),
+        void platform.notify(language.t("notification.session.error.title"), description, () =>
+          openNotificationSession(tabs, input.key, sessionID),
         )
       }
     })

packages/app/src/shell/notifications/sound.ts

@@ -74,6 +74,9 @@ function getLoads() {
 }
 
 const cache = new Map<SoundID, Promise<string | undefined>>()
+const claimed = new Set<string>()
+const CLAIMED_STORAGE_KEY = "opencode:notification-sounds"
+const MAX_CLAIMED = 500
 
 export function soundSrc(id: string | undefined) {
   const loads = getLoads()
@@ -100,3 +103,34 @@ export function playSound(src: string | undefined) {
 export function playSoundById(id: string | undefined) {
   return soundSrc(id).then((src) => playSound(src))
 }
+
+export async function playSoundByIdOnce(id: string | undefined, eventID: string) {
+  const play = async () => {
+    if (!claim(eventID)) return
+    await playSoundById(id)
+  }
+
+  if (typeof navigator === "undefined" || !navigator.locks) return play()
+  await navigator.locks.request(`${CLAIMED_STORAGE_KEY}:${eventID}`, play)
+}
+
+function claim(eventID: string) {
+  if (claimed.has(eventID)) return false
+
+  if (typeof localStorage !== "undefined") {
+    try {
+      const value: unknown = JSON.parse(localStorage.getItem(CLAIMED_STORAGE_KEY) ?? "[]")
+      const events = Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
+      if (events.includes(eventID)) {
+        claimed.add(eventID)
+        return false
+      }
+      localStorage.setItem(CLAIMED_STORAGE_KEY, JSON.stringify([...events, eventID].slice(-MAX_CLAIMED)))
+    } catch {
+      // The in-memory claim still prevents duplicates in this renderer when storage is unavailable.
+    }
+  }
+
+  claimed.add(eventID)
+  return true
+}

packages/app/test-browser/timeline-cache.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test"
 import type { SessionMessageInfo } from "@opencode/client/promise"
-import { batch, createMemo, createRoot, onCleanup } from "solid-js"
+import { createMemo, createRoot, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import { ServerScope, SessionRouteKey, SessionStateKey } from "../src/runtime/server/scope"
 import { createTimelineCache } from "../src/session/timeline/cache"
@@ -144,35 +144,6 @@ test("disposes views on workspace changes while the destination is not rendered"
   expect(input.disposed).toEqual(["ses_a", "ses_a"])
 })
 
-for (const order of ["session-first", "workspace-first"] as const) {
-  test(`keeps views live across five workspaces when updates are ${order}`, () => {
-    const input = setup()
-    const render = createRoot((dispose) => ({ selected: createMemo(input.cache), dispose }))
-    const visited = ["ses_a"]
-    try {
-      ;["ses_b", "ses_c", "ses_d", "ses_e", "ses_a", "ses_c", "ses_b", "ses_e", "ses_d", "ses_a"].forEach(
-        (id, index) => {
-          batch(() => {
-            if (order === "workspace-first") input.setState("directory", `/repo/${id}`)
-            input.setState("id", id)
-            if (order === "session-first") input.setState("directory", `/repo/${id}`)
-          })
-          expect(input.disposed).toEqual(visited)
-          input.setState("messages", id, [
-            { id: `msg_live_${index}`, type: "user", text: "Live update", time: { created: index + 3 } },
-          ])
-          expect((render.selected() as HTMLDivElement).dataset.messages).toBe(`msg_live_${index}`)
-          expect(input.views.get(id)!.active()).toBe(true)
-          visited.push(id)
-        },
-      )
-    } finally {
-      render.dispose()
-      input.dispose()
-    }
-  })
-}
-
 test("evicts the least recently selected view and disposes all retained owners", () => {
   const input = setup()
   try {

packages/cli/src/acp/config-option.ts

@@ -76,10 +76,7 @@ export function buildEffortSelectOption(input: {
     category: "thought_level",
     type: "select",
     currentValue: selectVariant(input.currentVariant, input.variants),
-    options: [...new Set([...input.variants, DEFAULT_VARIANT_VALUE])].map((variant) => ({
-      value: variant,
-      name: formatVariantName(variant),
-    })),
+    options: input.variants.map((variant) => ({ value: variant, name: formatVariantName(variant) })),
   }
 }
 
@@ -128,7 +125,6 @@ export function formatVariantName(variant: string) {
 }
 
 function selectVariant(variant: string | undefined, variants: readonly string[]) {
-  if (!variant || variant === DEFAULT_VARIANT_VALUE) return DEFAULT_VARIANT_VALUE
   if (variant && variants.includes(variant)) return variant
   if (variants.includes(DEFAULT_VARIANT_VALUE)) return DEFAULT_VARIANT_VALUE
   return variants[0] ?? DEFAULT_VARIANT_VALUE

packages/cli/src/acp/event.ts

@@ -201,7 +201,7 @@ export async function streamTurn(input: {
         if (!child) assistantMessageID = event.data.assistantMessageID
         await send({
           sessionUpdate: "agent_thought_chunk",
-          messageId: `${event.data.assistantMessageID}:reasoning:${event.data.ordinal}`,
+          messageId: event.data.assistantMessageID,
           content: { type: "text", text: event.data.delta },
         })
         continue
@@ -455,8 +455,6 @@ async function replayMessage(
     return
   }
   if (message.type !== "assistant") return
-  // Live reasoning ordinals count only reasoning parts, not the mixed content array.
-  let reasoningOrdinal = 0
   for (const part of message.content) {
     if (part.type === "text") {
       await connection.sessionUpdate({
@@ -474,7 +472,7 @@ async function replayMessage(
         sessionId: sessionID,
         update: {
           sessionUpdate: "agent_thought_chunk",
-          messageId: `${message.id}:reasoning:${reasoningOrdinal++}`,
+          messageId: message.id,
           content: { type: "text", text: part.text },
         },
       })

packages/cli/src/acp/service.ts

@@ -41,12 +41,7 @@ import type {
 } from "@agentclientprotocol/sdk"
 import { OPENCODE_VERSION } from "../version"
 import { SessionMessage } from "@opencode/schema/session-message"
-import {
-  buildConfigOptions,
-  DEFAULT_VARIANT_VALUE,
-  parseModelSelection,
-  type ConfigOptionProvider,
-} from "./config-option"
+import { buildConfigOptions, parseModelSelection, type ConfigOptionProvider } from "./config-option"
 import { promptContentToParts } from "./content"
 import {
   ChildSessionUpdateMethod,
@@ -280,7 +275,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
       if (typeof params.value !== "string") throw new ACPError.InvalidConfigOptionError({ configId: params.configId })
       switch (params.configId) {
         case "model": {
-          const selected = requireModel(state.catalog, params.value, state.model)
+          const selected = requireModel(state.catalog, params.value)
           state.model = selected
           await input.client.session.switchModel({ sessionID: state.id, model: selected })
           break
@@ -289,10 +284,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
           const model = state.catalog.models.find(
             (item) => item.providerID === state.model.providerID && item.id === state.model.id,
           )
-          if (
-            !model ||
-            (params.value !== DEFAULT_VARIANT_VALUE && !model.variants.some((variant) => variant.id === params.value))
-          )
+          if (!model?.variants.some((variant) => variant.id === params.value))
             throw new ACPError.InvalidEffortError({ effort: params.value })
           state.model = { ...state.model, variant: params.value }
           await input.client.session.switchModel({ sessionID: state.id, model: state.model })
@@ -461,7 +453,7 @@ function providers(models: readonly ModelInfo[]): ConfigOptionProvider[] {
     }))
 }
 
-function requireModel(catalog: Catalog, modelID: string, current: ModelRef): ModelRef {
+function requireModel(catalog: Catalog, modelID: string): ModelRef {
   const selected = parseModelSelection(modelID, catalog.providers)
   const model = catalog.models.find(
     (item) => item.providerID === selected.model.providerID && item.id === selected.model.modelID,
@@ -469,14 +461,7 @@ function requireModel(catalog: Catalog, modelID: string, current: ModelRef): Mod
   if (!model) throw new ACPError.InvalidModelError({ providerId: selected.model.providerID, modelId: modelID })
   if (selected.variant && !model.variants.some((variant) => variant.id === selected.variant))
     throw new ACPError.InvalidEffortError({ effort: selected.variant })
-  const variant =
-    selected.variant ??
-    (current.providerID === model.providerID &&
-    current.id === model.id &&
-    (current.variant === DEFAULT_VARIANT_VALUE || model.variants.some((variant) => variant.id === current.variant))
-      ? current.variant
-      : undefined)
-  return { providerID: model.providerID, id: model.id, variant }
+  return { providerID: model.providerID, id: model.id, variant: selected.variant }
 }
 
 async function selectMode(client: OpenCodeClient, state: Attached, modeID: string) {

packages/cli/src/commands/handlers/session/list.ts

@@ -47,7 +47,7 @@ const handler = Effect.fn("cli.session.list")(function* (
           null,
           2,
         )
-      : formatList(page.data)) + EOL
+      : formatTable(page.data)) + EOL
   const write = Effect.tryPromise(
     () =>
       new Promise<void>((resolve, reject) => {
@@ -96,14 +96,18 @@ export default Runtime.handler(Commands.commands.session.commands.list, (input)
   ),
 )
 
-function formatList(sessions: ReadonlyArray<SessionInfo>) {
-  return sessions
-    .map((session) =>
-      [
-        session.id,
-        (session.title ?? "Untitled session").replace(/[\r\n\t]/g, " "),
-        new Date(session.time.updated).toLocaleString(),
-      ].join("\t"),
-    )
-    .join(EOL)
+function formatTable(sessions: ReadonlyArray<SessionInfo>) {
+  const rows = sessions.map((session) => ({
+    id: session.id,
+    title: (session.title ?? "Untitled session").replace(/[\r\n\t]/g, " "),
+    updated: new Date(session.time.updated).toLocaleString(),
+  }))
+  const idWidth = Math.max(20, ...rows.map((row) => row.id.length))
+  const titleWidth = Math.max(25, ...rows.map((row) => row.title.length))
+  const header = `${"Session ID".padEnd(idWidth)}  ${"Title".padEnd(titleWidth)}  Updated`
+  return [
+    header,
+    "─".repeat(header.length),
+    ...rows.map((row) => `${row.id.padEnd(idWidth)}  ${row.title.padEnd(titleWidth)}  ${row.updated}`),
+  ].join(EOL)
 }

packages/cli/test/acp/config-options.subprocess.test.ts

@@ -50,11 +50,11 @@ describe("acp config option subprocess", () => {
     const effort = requireSelectOption((await newSession(acp, fixture.home)).configOptions, "effort")
 
     expect(effort.category).toBe("thought_level")
-    expect(effort.currentValue).toBe("default")
-    expect(flattenSelectOptions(effort).map((option) => option.value)).toEqual(["low", "high", "default"])
+    expect(effort.currentValue).toBe("low")
+    expect(flattenSelectOptions(effort).map((option) => option.value)).toEqual(["low", "high"])
   }, 60_000)
 
-  test("effort survives model synchronization and can be reset to default", async () => {
+  test("effort switch updates currentValue", async () => {
     await using fixture = await createAcpFixture()
     const acp = fixture.spawn()
     await initialize(acp)
@@ -70,23 +70,5 @@ describe("acp config option subprocess", () => {
     )
 
     expect(selectConfigOption(updated.configOptions, "effort")?.currentValue).toBe(nextEffort)
-
-    const synchronized = expectOk(
-      await acp.request<SetSessionConfigOptionResponse>("session/set_config_option", {
-        sessionId: session.sessionId,
-        configId: "model",
-        value: requireSelectOption(session.configOptions, "model").currentValue,
-      }),
-    )
-    expect(selectConfigOption(synchronized.configOptions, "effort")?.currentValue).toBe(nextEffort)
-
-    const reset = expectOk(
-      await acp.request<SetSessionConfigOptionResponse>("session/set_config_option", {
-        sessionId: session.sessionId,
-        configId: "effort",
-        value: "default",
-      }),
-    )
-    expect(selectConfigOption(reset.configOptions, "effort")?.currentValue).toBe("default")
   }, 60_000)
 })

packages/cli/test/acp/event-behavior.test.ts

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

packages/cli/test/acp/service-directory.test.ts

@@ -222,7 +222,7 @@ describe("acp service directory behavior", () => {
     await fixture.service.setSessionMode({ sessionId: session.sessionId, modeId: "build" })
 
     expect(currentValue(selectedModel, "model")).toBe("test/second-model")
-    expect(currentValue(selectedModel, "effort")).toBe("default")
+    expect(currentValue(selectedModel, "effort")).toBe("low")
     expect(currentValue(selectedEffort, "effort")).toBe("medium")
     expect(currentValue(selectedMode, "mode")).toBe("plan")
     expect(

packages/cli/test/acp/service-lifecycle.test.ts

@@ -32,7 +32,7 @@ describe("acp service lifecycle", () => {
         model: { providerID: "test", id: "second-model" },
       },
     })
-    expect(currentValue(created, "effort")).toBe("default")
+    expect(currentValue(created, "effort")).toBe("none")
   })
 
   test("loads and forks with paginated replay while resume does not replay", async () => {

packages/client/src/effect/api/api.ts

@@ -11,7 +11,6 @@ import type { RelativePath } from "@opencode/schema/schema"
 import type { Brand } from "effect"
 import type { Model } from "@opencode/schema/model"
 import type { DateTime } from "effect"
-import type { Permission } from "@opencode/schema/permission"
 import type { SessionMessage } from "@opencode/schema/session-message"
 import type { SessionInbox } from "@opencode/schema/session-inbox"
 import type { PromptInput } from "@opencode/schema/prompt-input"
@@ -27,6 +26,7 @@ import type { Integration } from "@opencode/schema/integration"
 import type { Form } from "@opencode/schema/form"
 import type { Mcp } from "@opencode/schema/mcp"
 import type { Credential } from "@opencode/schema/credential"
+import type { Permission } from "@opencode/schema/permission"
 import type { PermissionSaved } from "@opencode/schema/permission-saved"
 import type { FileSystem } from "@opencode/schema/filesystem"
 import type { Command } from "@opencode/schema/command"
@@ -209,7 +209,6 @@ export type SessionCreateInput = {
   readonly model?: Model.Ref | undefined
   readonly location?: Location.Ref | undefined
   readonly metadata?: Session.Metadata | undefined
-  readonly permissions?: Permission.Ruleset | undefined
 }
 export type SessionCreateOutput = Session.Info
 export type SessionCreateOperation<E = never> = (input?: SessionCreateInput) => Effect.Effect<SessionCreateOutput, E>
@@ -438,7 +437,6 @@ export type SessionLogOutput =
             readonly agent?: Agent.ID | undefined
             readonly model?: Model.Ref | undefined
             readonly metadata?: Session.Metadata | undefined
-            readonly permissions?: Permission.Ruleset | undefined
             readonly version: string
           }
         }
@@ -491,15 +489,6 @@ export type SessionLogOutput =
           readonly location?: Location.Ref | undefined
           readonly data: { readonly sessionID: Session.ID; readonly title: string }
         }
-      | {
-          readonly id: Event.ID
-          readonly created: number
-          readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.permissions.updated"
-          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
-          readonly location?: Location.Ref | undefined
-          readonly data: { readonly sessionID: Session.ID; readonly permissions: Permission.Ruleset }
-        }
       | {
           readonly id: Event.ID
           readonly created: number
@@ -1177,18 +1166,6 @@ export type MessageListInput = {
   readonly limit?: number | undefined
   readonly order?: "asc" | "desc" | undefined
   readonly cursor?: string | undefined
-  readonly type?:
-    | "agent-switched"
-    | "model-switched"
-    | "location-switched"
-    | "user"
-    | "synthetic"
-    | "system"
-    | "skill"
-    | "shell"
-    | "assistant"
-    | "compaction"
-    | undefined
 }
 export type MessageListOutput = {
   readonly data: ReadonlyArray<SessionMessage.Info>
@@ -1596,12 +1573,6 @@ export type PermissionReplyOperation<E = never> = (
   input: PermissionReplyInput,
 ) => Effect.Effect<PermissionReplyOutput, E>
 
-export type PermissionRulesInput = { readonly sessionID: Session.ID; readonly permissions: Permission.Ruleset }
-export type PermissionRulesOutput = void
-export type PermissionRulesOperation<E = never> = (
-  input: PermissionRulesInput,
-) => Effect.Effect<PermissionRulesOutput, E>
-
 export interface PermissionApi<E = never> {
   readonly request: { readonly list: PermissionRequestListOperation<E> }
   readonly saved: { readonly list: PermissionSavedListOperation<E>; readonly remove: PermissionSavedRemoveOperation<E> }
@@ -1609,7 +1580,6 @@ export interface PermissionApi<E = never> {
   readonly list: PermissionListOperation<E>
   readonly get: PermissionGetOperation<E>
   readonly reply: PermissionReplyOperation<E>
-  readonly rules: PermissionRulesOperation<E>
 }
 
 export type FileListInput = {

packages/client/src/effect/generated/client.ts

@@ -181,8 +181,6 @@ import type {
   PermissionGetOutput,
   PermissionReplyInput,
   PermissionReplyOutput,
-  PermissionRulesInput,
-  PermissionRulesOutput,
   FileListInput,
   FileListOutput,
   FileFindInput,
@@ -397,7 +395,6 @@ const EndpointSessionCreate = (raw: RawClient["server.session"]) => (input?: Ses
         model: input?.["model"],
         location: input?.["location"],
         metadata: input?.["metadata"],
-        permissions: input?.["permissions"],
       },
     }).pipe(
       Effect.mapError(mapClientError),
@@ -760,7 +757,7 @@ const EndpointMessageList = (raw: RawClient["server.message"]) => (input: Messag
   preserveEffect<MessageListOutput>()(
     raw["session.messages"]({
       params: { sessionID: input["sessionID"] },
-      query: { limit: input["limit"], order: input["order"], cursor: input["cursor"], type: input["type"] },
+      query: { limit: input["limit"], order: input["order"], cursor: input["cursor"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
@@ -1148,14 +1145,6 @@ const EndpointPermissionReply = (raw: RawClient["server.permission"]) => (input:
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const EndpointPermissionRules = (raw: RawClient["server.permission"]) => (input: PermissionRulesInput) =>
-  preserveEffect<PermissionRulesOutput>()(
-    raw["session.permission.rules"]({
-      params: { sessionID: input["sessionID"] },
-      payload: { permissions: input["permissions"] },
-    }).pipe(Effect.mapError(mapClientError)),
-  )
-
 const adaptGroupPermission = (raw: RawClient["server.permission"]) => ({
   request: { list: EndpointPermissionRequestList(raw) },
   saved: { list: EndpointPermissionSavedList(raw), remove: EndpointPermissionSavedRemove(raw) },
@@ -1163,7 +1152,6 @@ const adaptGroupPermission = (raw: RawClient["server.permission"]) => ({
   list: EndpointPermissionList(raw),
   get: EndpointPermissionGet(raw),
   reply: EndpointPermissionReply(raw),
-  rules: EndpointPermissionRules(raw),
 })
 
 const EndpointFileList = (raw: RawClient["server.fs"]) => (input?: FileListInput) =>

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

@@ -175,8 +175,6 @@ import type {
   PermissionGetOutput,
   PermissionReplyInput,
   PermissionReplyOutput,
-  PermissionRulesInput,
-  PermissionRulesOutput,
   FileReadInput,
   FileReadOutput,
   FileListInput,
@@ -567,7 +565,6 @@ export function make(options: ClientOptions) {
               model: input?.["model"],
               location: input?.["location"],
               metadata: input?.["metadata"],
-              permissions: input?.["permissions"],
             },
             successStatus: 200,
             declaredStatuses: [400, 401],
@@ -1018,7 +1015,7 @@ export function make(options: ClientOptions) {
           {
             method: "GET",
             path: `/api/session/${encodeURIComponent(input.sessionID)}/message`,
-            query: { limit: input["limit"], order: input["order"], cursor: input["cursor"], type: input["type"] },
+            query: { limit: input["limit"], order: input["order"], cursor: input["cursor"] },
             successStatus: 200,
             declaredStatuses: [400, 401, 404, 500],
             empty: false,
@@ -1569,18 +1566,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
-      rules: (input: PermissionRulesInput, requestOptions?: RequestOptions) =>
-        request<PermissionRulesOutput>(
-          {
-            method: "PUT",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/rules`,
-            body: { permissions: input["permissions"] },
-            successStatus: 204,
-            declaredStatuses: [400, 401, 404],
-            empty: true,
-          },
-          requestOptions,
-        ),
     },
     file: {
       read: (input: FileReadInput, requestOptions?: RequestOptions) =>

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

@@ -551,6 +551,28 @@ export type InstructionEntryInfo = { key: InstructionEntryKey; value: JsonValue
 
 export type InstructionEntrySnapshot = Array<{ key: InstructionEntryKey; value: JsonValue; removed: boolean }>
 
+export type SessionCreated = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.created"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: {
+    sessionID: string
+    projectID: string
+    location: LocationRef
+    subpath?: string
+    parentID?: string
+    slug: string
+    title?: string
+    agent?: string
+    model?: ModelRef
+    metadata?: SessionMetadata
+    version: string
+  }
+}
+
 export type SessionAgentSelected = {
   id: string
   created: number
@@ -1629,6 +1651,24 @@ export type SessionInboxMove = {
   delivery: SessionInboxDelivery
 }
 
+export type SessionInfo = {
+  id: string
+  parentID?: string
+  fork?: { sessionID: string; boundary: SessionForkBoundary }
+  projectID: string
+  agent?: string
+  model?: ModelRef
+  cost: MoneyUSD
+  tokens: TokenUsageInfo
+  outcome?: "succeeded" | "failed" | "interrupted"
+  time: { created: number; updated: number; idle?: number; viewed?: number; archived?: number }
+  title?: string
+  location: LocationRef
+  subpath?: string
+  metadata?: SessionMetadata
+  revert?: SessionRevert
+}
+
 export type SessionRevertStaged = {
   id: string
   created: number
@@ -1872,58 +1912,6 @@ export type AgentInfo = {
   permissions: PermissionRuleset
 }
 
-export type SessionPermissionsUpdated = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.permissions.updated"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: { sessionID: string; permissions: PermissionRuleset }
-}
-
-export type SessionInfo = {
-  id: string
-  parentID?: string
-  fork?: { sessionID: string; boundary: SessionForkBoundary }
-  projectID: string
-  agent?: string
-  model?: ModelRef
-  cost: MoneyUSD
-  tokens: TokenUsageInfo
-  outcome?: "succeeded" | "failed" | "interrupted"
-  time: { created: number; updated: number; idle?: number; viewed?: number; archived?: number }
-  title?: string
-  location: LocationRef
-  subpath?: string
-  metadata?: SessionMetadata
-  permissions?: PermissionRuleset
-  revert?: SessionRevert
-}
-
-export type SessionCreated = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.created"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: {
-    sessionID: string
-    projectID: string
-    location: LocationRef
-    subpath?: string
-    parentID?: string
-    slug: string
-    title?: string
-    agent?: string
-    model?: ModelRef
-    metadata?: SessionMetadata
-    permissions?: PermissionRuleset
-    version: string
-  }
-}
-
 export type ConfigEntry =
   | {
       type: "document"
@@ -2096,6 +2084,8 @@ export type ConfigEntry =
   | { type: "agents"; path: string }
   | { type: "claude"; path: string }
 
+export type SessionsResponse = { data: Array<SessionInfo>; cursor: { previous?: string | null; next?: string | null } }
+
 export type SessionInboxUser = {
   id: string
   sessionID: string
@@ -2150,8 +2140,6 @@ export type FormFields = [FormField, ...Array<FormField>]
 
 export type FormFields2 = [FormField1, ...Array<FormField1>]
 
-export type SessionsResponse = { data: Array<SessionInfo>; cursor: { previous?: string | null; next?: string | null } }
-
 export type SessionInboxInfo = SessionInboxUser | SessionInboxSynthetic | SessionInboxCompaction | SessionInboxMove
 
 export type SessionInboxEnqueued = {
@@ -2245,7 +2233,6 @@ export type SessionEventDurable =
   | SessionModelSelected
   | SessionMoved
   | SessionRenamed
-  | SessionPermissionsUpdated
   | SessionViewed
   | SessionDeleted
   | SessionForked
@@ -2305,7 +2292,6 @@ export type V2Event =
   | SessionModelSelected
   | SessionMoved
   | SessionRenamed
-  | SessionPermissionsUpdated
   | SessionViewed
   | SessionUsageUpdated
   | SessionDeleted
@@ -2818,11 +2804,6 @@ export type SessionCreateInput = {
     readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
     readonly metadata?: { readonly [x: string]: JsonValue } | null
-    readonly permissions?: ReadonlyArray<{
-      readonly action: string
-      readonly resource: string
-      readonly effect: "allow" | "deny" | "ask"
-    }> | null
   }["id"]
   readonly title?: {
     readonly id?: string | null
@@ -2831,11 +2812,6 @@ export type SessionCreateInput = {
     readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
     readonly metadata?: { readonly [x: string]: JsonValue } | null
-    readonly permissions?: ReadonlyArray<{
-      readonly action: string
-      readonly resource: string
-      readonly effect: "allow" | "deny" | "ask"
-    }> | null
   }["title"]
   readonly agent?: {
     readonly id?: string | null
@@ -2844,11 +2820,6 @@ export type SessionCreateInput = {
     readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
     readonly metadata?: { readonly [x: string]: JsonValue } | null
-    readonly permissions?: ReadonlyArray<{
-      readonly action: string
-      readonly resource: string
-      readonly effect: "allow" | "deny" | "ask"
-    }> | null
   }["agent"]
   readonly model?: {
     readonly id?: string | null
@@ -2857,11 +2828,6 @@ export type SessionCreateInput = {
     readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
     readonly metadata?: { readonly [x: string]: JsonValue } | null
-    readonly permissions?: ReadonlyArray<{
-      readonly action: string
-      readonly resource: string
-      readonly effect: "allow" | "deny" | "ask"
-    }> | null
   }["model"]
   readonly location?: {
     readonly id?: string | null
@@ -2870,11 +2836,6 @@ export type SessionCreateInput = {
     readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
     readonly metadata?: { readonly [x: string]: JsonValue } | null
-    readonly permissions?: ReadonlyArray<{
-      readonly action: string
-      readonly resource: string
-      readonly effect: "allow" | "deny" | "ask"
-    }> | null
   }["location"]
   readonly metadata?: {
     readonly id?: string | null
@@ -2883,25 +2844,7 @@ export type SessionCreateInput = {
     readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
     readonly metadata?: { readonly [x: string]: JsonValue } | null
-    readonly permissions?: ReadonlyArray<{
-      readonly action: string
-      readonly resource: string
-      readonly effect: "allow" | "deny" | "ask"
-    }> | null
   }["metadata"]
-  readonly permissions?: {
-    readonly id?: string | null
-    readonly title?: string | null
-    readonly agent?: string | null
-    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
-    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
-    readonly metadata?: { readonly [x: string]: JsonValue } | null
-    readonly permissions?: ReadonlyArray<{
-      readonly action: string
-      readonly resource: string
-      readonly effect: "allow" | "deny" | "ask"
-    }> | null
-  }["permissions"]
 }
 
 export type SessionCreateOutput = { data: SessionInfo }["data"]
@@ -2939,11 +2882,6 @@ export type SessionImportInput = {
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
       readonly metadata?: { readonly [x: string]: JsonValue }
-      readonly permissions?: ReadonlyArray<{
-        readonly action: string
-        readonly resource: string
-        readonly effect: "allow" | "deny" | "ask"
-      }>
       readonly revert?: {
         readonly messageID: string
         readonly partID?: string
@@ -3249,11 +3187,6 @@ export type SessionImportInput = {
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
       readonly metadata?: { readonly [x: string]: JsonValue }
-      readonly permissions?: ReadonlyArray<{
-        readonly action: string
-        readonly resource: string
-        readonly effect: "allow" | "deny" | "ask"
-      }>
       readonly revert?: {
         readonly messageID: string
         readonly partID?: string
@@ -3559,11 +3492,6 @@ export type SessionImportInput = {
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
       readonly metadata?: { readonly [x: string]: JsonValue }
-      readonly permissions?: ReadonlyArray<{
-        readonly action: string
-        readonly resource: string
-        readonly effect: "allow" | "deny" | "ask"
-      }>
       readonly revert?: {
         readonly messageID: string
         readonly partID?: string
@@ -4420,70 +4348,17 @@ export type MessageListInput = {
     readonly limit?: number | undefined
     readonly order?: "asc" | "desc" | undefined
     readonly cursor?: string | undefined
-    readonly type?:
-      | "agent-switched"
-      | "model-switched"
-      | "location-switched"
-      | "user"
-      | "synthetic"
-      | "system"
-      | "skill"
-      | "shell"
-      | "assistant"
-      | "compaction"
-      | undefined
   }["limit"]
   readonly order?: {
     readonly limit?: number | undefined
     readonly order?: "asc" | "desc" | undefined
     readonly cursor?: string | undefined
-    readonly type?:
-      | "agent-switched"
-      | "model-switched"
-      | "location-switched"
-      | "user"
-      | "synthetic"
-      | "system"
-      | "skill"
-      | "shell"
-      | "assistant"
-      | "compaction"
-      | undefined
   }["order"]
   readonly cursor?: {
     readonly limit?: number | undefined
     readonly order?: "asc" | "desc" | undefined
     readonly cursor?: string | undefined
-    readonly type?:
-      | "agent-switched"
-      | "model-switched"
-      | "location-switched"
-      | "user"
-      | "synthetic"
-      | "system"
-      | "skill"
-      | "shell"
-      | "assistant"
-      | "compaction"
-      | undefined
   }["cursor"]
-  readonly type?: {
-    readonly limit?: number | undefined
-    readonly order?: "asc" | "desc" | undefined
-    readonly cursor?: string | undefined
-    readonly type?:
-      | "agent-switched"
-      | "model-switched"
-      | "location-switched"
-      | "user"
-      | "synthetic"
-      | "system"
-      | "skill"
-      | "shell"
-      | "assistant"
-      | "compaction"
-      | undefined
-  }["type"]
 }
 
 export type MessageListOutput = SessionMessagesResponse
@@ -5825,19 +5700,6 @@ export type PermissionReplyInput = {
 
 export type PermissionReplyOutput = void
 
-export type PermissionRulesInput = {
-  readonly sessionID: { readonly sessionID: string }["sessionID"]
-  readonly permissions: {
-    readonly permissions: ReadonlyArray<{
-      readonly action: string
-      readonly resource: string
-      readonly effect: "allow" | "deny" | "ask"
-    }>
-  }["permissions"]
-}
-
-export type PermissionRulesOutput = void
-
 export type FileReadInput = {
   readonly location?: {
     readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined

packages/client/src/solid/data.ts

@@ -695,10 +695,6 @@ export function createData(config: CreateDataInput) {
         })
         return
       }
-      case "session.permissions.updated":
-        if (store.session.info[event.data.sessionID])
-          setStore("session", "info", event.data.sessionID, "permissions", event.data.permissions)
-        return
       case "session.moved": {
         const current = store.session.info[event.data.sessionID]
         if (current) {

packages/codemode/interpreter-support.md

@@ -31,8 +31,8 @@ ultimate source of truth.
 - [x] `null`, `undefined`, booleans, finite and non-finite numbers, and strings.
 - [x] Array literals, including holes and spread from arrays, strings, Maps, Sets, URLSearchParams, custom synchronous
       iterators, and synchronous generators.
-- [x] Object literals with shorthand, computed string/number keys, and spread following ToObject: data objects and
-      arrays copy own enumerable keys, strings copy index keys, and other values contribute nothing.
+- [x] Object literals with shorthand, computed string/number keys, and spread from plain data objects; `null` and
+      `undefined` are no-ops, while arrays are rejected.
 - [x] Template literals with interpolation.
 - [x] Regular-expression literals.
 - [x] `NaN` and `Infinity` globals.
@@ -44,21 +44,18 @@ ultimate source of truth.
 
 ## Bindings and destructuring
 
-- [x] `const`, `let`, and `var` declarations.
+- [x] `const`, `let`, and accepted `var` declarations.
 - [x] Object and array destructuring in declarations, parameters, assignment expressions, and `for...of` bindings.
 - [x] Nested patterns, defaults, elisions, and rest elements.
 - [x] Assignment to identifiers, plain-object fields, non-negative integer array indexes, and writable URL
       fields.
 - [x] Direct function declarations are hoisted in program and block statement lists.
 - [x] Parameter defaults observe a temporal dead zone for later parameters.
-- [x] `var` is function-scoped and hoisted: names declared anywhere in a function or program body, including loop
-      heads, blocks, `switch` cases, and `try`/`catch`, read as `undefined` before their statement runs; redeclaration
-      assigns the one binding; a same-named parameter keeps its argument; closures in parameter defaults see outer
-      names rather than body `var`s.
+- [ ] JavaScript-correct function scoping, hoisting, and redeclaration for accepted `var` declarations.
 - [x] Predeclare `let` and `const` bindings in every lexical scope, including program/block bodies, switch bodies, and
       loop headers, so reads before initialization and self- or cross-referential initializers observe the JavaScript
       temporal dead zone.
-- [x] Function declarations are hoisted across all cases of a `switch`, like any other statement list.
+- [ ] Hoist function declarations accepted directly in switch cases.
 - [x] Computed object destructuring keys such as `const { [field]: value } = record`.
 - [x] Object destructuring from arrays, such as `const { length } = values`.
 - [x] Array binding and assignment destructuring from strings, Maps, Sets, URLSearchParams, custom synchronous
@@ -73,7 +70,7 @@ ultimate source of truth.
 - [x] `for`, `while`, and `do...while`.
 - [x] `for...of` over arrays, strings, Maps, Sets, URLSearchParams, custom synchronous iterators, and confined
       synchronous generators. Abrupt completion invokes the iterator's optional `return()`.
-- [x] `for...in` over own keys of plain objects, arrays, strings, and tool references; other values iterate nothing.
+- [x] `for...in` over own keys of plain objects, arrays, and tool references.
 - [x] Unlabeled `break` and `continue`.
 - [x] `try`, `catch`, optional catch bindings, and `finally`.
 - [x] `throw` with arbitrary values.
@@ -213,15 +210,12 @@ ultimate source of truth.
       primitive wrapper objects (`Object(1)`) are rejected explicitly.
 - [x] Computed property names and object spread.
 - [x] `Object.keys`, `Object.values`, `Object.entries`, `Object.hasOwn`, `Object.assign`, and `Object.fromEntries`, with
-      synchronous iterator support for `fromEntries`. Sources follow ToObject: strings enumerate by index, other
-      primitives and wrappers contribute nothing, and `null`/`undefined` throw. `Object.assign` accepts array
-      targets for index keys only; a primitive target is a `TypeError` rather than a boxed object.
+      synchronous iterator support for `fromEntries`.
 - [x] `Object.keys` over arrays and tool references.
 - [x] Object identity is preserved by in-CodeMode Object helpers.
-- [x] `__proto__`, `constructor`, and `prototype` are ordinary own data keys. `x.constructor` without an own key resolves
-      to the owning built-in (`[].constructor === Array`, `new TypeError().constructor === TypeError`); prototype objects
-      are not observable, so `[].__proto__` and `Object.prototype` read as `undefined` and `o.__proto__ = x` sets an own
-      field.
+- [x] `__proto__`, `constructor`, and `prototype` are ordinary own data keys. Prototype machinery is not observable:
+      data objects have no prototype, so `({}).constructor` and `[].__proto__` read as `undefined` and `o.__proto__ = x`
+      sets an own field.
 - [x] Circular references are rejected when created (`o.self = o`, `array.push(array)`), not at serialization as in JS.
 - [x] `Object.is` for supported data values.
 - [x] `Object.groupBy` over finite collections and custom synchronous iterators/generators, with string-key coercion
@@ -253,13 +247,12 @@ ultimate source of truth.
 ## Strings
 
 - [x] Case/normalization: `toLowerCase`, `toUpperCase`, `normalize`.
-- [x] Trimming: `trim`, `trimStart`, and `trimEnd`, plus the Annex B `trimLeft` and `trimRight` aliases.
+- [x] Trimming: `trim`, `trimStart`, and `trimEnd`.
 - [x] Searching/tests: `includes`, `startsWith`, `endsWith`, `indexOf`, `lastIndexOf`, and `search`.
-- [x] Slicing/access: `slice`, `substring`, Annex B `substr`, `at`, `charAt`, `charCodeAt`, and `codePointAt`.
+- [x] Slicing/access: `slice`, `substring`, `at`, `charAt`, `charCodeAt`, and `codePointAt`.
 - [x] Construction/transformation: `split`, `concat`, `repeat`, `padStart`, `padEnd`, `replace`, and `replaceAll`.
 - [x] Regular-expression integration: `match`, materialized `matchAll`, `replace`, `replaceAll`, `split`, and `search`.
 - [x] `localeCompare`; locale and options arguments are currently ignored.
-- [x] `isWellFormed` and `toWellFormed`.
 - [x] `toString`, `length`, numeric indexing, spread, and `for...of` by Unicode code point.
 - [x] Static `String.fromCharCode` and `String.fromCodePoint`.
 - [x] Native argument coercion for supported String methods; for example, `includes(1)` and `slice("1")` coerce like
@@ -320,7 +313,6 @@ ultimate source of truth.
 - [x] Local and UTC Date setters, including native argument coercion, mutation, rollover, invalid-Date recovery, and
       `TimeClip` behavior.
 - [x] `Date.prototype.toUTCString` and its `toGMTString` alias.
-- [x] `toDateString` and `toTimeString` in the host's local timezone.
 - [x] Native one-argument Date coercion for supported values, including booleans, null, arrays, and plain objects.
 - [x] Native Date loose-equality and default primitive-coercion semantics, using CodeMode's deterministic ISO string
       representation for the string primitive.
@@ -364,14 +356,6 @@ ultimate source of truth.
       `entries`, `toString`, and `size`.
 - [x] URL values serialize to their href; URLSearchParams serialize to `{}`.
 
-## Web platform helpers
-
-- [x] `atob` and `btoa` with forgiving-base64 decoding and WebIDL string conversion; invalid input throws an Error
-      named `InvalidCharacterError`, since there is no `DOMException`.
-- [x] `crypto.randomUUID()`.
-- [ ] `crypto.getRandomValues` and `crypto.subtle`, `TextEncoder`/`TextDecoder`, and `Blob`: these need a binary
-      value type, which the JSON-like data model does not have yet.
-
 ## Errors and diagnostics
 
 - [x] `Error`, `TypeError`, `RangeError`, `SyntaxError`, `ReferenceError`, `EvalError`, and `URIError`, callable with
@@ -388,6 +372,6 @@ ultimate source of truth.
       shift them. The diagnostic names the rejected node type and attaches a short orientation to the supported
       subset; this matrix is the full reference.
 - [x] Model-visible host failure messages and underlying causes, including output-validation errors.
-- [x] Caught errors do not distinguish user throws, interpreter failures, and tool failures; a program sees one
-      Error-shaped value with `name` and `message` in `catch`, rejection handlers, and `Promise.allSettled` reasons.
-      This is deliberate: the program should handle a failure the same way regardless of where it originated.
+- [ ] Distinguish user-thrown failures from interpreter defects and explicit tool refusals from internal tool
+      failures; preserve those categories in caught errors, promise rejection handlers, and `Promise.allSettled`
+      reasons.

packages/codemode/src/codemode.ts

@@ -105,7 +105,7 @@ export type Result = typeof Result.Type
 
 /** Reusable confined runtime over explicit tools. */
 export type Runtime<R = never> = {
-  readonly catalog: ReadonlyArray<ToolDescription>
+  readonly catalog: () => ReadonlyArray<ToolDescription>
   readonly execute: (code: string) => Effect.Effect<Result, never, R>
 }
 
@@ -134,7 +134,7 @@ export const make = <const Provided extends Record<string, unknown> = {}>(
   const prepared = ToolRuntime.prepare((options.tools ?? {}) as Tools<Services<Provided>>)
   const limits = resolveExecutionLimits(options.limits)
   return {
-    catalog: prepared.catalog,
+    catalog: () => prepared.catalog,
     execute: (code) => executeProgram(code, prepared, limits, options),
   }
 }

packages/codemode/src/interpreter/globals.ts

@@ -11,7 +11,6 @@ import { regexpGlobal } from "../stdlib/regexp.js"
 import { stringGlobal } from "../stdlib/string.js"
 import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js"
 import { coercion, errorConstructors } from "../stdlib/value.js"
-import { atobGlobal, btoaGlobal, cryptoGlobal } from "../stdlib/web.js"
 import { ToolReference } from "../tool-runtime.js"
 import { errorGlobal } from "./errors.js"
 import { HostFunction } from "./host.js"
@@ -72,8 +71,5 @@ export const globals = <R>(host: Host<R>): ReadonlyArray<readonly [string, unkno
   ["encodeURIComponent", uriGlobal("encodeURIComponent")],
   ["decodeURI", uriGlobal("decodeURI")],
   ["decodeURIComponent", uriGlobal("decodeURIComponent")],
-  ["atob", atobGlobal],
-  ["btoa", btoaGlobal],
-  ["crypto", cryptoGlobal],
   ...[...errorConstructors].map((name) => [name, errorGlobal(name, host.runner)] as const),
 ]

packages/codemode/src/interpreter/methods.ts

@@ -118,11 +118,9 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
       result = value.trim()
       break
     case "trimStart":
-    case "trimLeft":
       result = value.trimStart()
       break
     case "trimEnd":
-    case "trimRight":
       result = value.trimEnd()
       break
     // Locale/options are deliberately unsupported; comparison uses the host default locale.
@@ -243,15 +241,6 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
     case "substring":
       result = value.substring(optNum(0) ?? 0, optNum(1))
       break
-    case "substr":
-      result = value.substr(optNum(0) ?? 0, optNum(1))
-      break
-    case "isWellFormed":
-      result = value.isWellFormed()
-      break
-    case "toWellFormed":
-      result = value.toWellFormed()
-      break
     case "charCodeAt":
       result = value.charCodeAt(optNum(0) ?? 0)
       break

packages/codemode/src/interpreter/promises.ts

@@ -32,17 +32,6 @@ export class PromiseRuntime<R> {
 
   constructor(private readonly scope: Scope.Scope) {}
 
-  // Resolution bodies need the promise's own identity to reject `resolve(promise)` self-resolution.
-  createWithSelf(
-    body: (self: { promise?: Values.Promise }) => Effect.Effect<unknown, unknown, R>,
-  ): Effect.Effect<Values.Promise, never, R> {
-    const self: { promise?: Values.Promise } = {}
-    return Effect.map(this.create(body(self)), (promise) => {
-      self.promise = promise
-      return promise
-    })
-  }
-
   create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<Values.Promise, never, R> {
     return Effect.suspend(() => {
       // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
@@ -137,7 +126,11 @@ export const resolvePromise = <R>(
   node: AstNode,
 ): Effect.Effect<Values.Promise, never, R> => {
   if (value instanceof Values.Promise) return Effect.succeed(value)
-  return promises.createWithSelf((self) => resolvePromiseValue(runner, value, node, self))
+  const box: { promise?: Values.Promise } = {}
+  return Effect.map(promises.create(resolvePromiseValue(runner, value, node, box)), (promise) => {
+    box.promise = promise
+    return promise
+  })
 }
 
 const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"] as const
@@ -261,9 +254,11 @@ const constructPromise = <R>(
   }
   return Effect.gen(function* () {
     const deferred = Deferred.makeUnsafe<unknown, unknown>()
-    const promise = yield* promises.createWithSelf((self) =>
-      Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, self)),
+    const box: { promise?: Values.Promise } = {}
+    const promise = yield* promises.create(
+      Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, box)),
     )
+    box.promise = promise
     const resolve = capability("resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)))
     const reject = capability("reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value))))
     const executed = yield* Effect.exit(runner.invokeFunction(executor, [resolve, reject]))
@@ -315,16 +310,19 @@ const chainReaction = <R>(
   method: string,
   node: AstNode,
 ): Effect.Effect<Values.Promise, never, R> => {
-  return promises.createWithSelf((self) =>
-    Effect.gen(function* () {
-      const exit = yield* reactionExit(promises, source)
-      const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected
-      if (handler === undefined) return yield* exit
-      const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(Cause.squash(exit.cause))
-      const result = yield* applyCollectionCallback(runner, handler, method, node)([input])
-      return yield* resolvePromiseValue(runner, result, node, self)
-    }),
-  )
+  const box: { promise?: Values.Promise } = {}
+  const body = Effect.gen(function* () {
+    const exit = yield* reactionExit(promises, source)
+    const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected
+    if (handler === undefined) return yield* exit
+    const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(Cause.squash(exit.cause))
+    const result = yield* applyCollectionCallback(runner, handler, method, node)([input])
+    return yield* resolvePromiseValue(runner, result, node, box)
+  })
+  return Effect.map(promises.create(body), (derived) => {
+    box.promise = derived
+    return derived
+  })
 }
 
 const chainFinally = <R>(

packages/codemode/src/interpreter/references.ts

@@ -108,12 +108,3 @@ export const typeofValue = (value: unknown): string => {
   if (value instanceof ToolReference) return value.path.length > 0 ? "function" : "object"
   return typeof value
 }
-
-const MAX_ARRAY_LENGTH = 4_294_967_295
-
-export const parseArrayIndex = (key: string | number): number | undefined => {
-  const property = String(key)
-  if (!/^(0|[1-9]\d*)$/.test(property)) return undefined
-  const index = Number(property)
-  return index < MAX_ARRAY_LENGTH ? index : undefined
-}

packages/codemode/src/interpreter/runtime.ts

@@ -75,7 +75,6 @@ import {
   containsOpaqueReference,
   describeValue,
   isRuntimeReference,
-  parseArrayIndex,
   rejectCircularInsertion,
   typeofValue,
 } from "./references.js"
@@ -86,20 +85,16 @@ import { numberMethods } from "../stdlib/number.js"
 import { constructRegExp, regexpMethods, regexpProperties } from "../stdlib/regexp.js"
 import { stringMethods } from "../stdlib/string.js"
 import { uriArgument, urlMethods, urlProperties, urlSearchParamsMethods, urlWritableProperties } from "../stdlib/url.js"
-import { enumerableSource } from "../stdlib/object.js"
-import { coerceToNumber, coerceToString, compoundOperators, errorBrandName } from "../stdlib/value.js"
+import { coerceToNumber, coerceToString, compoundOperators } from "../stdlib/value.js"
 import { Values } from "../values.js"
 
-// What a loop does with its body's result: exit with a StatementResult, or undefined to keep iterating.
-// Unlabelled break ends this loop; a label the loop does not carry propagates outward.
-const loopExit = (result: StatementResult, labels: ReadonlySet<string> | undefined): StatementResult | undefined => {
-  if (result.kind === "return") return result
-  if (result.kind === "break") {
-    if (result.label !== undefined && !labels?.has(result.label)) return result
-    return { kind: "none" }
-  }
-  if (result.kind === "continue" && result.label !== undefined && !labels?.has(result.label)) return result
-  return undefined
+const MAX_ARRAY_LENGTH = 4_294_967_295
+
+const parseArrayIndex = (key: string | number): number | undefined => {
+  const property = String(key)
+  if (!/^(0|[1-9]\d*)$/.test(property)) return undefined
+  const index = Number(property)
+  return index < MAX_ARRAY_LENGTH ? index : undefined
 }
 
 const calleeDescription = (callee: Expression | Super | undefined): string => {
@@ -118,25 +113,6 @@ const calleeDescription = (callee: Expression | Super | undefined): string => {
   return "The called value"
 }
 
-const hasOwn = (value: unknown, key: PropertyKey): boolean =>
-  value !== null && typeof value === "object" && Object.hasOwn(value, key)
-
-const constructorName = (value: unknown): string | undefined => {
-  if (typeof value === "string") return "String"
-  if (typeof value === "number") return "Number"
-  if (typeof value === "boolean") return "Boolean"
-  if (Array.isArray(value)) return "Array"
-  if (value instanceof Values.Date) return "Date"
-  if (value instanceof Values.RegExp) return "RegExp"
-  if (value instanceof Values.Map) return "Map"
-  if (value instanceof Values.Set) return "Set"
-  if (value instanceof Values.URL) return "URL"
-  if (value instanceof Values.URLSearchParams) return "URLSearchParams"
-  if (value instanceof Values.Promise) return "Promise"
-  if (value === null || typeof value !== "object" || isRuntimeReference(value)) return undefined
-  return errorBrandName(value) ?? "Object"
-}
-
 const instanceofValue = (lhs: unknown, rhs: unknown, node: AstNode): boolean => {
   if (rhs instanceof HostFunction && rhs.instanceOf !== undefined) return rhs.instanceOf(lhs)
   throw new InterpreterRuntimeError(
@@ -170,51 +146,6 @@ const collectPatternNames = (pattern: Pattern, out: Array<string> = []): Array<s
   return out
 }
 
-// `var` names declared anywhere in a function body except inside nested functions, which own theirs.
-// Memoized per body: a function's var names never change, and hoisting runs on every call.
-const varNames = new WeakMap<ReadonlyArray<Statement | ModuleDeclaration>, ReadonlyArray<string>>()
-const collectVarNames = (
-  node: Statement | ModuleDeclaration | null | undefined,
-  out: Array<string> = [],
-): Array<string> => {
-  if (!node) return out
-  switch (node.type) {
-    case "VariableDeclaration":
-      if (node.kind === "var") for (const declaration of node.declarations) collectPatternNames(declaration.id, out)
-      break
-    case "BlockStatement":
-      for (const statement of node.body) collectVarNames(statement, out)
-      break
-    case "IfStatement":
-      collectVarNames(node.consequent, out)
-      collectVarNames(node.alternate, out)
-      break
-    case "ForStatement":
-      if (node.init?.type === "VariableDeclaration") collectVarNames(node.init, out)
-      collectVarNames(node.body, out)
-      break
-    case "ForInStatement":
-    case "ForOfStatement":
-      if (node.left.type === "VariableDeclaration") collectVarNames(node.left, out)
-      collectVarNames(node.body, out)
-      break
-    case "WhileStatement":
-    case "DoWhileStatement":
-    case "LabeledStatement":
-      collectVarNames(node.body, out)
-      break
-    case "SwitchStatement":
-      for (const item of node.cases) for (const statement of item.consequent) collectVarNames(statement, out)
-      break
-    case "TryStatement":
-      collectVarNames(node.block, out)
-      collectVarNames(node.handler?.body, out)
-      collectVarNames(node.finalizer, out)
-      break
-  }
-  return out
-}
-
 const loopDeclaration = (left: VariableDeclaration | Pattern, statement: "for...of" | "for...in") => {
   if (left.type !== "VariableDeclaration") return undefined
   const declaration = left.declarations.length === 1 ? left.declarations[0] : undefined
@@ -275,8 +206,6 @@ const promiseResolutionNode: AstNode = { type: "PromiseResolution", start: 0, en
 /** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
 export class Runtime<R> {
   readonly runner: Runner<R>
-  /** Built-in globals by name, unaffected by program shadowing. */
-  readonly builtins: ReadonlyMap<string, unknown>
   private readonly root: Frame<R>
 
   constructor(
@@ -295,8 +224,7 @@ export class Runtime<R> {
       settlePromise: (promise) => this.root.settlePromise(promise),
       syncIterator: (value, node) => this.root.syncIterator(value, node),
     }
-    this.builtins = new Map(globals(this))
-    for (const [name, value] of this.builtins) globalScope.set(name, { mutable: false, value })
+    for (const [name, value] of globals(this)) globalScope.set(name, { mutable: false, value })
   }
 
   run(program: Program): Effect.Effect<unknown, unknown, R> {
@@ -321,7 +249,6 @@ class Frame<R> {
     return Effect.gen(function* () {
       self.predeclareLexical(program.body)
       self.hoistFunctions(program.body)
-      self.hoistVars(program.body)
       let value: unknown = undefined
       for (const [index, statement] of program.body.entries()) {
         if (index === program.body.length - 1 && statement.type === "ExpressionStatement") {
@@ -445,20 +372,6 @@ class Frame<R> {
     }
   }
 
-  // Hoisted `var` bindings start undefined, or copy a same-named parameter. Function bodies hoist
-  // into their own scope above the parameters so closures in parameter defaults keep seeing outer names.
-  private hoistVars(statements: ReadonlyArray<Statement | ModuleDeclaration>, parameters?: Map<string, Binding>): void {
-    const names =
-      varNames.get(statements) ??
-      statements.reduce<Array<string>>((out, statement) => collectVarNames(statement, out), [])
-    varNames.set(statements, names)
-    const scope = this.scopes.current()
-    for (const name of names) {
-      if (scope.has(name)) continue
-      scope.set(name, { mutable: true, value: parameters?.get(name)?.value, initialized: true })
-    }
-  }
-
   private predeclareLexical(statements: ReadonlyArray<Statement | ModuleDeclaration>): void {
     for (const statement of statements) {
       if (statement.type !== "VariableDeclaration") continue
@@ -496,9 +409,7 @@ class Frame<R> {
       self.scopes.push()
       return yield* Effect.gen(function* () {
         const cases = node.cases
-        const statements = cases.flatMap((branch) => branch.consequent)
-        self.predeclareLexical(statements)
-        self.hoistFunctions(statements)
+        self.predeclareLexical(cases.flatMap((branch) => branch.consequent))
         let defaultIndex: number | undefined
         let selected: number | undefined
         for (const [index, branch] of cases.entries()) {
@@ -540,8 +451,21 @@ class Frame<R> {
     const self = this
     return Effect.gen(function* () {
       while (yield* self.evaluateExpression(node.test)) {
-        const exit = loopExit(yield* self.evaluateStatement(node.body), labels)
-        if (exit !== undefined) return exit
+        const result = yield* self.evaluateStatement(node.body)
+
+        if (result.kind === "continue") {
+          if (result.label !== undefined && !labels?.has(result.label)) return result
+          continue
+        }
+
+        if (result.kind === "break") {
+          if (result.label !== undefined && !labels?.has(result.label)) return result
+          return { kind: "none" } satisfies StatementResult
+        }
+
+        if (result.kind === "return") {
+          return result
+        }
       }
 
       return { kind: "none" } satisfies StatementResult
@@ -555,8 +479,21 @@ class Frame<R> {
     const self = this
     return Effect.gen(function* () {
       do {
-        const exit = loopExit(yield* self.evaluateStatement(node.body), labels)
-        if (exit !== undefined) return exit
+        const result = yield* self.evaluateStatement(node.body)
+
+        if (result.kind === "continue") {
+          if (result.label !== undefined && !labels?.has(result.label)) return result
+          continue
+        }
+
+        if (result.kind === "break") {
+          if (result.label !== undefined && !labels?.has(result.label)) return result
+          return { kind: "none" } satisfies StatementResult
+        }
+
+        if (result.kind === "return") {
+          return result
+        }
       } while (yield* self.evaluateExpression(node.test))
 
       return { kind: "none" } satisfies StatementResult
@@ -602,13 +539,27 @@ class Frame<R> {
       nextIteration()
 
       while (testNode ? yield* self.evaluateExpression(testNode) : true) {
-        const exit = loopExit(yield* self.evaluateStatement(node.body), labels)
-        if (exit !== undefined) return exit
+        const result = yield* self.evaluateStatement(node.body)
+
+        if (result.kind === "return") {
+          return result
+        }
+
+        if (result.kind === "break") {
+          if (result.label !== undefined && !labels?.has(result.label)) return result
+          return { kind: "none" } satisfies StatementResult
+        }
+
+        if (result.kind === "continue" && result.label !== undefined && !labels?.has(result.label)) return result
 
         nextIteration()
         if (updateNode) {
           yield* self.evaluateExpression(updateNode)
         }
+
+        if (result.kind === "continue") {
+          continue
+        }
       }
 
       return { kind: "none" } satisfies StatementResult
@@ -651,12 +602,10 @@ class Frame<R> {
 
       const evaluateBody = (value: unknown) =>
         Effect.gen(function* () {
-          if (declared?.lexical) {
+          if (declared) {
             self.scopes.push()
-            self.predeclarePattern(declared.pattern, declared.mutable, left)
-            yield* self.declarePattern(declared.pattern, value, declared.mutable, left, true)
-          } else if (declared) {
-            yield* self.assignPattern(declared.pattern, value, left)
+            if (declared.lexical) self.predeclarePattern(declared.pattern, declared.mutable, left)
+            yield* self.declarePattern(declared.pattern, value, declared.mutable, left, declared.lexical)
           } else if (assignment) {
             yield* self.assignPattern(assignment, value, left)
           }
@@ -664,7 +613,7 @@ class Frame<R> {
         }).pipe(
           Effect.ensuring(
             Effect.sync(() => {
-              if (declared?.lexical) self.scopes.pop()
+              if (declared) self.scopes.pop()
             }),
           ),
         )
@@ -683,10 +632,22 @@ class Frame<R> {
           }
           return yield* Effect.failCause(bodyExit.cause)
         }
-        const exit = loopExit(bodyExit.value, labels)
-        if (exit !== undefined) {
+        const result = bodyExit.value
+
+        if (result.kind === "return") {
           yield* close()
-          return exit
+          return result
+        }
+
+        if (result.kind === "break") {
+          yield* close()
+          if (result.label !== undefined && !labels?.has(result.label)) return result
+          return { kind: "none" } satisfies StatementResult
+        }
+
+        if (result.kind === "continue" && result.label !== undefined && !labels?.has(result.label)) {
+          yield* close()
+          return result
         }
       }
     }).pipe(
@@ -869,11 +830,17 @@ class Frame<R> {
     throw new InterpreterRuntimeError(`${context} must be a function.`, node).as("TypeError")
   }
 
-  // for...in over null/undefined iterates nothing, like JS.
-  private enumerableKeys(value: unknown, node: AstNode): Array<string> {
-    if (value instanceof ToolReference) return [...this.runtime.toolKeys(value.path)]
-    if (value === null || value === undefined) return []
-    return Object.keys(enumerableSource("for...in", value, node))
+  private enumerableKeys(value: unknown): Array<string> | undefined {
+    if (value instanceof ToolReference) {
+      return [...this.runtime.toolKeys(value.path)]
+    }
+    if (Array.isArray(value)) {
+      return Object.keys(value)
+    }
+    if (value !== null && typeof value === "object" && !isRuntimeReference(value)) {
+      return Object.keys(value)
+    }
+    return undefined
   }
 
   private evaluateForInStatement(
@@ -889,7 +856,13 @@ class Frame<R> {
       if (declared?.lexical) self.predeclarePattern(declared.pattern, declared.mutable, left)
       const right = yield* self.evaluateExpression(node.right)
 
-      const keys = self.enumerableKeys(right, node.right)
+      const keys = self.enumerableKeys(right)
+      if (keys === undefined) {
+        throw new InterpreterRuntimeError(
+          "for...in requires a plain object, array, or tools reference. Use for...of for arrays/strings/Maps/Sets, or Object.keys(value) for a key list.",
+          node,
+        )
+      }
 
       if (left.type !== "Identifier" && left.type !== "VariableDeclaration") {
         throw new InterpreterRuntimeError("Unsupported for...in binding.", left)
@@ -898,12 +871,10 @@ class Frame<R> {
 
       for (const key of keys) {
         const result = yield* Effect.gen(function* () {
-          if (declared?.lexical) {
+          if (declared) {
             self.scopes.push()
-            self.predeclarePattern(declared.pattern, declared.mutable, left)
-            yield* self.declarePattern(declared.pattern, key, declared.mutable, left, true)
-          } else if (declared) {
-            yield* self.assignPattern(declared.pattern, key, left)
+            if (declared.lexical) self.predeclarePattern(declared.pattern, declared.mutable, left)
+            yield* self.declarePattern(declared.pattern, key, declared.mutable, left, declared.lexical)
           } else if (assignmentName) {
             self.scopes.set(assignmentName, key, left)
           }
@@ -911,13 +882,24 @@ class Frame<R> {
         }).pipe(
           Effect.ensuring(
             Effect.sync(() => {
-              if (declared?.lexical) self.scopes.pop()
+              if (declared) self.scopes.pop()
             }),
           ),
         )
 
-        const exit = loopExit(result, labels)
-        if (exit !== undefined) return exit
+        if (result.kind === "return") {
+          return result
+        }
+
+        if (result.kind === "break") {
+          if (result.label !== undefined && !labels?.has(result.label)) return result
+          return { kind: "none" } satisfies StatementResult
+        }
+
+        if (result.kind === "continue") {
+          if (result.label !== undefined && !labels?.has(result.label)) return result
+          continue
+        }
       }
 
       return { kind: "none" } satisfies StatementResult
@@ -1018,13 +1000,8 @@ class Frame<R> {
         }
 
         const init = declaration.init
-        // `var x` alone is a no-op: the binding was hoisted on function entry.
-        if (kind === "var") {
-          if (init) yield* self.assignPattern(declaration.id, yield* self.evaluateExpression(init), declaration)
-          continue
-        }
         const value = init ? yield* self.evaluateExpression(init) : undefined
-        yield* self.declarePattern(declaration.id, value, kind !== "const", declaration, true)
+        yield* self.declarePattern(declaration.id, value, kind !== "const", declaration, kind !== "var")
       }
     })
   }
@@ -1645,8 +1622,6 @@ class Frame<R> {
       }
 
       if (fn.body.type === "BlockStatement") {
-        invocation.scopes.push()
-        invocation.hoistVars(fn.body.body, paramScope)
         const result = yield* invocation.evaluateStatement(fn.body)
         return result.kind === "return" ? result.value : undefined
       }
@@ -1655,8 +1630,16 @@ class Frame<R> {
     })
     if (fn.generator) return Effect.succeed(this.createGenerator(invocation, run, fn.async))
     if (!fn.async) return run
-    return this.runtime.promises.createWithSelf((self) =>
-      Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, fn.body, self)),
+    // The initial yield assigns the promise before the body can self-resolve.
+    const box: { promise?: Values.Promise } = {}
+    return Effect.map(
+      this.createPromise(
+        Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, fn.body, box)),
+      ),
+      (promise) => {
+        box.promise = promise
+        return promise
+      },
     )
   }
 
@@ -1911,10 +1894,16 @@ class Frame<R> {
       for (const property of node.properties) {
         if (property.type === "SpreadElement") {
           const spread = yield* self.evaluateExpression(property.argument)
-          if (spread === null || spread === undefined) continue
-          const from = enumerableSource("Object spread", spread, property)
-          for (const [key, value] of Object.entries(from)) objectValue[key] = value
-          if (typeof from === "object") copyIteratorSymbols(from, objectValue)
+          if (spread === null || spread === undefined || Values.isValue(spread)) continue
+          if (typeof spread !== "object" || Array.isArray(spread) || isRuntimeReference(spread)) {
+            throw new InterpreterRuntimeError(
+              `Object spread requires a data object, received ${describeValue(spread)}.`,
+              property,
+              "InvalidDataValue",
+            )
+          }
+          for (const [key, value] of Object.entries(spread)) objectValue[key] = value
+          copyIteratorSymbols(spread, objectValue)
           continue
         }
 
@@ -2013,7 +2002,7 @@ class Frame<R> {
 
   private getMemberReference(
     node: MemberExpression,
-    operation: "read" | "write" | "delete" = "read",
+    operation: "read" | "delete" = "read",
   ): Effect.Effect<
     | MemberReference
     | ToolReference
@@ -2054,12 +2043,6 @@ class Frame<R> {
         return new ComputedValue(objectValue.member(key, propertyNode))
       }
 
-      // Values have no prototype chain, so `.constructor` resolves to the owning built-in directly.
-      if (operation === "read" && key === "constructor" && !hasOwn(objectValue, key)) {
-        const name = constructorName(objectValue)
-        if (name !== undefined) return new ComputedValue(self.runtime.builtins.get(name))
-      }
-
       if (typeof objectValue === "string") {
         if (key === "length") return new ComputedValue(objectValue.length)
         const index = typeof key === "symbol" ? undefined : parseArrayIndex(key)
@@ -2215,7 +2198,7 @@ class Frame<R> {
   ): Effect.Effect<unknown, unknown, R> {
     const self = this
     return Effect.gen(function* () {
-      const reference = yield* self.getMemberReference(node, "write")
+      const reference = yield* self.getMemberReference(node)
       if (
         reference === OptionalShortCircuit ||
         reference instanceof ComputedValue ||

packages/codemode/src/stdlib/date.ts

@@ -29,8 +29,6 @@ export const dateMethods = new Set([
   "toISOString",
   "toJSON",
   "toString",
-  "toDateString",
-  "toTimeString",
   "toUTCString",
   "toGMTString",
   "getFullYear",
@@ -105,10 +103,6 @@ export const invokeDateMethod = (
       return Number.isFinite(value.time) ? hosted.toISOString() : null
     case "toString":
       return coerceToString(value)
-    case "toDateString":
-      return hosted.toDateString()
-    case "toTimeString":
-      return hosted.toTimeString()
     case "toUTCString":
     case "toGMTString":
       return hosted.toUTCString()

packages/codemode/src/stdlib/object.ts

@@ -5,8 +5,6 @@ import { type AstNode, AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSym
 import {
   containsOpaqueReference,
   describeValue,
-  isRuntimeReference,
-  parseArrayIndex,
   rejectCircularInsertion,
   typeofValue,
 } from "../interpreter/references.js"
@@ -16,53 +14,28 @@ import { Values } from "../values.js"
 import { groupBy } from "./collections.js"
 import { coerceToString } from "./value.js"
 
-// ToObject for enumeration. Strings return themselves: the host's Object.keys/entries/hasOwn index a
-// primitive string directly. Numbers, booleans, wrappers, and functions have no own enumerable keys.
-export const enumerableSource = (label: string, value: unknown, node: AstNode): Record<string, unknown> => {
-  if (value === null || value === undefined) {
-    throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node).as(
-      "TypeError",
-    )
-  }
-  if (value instanceof Values.Promise) {
+const requireObject = (name: string, input: unknown, node: AstNode): Record<string, unknown> => {
+  if (Array.isArray(input)) return input as unknown as Record<string, unknown>
+  if (Values.isValue(input)) return {}
+  const prototype = input === null || typeof input !== "object" ? undefined : Object.getPrototypeOf(input)
+  if (prototype !== null && prototype !== Object.prototype) {
     throw new InterpreterRuntimeError(
-      `${label} received an un-awaited Promise; await it before inspecting the result.`,
+      `Object.${name} expects a data object or array, received ${describeValue(input)}.`,
       node,
       "InvalidDataValue",
     )
   }
-  if (value instanceof ToolReference) {
-    throw new InterpreterRuntimeError(
-      `${label} cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`,
-      node,
-      "InvalidDataValue",
-    )
-  }
-  if (typeof value === "string") return value as unknown as Record<string, unknown>
-  if (typeof value !== "object" || Values.isValue(value) || isRuntimeReference(value)) return {}
-  return value as Record<string, unknown>
+  return input as Record<string, unknown>
 }
 
 export const objectAssign = (args: Array<unknown>, node: AstNode): unknown => {
   const target = args[0]
-  // JS would box a primitive target; wrappers and primitives cannot hold fields here.
-  if (target === null || typeof target !== "object" || Values.isValue(target) || isRuntimeReference(target)) {
-    throw new InterpreterRuntimeError(
-      `Object.assign expects a data object or array target, received ${describeValue(target)}.`,
-      node,
-    ).as("TypeError")
+  if (target === null || typeof target !== "object" || Array.isArray(target) || Values.isValue(target)) {
+    throw new InterpreterRuntimeError("Object.assign expects a data object target.", node)
   }
   const out = target as Record<string, unknown>
   const seen = new Set<object>()
   const guardedSet = (key: PropertyKey, item: unknown): void => {
-    // Arrays hold only indexed elements, as with direct assignment; Reflect.set would otherwise
-    // reach Array's length and Object.prototype's __proto__ setter.
-    if (Array.isArray(out) && (typeof key === "symbol" || parseArrayIndex(key) === undefined)) {
-      throw new InterpreterRuntimeError(
-        `Object.assign cannot assign '${String(key)}' to an array: only array indexes may be assigned.`,
-        node,
-      ).as("TypeError")
-    }
     rejectCircularInsertion(out, item, "Object.assign result", node, seen)
     if (!Reflect.set(out, key, item))
       throw new InterpreterRuntimeError(`Object.assign could not assign property '${String(key)}'.`, node).as(
@@ -70,15 +43,18 @@ export const objectAssign = (args: Array<unknown>, node: AstNode): unknown => {
       )
   }
   for (const source of args.slice(1)) {
-    if (source === null || source === undefined) continue
-    const from = enumerableSource("Object.assign(...)", source, node)
-    if (typeof from !== "object") {
-      for (const [key, item] of Object.entries(from)) guardedSet(key, item)
-      continue
+    if (source === null || source === undefined || Values.isValue(source)) continue
+    if (typeof source !== "object" || Array.isArray(source)) {
+      throw new InterpreterRuntimeError("Object.assign expects data objects.", node)
     }
-    for (const key of Reflect.ownKeys(from)) {
-      if (typeof key === "symbol" && key !== AsyncIteratorSymbol && key !== IteratorSymbol) continue
-      if (Object.prototype.propertyIsEnumerable.call(from, key)) guardedSet(key, Reflect.get(from, key))
+    for (const key of Reflect.ownKeys(source)) {
+      if (typeof key === "string") {
+        if (Object.prototype.propertyIsEnumerable.call(source, key)) guardedSet(key, Reflect.get(source, key))
+        continue
+      }
+      if (key !== AsyncIteratorSymbol && key !== IteratorSymbol) continue
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue
+      guardedSet(key, Reflect.get(source, key))
     }
   }
   return out
@@ -134,6 +110,22 @@ const constructObject = (args: Array<unknown>, node: AstNode): unknown => {
   )
 }
 
+// Tool references are not data; only Object.keys(tools) reads them, for tool names.
+const rejectTools = (name: string, args: Array<unknown>, node: AstNode): void => {
+  if (!(args[0] instanceof ToolReference)) return
+  throw new InterpreterRuntimeError(
+    `Object.${name}(...) cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`,
+    node,
+    "InvalidDataValue",
+  )
+}
+
+const objectStatic = (name: string, impl: (args: Array<unknown>, node: AstNode) => unknown) =>
+  sync(`Object.${name}`, (args, node) => {
+    rejectTools(name, args, node)
+    return impl(args, node)
+  })
+
 // Object constructs identically with or without new, like JS. Only `keys` copies its result into the
 // program; `values`, `entries`, `assign`, and `fromEntries` hand back the program's own values.
 export const objectGlobal = <R>(runner: Runner<R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>) =>
@@ -147,32 +139,34 @@ export const objectGlobal = <R>(runner: Runner<R>, toolKeys: (path: ReadonlyArra
         toProgram(
           args[0] instanceof ToolReference
             ? [...toolKeys(args[0].path)]
-            : Object.keys(enumerableSource("Object.keys(...)", args[0], node)),
+            : Object.keys(requireObject("keys", args[0], node)),
           "Object.keys result",
         ),
       ),
-      values: sync("Object.values", (args, node) =>
-        Object.values(enumerableSource("Object.values(...)", args[0], node)),
+      values: objectStatic("values", (args, node) => Object.values(requireObject("values", args[0], node))),
+      entries: objectStatic("entries", (args, node) =>
+        Object.entries(requireObject("entries", args[0], node)).map(([key, item]) => [key, item]),
       ),
-      entries: sync("Object.entries", (args, node) =>
-        Object.entries(enumerableSource("Object.entries(...)", args[0], node)).map(([key, item]) => [key, item]),
-      ),
-      hasOwn: sync("Object.hasOwn", (args, node) =>
+      hasOwn: objectStatic("hasOwn", (args, node) =>
         Object.hasOwn(
-          enumerableSource("Object.hasOwn(...)", args[0], node),
+          requireObject("hasOwn", args[0], node),
           args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]),
         ),
       ),
-      is: sync("Object.is", (args, node) => {
+      is: objectStatic("is", (args, node) => {
         if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
           throw new InterpreterRuntimeError("Object.is requires data values.", node, "InvalidDataValue")
         }
         return Object.is(args[0], args[1])
       }),
-      assign: sync("Object.assign", objectAssign),
+      assign: objectStatic("assign", objectAssign),
       fromEntries: new HostFunction<R>({
         name: "Object.fromEntries",
-        call: (args, node) => Effect.suspend(() => objectFromEntries(runner, args[0], node)),
+        call: (args, node) =>
+          Effect.suspend(() => {
+            rejectTools("fromEntries", args, node)
+            return objectFromEntries(runner, args[0], node)
+          }),
       }),
       groupBy: groupBy(runner, "Object"),
     },

packages/codemode/src/stdlib/string.ts

@@ -8,12 +8,9 @@ export const stringMethods = new Set([
   "trim",
   "trimStart",
   "trimEnd",
-  "trimLeft",
-  "trimRight",
   "split",
   "slice",
   "substring",
-  "substr",
   "includes",
   "startsWith",
   "endsWith",
@@ -35,8 +32,6 @@ export const stringMethods = new Set([
   "search",
   "localeCompare",
   "normalize",
-  "isWellFormed",
-  "toWellFormed",
 ])
 
 const codeUnits = (name: string, op: (...codes: Array<number>) => string) =>

packages/codemode/src/stdlib/web.ts

@@ -1,23 +0,0 @@
-import { HostNamespace, sync } from "../interpreter/host.js"
-import { InterpreterRuntimeError } from "../interpreter/model.js"
-import { coerceToString } from "./value.js"
-
-// WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies.
-const base64 = (name: "atob" | "btoa") =>
-  sync(name, (args, node) => {
-    if (args.length === 0)
-      throw new InterpreterRuntimeError(`${name} requires 1 argument (a string)`, node).as("TypeError")
-    const input = coerceToString(args[0])
-    try {
-      return name === "atob" ? atob(input) : btoa(input)
-    } catch {
-      throw new InterpreterRuntimeError("The string contains invalid characters.", node).as("InvalidCharacterError")
-    }
-  })
-
-export const atobGlobal = base64("atob")
-export const btoaGlobal = base64("btoa")
-
-export const cryptoGlobal = new HostNamespace("crypto", {
-  randomUUID: sync("crypto.randomUUID", () => crypto.randomUUID()),
-})

packages/codemode/test/LICENSE.wpt

@@ -1,11 +0,0 @@
-# The 3-Clause BSD License
-
-Copyright © web-platform-tests contributors
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

packages/codemode/test/codemode.test.ts

@@ -528,7 +528,7 @@ describe("CodeMode schema flexibility", () => {
     })
     const runtime = CodeMode.make({ tools: { adapter: { call } } })
 
-    expect(runtime.catalog).toStrictEqual([
+    expect(runtime.catalog()).toStrictEqual([
       {
         path: "adapter.call",
         description: "Call an adapter-described tool",
@@ -611,7 +611,7 @@ describe("CodeMode schema flexibility", () => {
     })
     const runtime = CodeMode.make({ tools: { users: { lookup } } })
 
-    expect(runtime.catalog).toStrictEqual([
+    expect(runtime.catalog()).toStrictEqual([
       {
         path: "users.lookup",
         description: "Look up a user",
@@ -631,7 +631,7 @@ describe("CodeMode schema flexibility", () => {
       execute: () => Effect.succeed("pong"),
     })
     const runtime = CodeMode.make({ tools: { net: { ping } } })
-    expect(runtime.catalog[0]?.signature).toBe("tools.net.ping(input: {\n  host: string,\n}): Promise<void>")
+    expect(runtime.catalog()[0]?.signature).toBe("tools.net.ping(input: {\n  host: string,\n}): Promise<void>")
 
     const result = await Effect.runPromise(runtime.execute(`return await tools.net.ping({ host: "example.test" })`))
     expect(result.ok).toBe(true)
@@ -684,7 +684,7 @@ describe("CodeMode public contract", () => {
 
   test("describes the catalog and keeps the search built-in registered", async () => {
     const runtime = CodeMode.make({ tools })
-    expect(runtime.catalog).toStrictEqual([
+    expect(runtime.catalog()).toStrictEqual([
       {
         path: "orders.lookup",
         description: "Look up an order by ID",
@@ -726,8 +726,8 @@ describe("CodeMode public contract", () => {
     const first = CodeMode.make({ tools: { zeta: { zeta, alpha }, alpha: { zeta, alpha } } })
     const second = CodeMode.make({ tools: { alpha: { alpha, zeta }, zeta: { alpha, zeta } } })
 
-    expect(first.catalog).toStrictEqual(second.catalog)
-    expect(first.catalog.map((tool) => tool.path)).toEqual(["alpha.alpha", "alpha.zeta", "zeta.alpha", "zeta.zeta"])
+    expect(first.catalog()).toStrictEqual(second.catalog())
+    expect(first.catalog().map((tool) => tool.path)).toEqual(["alpha.alpha", "alpha.zeta", "zeta.alpha", "zeta.zeta"])
   })
 
   test("renders bracket notation for tool names that are not JavaScript identifiers", async () => {
@@ -739,7 +739,7 @@ describe("CodeMode public contract", () => {
     })
     const runtime = CodeMode.make({ tools: { context7: { "resolve-library-id": resolveLibrary } } })
 
-    expect(runtime.catalog).toStrictEqual([
+    expect(runtime.catalog()).toStrictEqual([
       {
         path: "context7.resolve-library-id",
         description: "Resolve a library ID",

packages/codemode/test/constructor-test262.test.ts

@@ -1,66 +0,0 @@
-/**
- * Portions adapted from Test262 at revision 250f204f23a9249ff204be2baec29600faae7b75:
- * - test/built-ins/RegExp/S15.10.7_A3_T1.js
- * - test/built-ins/RegExp/S15.10.7_A3_T2.js
- * - test/built-ins/Object/S15.2.2.1_A1_T1.js
- *
- * Copyright 2009 the Sputnik authors. All rights reserved.
- * Test262 portions are governed by the BSD license in LICENSE.test262.
- *
- * Only the instance-side assertions are ported. Test262 otherwise reaches `constructor` through
- * `X.prototype.constructor`, boxed primitives (`new Object(1)`), `Function`, `isPrototypeOf`, or
- * `.call`, none of which CodeMode exposes: values have no prototype chain, so `x.constructor`
- * resolves directly to the owning built-in.
- */
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { CodeMode } from "../src/index.js"
-
-const value = async (code: string) => {
-  const result = await Effect.runPromise(CodeMode.execute({ code, tools: {} }))
-  if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
-  return result.value
-}
-
-describe("constructor Test262 parity", () => {
-  test("test/built-ins/RegExp/S15.10.7_A3_T1.js", async () => {
-    expect(
-      await value(`
-        const __re = /[^a]*/
-        return [typeof __re, __re.constructor === RegExp, __re instanceof RegExp]
-      `),
-    ).toEqual(["object", true, true])
-  })
-
-  test("test/built-ins/RegExp/S15.10.7_A3_T2.js", async () => {
-    expect(
-      await value(`
-        const __re = new RegExp()
-        return [typeof __re, __re.constructor === RegExp, __re instanceof RegExp]
-      `),
-    ).toEqual(["object", true, true])
-  })
-
-  test("test/built-ins/Object/S15.2.2.1_A1_T1.js", async () => {
-    expect(
-      await value(`
-        const obj = new Object()
-        return [obj !== undefined, obj.constructor === Object]
-      `),
-    ).toEqual([true, true])
-  })
-
-  test("every built-in reports itself for its own values", async () => {
-    expect(
-      await value(`
-        return [
-          [].constructor === Array, "".constructor === String, (1).constructor === Number, true.constructor === Boolean,
-          new Date(0).constructor === Date, new Map().constructor === Map, new Set().constructor === Set,
-          new URL("https://a.b/").constructor === URL, new URLSearchParams("a=1").constructor === URLSearchParams,
-          Promise.resolve(1).constructor === Promise, new TypeError("x").constructor === TypeError,
-          new RangeError("x").constructor === RangeError, new AggregateError([]).constructor === AggregateError,
-        ]
-      `),
-    ).toEqual(Array(13).fill(true))
-  })
-})

packages/codemode/test/enumeration.test.ts

@@ -85,16 +85,18 @@ describe("Object.keys over arrays", () => {
     expect(await value(`return Object.keys({ a: 1, b: 2 })`)).toEqual(["a", "b"])
   })
 
-  test("non-object inputs follow ToObject, and nullish inputs name what was received", async () => {
-    expect(
-      await value(`return [Object.keys("ab"), Object.entries(42), Object.keys(() => 1), Object.keys(true)]`),
-    ).toEqual([["0", "1"], [], [], []])
-    expect(await value(`try { Object.values(null) } catch (e) { return [e.name, e.message] }`)).toEqual([
-      "TypeError",
-      "Object.values(...) cannot convert null to an object.",
-    ])
+  test("non-object inputs name what was received", async () => {
+    expect((await error(`return Object.keys("nope")`)).message).toContain(
+      "Object.keys expects a data object or array, received a string.",
+    )
+    expect((await error(`return Object.entries(42)`)).message).toContain("received a number.")
+    expect((await error(`return Object.values(null)`)).message).toContain("received null.")
     expect((await error(`return Object.keys(tools.github.list_issues({ value: "x" }))`)).message).toContain(
-      "received an un-awaited Promise",
+      "received an un-awaited Promise.",
+    )
+    expect((await error(`return Object.entries(() => 1)`)).message).toContain("received a function.")
+    expect((await error(`return { ...[1] }`)).message).toContain(
+      "Object spread requires a data object, received an array.",
     )
     expect((await error(`const { a } = new Map(); return a`)).message).toContain("received a Map.")
     expect((await error(`return Array.from(7)`)).message).toContain("received a number.")
@@ -159,21 +161,11 @@ describe("for...in", () => {
     ).toEqual(["github.list_issues", "github.get_issue", "memory.search", "playwright.navigate"])
   })
 
-  test("non-object values enumerate like JS: strings by index, everything else nothing", async () => {
-    expect(
-      await value(`
-        const out = []
-        for (const key in "ab") out.push(key)
-        for (const key in 42) out.push(key)
-        for (const key in null) out.push(key)
-        for (const key in undefined) out.push(key)
-        for (const key in new Map([[1, 2]])) out.push(key)
-        for (const key in Math) out.push(key)
-        return out
-      `),
-    ).toEqual(["0", "1"])
-    expect((await error(`for (const key in tools.github.list_issues({ value: "x" })) {}`)).message).toContain(
-      "un-awaited Promise",
-    )
+  test("unsupported values fail with a hint at for...of and Object.keys", async () => {
+    for (const expression of [`"text"`, "new Map([[1, 2]])", "new Set([1])", "42", "null"]) {
+      const failure = await error(`for (const key in ${expression}) {}; return "no"`)
+      expect(failure.message).toContain("for...in requires a plain object, array, or tools reference")
+      expect(failure.message).toContain("Use for...of for arrays/strings/Maps/Sets, or Object.keys(value)")
+    }
   })
 })

packages/codemode/test/fixtures/wpt-base64.json

@@ -1,82 +0,0 @@
-[
-  ["", []],
-  ["abcd", [105, 183, 29]],
-  [" abcd", [105, 183, 29]],
-  ["abcd ", [105, 183, 29]],
-  [" abcd===", null],
-  ["abcd=== ", null],
-  ["abcd ===", null],
-  ["a", null],
-  ["ab", [105]],
-  ["abc", [105, 183]],
-  ["abcde", null],
-  ["𐀀", null],
-  ["=", null],
-  ["==", null],
-  ["===", null],
-  ["====", null],
-  ["=====", null],
-  ["a=", null],
-  ["a==", null],
-  ["a===", null],
-  ["a====", null],
-  ["a=====", null],
-  ["ab=", null],
-  ["ab==", [105]],
-  ["ab===", null],
-  ["ab====", null],
-  ["ab=====", null],
-  ["abc=", [105, 183]],
-  ["abc==", null],
-  ["abc===", null],
-  ["abc====", null],
-  ["abc=====", null],
-  ["abcd=", null],
-  ["abcd==", null],
-  ["abcd===", null],
-  ["abcd====", null],
-  ["abcd=====", null],
-  ["abcde=", null],
-  ["abcde==", null],
-  ["abcde===", null],
-  ["abcde====", null],
-  ["abcde=====", null],
-  ["=a", null],
-  ["=a=", null],
-  ["a=b", null],
-  ["a=b=", null],
-  ["ab=c", null],
-  ["ab=c=", null],
-  ["abc=d", null],
-  ["abc=d=", null],
-  ["ab\u000Bcd", null],
-  ["ab\u3000cd", null],
-  ["ab\u3001cd", null],
-  ["ab\tcd", [105, 183, 29]],
-  ["ab\ncd", [105, 183, 29]],
-  ["ab\fcd", [105, 183, 29]],
-  ["ab\rcd", [105, 183, 29]],
-  ["ab cd", [105, 183, 29]],
-  ["ab\u00a0cd", null],
-  ["ab\t\n\f\r cd", [105, 183, 29]],
-  [" \t\n\f\r ab\t\n\f\r cd\t\n\f\r ", [105, 183, 29]],
-  ["ab\t\n\f\r =\t\n\f\r =\t\n\f\r ", [105]],
-  ["A", null],
-  ["/A", [252]],
-  ["//A", [255, 240]],
-  ["///A", [255, 255, 192]],
-  ["////A", null],
-  ["/", null],
-  ["A/", [3]],
-  ["AA/", [0, 15]],
-  ["AAAA/", null],
-  ["AAA/", [0, 0, 63]],
-  ["\u0000nonsense", null],
-  ["abcd\u0000nonsense", null],
-  ["YQ", [97]],
-  ["YR", [97]],
-  ["~~", null],
-  ["..", null],
-  ["--", null],
-  ["__", null]
-]

packages/codemode/test/object-coercion-test262.test.ts

@@ -1,217 +0,0 @@
-/**
- * Portions adapted from Test262 at revision 250f204f23a9249ff204be2baec29600faae7b75:
- * - test/built-ins/Object/keys/15.2.3.14-1-1.js
- * - test/built-ins/Object/keys/15.2.3.14-1-2.js
- * - test/built-ins/Object/keys/15.2.3.14-1-3.js
- * - test/built-ins/Object/keys/15.2.3.14-1-4.js
- * - test/built-ins/Object/keys/15.2.3.14-1-5.js
- * - test/built-ins/Object/entries/primitive-strings.js
- * - test/built-ins/Object/entries/primitive-numbers.js
- * - test/built-ins/Object/entries/primitive-booleans.js
- * - test/built-ins/Object/values/primitive-strings.js
- * - test/built-ins/Object/values/primitive-numbers.js
- * - test/built-ins/Object/values/primitive-booleans.js
- * - test/built-ins/Object/hasOwn/toobject_null.js
- * - test/built-ins/Object/hasOwn/toobject_undefined.js
- * - test/built-ins/Object/hasOwn/hasown_nonexistent.js
- * - test/built-ins/Object/assign/Source-String.js
- * - test/built-ins/Object/assign/Source-Null-Undefined.js
- * - test/built-ins/Object/assign/target-Array.js
- * - test/built-ins/Object/assign/Target-Null.js
- * - test/built-ins/Object/assign/Target-Undefined.js
- * - test/built-ins/Object/assign/Target-Object.js
- * - test/built-ins/Object/assign/Override.js
- * - test/built-ins/Object/assign/ObjectOverride-sameproperty.js
- *
- * Copyright (c) 2012 Ecma International. All rights reserved.
- * Copyright (C) 2015 Jordan Harband. All rights reserved.
- * Copyright 2015 Microsoft Corporation. All rights reserved.
- * Copyright 2021 Jamie Kyle. All rights reserved.
- * Test262 portions are governed by the BSD license in LICENSE.test262.
- *
- * Boxed-primitive cases (`Object.assign("a")`, `Object.assign(1, …)`) are omitted: CodeMode has no
- * wrapper objects, so a primitive target is a TypeError rather than a boxed result. `Override.js`
- * checks `Object.keys(result).length` instead of `Object.getOwnPropertyNames`. `target-Array.js`
- * omits its named-key (`-0`, `1.5`, `4294967295`), `length`, and Proxy assertions: arrays here hold
- * only indexed elements, so those keys are a TypeError (pinned below) rather than array properties.
- */
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { CodeMode } from "../src/index.js"
-
-const value = async (code: string) => {
-  const result = await Effect.runPromise(CodeMode.execute({ code, tools: {} }))
-  if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
-  return result.value
-}
-
-const throwsTypeError = (expression: string) =>
-  value(`try { ${expression}; return "no throw" } catch (error) { return error.name }`)
-
-describe("Object.keys Test262 parity", () => {
-  test("test/built-ins/Object/keys/15.2.3.14-1-{1,2,3}.js: primitives are coerced", async () => {
-    expect(await value(`return [Object.keys(0), Object.keys(true), Object.keys("abc")]`)).toEqual([
-      [],
-      [],
-      ["0", "1", "2"],
-    ])
-  })
-
-  test("test/built-ins/Object/keys/15.2.3.14-1-{4,5}.js: null and undefined throw TypeError", async () => {
-    expect(await throwsTypeError(`Object.keys(null)`)).toBe("TypeError")
-    expect(await throwsTypeError(`Object.keys(undefined)`)).toBe("TypeError")
-  })
-})
-
-describe("Object.entries and Object.values Test262 parity", () => {
-  test("test/built-ins/Object/entries/primitive-strings.js", async () => {
-    expect(
-      await value(`
-        const result = Object.entries('abc')
-        return [Array.isArray(result), result.length, result[0][0], result[0][1], result[1][0], result[1][1], result[2][0], result[2][1]]
-      `),
-    ).toEqual([true, 3, "0", "a", "1", "b", "2", "c"])
-  })
-
-  test("test/built-ins/Object/entries/primitive-numbers.js", async () => {
-    expect(
-      await value(`
-        return [0, -0, Infinity, -Infinity, NaN, Math.PI].map((number) => Object.entries(number).length)
-      `),
-    ).toEqual([0, 0, 0, 0, 0, 0])
-  })
-
-  test("test/built-ins/Object/entries/primitive-booleans.js", async () => {
-    expect(
-      await value(`
-        const trueResult = Object.entries(true)
-        const falseResult = Object.entries(false)
-        return [Array.isArray(trueResult), trueResult.length, Array.isArray(falseResult), falseResult.length]
-      `),
-    ).toEqual([true, 0, true, 0])
-  })
-
-  test("test/built-ins/Object/values/primitive-strings.js", async () => {
-    expect(
-      await value(`
-        const result = Object.values('abc')
-        return [Array.isArray(result), result.length, result[0], result[1], result[2]]
-      `),
-    ).toEqual([true, 3, "a", "b", "c"])
-  })
-
-  test("test/built-ins/Object/values/primitive-numbers.js", async () => {
-    expect(
-      await value(`
-        return [0, -0, Infinity, -Infinity, NaN, Math.PI].map((number) => Object.values(number).length)
-      `),
-    ).toEqual([0, 0, 0, 0, 0, 0])
-  })
-
-  test("test/built-ins/Object/values/primitive-booleans.js", async () => {
-    expect(
-      await value(`
-        const trueResult = Object.values(true)
-        const falseResult = Object.values(false)
-        return [Array.isArray(trueResult), trueResult.length, Array.isArray(falseResult), falseResult.length]
-      `),
-    ).toEqual([true, 0, true, 0])
-  })
-})
-
-describe("Object.hasOwn Test262 parity", () => {
-  test("test/built-ins/Object/hasOwn/toobject_{null,undefined}.js", async () => {
-    expect(await throwsTypeError(`Object.hasOwn(null, 'foo')`)).toBe("TypeError")
-    expect(await throwsTypeError(`Object.hasOwn(undefined, 'foo')`)).toBe("TypeError")
-  })
-
-  test("test/built-ins/Object/hasOwn/hasown_nonexistent.js", async () => {
-    expect(await value(`const o = {}; return Object.hasOwn(o, "foo")`)).toBe(false)
-  })
-})
-
-describe("Object.assign Test262 parity", () => {
-  test("test/built-ins/Object/assign/Source-String.js", async () => {
-    expect(
-      await value(`
-        const target = new Object()
-        const result = Object.assign(target, "123")
-        return [result[0], result[1], result[2]]
-      `),
-    ).toEqual(["1", "2", "3"])
-  })
-
-  test("test/built-ins/Object/assign/Source-Null-Undefined.js", async () => {
-    expect(
-      await value(`
-        const target = new Object()
-        const result = Object.assign(target, undefined, null)
-        return result === target
-      `),
-    ).toBe(true)
-  })
-
-  test("test/built-ins/Object/assign/target-Array.js", async () => {
-    expect(
-      await value(`
-        const target = [7, 8, 9]
-        let result = Object.assign(target, [1])
-        const first = [result === target, [...result]]
-        const sparseArraySource = []
-        sparseArraySource[2] = 3
-        result = Object.assign(target, sparseArraySource)
-        const second = [result === target, [...result]]
-        result = Object.assign(target, { 4: 0 })
-        return [...first, ...second, result === target, result.length, result[3] === undefined, result[4]]
-      `),
-    ).toEqual([true, [1, 8, 9], true, [1, 8, 3], true, 5, true, 0])
-  })
-
-  test("array targets accept only array indexes (deviation from target-Array.js)", async () => {
-    expect(
-      await value(`
-        const target = [7]
-        const out = []
-        for (const source of [{ length: 0 }, { x: 1 }, { "1.5": 1 }, { "-0": 1 }, { ["__proto__"]: null }]) {
-          try { Object.assign(target, source) } catch (error) { out.push(error.name) }
-        }
-        return [out, [...target], target.length, Object.keys(target)]
-      `),
-    ).toEqual([["TypeError", "TypeError", "TypeError", "TypeError", "TypeError"], [7], 1, ["0"]])
-  })
-
-  test("test/built-ins/Object/assign/Target-{Null,Undefined}.js", async () => {
-    expect(await throwsTypeError(`Object.assign(null, { a: 1 })`)).toBe("TypeError")
-    expect(await throwsTypeError(`Object.assign(undefined, { a: 1 })`)).toBe("TypeError")
-  })
-
-  test("test/built-ins/Object/assign/Target-Object.js", async () => {
-    expect(
-      await value(`
-        const target = { foo: 1 }
-        const result = Object.assign(target, { a: 2 })
-        return [result.foo, result.a]
-      `),
-    ).toEqual([1, 2])
-  })
-
-  test("test/built-ins/Object/assign/Override.js", async () => {
-    expect(
-      await value(`
-        const target = { a: 1 }
-        const result = Object.assign(target, "1a2c3", { a: "c" }, undefined, { b: 6 }, null, 125, { a: 5 })
-        return [Object.keys(result).length, result.a, result[0], result[1], result[2], result[3], result[4], result.b]
-      `),
-    ).toEqual([7, 5, "1", "a", "2", "c", "3", 6])
-  })
-
-  test("test/built-ins/Object/assign/ObjectOverride-sameproperty.js", async () => {
-    expect(
-      await value(`
-        const target = { a: 1 }
-        const result = Object.assign(target, { a: 2 }, { a: "c" })
-        return result.a
-      `),
-    ).toBe("c")
-  })
-})

packages/codemode/test/parity.test.ts

@@ -118,12 +118,9 @@ describe("H6: object spread of null/undefined is a no-op", () => {
     expect(await value(`const o = { a: 1 }; return { ...o, b: 2 }`)).toEqual({ a: 1, b: 2 })
   })
 
-  test("spreading an array or string into an object copies index keys, like JS", async () => {
-    expect(await value(`return { ...[1,2], a: 1 }`)).toEqual({ 0: 1, 1: 2, a: 1 })
-    expect(await value(`return { ..."ab", ...5, ...true, ...(() => 1), ...new Map([[1, 2]]) }`)).toEqual({
-      0: "a",
-      1: "b",
-    })
+  test("spreading an array into an object still errors", async () => {
+    const err = await error(`return { ...[1,2], a: 1 }`)
+    expect(err.kind).toBe("InvalidDataValue")
   })
 })
 
@@ -491,8 +488,12 @@ describe("CodeMode-specific string behavior", () => {
     expect(await value(`try { "x".normalize("nope"); return "no" } catch (e) { return e.message }`)).toContain('"NFC"')
   })
 
-  test("exposes the Annex B string aliases every engine ships", async () => {
-    expect(await value(`return [" x ".trimLeft(), " x ".trimRight(), "abc".substr(1, 1)]`)).toEqual(["x ", " x", "b"])
+  test("does not expose obsolete string aliases", async () => {
+    expect(await value(`return [typeof "x".trimLeft, typeof "x".trimRight, typeof "x".substr]`)).toEqual([
+      "undefined",
+      "undefined",
+      "undefined",
+    ])
   })
 })
 

packages/codemode/test/signature.test.ts

@@ -740,7 +740,7 @@ describe("JSDoc signatures in catalogs and search results", () => {
       "}",
     ].join("\n")
     const signature = `tools.constrained(input: ${type}): Promise<${type}>`
-    expect(runtime.catalog[0]?.signature).toBe(signature)
+    expect(runtime.catalog()[0]?.signature).toBe(signature)
     const result = await Effect.runPromise(runtime.execute('return search({ query: "tools.constrained" })'))
     expect(result.ok).toBe(true)
     if (!result.ok) throw new Error("search failed")
@@ -796,7 +796,7 @@ describe("JSDoc signatures in catalogs and search results", () => {
   })
 
   test("the catalog uses the same JSDoc signatures as search", async () => {
-    const catalog = runtime.catalog
+    const catalog = runtime.catalog()
     const github = (await search("list issues repository")).items.find(
       ({ path }) => path === "tools.github.list_issues",
     )!
@@ -824,7 +824,7 @@ describe("non-identifier tool paths", () => {
   const runtime = CodeMode.make({ tools: { context7: { "resolve-library-id": resolveLibrary } } })
 
   test("catalog signatures use bracket notation for dashed tool names", () => {
-    expect(runtime.catalog[0]?.signature).toBe(
+    expect(runtime.catalog()[0]?.signature).toBe(
       'tools.context7["resolve-library-id"](input: {\n  query: string,\n  libraryName: string,\n}): Promise<unknown>',
     )
   })

packages/codemode/test/stdlib.test.ts

@@ -722,17 +722,6 @@ describe("Set", () => {
 })
 
 describe("stdlib integration", () => {
-  test("constructor follows own keys, shadowing, writes, and new", async () => {
-    expect(
-      await value(`return [JSON.parse('{"constructor":"Foo"}').constructor, ({ constructor: 1 }).constructor]`),
-    ).toEqual(["Foo", 1])
-    expect(await value(`const Array = 5; return [].constructor.isArray([])`)).toBe(true)
-    expect(await value(`const o = {}; o.constructor = 7; return o.constructor`)).toBe(7)
-    expect(await value(`return new ([].constructor)(3).length`)).toBe(3)
-    expect(await value(`return typeof ({}).constructor`)).toBe("function")
-    expect(await value(`return ({}).constructor.constructor`)).toBeNull()
-  })
-
   test("new dispatches on the constructor value, not its name", async () => {
     expect(await value(`const D = Date; return new D(0) instanceof Date`)).toBe(true)
     expect(await value(`const make = (C) => new C([["a", 1]]); return make(Map).get("a")`)).toBe(1)
@@ -1130,7 +1119,7 @@ describe("CodeMode values at intra-CodeMode checkpoints", () => {
     const diagnostic = await error(`return Object.keys(Promise.resolve({ a: 1 }))`)
     expect(diagnostic.kind).toBe("InvalidDataValue")
     expect(diagnostic.message).toContain("await")
-    expect(await value(`return Object.keys(Math)`)).toEqual([])
+    expect((await error(`return Object.keys(Math)`)).kind).toBe("InvalidDataValue")
   })
 
   test("Object.assign keeps Maps usable", async () => {

packages/codemode/test/string-date-methods-test262.test.ts

@@ -1,179 +0,0 @@
-/**
- * Portions adapted from Test262 at revision 250f204f23a9249ff204be2baec29600faae7b75:
- * - test/annexB/built-ins/String/prototype/substr/length-falsey.js
- * - test/annexB/built-ins/String/prototype/substr/length-negative.js
- * - test/annexB/built-ins/String/prototype/substr/length-positive.js
- * - test/annexB/built-ins/String/prototype/substr/length-undef.js
- * - test/annexB/built-ins/String/prototype/substr/start-negative.js
- * - test/annexB/built-ins/String/prototype/substr/surrogate-pairs.js
- * - test/built-ins/String/prototype/isWellFormed/returns-boolean.js
- * - test/built-ins/String/prototype/toWellFormed/returns-well-formed-string.js
- * - test/built-ins/Date/prototype/toDateString/format.js
- * - test/built-ins/Date/prototype/toDateString/invalid-date.js
- * - test/built-ins/Date/prototype/toDateString/negative-year.js
- * - test/built-ins/Date/prototype/toTimeString/format.js
- * - test/built-ins/Date/prototype/toTimeString/invalid-date.js
- *
- * Copyright (C) 2016, 2017 the V8 project authors. All rights reserved.
- * Copyright (C) 2018 Richard Gibson. All rights reserved.
- * Copyright (C) 2022 Jordan Harband. All rights reserved.
- * Test262 portions are governed by the BSD license in LICENSE.test262.
- *
- * The `typeof String.prototype.method` checks are replaced with `typeof "".method` because
- * CodeMode has no prototype objects.
- */
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { CodeMode } from "../src/index.js"
-
-const value = async (code: string) => {
-  const result = await Effect.runPromise(CodeMode.execute({ code, tools: {} }))
-  if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
-  return result.value
-}
-
-describe("String.prototype.substr Test262 parity", () => {
-  test("test/annexB/built-ins/String/prototype/substr/length-falsey.js", async () => {
-    expect(
-      await value(`
-        return [false, NaN, "", null].flatMap((length) => [0, 1, 2, 3].map((start) => "abc".substr(start, length)))
-      `),
-    ).toEqual(Array(16).fill(""))
-  })
-
-  test("test/annexB/built-ins/String/prototype/substr/length-negative.js", async () => {
-    expect(
-      await value(`
-        return [0, 1, 2, 3].flatMap((start) => [-1, -2, -3, -4].map((length) => "abc".substr(start, length)))
-      `),
-    ).toEqual(Array(16).fill(""))
-  })
-
-  test("test/annexB/built-ins/String/prototype/substr/length-positive.js", async () => {
-    expect(
-      await value(`
-        return [0, 1, 2, 3].map((start) => [1, 2, 3, 4].map((length) => "abc".substr(start, length)))
-      `),
-    ).toEqual([
-      ["a", "ab", "abc", "abc"],
-      ["b", "bc", "bc", "bc"],
-      ["c", "c", "c", "c"],
-      ["", "", "", ""],
-    ])
-  })
-
-  test("test/annexB/built-ins/String/prototype/substr/length-undef.js", async () => {
-    expect(
-      await value(`
-        return [
-          "abc".substr(0), "abc".substr(1), "abc".substr(2), "abc".substr(3),
-          "abc".substr(0, undefined), "abc".substr(1, undefined), "abc".substr(2, undefined), "abc".substr(3, undefined),
-        ]
-      `),
-    ).toEqual(["abc", "bc", "c", "", "abc", "bc", "c", ""])
-  })
-
-  test("test/annexB/built-ins/String/prototype/substr/start-negative.js", async () => {
-    expect(
-      await value(`
-        return ["abc".substr(-1), "abc".substr(-2), "abc".substr(-3), "abc".substr(-4), "abc".substr(-1.1)]
-      `),
-    ).toEqual(["c", "bc", "abc", "abc", "c"])
-  })
-
-  test("test/annexB/built-ins/String/prototype/substr/surrogate-pairs.js", async () => {
-    expect(
-      await value(`
-        const pair = "\\ud834\\udf06"
-        return [pair.substr(0), pair.substr(1), pair.substr(2), pair.substr(0, 0), pair.substr(0, 1), pair.substr(0, 2)]
-      `),
-    ).toEqual(["\ud834\udf06", "\udf06", "", "", "\ud834", "\ud834\udf06"])
-  })
-})
-
-describe("String well-formedness Test262 parity", () => {
-  test("test/built-ins/String/prototype/isWellFormed/returns-boolean.js", async () => {
-    expect(
-      await value(`
-        const leadingPoo = "\\uD83D"
-        const trailingPoo = "\\uDCA9"
-        const wholePoo = leadingPoo + trailingPoo
-        return [
-          typeof "".isWellFormed,
-          ("a" + leadingPoo + "c" + leadingPoo + "e").isWellFormed(),
-          ("a" + trailingPoo + "c" + trailingPoo + "e").isWellFormed(),
-          ("a" + trailingPoo + leadingPoo + "d").isWellFormed(),
-          "a💩c".isWellFormed(),
-          "a\\uD83D\\uDCA9c".isWellFormed(),
-          ("a" + leadingPoo + trailingPoo + "d").isWellFormed(),
-          wholePoo.slice(0, 1).isWellFormed(),
-          wholePoo.slice(1).isWellFormed(),
-          "abc".isWellFormed(),
-          "a\\u25A8c".isWellFormed(),
-        ]
-      `),
-    ).toEqual(["function", false, false, false, true, true, true, false, false, true, true])
-  })
-
-  test("test/built-ins/String/prototype/toWellFormed/returns-well-formed-string.js", async () => {
-    expect(
-      await value(`
-        const replacementChar = "\\uFFFD"
-        const leadingPoo = "\\uD83D"
-        const trailingPoo = "\\uDCA9"
-        const wholePoo = leadingPoo + trailingPoo
-        return [
-          typeof "".toWellFormed,
-          ("a" + leadingPoo + "c" + leadingPoo + "e").toWellFormed() === "a" + replacementChar + "c" + replacementChar + "e",
-          ("a" + trailingPoo + "c" + trailingPoo + "e").toWellFormed() === "a" + replacementChar + "c" + replacementChar + "e",
-          ("a" + trailingPoo + leadingPoo + "d").toWellFormed() === "a" + replacementChar + replacementChar + "d",
-          "a💩c".toWellFormed() === "a💩c",
-          "a\\uD83D\\uDCA9c".toWellFormed() === "a\\uD83D\\uDCA9c",
-          ("a" + leadingPoo + trailingPoo + "d").toWellFormed() === "a" + wholePoo + "d",
-          wholePoo.slice(0, 1).toWellFormed() === replacementChar,
-          wholePoo.slice(1).toWellFormed() === replacementChar,
-          "abc".toWellFormed() === "abc",
-          "a\\u25A8c".toWellFormed() === "a\\u25A8c",
-        ]
-      `),
-    ).toEqual(["function", true, true, true, true, true, true, true, true, true, true])
-  })
-})
-
-describe("Date string formatting Test262 parity", () => {
-  test("test/built-ins/Date/prototype/toDateString/format.js", async () => {
-    expect(
-      await value(`
-        const dateRegExp = /^(Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) [0-9]{2} [0-9]{4}$/
-        return [dateRegExp.test(new Date(0).toDateString()), dateRegExp.test(new Date("0020-01-01T00:00:00Z").toDateString())]
-      `),
-    ).toEqual([true, true])
-  })
-
-  test("test/built-ins/Date/prototype/toDateString/invalid-date.js", async () => {
-    expect(await value(`return new Date(NaN).toDateString()`)).toBe("Invalid Date")
-  })
-
-  test("test/built-ins/Date/prototype/toDateString/negative-year.js", async () => {
-    expect(
-      await value(`
-        return ["-000001", "-000012", "-000123", "-001234", "-012345", "-123456"].map(
-          (year) => new Date(year + "-07-01T00:00Z").toDateString().split(" ")[3],
-        )
-      `),
-    ).toEqual(["-0001", "-0012", "-0123", "-1234", "-12345", "-123456"])
-  })
-
-  test("test/built-ins/Date/prototype/toTimeString/format.js", async () => {
-    expect(
-      await value(`
-        const timeRegExp = /^[0-9]{2}:[0-9]{2}:[0-9]{2} GMT[+-][0-9]{4}( \\(.+\\))?$/
-        return timeRegExp.test(new Date(0).toTimeString())
-      `),
-    ).toBe(true)
-  })
-
-  test("test/built-ins/Date/prototype/toTimeString/invalid-date.js", async () => {
-    expect(await value(`return new Date(NaN).toTimeString()`)).toBe("Invalid Date")
-  })
-})

packages/codemode/test/tool-paths.test.ts

@@ -26,7 +26,7 @@ describe("dotted tool names", () => {
   const runtime = CodeMode.make({ tools: { api: { "issues.list": echo("List issues", "listed") } } })
 
   test("a dotted name becomes nested namespaces in the catalog", () => {
-    const catalog = runtime.catalog
+    const catalog = runtime.catalog()
     expect(catalog).toHaveLength(1)
     expect(catalog[0]?.path).toBe("api.issues.list")
     expect(catalog[0]?.signature).toStartWith("tools.api.issues.list(")
@@ -51,7 +51,7 @@ describe("dotted tool names", () => {
 
   test("a top-level dotted name nests from the root", async () => {
     const flat = CodeMode.make({ tools: { "issues.list": echo("List issues", "flat") } })
-    expect(flat.catalog[0]?.path).toBe("issues.list")
+    expect(flat.catalog()[0]?.path).toBe("issues.list")
     expect(await value(flat, `return await tools.issues.list({})`)).toBe("flat")
   })
 
@@ -85,7 +85,7 @@ describe("callable namespaces", () => {
   test("a path can hold a tool and child tools at once", async () => {
     expect(await value(runtime, `return await tools.issues({})`)).toBe("all")
     expect(await value(runtime, `return await tools.issues.list({})`)).toBe("list")
-    expect(runtime.catalog.map((tool) => tool.path)).toEqual(["issues", "issues.list"])
+    expect(runtime.catalog().map((tool) => tool.path)).toEqual(["issues", "issues.list"])
   })
 
   test("a callable namespace enumerates its children", async () => {
@@ -145,7 +145,7 @@ describe("tool input diagnostics", () => {
 
   test("an empty-input tool advertises () and runs with zero arguments", async () => {
     const empty = CodeMode.make({ tools: { ping: echo("Ping", "pong") } })
-    expect(empty.catalog[0]?.signature).toBe("tools.ping(): Promise<string>")
+    expect(empty.catalog()[0]?.signature).toBe("tools.ping(): Promise<string>")
     expect(await value(empty, `return await tools.ping()`)).toBe("pong")
   })
 })
@@ -160,7 +160,7 @@ describe("blocked member names on tool paths", () => {
   })
 
   test("tools may use blocked member names because path segments never touch real properties", async () => {
-    expect(runtime.catalog.map((tool) => tool.path)).toEqual(["issues.constructor", "nested.__proto__", "prototype"])
+    expect(runtime.catalog().map((tool) => tool.path)).toEqual(["issues.constructor", "nested.__proto__", "prototype"])
     expect(await value(runtime, `return await tools.prototype({})`)).toBe("proto")
     expect(await value(runtime, `return await tools.issues.constructor({})`)).toBe("ctor")
     expect(await value(runtime, `return await tools["issues.constructor"]({})`)).toBe("ctor")
@@ -172,7 +172,7 @@ describe("blocked member names on tool paths", () => {
     const poisoned = CodeMode.make({
       tools: { ns: { __proto__: echo("Hidden", "hidden"), real: echo("Real tool", "real") } },
     })
-    expect(poisoned.catalog.map((tool) => tool.path)).toEqual(["ns.real"])
+    expect(poisoned.catalog().map((tool) => tool.path)).toEqual(["ns.real"])
     expect(await value(poisoned, `return await tools.ns.real({})`)).toBe("real")
   })
 
@@ -185,17 +185,17 @@ describe("blocked member names on tool paths", () => {
         const array = []
         object.__proto__ = { polluted: true }
         return [
-          object.constructor === Object, array.constructor === Array, "".constructor === String, Math.constructor,
-          object.__proto__.polluted, ({}).polluted, array.__proto__, Object().__proto__, new Object().constructor === Object,
-          ({}).constructor.constructor, [].constructor.__proto__, typeof [].__proto__,
+          object.constructor, array.constructor, "".constructor, Math.constructor,
+          object.__proto__.polluted, ({}).polluted, array.__proto__, Object().__proto__, new Object().constructor,
+          typeof ({}).constructor, typeof [].__proto__,
         ]
       `,
       ),
-    ).toEqual([true, true, true, null, true, null, null, null, true, null, null, "undefined"])
+    ).toEqual([null, null, null, null, true, null, null, null, null, "undefined", "undefined"])
     expect((await failure(runtime, `return (() => 1).constructor`)).message).toContain(
       "Cannot read properties of a function",
     )
-    const escape = await failure(runtime, `return ({}).constructor.constructor.constructor("return 1")()`)
+    const escape = await failure(runtime, `return ({}).constructor.constructor("return 1")()`)
     expect(escape.message).toContain("Cannot access a property on a non-object value")
     const poisoned = await failure(runtime, `const o = {}; o.__proto__.constructor("return 1")`)
     expect(poisoned.message).toContain("Cannot access a property on a non-object value")
@@ -221,7 +221,7 @@ describe("namespace metadata", () => {
   const runtime = CodeMode.make({ tools })
 
   test("the wrapper does not add a segment to callable paths", async () => {
-    expect(runtime.catalog.map((tool) => tool.path)).toEqual(["api.status", "api.users.list", "plain.read"])
+    expect(runtime.catalog().map((tool) => tool.path)).toEqual(["api.status", "api.users.list", "plain.read"])
     expect(await value(runtime, `return await tools.api.users.list({})`)).toBe("users")
   })
 
@@ -260,8 +260,8 @@ describe("canonical path collisions", () => {
       tools: { "issues.list": echo("First", "first"), issues: { list: echo("Second", "second") } },
     })
     expect(await value(runtime, `return await tools.issues.list({})`)).toBe("second")
-    expect(runtime.catalog).toHaveLength(1)
-    expect(runtime.catalog[0]?.description).toBe("Second")
+    expect(runtime.catalog()).toHaveLength(1)
+    expect(runtime.catalog()[0]?.description).toBe("Second")
   })
 
   test("overriding one path keeps sibling tools from both shapes", async () => {
@@ -272,7 +272,7 @@ describe("canonical path collisions", () => {
         "issues.close": echo("Close issue", "closed"),
       },
     })
-    expect(runtime.catalog.map((tool) => tool.path)).toEqual(["issues.close", "issues.get", "issues.list"])
+    expect(runtime.catalog().map((tool) => tool.path)).toEqual(["issues.close", "issues.get", "issues.list"])
     expect(await value(runtime, `return await tools.issues.list({})`)).toBe("second")
     expect(await value(runtime, `return await tools.issues.get({})`)).toBe("got")
     expect(await value(runtime, `return await tools.issues.close({})`)).toBe("closed")

packages/codemode/test/var-hoisting-test262.test.ts

@@ -1,242 +0,0 @@
-/**
- * Portions adapted from Test262 at revision 250f204f23a9249ff204be2baec29600faae7b75:
- * - test/language/statements/variable/S12.2_A1.js
- * - test/language/statements/variable/S12.2_A3.js
- * - test/language/statements/variable/S12.2_A6_T1.js
- * - test/language/statements/variable/S12.2_A7.js
- * - test/language/statements/variable/S12.2_A10.js
- * - test/language/statements/variable/S12.2_A12.js
- * - test/language/block-scope/shadowing/hoisting-var-declarations-out-of-blocks.js
- * - test/language/block-scope/shadowing/catch-parameter-shadowing-var-variable.js
- * - test/language/statements/for/head-var-bound-names-in-stmt.js
- * - test/language/statements/function/scope-paramsbody-var-open.js
- * - test/language/statements/function/scope-paramsbody-var-close.js
- *
- * Copyright 2009 the Sputnik authors. All rights reserved.
- * Copyright (C) 2011, 2016 the V8 project authors. All rights reserved.
- * Test262 portions are governed by the BSD license in LICENSE.test262.
- *
- * Files that observe `var` through `eval`, `this`, `delete`, or the global object (S12.2_A2, A5, A9,
- * A11, `scope-*-none.js`, `scope-param-elem-*.js`) have no analogue here and are not ported.
- */
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { CodeMode } from "../src/index.js"
-
-const value = async (code: string) => {
-  const result = await Effect.runPromise(CodeMode.execute({ code, tools: {} }))
-  if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
-  return result.value
-}
-
-describe("var hoisting Test262 parity", () => {
-  test("test/language/statements/variable/S12.2_A1.js: use before declaration reads undefined", async () => {
-    expect(
-      await value(`
-        __x = __x
-        __y = __x ? "good fellow" : "liar"
-        __z = __z === __x ? 1 : 0
-        let unknown
-        try { __something__undefined = __something__undefined } catch (error) { unknown = error.name }
-        const before = [__y, __z, unknown]
-        var __x, __y = true, __z = __y ? "smeagol" : "golum"
-        return [...before, __y, __z]
-      `),
-    ).toEqual(["liar", 1, "ReferenceError", true, "smeagol"])
-  })
-
-  test("test/language/statements/variable/S12.2_A3.js: nested functions redeclare or assign", async () => {
-    expect(
-      await value(`
-        var __var = "OUT"
-        const inner = (function () {
-          var __var = "IN"
-          ;(function () { __var = "INNER_SPACE" })()
-          ;(function () { var __var = "INNER_SUN" })()
-          return __var
-        })()
-        const after = __var
-        const assigned = (function () {
-          __var = "IN"
-          ;(function () { __var = "INNERED" })()
-          ;(function () { var __var = "INNAGER" })()
-          return __var
-        })()
-        return [inner, after, assigned, __var]
-      `),
-    ).toEqual(["INNER_SPACE", "OUT", "INNERED", "INNERED"])
-  })
-
-  test("test/language/statements/variable/S12.2_A6_T1.js: var inside try and catch is hoisted", async () => {
-    expect(
-      await value(`
-        intry__var = intry__var
-        incatch__var = incatch__var
-        try { var intry__var } catch (e) { var incatch__var }
-        return [typeof intry__var, typeof incatch__var]
-      `),
-    ).toEqual(["undefined", "undefined"])
-  })
-
-  test("test/language/statements/variable/S12.2_A7.js: var after break inside for is hoisted", async () => {
-    expect(
-      await value(`
-        infor_var = infor_var
-        for (;;) { break; var infor_var }
-        return typeof infor_var
-      `),
-    ).toBe("undefined")
-  })
-
-  test("test/language/statements/variable/S12.2_A10.js: var in for head is hoisted", async () => {
-    expect(
-      await value(`
-        __ind = __ind
-        for (var __ind; ; ) { break }
-        return typeof __ind
-      `),
-    ).toBe("undefined")
-  })
-
-  test("test/language/statements/variable/S12.2_A12.js: var in do-while body is hoisted", async () => {
-    expect(
-      await value(`
-        x = x
-        do var x; while (false)
-        return typeof x
-      `),
-    ).toBe("undefined")
-  })
-
-  test("test/language/block-scope/shadowing/hoisting-var-declarations-out-of-blocks.js", async () => {
-    expect(
-      await value(`
-        function fn() {
-          { var x = 1; var y }
-          return [x, typeof y]
-        }
-        return fn()
-      `),
-    ).toEqual([1, "undefined"])
-  })
-
-  test("test/language/block-scope/shadowing/catch-parameter-shadowing-var-variable.js", async () => {
-    expect(
-      await value(`
-        function fn() {
-          var a = 1
-          let caught
-          try { throw "stuff3" } catch (a) { caught = a }
-          return [caught, a]
-        }
-        return fn()
-      `),
-    ).toEqual(["stuff3", 1])
-  })
-
-  test("test/language/statements/for/head-var-bound-names-in-stmt.js: redeclaring the head var in the body", async () => {
-    expect(
-      await value(`
-        var iterCount = 0
-        var first = true
-        for (var x; first; first = false) {
-          var x
-          iterCount += 1
-        }
-        return iterCount
-      `),
-    ).toBe(1)
-  })
-
-  test("test/language/statements/function/scope-paramsbody-var-open.js: parameter defaults see the outer var", async () => {
-    expect(
-      await value(`
-        var x = "outside"
-        var probeParams, probeBody
-        function f(_ = probeParams = function () { return x }) {
-          var x = "inside"
-          probeBody = function () { return x }
-        }
-        f()
-        return [probeParams(), probeBody()]
-      `),
-    ).toEqual(["outside", "inside"])
-  })
-
-  test("test/language/statements/function/scope-paramsbody-var-close.js: body var does not leak out", async () => {
-    expect(
-      await value(`
-        var probe
-        function f(_ = null) {
-          var x = "inside"
-          probe = function () { return x }
-        }
-        f()
-        var x = "outside"
-        return [probe(), x]
-      `),
-    ).toEqual(["inside", "outside"])
-  })
-})
-
-describe("var semantics beyond Test262", () => {
-  test("redeclaration and block-level var assign the one function-scoped binding", async () => {
-    expect(await value(`var a = 1; var a = 2; { var a = 3 } return a`)).toBe(3)
-    expect(await value(`var q = 1; { let q = 2 } return q`)).toBe(1)
-  })
-
-  test("var loop counters are shared by closures, let counters are not", async () => {
-    expect(
-      await value(`
-        const byVar = []
-        for (var i = 0; i < 3; i++) byVar.push(() => i)
-        const byLet = []
-        for (let j = 0; j < 3; j++) byLet.push(() => j)
-        return [byVar.map((f) => f()), byLet.map((f) => f())]
-      `),
-    ).toEqual([
-      [3, 3, 3],
-      [0, 1, 2],
-    ])
-  })
-
-  test("for...in and for...of var heads survive the loop", async () => {
-    expect(await value(`for (var k in { a: 1 }) {} for (var [p, q] of [[1, 2]]) {} return [k, p, q]`)).toEqual([
-      "a",
-      1,
-      2,
-    ])
-  })
-
-  test("var and function declarations of the same name share a binding", async () => {
-    expect(await value(`var fn = 1; function fn() {} return typeof fn`)).toBe("number")
-    expect(await value(`function fn() {} var fn; return typeof fn`)).toBe("function")
-    expect(await value(`function h() { var fn = 1; function fn() {} return typeof fn } return h()`)).toBe("number")
-  })
-
-  test("a var named after a parameter keeps the argument until assigned", async () => {
-    expect(await value(`function f(a) { var a; return a } return f(7)`)).toBe(7)
-    expect(await value(`function f(a) { var a = 2; return a } return f(7)`)).toBe(2)
-  })
-
-  test("var does not hoist across function boundaries", async () => {
-    expect(await value(`return [typeof b, (() => { var b = 1; return b })()]; var b`)).toEqual(["undefined", 1])
-    expect(
-      await value(
-        `function outer() { var o = 1; function inner() { var o = 2; return o } return [inner(), o] } return outer()`,
-      ),
-    ).toEqual([2, 1])
-  })
-
-  test("switch cases, labels, and generators hoist var", async () => {
-    expect(await value(`switch (1) { case 1: var s = 9 } label: { var lb = 1 } return [s, lb]`)).toEqual([9, 1])
-    expect(await value(`function* gen() { var t = 1; yield t; var t = 2; yield t } return [...gen()]`)).toEqual([1, 2])
-  })
-})
-
-describe("switch case function hoisting", () => {
-  test("function declarations are visible across all cases before their statement runs", async () => {
-    expect(await value(`switch (1) { case 1: return foo(); function foo() { return "hoisted" } }`)).toBe("hoisted")
-    expect(await value(`switch (2) { case 1: function foo() { return "a" } break; case 2: return foo() }`)).toBe("a")
-  })
-})

packages/codemode/test/web-wpt.test.ts

@@ -1,169 +0,0 @@
-/**
- * Portions adapted from web-platform-tests at revision 863077959ca8c1a7ceecfbe2534b75d2527b9013:
- * - html/webappapis/atob/base64.any.js (btoa reference encoder, input list, and atob WebIDL cases)
- * - fetch/data-urls/resources/base64.json (copied to fixtures/wpt-base64.json)
- * - WebCryptoAPI/randomUUID.https.any.js
- *
- * Copyright © web-platform-tests contributors. Governed by the 3-Clause BSD license in LICENSE.wpt.
- *
- * `assert_throws_dom("InvalidCharacterError", …)` becomes a check on `error.name`: CodeMode has no
- * DOMException, so the name is carried on a plain Error.
- */
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { CodeMode } from "../src/index.js"
-
-const base64Cases = (await Bun.file(new URL("./fixtures/wpt-base64.json", import.meta.url)).json()) as Array<
-  [string, Array<number> | null]
->
-
-const value = async (code: string) => {
-  const result = await Effect.runPromise(CodeMode.execute({ code, tools: {} }))
-  if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
-  return result.value
-}
-
-// The reference encoder from base64.any.js, run inside the interpreter so btoa is checked against
-// an independent implementation rather than against the host's btoa.
-const referenceEncoder = `
-  function btoaLookup(idx) {
-    if (idx < 26) return String.fromCharCode(idx + "A".charCodeAt(0))
-    if (idx < 52) return String.fromCharCode(idx - 26 + "a".charCodeAt(0))
-    if (idx < 62) return String.fromCharCode(idx - 52 + "0".charCodeAt(0))
-    if (idx == 62) return "+"
-    if (idx == 63) return "/"
-  }
-  function mybtoa(s) {
-    s = String(s)
-    for (var i = 0; i < s.length; i++) if (s.charCodeAt(i) > 255) return "INVALID_CHARACTER_ERR"
-    var out = ""
-    for (var i = 0; i < s.length; i += 3) {
-      var groupsOfSix = [undefined, undefined, undefined, undefined]
-      groupsOfSix[0] = s.charCodeAt(i) >> 2
-      groupsOfSix[1] = (s.charCodeAt(i) & 0x03) << 4
-      if (s.length > i + 1) {
-        groupsOfSix[1] |= s.charCodeAt(i + 1) >> 4
-        groupsOfSix[2] = (s.charCodeAt(i + 1) & 0x0f) << 2
-      }
-      if (s.length > i + 2) {
-        groupsOfSix[2] |= s.charCodeAt(i + 2) >> 6
-        groupsOfSix[3] = s.charCodeAt(i + 2) & 0x3f
-      }
-      for (var j = 0; j < groupsOfSix.length; j++) {
-        out += typeof groupsOfSix[j] == "undefined" ? "=" : btoaLookup(groupsOfSix[j])
-      }
-    }
-    return out
-  }
-  function testBtoa(input) {
-    var expected = mybtoa(input)
-    if (expected === "INVALID_CHARACTER_ERR") {
-      try { btoa(input) } catch (error) { return error.name === "InvalidCharacterError" ? "ok" : error.name }
-      return "did not throw"
-    }
-    if (btoa(input) !== expected) return "btoa mismatch"
-    if (atob(btoa(input)) !== String(input)) return "roundtrip mismatch"
-    return "ok"
-  }
-`
-
-describe("btoa WPT parity (html/webappapis/atob/base64.any.js)", () => {
-  test("every input encodes like the reference encoder and round-trips through atob", async () => {
-    expect(
-      await value(`
-        ${referenceEncoder}
-        var tests = ["עברית", "", "ab", "abc", "abcd", "abcde", "\\xff\\xff\\xc0", "\\0a", "a\\0b",
-          undefined, null, 7, 12, 1.5, true, false, NaN, +Infinity, -Infinity, 0, -0]
-        for (var i = 0; i < 258; i++) tests.push(String.fromCharCode(i))
-        tests.push(String.fromCharCode(10000), String.fromCharCode(65534), String.fromCharCode(65535))
-        tests.push(String.fromCharCode(0xd800, 0xdc00))
-        var everything = ""
-        for (var i = 0; i < 256; i++) everything += String.fromCharCode(i)
-        tests.push(everything)
-        return tests.map(testBtoa).filter((outcome) => outcome !== "ok")
-      `),
-    ).toEqual([])
-  })
-})
-
-describe("atob WPT parity (fetch/data-urls/resources/base64.json)", () => {
-  const idlCases: Array<[unknown, Array<number> | null]> = [
-    [undefined, null],
-    [null, [158, 233, 101]],
-    [7, null],
-    [12, [215]],
-    [1.5, null],
-    [true, [182, 187]],
-    [false, null],
-    [NaN, [53, 163]],
-    [Infinity, [34, 119, 226, 158, 43, 114]],
-    [-Infinity, null],
-    [0, null],
-    [-0, null],
-  ]
-
-  test(`${base64Cases.length} forgiving-base64 inputs decode to the expected bytes or throw InvalidCharacterError`, async () => {
-    expect(
-      await value(`
-        const cases = ${JSON.stringify(base64Cases)}
-        return cases.flatMap(([input, output]) => {
-          try {
-            const result = atob(input)
-            if (output === null) return [[input, "expected throw"]]
-            const bytes = Array.from({ length: result.length }, (_, i) => result.charCodeAt(i))
-            return JSON.stringify(bytes) === JSON.stringify(output) ? [] : [[input, bytes]]
-          } catch (error) {
-            return output === null && error.name === "InvalidCharacterError" ? [] : [[input, error.name]]
-          }
-        })
-      `),
-    ).toEqual([])
-  })
-
-  test("WebIDL argument conversion stringifies non-string inputs", async () => {
-    const literal = (input: unknown) =>
-      Object.is(input, -0)
-        ? "-0"
-        : typeof input === "number" || input === undefined
-          ? String(input)
-          : JSON.stringify(input)
-    expect(
-      await value(`
-        const cases = [${idlCases.map(([input, output]) => `[${literal(input)}, ${JSON.stringify(output)}]`).join(",")}]
-        return cases.flatMap(([input, output]) => {
-          try {
-            const result = atob(input)
-            if (output === null) return [[String(input), "expected throw"]]
-            // The source loop checks only the listed prefix of the decoded bytes.
-            const bytes = output.map((_, i) => result.charCodeAt(i))
-            return JSON.stringify(bytes) === JSON.stringify(output) ? [] : [[String(input), bytes]]
-          } catch (error) {
-            return output === null && error.name === "InvalidCharacterError" ? [] : [[String(input), error.name]]
-          }
-        })
-      `),
-    ).toEqual([])
-  })
-})
-
-describe("crypto.randomUUID WPT parity (WebCryptoAPI/randomUUID.https.any.js)", () => {
-  test("namespace format, version, and variant bits over 256 iterations without collision", async () => {
-    expect(
-      await value(`
-        const uuids = new Set()
-        const randomUUID = () => {
-          const uuid = crypto.randomUUID()
-          if (uuids.has(uuid)) throw new Error("uuid collision " + uuid)
-          uuids.add(uuid)
-          return uuid
-        }
-        const UUIDRegex = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
-        let format = true, version = true, variant = true
-        for (let i = 0; i < 256; i++) format = format && UUIDRegex.test(randomUUID())
-        for (let i = 0; i < 256; i++) version = version && (parseInt(randomUUID().split("-")[2].slice(0, 2), 16) & 0b11110000) === 0b01000000
-        for (let i = 0; i < 256; i++) variant = variant && (parseInt(randomUUID().split("-")[3].slice(0, 2), 16) & 0b11000000) === 0b10000000
-        return [format, version, variant, uuids.size]
-      `),
-    ).toEqual([true, true, true, 768])
-  })
-})

packages/core/src/aisdk-native.ts

@@ -163,7 +163,7 @@ function mapProviderOptions(settings: Readonly<Record<string, unknown>>, exclude
 
 function mapBedrockMantle(input: MapInput, baseSettings: Readonly<Record<string, unknown>>): Mapping | undefined {
   const settings = input.settings
-  const chat = input.modelID.includes("gpt-oss")
+  const chat = input.modelID === "openai.gpt-oss-safeguard-20b" || input.modelID === "openai.gpt-oss-safeguard-120b"
   return {
     package: `@opencode/ai/providers/amazon-bedrock/mantle/${chat ? "chat" : "responses"}`,
     settings: {

packages/core/src/aisdk.ts

@@ -547,14 +547,6 @@ function assistantPart(part: ContentPart): AssistantContent {
       ]
     case "tool-result":
       return toolResultPart(part)
-    case "effort":
-      throw ProviderShared.unsupportedContent("AI SDK", "assistant", [
-        "text",
-        "media",
-        "reasoning",
-        "tool-call",
-        "tool-result",
-      ])
   }
 }
 

packages/core/src/codemode/tool.ts

@@ -166,7 +166,7 @@ export const catalog = (inventory: Inventory) => {
   )
   const root: CatalogNode = { children: new Map() }
   for (const namespace of inventory.namespaces?.values() ?? []) getNode(root, namespace.name).namespace = namespace
-  for (const tool of runtime(inventory, () => Effect.fail(toolError("Execute context is unavailable"))).catalog)
+  for (const tool of runtime(inventory, () => Effect.fail(toolError("Execute context is unavailable"))).catalog())
     getNode(root, tool.path).tool = {
       type: "tool",
       name: tool.path.split(".").at(-1) ?? tool.path,

packages/core/src/database/migration.gen.ts

@@ -45,7 +45,6 @@ import m42 from "./migration/20260812181746_session_inbox.js"
 import m43 from "./migration/20260812213948_worktree.js"
 import m44 from "./migration/20260819222447_session_viewed_state.js"
 import m45 from "./migration/20260823191254_nullable_workspace_binding.js"
-import m46 from "./migration/20260910120000_clear_v1_session_permission.js"
 
 export const migrations = [
   m00,
@@ -94,5 +93,4 @@ export const migrations = [
   m43,
   m44,
   m45,
-  m46,
 ] satisfies DatabaseMigration.Migration[]

packages/core/src/database/migration/20260910120000_clear_v1_session_permission.ts

@@ -1,13 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration.js"
-
-const migration: DatabaseMigration.Migration = {
-  id: "20260910120000_clear_v1_session_permission",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`UPDATE \`session_v2\` SET \`permission\` = NULL;`)
-    })
-  },
-}
-
-export default migration

packages/core/src/database/v1-migration.bun.ts

@@ -600,7 +600,7 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
                     id, ${projectID}, workspace_id, parent_id, slug, directory, path, title, version, share_url,
                     summary_additions, summary_deletions, summary_files, summary_diffs, metadata, cost,
                     tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
-                    revert, NULL, agent, model, time_created, time_updated, time_compacting, time_archived
+                    revert, permission, agent, model, time_created, time_updated, time_compacting, time_archived
                   FROM session
                   WHERE id = ${nextID.id}
                 `)

packages/core/src/generate.ts

@@ -41,8 +41,6 @@ export const layer = Layer.effect(
           [
             "SessionRunnerModel.VariantUnavailableError",
             "SessionRunnerModel.UnsupportedPackageError",
-            "SessionRunnerModel.ModelConfigurationError",
-            "SessionRunnerModel.ModelInitializationError",
             "SessionRunnerModel.UnresolvedProviderVariablesError",
             "SessionRunnerModel.UnsupportedCompactionError",
           ],

packages/core/src/github-copilot/models.ts

@@ -203,7 +203,7 @@ function variants(remote: UsableModel, messages: boolean): Model.Info["variants"
       settings: {
         thinking: {
           type: "adaptive",
-          display: "summarized",
+          ...(remote.id.includes("opus-4.7") ? { display: "summarized" } : {}),
         },
         effort,
       },