chore(core): keep import formatting

refactor(core): keep the original output return, parse before it
refactor(core): use startsWith for the JSON text check
2026-09-10 19:06:24 +00:00 · 2026-09-10 12:15:17 -05:00 · 2026-09-10 12:14:52 -05:00 · 2026-09-10 12:10:09 -05:00 · 2026-09-10 12:09:35 -05:00 · 2026-09-10 12:08:35 -05:00
38 changed files with 786 additions and 366 deletions
@@ -18,7 +18,6 @@ const WebSocketResponseCreate = Schema.StructWithRest(Schema.Struct({ type: Sche
 ])
 const decodeMessage = ProviderShared.validateWith(Schema.decodeUnknownEffect(WebSocketResponseCreate))
 const encodeMessage = Schema.encodeSync(Schema.fromJsonString(WebSocketResponseCreate))
-const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)

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

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

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

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

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

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

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

-export const OpenResponsesContinuation = { driver } as const
+export * as OpenResponsesContinuation from "./open-responses-continuation.js"
@@ -405,6 +405,24 @@ export const Event = Schema.StructWithRest(
 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
@@ -41,6 +41,10 @@ const responsesRoute = Route.make({
    id: "openai-responses",
    name: "xAI Responses",
    rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
+    // xAI continues a chain only from stored responses: with `store: false` (the route default) `previous_response_id`
+    // fails with "Response with id=… not found", so those steps are sent in full over the reused connection. It also
+    // rejects `instructions` next to `previous_response_id` and keeps the instructions of the response it continues.
+    continuation: ({ instructions: _instructions, ...request }) => (request.store === false ? undefined : request),
  }),
  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 })
@@ -90,7 +90,11 @@ const classifyingChannelDriver = (message: string): WebSocketChannelDriver => {
  }
 }

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

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

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

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

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

+  it.effect("classifies xAI's untyped WebSocket error envelope", () =>
+    Effect.gen(function* () {
+      // xAI answers a rejected response.create with an error envelope that carries no event type.
+      const envelope = ProviderShared.encodeJson({
+        error: {
+          message:
+            'Request validation error: {"code":"400","error":"Argument not supported: instructions and previous_response_id together"}',
+          type: "api_error",
+        },
+      })
+      const webSocket = WebSocketTransport.makeDirect({
+        open: () =>
+          Effect.succeed({ sendText: () => Effect.void, messages: Stream.make(envelope), close: Effect.void }),
+      })
+      const error = yield* LLMClient.generate(LLM.request({ model, prompt: "Hello" }), { webSocket }).pipe(
+        Effect.provide(
+          LLMClient.layer.pipe(
+            Layer.provide(
+              Layer.succeed(
+                RequestExecutor.Service,
+                RequestExecutor.Service.of({ execute: () => Effect.die("unexpected HTTP request") }),
+              ),
+            ),
+          ),
+        ),
+        Effect.flip,
+      )
+
+      expect(error.reason._tag).toBe("ProviderInternal")
+      expect(error.message).toContain("Argument not supported: instructions and previous_response_id together")
+      expect(error.reason.body).toBe(envelope)
+    }),
+  )
+
+  it.effect("continues stored responses without instructions and sends unstored steps in full", () =>
+    Effect.gen(function* () {
+      const step = (store: boolean, ...prompts: string[]) =>
+        LLM.request({
+          model,
+          system: "You are terse.",
+          messages: prompts.map((prompt) => Message.user(prompt)),
+          providerOptions: { store },
+        })
+      const send = (store: boolean, checkpoint: ChannelCheckpoint) =>
+        channelDriver(step(store, "First", "Second")).pipe(Effect.flatMap((driver) => driver.create(checkpoint)))
+
+      const stored = yield* send(true, yield* completed(yield* channelDriver(step(true, "First")), "resp_1"))
+      expect(stored.mode).toBe("incremental")
+      expect(JSON.parse(stored.message)).toEqual({
+        type: "response.create",
+        model: "grok-4.6",
+        store: true,
+        include: ["reasoning.encrypted_content"],
+        previous_response_id: "resp_1",
+        input: [{ role: "user", content: [{ type: "input_text", text: "Second" }] }],
+      })
+
+      // The connection cache only serves stored responses, so the default store: false never chains.
+      const unstored = yield* send(false, yield* completed(yield* channelDriver(step(false, "First")), "resp_1"))
+      expect(unstored.mode).toBe("full")
+      expect(JSON.parse(unstored.message)).toMatchObject({
+        instructions: "You are terse.",
+        store: false,
+        input: [
+          { role: "user", content: [{ type: "input_text", text: "First" }] },
+          { role: "user", content: [{ type: "input_text", text: "Second" }] },
+        ],
+      })
+      expect(JSON.parse(unstored.message).previous_response_id).toBeUndefined()
+    }),
+  )
+
  it.effect("parses xAI hosted tool items", () =>
    Effect.gen(function* () {
      const item = { type: "x_search_call", id: "x_search_1", status: "completed", action: { query: "news" } }
@@ -0,0 +1,74 @@
+import { expect, test } from "@playwright/test"
+import { sessionID, setupTimeline, userMessage } from "../performance/timeline-stability/fixture"
+
+test("keeps a submitted prompt in place while its optimistic rows are measured", async ({ page }) => {
+  await setupTimeline(page, { messages: [userMessage()], seedHistory: true })
+  const release = Promise.withResolvers<void>()
+  await page.route(`**/api/session/${sessionID}/prompt`, async (route) => {
+    if (route.request().method() !== "POST") return route.fallback()
+    await release.promise
+    return route.fallback()
+  })
+
+  const editor = page.locator('[data-component="composer"]').getByRole("textbox")
+  await expect(editor).toBeEditable()
+  await editor.fill("Observe optimistic prompt spacing.")
+  await expect
+    .poll(() =>
+      page.locator("[data-timeline-virtual-content]").evaluate((element) => {
+        const root = element.parentElement!
+        return root.scrollHeight - root.clientHeight - root.scrollTop
+      }),
+    )
+    .toBe(0)
+
+  const observation = await page.evaluateHandle(() => {
+    const frames: { prompt?: number; working: boolean }[] = []
+    let frame = 0
+    const sample = () => {
+      const prompt = [...document.querySelectorAll<HTMLElement>('[data-timeline-row="UserMessage"]')].find((row) =>
+        row.textContent?.includes("Observe optimistic prompt spacing."),
+      )
+      frames.push({
+        ...(prompt ? { prompt: prompt.getBoundingClientRect().y } : {}),
+        working: !!document.querySelector('[data-component="session-working"]'),
+      })
+      frame = requestAnimationFrame(sample)
+    }
+    frame = requestAnimationFrame(sample)
+    return {
+      stop: () => {
+        cancelAnimationFrame(frame)
+        return frames
+      },
+    }
+  })
+  const requested = page.waitForRequest(
+    (request) => request.method() === "POST" && new URL(request.url()).pathname === `/api/session/${sessionID}/prompt`,
+  )
+  try {
+    await editor.press("Enter")
+    await requested
+    const prompt = page
+      .locator('[data-timeline-row="UserMessage"]')
+      .filter({ hasText: "Observe optimistic prompt spacing." })
+    await expect(prompt).toBeInViewport()
+    await expect(page.locator('[data-component="session-working"]')).toBeVisible()
+    await expect
+      .poll(() =>
+        page.locator("[data-timeline-virtual-content]").evaluate((element) => {
+          const root = element.parentElement!
+          return root.scrollHeight - root.clientHeight - root.scrollTop
+        }),
+      )
+      .toBe(0)
+    const frames = await observation.evaluate((value) => value.stop())
+    expect(frames.some((frame) => frame.working && frame.prompt === undefined)).toBe(false)
+    const positions = frames.flatMap((frame) => (frame.prompt === undefined ? [] : [frame.prompt]))
+    expect(positions.length).toBeGreaterThan(0)
+    expect(new Set(positions).size).toBe(1)
+  } finally {
+    release.resolve()
+    await observation.dispose()
+  }
+})
@@ -122,7 +122,15 @@ test("renders compaction progress, summary, and outcome in order", async ({ page
  )
  await expect(compaction.getByRole("heading", { name: "Checkpoint" })).toBeVisible()
  await expect(compaction).toContainText("Streamed implementation details.")
-  await expect(compaction.getByRole("status").getByLabel("Compacting", { exact: true })).toBeVisible()
+  const running = compaction.getByRole("status").getByLabel("Compacting", { exact: true })
+  await expect(running).toBeVisible()
+  await expect
+    .poll(async () => {
+      const summary = await compaction.locator('[data-component="text-part"]').boundingBox()
+      const status = await running.boundingBox()
+      return !!summary && !!status && status.y >= summary.y + summary.height
+    })
+    .toBe(true)
  await expect(compaction.getByText("Session compacted", { exact: true })).toHaveCount(0)

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

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

 async function buildSubmissionRequest(session: ComposerSession, value: ComposerSubmission) {
@@ -515,6 +515,19 @@ export function createTimelineVirtualizer(input: Input) {
          <div
            ref={(value) => {
              element = value
+              if (row()._tag !== "UserMessage" || !addedKeys.has(rowProps.rowKey) || !input.pinned() || coldPending)
+                return
+              // The optimistic row can paint before ResizeObserver corrects the tail estimates.
+              // Measure the mounted tail and pin it in this render's microtask instead.
+              queueMicrotask(() => {
+                if (!input.pinned() || !virtualContent?.isConnected) return
+                virtualizer.elementsCache.forEach((item) => {
+                  if (item.isConnected) virtualizer.resizeItem(virtualizer.indexFromElement(item), item.offsetHeight)
+                })
+                virtualizer.resizeItem(item().index, element.offsetHeight)
+                virtualContent.style.height = `${virtualizer.getTotalSize()}px`
+                virtualizer.scrollToEnd()
+              })
            }}
            data-index={item().index}
            style={{ "min-height": ready() ? undefined : `${initialItem.size}px` }}
@@ -58,7 +58,7 @@ ultimate source of truth.
 - [x] Predeclare `let` and `const` bindings in every lexical scope, including program/block bodies, switch bodies, and
      loop headers, so reads before initialization and self- or cross-referential initializers observe the JavaScript
      temporal dead zone.
- [ ] Hoist function declarations accepted directly in switch cases.
+- [x] Function declarations are hoisted across all cases of a `switch`, like any other statement list.
 - [x] Computed object destructuring keys such as `const { [field]: value } = record`.
 - [x] Object destructuring from arrays, such as `const { length } = values`.
 - [x] Array binding and assignment destructuring from strings, Maps, Sets, URLSearchParams, custom synchronous
@@ -364,6 +364,14 @@ ultimate source of truth.
      `entries`, `toString`, and `size`.
 - [x] URL values serialize to their href; URLSearchParams serialize to `{}`.

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

 - [x] `Error`, `TypeError`, `RangeError`, `SyntaxError`, `ReferenceError`, `EvalError`, and `URIError`, callable with
@@ -380,6 +388,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.
- [ ] Distinguish user-thrown failures from interpreter defects and explicit tool refusals from internal tool
-      failures; preserve those categories in caught errors, promise rejection handlers, and `Promise.allSettled`
-      reasons.
+- [x] Caught errors do not distinguish user throws, interpreter failures, and tool failures; a program sees one
+      Error-shaped value with `name` and `message` in `catch`, rejection handlers, and `Promise.allSettled` reasons.
+      This is deliberate: the program should handle a failure the same way regardless of where it originated.
@@ -11,6 +11,7 @@ import { regexpGlobal } from "../stdlib/regexp.js"
 import { stringGlobal } from "../stdlib/string.js"
 import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js"
 import { coercion, errorConstructors } from "../stdlib/value.js"
+import { atobGlobal, btoaGlobal, cryptoGlobal } from "../stdlib/web.js"
 import { ToolReference } from "../tool-runtime.js"
 import { errorGlobal } from "./errors.js"
 import { HostFunction } from "./host.js"
@@ -71,5 +72,8 @@ export const globals = <R>(host: Host<R>): ReadonlyArray<readonly [string, unkno
  ["encodeURIComponent", uriGlobal("encodeURIComponent")],
  ["decodeURI", uriGlobal("decodeURI")],
  ["decodeURIComponent", uriGlobal("decodeURIComponent")],
+  ["atob", atobGlobal],
+  ["btoa", btoaGlobal],
+  ["crypto", cryptoGlobal],
  ...[...errorConstructors].map((name) => [name, errorGlobal(name, host.runner)] as const),
 ]
@@ -171,6 +171,8 @@ const collectPatternNames = (pattern: Pattern, out: Array<string> = []): Array<s
 }

 // `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> = [],
@@ -446,12 +448,14 @@ 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 statement of statements) {
-      for (const name of collectVarNames(statement)) {
-        if (scope.has(name)) continue
-        scope.set(name, { mutable: true, value: parameters?.get(name)?.value, initialized: true })
-      }
+    for (const name of names) {
+      if (scope.has(name)) continue
+      scope.set(name, { mutable: true, value: parameters?.get(name)?.value, initialized: true })
    }
  }

@@ -492,7 +496,9 @@ class Frame<R> {
      self.scopes.push()
      return yield* Effect.gen(function* () {
        const cases = node.cases
-        self.predeclareLexical(cases.flatMap((branch) => branch.consequent))
+        const statements = cases.flatMap((branch) => branch.consequent)
+        self.predeclareLexical(statements)
+        self.hoistFunctions(statements)
        let defaultIndex: number | undefined
        let selected: number | undefined
        for (const [index, branch] of cases.entries()) {
@@ -1649,16 +1655,8 @@ class Frame<R> {
    })
    if (fn.generator) return Effect.succeed(this.createGenerator(invocation, run, fn.async))
    if (!fn.async) return run
-    // 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
-      },
+    return this.runtime.promises.createWithSelf((self) =>
+      Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, fn.body, self)),
    )
  }

@@ -0,0 +1,24 @@
+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, but only 0 were provided.`, 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()),
+})
@@ -0,0 +1,11 @@
+# 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.
@@ -0,0 +1,82 @@
+[
+  ["", []],
+  ["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]
+]
@@ -233,3 +233,10 @@ describe("var semantics beyond Test262", () => {
    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")
+  })
+})
@@ -0,0 +1,169 @@
+/**
+ * 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])
+  })
+})
@@ -99,6 +99,17 @@ export const create = (
              const outputFileParts = outputFiles(content)
              if (outputFileParts.length > 0)
                yield* Ref.update(files, (items) => [...items, { index, files: outputFileParts }])
+              // Agents assume JSON returned as text is already an object. mcp.ts folds text content into
+              // `output` as a string, so parse it for MCP tools without an output schema (registered as `{}`).
+              const noSchema = tool.output !== undefined && Object.keys(tool.output).length === 0
+              if (typeof executed.output === "string" && noSchema) {
+                const trimmed = executed.output.trimStart()
+                if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+                  try {
+                    return JSON.parse(executed.output)
+                  } catch {}
+                }
+              }
              if (executed.output !== undefined) return executed.output
              const text = content.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n")
              return text === "" ? null : text
@@ -178,50 +178,29 @@ export const AzurePlugin = define({
      Effect.forkScoped({ startImmediately: true }),
    )

-    // Entra bearer tokens are minted per request from the target URL's scope, so they are injected at the
-    // transport hooks rather than stored as a credential.
-    const bearer = Effect.fn(function* (url: string) {
-      const connection = yield* ctx.integration.connection.active(Provider.ID.azure)
-      const credential = connection
-        ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => undefined))
-        : undefined
-      if (credential?.type !== "oauth" || credential.methodID !== methodID) return
-      const target = new URL(url)
-      const scope =
-        target.hostname.endsWith(".services.ai.azure.com") && !target.pathname.startsWith("/models")
-          ? foundryScope
-          : cognitiveScope
-      const current = yield* token(scope).pipe(Effect.orDie)
-      return `Bearer ${current.access}`
-    })
    yield* ctx.session.hook(
      "http.request",
      (evt) =>
        Effect.gen(function* () {
          if (evt.model.providerID !== Provider.ID.azure) return
-          const authorization = yield* bearer(evt.request.url)
-          if (!authorization) return
+          const connection = yield* ctx.integration.connection.active(Provider.ID.azure)
+          const credential = connection
+            ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => undefined))
+            : undefined
+          if (credential?.type !== "oauth" || credential.methodID !== methodID) return
+          const url = new URL(evt.request.url)
+          const scope =
+            url.hostname.endsWith(".services.ai.azure.com") && !url.pathname.startsWith("/models")
+              ? foundryScope
+              : cognitiveScope
+          const current = yield* token(scope).pipe(Effect.orDie)
          evt.request.headers.delete("api-key")
          evt.request.headers.delete("x-api-key")
-          evt.request.headers.set("authorization", authorization)
+          evt.request.headers.set("authorization", `Bearer ${current.access}`)
          evt.request.headers.set("user-agent", App.useragent(ctx.app))
        }),
      { providerID: Provider.ID.azure },
    )
-    yield* ctx.session.hook(
-      "experimental.ws.handshake",
-      (evt) =>
-        Effect.gen(function* () {
-          if (evt.model.providerID !== Provider.ID.azure) return
-          const authorization = yield* bearer(evt.url)
-          if (!authorization) return
-          delete evt.headers["api-key"]
-          delete evt.headers["x-api-key"]
-          evt.headers.authorization = authorization
-          evt.headers["user-agent"] = App.useragent(ctx.app)
-        }),
-      { providerID: Provider.ID.azure },
-    )

    yield* ctx.aisdk.hook(
      "sdk",
@@ -101,6 +101,7 @@ export const XAIPlugin = define({
      for (const model of provider.models.values()) {
        catalog.model.update(providerID, model.id, (draft) => {
          draft.capabilities.responsesWebsockets = true
+          draft.websocket = true
        })
      }
    })
@@ -316,28 +316,17 @@ export const layer = Layer.effect(
              return HttpClientResponse.fromWeb(sent, after.response)
            }).pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause)))))
        : undefined
+      // HTTP hooks must observe every request, so they keep the provider on HTTP.
      const webSocket =
-        input.webSocket === "session" && model.capabilities.responsesWebsockets === true && model.websocket
-      const interceptor: SessionModelTransport.Interceptor = {
-        handshake: (connect) =>
-          hooks.trigger("session", "experimental.ws.handshake", {
-            ...scope,
-            url: connect.url,
-            headers: connect.headers,
-          }),
-        send: (frame, mode) =>
-          hooks.trigger("session", "experimental.ws.send", { ...scope, mode, frame }).pipe(Effect.map((e) => e.frame)),
-        receive: (frame) =>
-          hooks.trigger("session", "experimental.ws.receive", { ...scope, frame }).pipe(Effect.map((e) => e.frame)),
-      }
+        input.webSocket === "session" &&
+        !hasHttpHooks &&
+        model.capabilities.responsesWebsockets === true &&
+        model.websocket

      return {
        event: shaped,
        request,
-        options: {
-          ...(http ? { http } : {}),
-          ...(webSocket ? { webSocket: transport.bind(session.id, interceptor) } : {}),
-        },
+        options: { ...(http ? { http } : {}), ...(webSocket ? { webSocket: transport.bind(session.id) } : {}) },
        retry: (event: Parameters<Prepared["retry"]>[0]) =>
          hooks.trigger("session", "retry", event).pipe(Effect.asVoid),
        // Permission.assert and the question tool throw declines as defects so tools cannot
@@ -2,7 +2,6 @@ export * as SessionModelTransport from "./model-transport.js"

 import {
  WebSocketTransport,
-  type ChannelCreate,
  type ChannelObservation,
  type ChannelCheckpoint,
  type WebSocketChannelExchange,
@@ -14,7 +13,6 @@ import {
 import { AIError, AIErrorReason, TransportError, type TransportOperation } from "@opencode/ai"
 import { Hash } from "@opencode/util/hash"
 import { Cause, Clock, Context, Effect, Fiber, Layer, Metric, Queue, Scope, Semaphore, Stream } from "effect"
-import { Headers } from "effect/unstable/http"
 import { Socket } from "effect/unstable/socket"
 import { makeGlobalNode } from "@opencode/util/effect/app-node"
 import { SessionSchema } from "./schema.js"
@@ -54,18 +52,8 @@ interface State {
  channel?: Channel
 }

-/** Per-exchange plugin hooks. `handshake` output selects the connection; frames are what crosses the wire. */
-export interface Interceptor {
-  readonly handshake: (connect: {
-    readonly url: string
-    readonly headers: Record<string, string>
-  }) => Effect.Effect<{ readonly url: string; readonly headers: Record<string, string> }>
-  readonly send: (frame: string, mode: ChannelCreate["mode"]) => Effect.Effect<string>
-  readonly receive: (frame: string) => Effect.Effect<string>
-}
-
 export interface Interface {
-  readonly bind: (sessionID: SessionSchema.ID, interceptor?: Interceptor) => WebSocketChannelExecutor
+  readonly bind: (sessionID: SessionSchema.ID) => WebSocketChannelExecutor
  readonly close: (sessionID: SessionSchema.ID) => Effect.Effect<void>
  readonly closeAll: Effect.Effect<void>
 }
@@ -279,8 +267,7 @@ export const makeLayer = (connector: WebSocketConnector) =>

      const start = Effect.fn("SessionModelTransport.start")(function* (
        owner: State,
-        input: WebSocketChannelExchange,
-        interceptor?: Interceptor,
+        exchange: WebSocketChannelExchange,
      ) {
        if (owner.closed)
          return yield* transportError("Session WebSocket owner is closed", {
@@ -289,16 +276,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
            phase: "queue",
            delivery: "not-sent",
          })
-        if (owner.httpFallback) return fallback(input)
-        const handshake = interceptor
-          ? yield* interceptor.handshake({ url: input.connect.url, headers: { ...input.connect.headers } })
-          : undefined
-        const exchange: WebSocketChannelExchange = handshake
-          ? {
-              ...input,
-              connect: { ...input.connect, url: handshake.url, headers: Headers.fromInput(handshake.headers) },
-            }
-          : input
+        if (owner.httpFallback) return fallback(exchange)
        const key = affinity(exchange)
        const now = yield* Clock.currentTimeMillis
        const current = owner.channel
@@ -359,7 +337,6 @@ export const makeLayer = (connector: WebSocketConnector) =>
          Effect.onInterrupt(() => closeChannel(owner, channel)),
        )
        if (create.mode === "full") channel.checkpoint = undefined
-        const message = interceptor ? yield* interceptor.send(create.message, create.mode) : create.message
        yield* Effect.logDebug("session websocket sending", {
          sessionTransport: "websocket",
          phase: "send",
@@ -370,7 +347,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
          delivery: "send-attempted",
        }
        channel.active = active
-        const sent = yield* channel.connection.sendText(message).pipe(
+        const sent = yield* channel.connection.sendText(create.message).pipe(
          Effect.withSpan("SessionModelTransport.send"),
          Effect.onInterrupt(() => closeChannel(owner, channel)),
          Effect.result,
@@ -411,7 +388,6 @@ export const makeLayer = (connector: WebSocketConnector) =>
                }),
              ),
          }),
-          Stream.mapEffect((frame) => (interceptor ? interceptor.receive(frame) : Effect.succeed(frame))),
          Stream.mapEffect((frame) => exchange.driver.observe(create, frame)),
          Stream.tap((observation) =>
            Effect.sync(() => {
@@ -489,7 +465,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
        return { frames, complete, http: channel.connection.http }
      })

-      const bind = (sessionID: SessionSchema.ID, interceptor?: Interceptor): WebSocketChannelExecutor => ({
+      const bind = (sessionID: SessionSchema.ID): WebSocketChannelExecutor => ({
        execute: (exchange) => {
          const owner = state(sessionID)
          let execution: WebSocketChannelExecution | undefined
@@ -499,7 +475,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
            },
            frames: Stream.unwrap(
              Effect.acquireRelease(owner.lock.take(1), () => owner.lock.release(1), { interruptible: true }).pipe(
-                Effect.andThen(start(owner, exchange, interceptor)),
+                Effect.andThen(start(owner, exchange)),
                Effect.tap((started) =>
                  Effect.sync(() => {
                    execution = started
@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test"
+import { CodeModeTool } from "@opencode/core/codemode/tool"
+import type { Context, Info, Result } from "@opencode/schema/tool"
+import { Effect, Schema } from "effect"
+
+// Runs `tools.probe({})` and returns what the program saw as [typeof value, value].
+const run = async (output: Info["output"], result: Result) => {
+  const tool: Info = {
+    name: "probe",
+    description: "probe",
+    input: Schema.Struct({}),
+    execute: () => Effect.succeed(result),
+    ...(output === undefined ? {} : { output }),
+  }
+  const execute = CodeModeTool.create({ tools: new Map([["probe", tool]]) }, () => Effect.succeed(result))
+  const context = { progress: () => Effect.void } as unknown as Context
+  const executed = await Effect.runPromise(
+    execute.execute({ code: "const r = await tools.probe({}); return [typeof r, r]" }, context),
+  )
+  return JSON.parse(executed.output.output)
+}
+
+// An MCP-shaped result: text content, output mirrors the text, and `{}` for a missing outputSchema.
+const mcp = (text: string) => ({ output: text, content: [{ type: "text" as const, text }] })
+
+describe("code mode parses JSON text results from MCP tools without an outputSchema", () => {
+  test("one JSON object or array text block becomes a value", async () => {
+    expect(await run({}, mcp('{"issues":[{"id":1}]}'))).toEqual(["object", { issues: [{ id: 1 }] }])
+    expect(await run({}, mcp(" [1, 2]"))).toEqual(["object", [1, 2]])
+  })
+
+  test("structuredContent is untouched", async () => {
+    expect(await run({}, { output: { a: 1 }, content: [{ type: "text", text: "ignored" }] })).toEqual([
+      "object",
+      { a: 1 },
+    ])
+  })
+
+  test("a declared output schema is never second-guessed", async () => {
+    expect(await run({ type: "string" }, mcp('{"a":1}'))).toEqual(["string", '{"a":1}'])
+    expect(await run(Schema.String, mcp('{"a":1}'))).toEqual(["string", '{"a":1}'])
+  })
+
+  test("tools without any output schema keep their advertised string result", async () => {
+    expect(await run(undefined, { content: [{ type: "text", text: '{"a":1}' }] })).toEqual(["string", '{"a":1}'])
+  })
+
+  test("primitives and prose stay strings", async () => {
+    expect(await run({}, mcp("42"))).toEqual(["string", "42"])
+    expect(await run({}, mcp("null"))).toEqual(["string", "null"])
+    expect(await run({}, mcp("[INFO] started"))).toEqual(["string", "[INFO] started"])
+    expect(await run({}, mcp("{not json"))).toEqual(["string", "{not json"])
+  })
+
+  test("multiple text blocks are joined, not parsed", async () => {
+    const content = [
+      { type: "text" as const, text: "Result:" },
+      { type: "text" as const, text: '{"a":1}' },
+    ]
+    expect(await run({}, { output: 'Result:\n{"a":1}', content })).toEqual(["string", 'Result:\n{"a":1}'])
+  })
+})
@@ -303,20 +303,6 @@ describe("AzurePlugin", () => {
          })
          expect(foundry.request.headers.get("authorization")).toBe("Bearer https://ai.azure.com/.default-token")
          expect(foundry.request.headers.has("x-api-key")).toBe(false)
-
-          const handshake = yield* hooks.trigger("session", "experimental.ws.handshake", {
-            sessionID: Session.ID.make("ses_azure_ws"),
-            agent: Agent.ID.make("build"),
-            model,
-            kind: "primary",
-            url: "wss://test-resource.openai.azure.com/openai/v1/responses",
-            headers: { "api-key": "stored-token", "x-keep": "yes" },
-          })
-          expect(handshake.headers).toMatchObject({
-            authorization: "Bearer https://cognitiveservices.azure.com/.default-token",
-            "x-keep": "yes",
-          })
-          expect(handshake.headers["api-key"]).toBeUndefined()
        }),
    ),
  )
@@ -69,7 +69,7 @@ describe("XAIPlugin", () => {
    }),
  )

-  it.effect("keeps xAI Responses WebSockets opt-in", () =>
+  it.effect("enables xAI Responses WebSockets", () =>
    Effect.gen(function* () {
      const catalog = yield* Catalog.Service
      const providerID = Provider.ID.make("xai")
@@ -84,7 +84,7 @@ describe("XAIPlugin", () => {

      const model = yield* catalog.model.get(providerID, Model.ID.make("grok-4.6"))
      expect(model?.capabilities.responsesWebsockets).toBe(true)
-      expect(model?.websocket).toBeUndefined()
+      expect(model?.websocket).toBe(true)
    }),
  )
 })
@@ -79,68 +79,4 @@ describe("SessionModelRequest HTTP hooks", () => {
      )
    }).pipe(Effect.provideService(SessionModelTransport.Service, transport)),
  )
-
-  it.effect("runs experimental.ws hooks through the transport interceptor alongside http hooks", () =>
-    Effect.gen(function* () {
-      const hooks = yield* PluginHooks.Service
-      const seen: Array<string> = []
-      yield* hooks.register("session", "http.request", () => Effect.void)
-      yield* hooks.register("session", "experimental.ws.handshake", (event) =>
-        Effect.sync(() => {
-          seen.push(`handshake:${event.kind}:${event.agent}`)
-          event.url = `${event.url}?hooked`
-          event.headers.authorization = "Bearer hooked"
-        }),
-      )
-      yield* hooks.register("session", "experimental.ws.send", (event) =>
-        Effect.sync(() => {
-          seen.push(`send:${event.kind}:${event.mode}`)
-          event.frame = `${event.frame}:sent`
-        }),
-      )
-      yield* hooks.register("session", "experimental.ws.receive", (event) =>
-        Effect.sync(() => {
-          seen.push(`receive:${event.kind}`)
-          event.frame = `${event.frame}:received`
-        }),
-      )
-      let interceptor: SessionModelTransport.Interceptor | undefined
-      const capturing = SessionModelTransport.Service.of({
-        bind: (_sessionID, bound) => {
-          interceptor = bound
-          return { execute: () => Effect.die("unused WebSocket execution") }
-        },
-        close: () => Effect.void,
-        closeAll: Effect.void,
-      })
-      const requests = yield* SessionModelRequest.Service.pipe(
-        Effect.provide(SessionModelRequest.layer),
-        Effect.provideService(SessionModelTransport.Service, capturing),
-      )
-      const prepared = yield* requests.compaction({
-        session,
-        agent: Agent.ID.make("build"),
-        model: SessionRunnerModel.resolved(OpenAIChat.route.model({ id: "gpt-5.5", provider: "test" }), {
-          capabilities: { tools: true, input: ["text"], output: ["text"], responsesWebsockets: true },
-          cost: [],
-          limit: { context: 200_000, output: 32_000 },
-          websocket: true,
-        }),
-        system: [],
-        messages: [],
-        webSocket: "session",
-      })
-      expect(prepared.options.http).toBeDefined()
-      expect(prepared.options.webSocket).toBeDefined()
-      if (!interceptor) throw new Error("Expected the transport to receive an interceptor")
-
-      expect(yield* interceptor.handshake({ url: "wss://example.test/v1/responses", headers: {} })).toMatchObject({
-        url: "wss://example.test/v1/responses?hooked",
-        headers: { authorization: "Bearer hooked" },
-      })
-      expect(yield* interceptor.send("frame", "incremental")).toBe("frame:sent")
-      expect(yield* interceptor.receive("frame")).toBe("frame:received")
-      expect(seen).toEqual(["handshake:compaction:build", "send:compaction:incremental", "receive:compaction"])
-    }),
-  )
 })
@@ -822,36 +822,6 @@ describe("SessionModelTransport", () => {
    )
  })

-  test("runs interceptors on the handshake and both frame directions", async () => {
-    const fixture = automatic()
-    const seen: Array<string> = []
-    let authorization = "one"
-
-    await run(
-      fixture.connector,
-      Effect.gen(function* () {
-        const transport = yield* SessionModelTransport.Service
-        const executor = transport.bind(session, {
-          handshake: (connect) =>
-            Effect.succeed({ url: `${connect.url}?hooked`, headers: { ...connect.headers, authorization } }),
-          send: (frame, mode) => Effect.succeed(`${frame}:${mode}`),
-          receive: (frame) =>
-            Effect.sync(() => {
-              seen.push(frame)
-              return frame.toUpperCase()
-            }),
-        })
-        expect(yield* collect(executor, exchange("first"))).toEqual(["COMPLETED:FIRST:FULL"])
-        authorization = "two"
-        expect(yield* collect(executor, exchange("second"))).toEqual(["COMPLETED:SECOND:FULL"])
-        expect(seen).toEqual(["completed:first:full", "completed:second:full"])
-        expect(fixture.connections).toHaveLength(2)
-        expect(fixture.connections.map((item) => item.headers.authorization)).toEqual(["one", "two"])
-        expect(fixture.connections.map((item) => item.sent)).toEqual([["first:full"], ["second:full"]])
-      }),
-    )
-  })
-
  test("rotates when the connection exceeds its requested age limit", async () => {
    const fixture = automatic()

@@ -1944,7 +1944,16 @@ describe("SessionRunnerLLM", () => {
    expect(yield* entries.list(sessionID)).toEqual([{ key: "nullable", value: null }])
  })

-  scenario("rejects API instruction entries larger than 8KB", function* () {
+  scenario("accepts API instruction entries up to 256 KiB", function* () {
+    const entries = yield* InstructionEntry.Service
+    const value = "x".repeat(InstructionEntry.MaxValueBytes - 2)
+
+    yield* entries.put({ sessionID, key: "large", value })
+
+    expect(yield* entries.list(sessionID)).toEqual([{ key: "large", value }])
+  })
+
+  scenario("rejects API instruction entries larger than 256 KiB", function* () {
    const entries = yield* InstructionEntry.Service

    const exit = yield* entries
@@ -86,34 +86,6 @@ export interface SessionHttpResponse {
  response: Response
 }

-/** Connection a WebSocket request needs. Changing `url` or `headers` reopens the Session's socket. */
-export interface SessionWebSocketHandshake {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-  readonly kind: SessionRequestKind
-  url: string
-  headers: Record<string, string>
-}
-
-export interface SessionWebSocketSend {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-  readonly kind: SessionRequestKind
-  /** Incremental frames carry only what changed since the provider's last checkpoint. */
-  readonly mode: "full" | "incremental"
-  frame: string
-}
-
-export interface SessionWebSocketReceive {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-  readonly kind: SessionRequestKind
-  frame: string
-}
-
 export type SessionRetryDecision = { retry: false } | { retry: true; delay: number }

 export interface SessionRetry {
@@ -134,9 +106,6 @@ export interface SessionHooks {
  readonly "model.request": SessionModelRequest
  readonly "http.request": SessionHttpRequest
  readonly "http.response": SessionHttpResponse
-  readonly "experimental.ws.handshake": SessionWebSocketHandshake
-  readonly "experimental.ws.send": SessionWebSocketSend
-  readonly "experimental.ws.receive": SessionWebSocketReceive
  readonly retry: SessionRetry
 }

@@ -86,34 +86,6 @@ export interface SessionHttpResponse {
  response: Response
 }

-/** Connection a WebSocket request needs. Changing `url` or `headers` reopens the Session's socket. */
-export interface SessionWebSocketHandshake {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-  readonly kind: SessionRequestKind
-  url: string
-  headers: Record<string, string>
-}
-
-export interface SessionWebSocketSend {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-  readonly kind: SessionRequestKind
-  /** Incremental frames carry only what changed since the provider's last checkpoint. */
-  readonly mode: "full" | "incremental"
-  frame: string
-}
-
-export interface SessionWebSocketReceive {
-  readonly sessionID: Session.ID
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
-  readonly kind: SessionRequestKind
-  frame: string
-}
-
 export type SessionRetryDecision = { retry: false } | { retry: true; delay: number }

 export interface SessionRetry {
@@ -134,9 +106,6 @@ export interface SessionHooks {
  readonly "model.request": SessionModelRequest
  readonly "http.request": SessionHttpRequest
  readonly "http.response": SessionHttpResponse
-  readonly "experimental.ws.handshake": SessionWebSocketHandshake
-  readonly "experimental.ws.send": SessionWebSocketSend
-  readonly "experimental.ws.receive": SessionWebSocketReceive
  readonly retry: SessionRetry
 }

@@ -27,7 +27,7 @@ export const Snapshot = Schema.Array(
 ).annotate({ identifier: "InstructionEntry.Snapshot" })
 export type Snapshot = typeof Snapshot.Type

-export const MaxValueBytes = 8 * 1024
+export const MaxValueBytes = 256 * 1024

 export class ValueTooLargeError extends Schema.TaggedError<ValueTooLargeError>()(
  "InstructionEntryValueTooLargeError",
@@ -427,17 +427,6 @@ export function SessionCompactionMessage(props: { message: SessionMessageCompact
      <div class="py-2">
        <TimelineSeparator label={i18n.t("ui.messagePart.compaction.started")} />
      </div>
-      <Show when={props.message.status === "running"}>
-        <div role="status" class="py-2">
-          <BasicTool
-            icon="archive"
-            trigger={{ title: i18n.t("ui.messagePart.compaction.running") }}
-            status="running"
-            locked
-            hideDetails
-          />
-        </div>
-      </Show>
      <Show when={summary().trim()}>
        <div data-component="text-part" data-timeline-part-id={props.message.id}>
          <div data-slot="text-part-body">
@@ -449,6 +438,17 @@ export function SessionCompactionMessage(props: { message: SessionMessageCompact
          </div>
        </div>
      </Show>
+      <Show when={props.message.status === "running"}>
+        <div role="status" class="py-2">
+          <BasicTool
+            icon="archive"
+            trigger={{ title: i18n.t("ui.messagePart.compaction.running") }}
+            status="running"
+            locked
+            hideDetails
+          />
+        </div>
+      </Show>
      <Show when={props.message.status !== "running"}>
        <div class="py-2">
          <TimelineSeparator label={label()} />
@@ -51,7 +51,8 @@ export function createClipboardAdapter(clipboard: CoreClipboardService): OwnedCl
      throw new Error(`Unexpected clipboard MIME type: ${result.representation.mimeType}`)
    },
    async write(text) {
-      const result = await clipboard.writeText(text, {
+      // OpenTUI rejects NUL before any destination; host clipboard text cannot contain it.
+      const result = await clipboard.writeText(text.replaceAll("\0", ""), {
        destination: "all-available",
        selection: "clipboard",
      })
@@ -102,6 +102,19 @@ test("uses all available routes but skips the process host remotely", async () =
  expect(writes).toEqual({ host: 0, terminal: 1 })
 })

+test("removes NUL characters before writing", async () => {
+  const writes: string[] = []
+  const clipboard = createClipboardAdapter(
+    coreClipboard({
+      onWrite: (text) => writes.push(text),
+    }),
+  )
+
+  expect(await clipboard.write("before\0after")).toBeUndefined()
+  expect(await clipboard.write("clean")).toBeUndefined()
+  expect(writes).toEqual(["beforeafter", "clean"])
+})
+
 test("rejects only when no clipboard route accepted the write", async () => {
  const writes: [string, ClipboardWriteOptions][] = []
  const failure = new Error("native clipboard failed")
@@ -1151,24 +1151,6 @@ effect: (ctx) =>
  }),
 ```

-WebSocket providers do not issue one HTTP request per model call, so the HTTP hooks never see that traffic. Three
-experimental hooks cover it: `experimental.ws.handshake` runs once per model call with the URL and headers the connection
-needs (changing either reopens the session's socket), `experimental.ws.send` runs on the outbound frame, and
-`experimental.ws.receive` on every inbound frame. Incremental `send` frames carry only what changed since the provider's
-last checkpoint; rewriting them changes what the provider sees without changing what OpenCode believes it sent.
-
-```ts
-effect: (ctx) =>
-  Effect.gen(function* () {
-    yield* ctx.session.hook("experimental.ws.handshake", (event) =>
-      Effect.sync(() => {
-        event.headers.authorization = `Bearer ${token}`
-      }),
-    )
-    yield* ctx.session.hook("experimental.ws.receive", (event) => Effect.log(event.frame))
-  }),
-```
-
 Override the retry decision for a provider failure or replace its delay in milliseconds. The hook runs after OpenCode
 classifies the failure and proposes its policy, but before any retry is scheduled. It does not expose how OpenCode
 internally performs the next attempt.
@@ -1209,9 +1191,6 @@ interface SessionHooks {
  readonly "model.request": SessionModelRequest
  readonly "http.request": SessionHttpRequest
  readonly "http.response": SessionHttpResponse
-  readonly "experimental.ws.handshake": SessionWebSocketHandshake
-  readonly "experimental.ws.send": SessionWebSocketSend
-  readonly "experimental.ws.receive": SessionWebSocketReceive
  readonly retry: SessionRetry
 }

@@ -1294,32 +1294,6 @@ await ctx.session.hook("http.response", (event) => {
 })
 ```

-#### WebSocket (experimental)
-
-Providers that stream over a WebSocket do not issue one HTTP request per model call, so `http.request` and
-`http.response` never see that traffic. Three experimental hooks cover it instead. `experimental.ws.handshake` runs
-once per model call with the URL and headers the connection needs; changing either reopens the session's socket.
-`experimental.ws.send` runs on the outbound frame, and `experimental.ws.receive` on every inbound frame. All three carry
-the same `sessionID`, `agent`, `model`, and `kind` as the HTTP hooks.
-
-```ts
-await ctx.session.hook("experimental.ws.handshake", (event) => {
-  event.headers.authorization = `Bearer ${token}`
-})
-
-await ctx.session.hook("experimental.ws.send", (event) => {
-  if (event.mode === "full") event.frame = redact(event.frame)
-})
-
-await ctx.session.hook("experimental.ws.receive", (event) => {
-  log(event.frame)
-})
-```
-
-`send` frames in `"incremental"` mode carry only what changed since the provider's last checkpoint. Rewriting them
-changes what the provider sees without changing what OpenCode believes it sent, so treat them as read-only unless you
-also handle the resulting drift.
-
 #### Retry policy

 Override the retry decision for a provider failure or replace its delay in milliseconds. The hook runs after OpenCode
@@ -1365,9 +1339,6 @@ interface SessionHooks {
  "model.request": SessionModelRequestHook
  "http.request": SessionHttpRequestHook
  "http.response": SessionHttpResponseHook
-  "experimental.ws.handshake": SessionWebSocketHandshakeHook
-  "experimental.ws.send": SessionWebSocketSendHook
-  "experimental.ws.receive": SessionWebSocketReceiveHook
  retry: SessionRetryHook
 }

@@ -110,10 +110,11 @@ role for other Foundry models. If a request fails because the token belongs to a

 ## WebSocket transport

-OpenAI and supported Azure Responses models keep one WebSocket connection open per session and send each step over it
-instead of opening a new HTTP request. While the request prefix is unchanged, consecutive steps only transmit what was
-added since the previous response, which cuts upload volume on long sessions. Provider compaction runs over the same
-connection.
+OpenAI, xAI, and supported Azure Responses models keep one WebSocket connection open per session and send each step
+over it instead of opening a new HTTP request. While the request prefix is unchanged, consecutive steps only transmit
+what was added since the previous response, which cuts upload volume on long sessions. OpenAI provider compaction runs
+over the same connection. xAI continues a chain only from stored responses, so with its default `store: false` each step
+is sent in full over the reused connection.

 The connection is transparent. When the provider closes the socket, the next step reconnects; when a connection cannot
 be opened at all, the session continues over HTTP. Plugins that register `http.request` or `http.response` hooks for a
Author	SHA1	Message	Date
Aiden Cline	003c800056	chore(core): keep import formatting	2026-09-10 12:15:17 -05:00
Aiden Cline	d2b4eaf972	refactor(core): keep the original output return, parse before it	2026-09-10 12:14:52 -05:00
Aiden Cline	85ff0b522e	refactor(core): use startsWith for the JSON text check	2026-09-10 12:10:09 -05:00
Aiden Cline	2d6328f492	refactor(core): spell out the JSON text check	2026-09-10 12:09:35 -05:00
Aiden Cline	895479f2d8	refactor(core): simplify the code mode JSON text parse	2026-09-10 12:08:35 -05:00
Aiden Cline	efae1de63f	refactor(core): inline the code mode JSON text parse	2026-09-10 11:49:54 -05:00
Aiden Cline	7551adbf62	feat(core): parse JSON text tool results in code mode	2026-09-10 11:41:56 -05:00
opencode-agent[bot]andnexxeln	9e153ce7b3	fix(core): raise instruction entry limit (#48350 ) Co-authored-by: nexxeln <nexxeln@users.noreply.github.com>	2026-09-10 20:59:38 +05:30
Simon Klee	eb357f17cf	fix(tui): strip NUL characters before clipboard writes (#48337 )	2026-09-10 15:47:03 +02:00
Shoubhit Dash	573d76933f	fix(ai): make xAI Responses websockets work and enable them (#48318 )	2026-09-10 17:27:43 +05:30
usrnk1andBrendonovich	bb8194395a	feat(desktop): respect follow-up behavior for slash commands (#48169 ) Co-authored-by: Brendonovich <14191578+Brendonovich@users.noreply.github.com>	2026-09-10 19:24:23 +08:00
opencode-agent[bot]andHona	2e8ed86658	fix(app): move compaction status below summary (#48262 ) Co-authored-by: Hona <10430890+Hona@users.noreply.github.com>	2026-09-10 18:27:08 +08:00
Brendan Allan	2695607fbc	fix(app): stabilize optimistic prompt position (#46723 )	2026-09-10 17:49:55 +08:00
Aiden Cline	f3ef84556a	feat(codemode): add atob, btoa, and crypto.randomUUID (#48290 )	2026-09-10 01:21:41 -05:00
Aiden Cline	08ff21179c	fix(codemode): hoist switch-case functions and memoize var names (#48287 )	2026-09-10 00:42:08 -05:00