fix(core): route Vertex multi-regions through REP

Co-authored-by: Aiden Cline <rekram1-node@users.noreply.github.com>

.changeset/quiet-forms-replace-questions.md

@@ -0,0 +1,8 @@
+---
+"@opencode-ai/core": minor
+"@opencode-ai/schema": minor
+"@opencode-ai/protocol": minor
+"@opencode-ai/client": minor
+---
+
+Remove the unused question request API and use session forms for question tool interactions.

.changeset/shell-permission-scan.md

@@ -5,4 +5,5 @@
 "@opencode-ai/client": minor
 ---
 
-Replace Core shell permission parsing with portable, fail-closed Bash and PowerShell scanners.
+Add an opt-in portable shell permission scanner. Opaque commands use normal shell authorization without inferring
+external directories, while the default tree-sitter path remains unchanged.

.github/workflows/deploy-lab-catalog.yml

@@ -1,49 +0,0 @@
-name: deploy-lab-catalog
-
-on:
-  push:
-    branches: [v2]
-    paths:
-      - ".github/workflows/deploy-lab-catalog.yml"
-      - "bun.lock"
-      - "package.json"
-      - "packages/drive/**"
-      - "packages/protocol/src/simulation.ts"
-      - "packages/simulation/**"
-      - "packages/lab/catalog/**"
-  workflow_dispatch:
-
-concurrency:
-  group: deploy-lab-catalog-${{ github.ref_name }}
-  cancel-in-progress: false
-
-permissions:
-  contents: read
-
-jobs:
-  deploy:
-    if: github.repository == 'anomalyco/opencode' && github.ref_name == 'v2'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
-
-      - uses: ./.github/actions/setup-bun
-
-      - name: Install ffmpeg
-        run: |
-          sudo apt-get update
-          sudo apt-get install --yes ffmpeg
-
-      - name: Validate
-        run: |
-          bun --cwd packages/protocol typecheck
-          bun --cwd packages/simulation typecheck
-          bun --cwd packages/drive run check
-          bun --cwd packages/drive run test
-          bun --cwd packages/lab/catalog run check
-
-      - name: Deploy
-        working-directory: packages/lab/catalog
-        run: bun run deploy
-        env:
-          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

.github/workflows/test.yml

@@ -72,20 +72,10 @@ jobs:
 
       - name: Run unit tests
         timeout-minutes: 20
-        run: GITHUB_ACTIONS=false bun turbo test ${{ runner.os == 'Windows' && '--filter=!opencode-drive' || '' }}
+        run: GITHUB_ACTIONS=false bun turbo test
         env:
           OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: ${{ runner.os == 'Windows' && 'true' || 'false' }}
 
-      - name: Verify PowerShell 7 scanner conformance
-        if: always() && runner.os == 'Windows'
-        working-directory: packages/shell-scan
-        run: PWSH=pwsh bun run research:powershell
-
-      - name: Verify Windows PowerShell scanner conformance
-        if: always() && runner.os == 'Windows'
-        working-directory: packages/shell-scan
-        run: PWSH=powershell.exe bun run research:powershell
-
       - name: Verify compiled service lifecycle
         if: always()
         timeout-minutes: 10

.opencode/skills/opencode-drive/SKILL.md

@@ -1,253 +0,0 @@
----
-name: opencode-drive
-description: Use when an agent needs drive OpenCode via a script or interact with an isolated instance
----
-
-# OpenCode Drive
-
-Use `opencode-drive` to launch an isolated OpenCode instance and control it via commands or a script.
-
-There are two modes. Always default to using a script unless specifically directed to be interactive (connect
-to an existing running instance, or start a new one, and make a few changes to the UI and read it, and iterate
-on changes).
-
-Scripts allow you to run a full walkthrough in one run. When the script is done opencode-drive exits,
-stops all processes, and cleans up all artifacts.
-
-# Prepare The Environment
-
-Use `init` when files must be added to the isolated home or project before OpenCode starts. It prints the artifact directory without launching OpenCode. A later `start` with the same name reuses it.
-
-```bash
-artifacts=$(opencode-drive init --name demo)
-cp -R ./fixtures/home/. "$artifacts/"
-cp -R ./fixtures/project/. "$artifacts/files/"
-opencode-drive start --name demo --dev ~/projects/opencode
-```
-
-The simulated project is under `$artifacts/files`. Running `start` without a prior `init` initializes the artifacts automatically.
-
-# Scripted usage
-
-You can write scripts that walk through entire flows, and gives you full access to controlling
-the backend too. See examples of the script API at the bottom of this file.
-
-After creating or editing a script, always typecheck it before running. Never skip this step:
-
-```bash
-opencode-drive check ./reproduce-stale-exploring-empty.ts
-```
-
-Run it by passing `--script` to start:
-
-```bash
-opencode-drive start --name auto-stop-reproduction --script ./reproduce-stale-exploring-empty.ts
-```
-
-It will output information about the run, including paths to log files which you can read
-to inspect what happened. If you need to dig into failures that aren't clear, read those log
-files. If the script is unsuccessful, automatically fix the script and run it again.
-
-Scripts use one typed definition object. `setup` runs before OpenCode starts,
-and `fs.writeFile` always writes inside the simulated project.
-
-You can read the full typed API here: https://raw.githubusercontent.com/anomalyco/opencode/v2/packages/drive/src/script/types.ts
-
-```ts
-import { defineScript } from "opencode-drive"
-
-export default defineScript({
-  async setup({ fs, config }) {
-    config.autoupdate = false
-    await fs.writeFile("src/example.ts", "export const value = 1\n")
-  },
-
-  async run({ ui, llm }) {
-    await ui.submit("Open src/example.ts")
-    await llm.send(llm.text("The file exports `value`."))
-    await ui.waitFor("The file exports `value`.")
-  },
-})
-```
-
-`setup` receives the current OpenCode config object, which starts from the
-default drive config unless the prepared instance already has one. When a script
-needs custom config, mutate this `config` parameter instead of generating and
-writing a new config object from scratch, so the script keeps the default
-provider/model settings unless it intentionally changes them.
-
-Note that the simulated model is a GPT model type, and opencode uses the `patch` tool for working with files Do not use a `edit` or `write` tool to edit files.
-
-Use `launch: "manual"` when the script needs to launch the server and every TUI
-itself (this is extremely rare, do not use this unless explicitly asked). In this
-mode `ui` is typed as `null`; call `server.launch()` exactly
-once before launching clients. Each `clients.launch(name)` result provides the
-same UI methods as the automatic client. You can see an example of this API
-here: https://raw.githubusercontent.com/anomalyco/opencode/v2/packages/drive/examples/multiple-clients.ts
-
-Use the exported `wait(milliseconds)` utility for an unconditional delay.
-
-`await llm.send(...)` waits for the next request and resolves after OpenCode
-acknowledges its complete response. `llm.queue(...)` declares responses in
-advance. Chunks may be built with `text`, `reasoning`, `toolCall`, `raw`,
-`finish`, and `disconnect`. A normal response receives `finish("stop")`
-automatically unless it yields or queues an explicit terminal event.
-
-`llm.text(text, { delay, chunkSize })` defaults to a 2 ms delay and a
-15-character target varied by plus or minus 5 per chunk.
-
-`llm.reasoning` accepts the same options, and `llm.pause(milliseconds)` adds a
-delay between any two outputs.
-
-Use `llm.serve` for an ongoing typed response generator:
-
-```ts
-llm.serve(async function* (request, index) {
-  yield llm.reasoning(`Handling request ${index + 1}`)
-  yield llm.text(`Received ${request.id}`)
-  yield llm.finish("stop")
-})
-```
-
-The backend connection, response cleanup, cancellation, and recording
-completion are automatic.
-
-You can see some example scripts here:
-
-- https://raw.githubusercontent.com/anomalyco/opencode/v2/packages/drive/examples/simple.ts
-- https://raw.githubusercontent.com/anomalyco/opencode/v2/packages/drive/examples/serve.ts
-
-## Prune
-
-- `prune` removes artifact directories. These are always cleaned up after running a script
-  successfully, but leftover on failed runs. Always call this if a script fails.
-
-```bash
-opencode-drive prune --name demo
-
-// --force cleans up all artifcat directories
-opencode-dirve prune --force
-```
-
-# Live interaction usage
-
-- Always give headless instances a unique `--name`. Visible instances may omit it.
-- A normal headless `start` detaches automatically and returns after the instance is ready.
-- Do not add `&`; the long-running owner already runs in the background.
-- Configure simulated model responses after startup when needed.
-- Send ordered UI commands with `send`.
-- Always stop the instance when finished.
-
-```bash
-opencode-drive start --name demo
-
-opencode-drive send --name demo \
-  --command.ui.type '{"text":"Explain this project"}' \
-  --command.ui.enter
-
-opencode-drive stop --name demo
-```
-
-## Send UI Commands
-
-- Every `send` opens a connection to the named instance, runs its commands in order, and exits.
-- Combine typing and Enter in one command when submitting a prompt.
-- JSON-valued commands require one JSON argument.
-- Multiple command flags execute from left to right.
-
-Commands:
-
-- `--command.ui.type <json>` types into the focused editor. Arguments: `text` string.
-- `--command.ui.press <json>` presses a key. Arguments: `key` string; optional `modifiers` object with boolean `ctrl`, `shift`, `meta`, `super`, or `hyper`.
-- `--command.ui.enter` presses Enter. Arguments: none.
-- `--command.ui.arrow <json>` presses an arrow key. Arguments: `direction` is `up`, `down`, `left`, or `right`.
-- `--command.ui.focus <json>` focuses an element. Arguments: `target` is the numeric element `num` returned by `ui.state`.
-- `--command.ui.click <json>` clicks an element. Arguments: numeric `target`, `x`, and `y`; use the element `num` returned by `ui.state` as `target`.
-- `--command.ui.state` prints focus and interactive element metadata as JSON. Arguments: none.
-- `--command.ui.matches <json>` prints whether literal, case-sensitive text appears on screen. Arguments: `text` string.
-
-```bash
-opencode-drive send --name demo \
-  --command.ui.type '{"text":"Find the relevant code and explain it"}' \
-  --command.ui.enter
-
-opencode-drive send --name demo \
-  --command.ui.press '{"key":"p","modifiers":{"ctrl":true}}'
-
-opencode-drive send --name demo \
-  --command.ui.arrow '{"direction":"down"}'
-
-opencode-drive send --name demo \
-  --command.ui.focus '{"target":12}'
-
-opencode-drive send --name demo \
-  --command.ui.click '{"target":12,"x":4,"y":1}'
-
-opencode-drive send --name demo \
-  --command.ui.matches '{"text":"OpenCode"}'
-```
-
-To read the UI state and see information about interactable elements, use the `ui.state` command:
-
-```bash
-opencode-drive send --name demo --command.ui.state
-```
-
-## Configure LLM Responses
-
-- `responses` controls what the LLM responds with
-- Only use this if you are wanting to reproduce an exact type of response
-- Defaults are `text,reasoning,diff,tool` with `write,apply_patch`.
-- Supported types are `text`, `reasoning`, `diff`, and `tool`.
-- `--tools` limits generated tool calls to names offered by OpenCode.
-
-```bash
-opencode-drive responses --name demo \
-  --types text,reasoning,diff,tool \
-  --tools write,apply_patch
-
-opencode-drive responses --name demo \
-  --types tool \
-  --tools read,glob,grep
-```
-
-## Inspect The UI
-
-- `ui.state` prints focus and interactive element metadata as JSON.
-- `ui.matches` checks for literal, case-sensitive screen text.
-- `screenshot` prints the generated image path.
-
-```bash
-opencode-drive screenshot --name demo
-```
-
-## Lifecycle
-
-- `stop` waits for recording export and owner cleanup before returning.
-
-```bash
-opencode-drive stop --name demo
-```
-
-# Record The UI
-
-- Start with `--record` to capture a headless instance from its first rendered frame.
-- `stop` finishes the recording, exports an MP4, and prints its path.
-
-```bash
-opencode-drive start --name demo --record
-
-opencode-drive send --name demo \
-  --command.ui.type '{"text":"Show me the current architecture"}' \
-  --command.ui.enter
-
-opencode-drive stop --name demo
-```
-
-# Artifacts dir
-
-- `dir` prints the artifact directory for the instance.
-
-```bash
-opencode-drive dir --name demo
-```

AGENTS.md

@@ -12,6 +12,20 @@
 - The script discovers the server with `opencode2 service status`, injects its private local credential from `opencode2 service get password`, and uses the `next` TUI storage channel so tabs and other client-local state match the installed client.
 - Prefer `dev:live` over plain `bun run dev` for this workflow. An implicit managed-service connection may replace the live server when the worktree client version differs; explicit `--server` warns and continues without replacing it.
 
+## V2 TUI Stories
+
+- When a user asks for a TUI story, add a fixture-driven story under `packages/tui/src/feature-plugins/system/storybook` and register it in `index.tsx`.
+- Render the real production component rather than a visual copy. Keep submissions and other side effects local to the story so it is safe to explore repeatedly.
+- Expose the meaningful state dimensions through story keybindings and list them in `StoryFooter`; include a reset command when combinations can leave the fixture in a confusing state.
+- Run a specific story with `OPENCODE_STORY=<story-id> bun run dev:live` from the development worktree, and exercise narrow and wide terminal sizes when layout is relevant.
+
+## TUI Theme Tokens
+
+- Choose theme tokens by semantic role, not by their current color. Do not use raw `theme.hue` values or borrow an unrelated semantic token to achieve a preferred appearance.
+- Use `text.feedback` and `background.feedback` only for outcome or status feedback such as errors, warnings, success messages, and informational messages. Use `formfield` states for form-control text, ordinals, and selection markers, and `action` states for actions.
+- If the theme does not expose a token for the required semantic role, extend the theme schema, defaults, resolution, and types with that role before using it in a component. Do not repurpose the nearest-looking existing token.
+- When changing the public theme token surface, verify the built-in light and dark defaults and the custom-theme fallback path in addition to the affected TUI component.
+
 ## Branch Names
 
 Use a short branch name of at most three words, separated by hyphens. Do not use slashes or type prefixes such as `feat/` or `fix/`.

package.json

@@ -33,7 +33,6 @@
     "packages": [
       "packages/*",
       "packages/console/*",
-      "packages/lab/*",
       "packages/stats/*",
       "packages/slack"
     ],
@@ -47,9 +46,9 @@
       "@octokit/rest": "22.0.0",
       "@hono/standard-validator": "0.2.0",
       "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.2",
-      "@opentui/keymap": "0.5.2",
-      "@opentui/solid": "0.5.2",
+      "@opentui/core": "0.5.3",
+      "@opentui/keymap": "0.5.3",
+      "@opentui/solid": "0.5.3",
       "@tanstack/solid-virtual": "3.13.32",
       "@shikijs/stream": "4.2.0",
       "@standard-schema/spec": "1.1.0",
@@ -145,6 +144,10 @@
     "esbuild",
     "node-pty",
     "protobufjs",
+    "tree-sitter",
+    "tree-sitter-bash",
+    "tree-sitter-powershell",
+    "web-tree-sitter",
     "electron"
   ],
   "overrides": {
@@ -170,7 +173,6 @@
     "@modelcontextprotocol/sdk@1.29.0": "patches/@modelcontextprotocol%2Fsdk@1.29.0.patch",
     "effect@4.0.0-beta.101": "patches/effect@4.0.0-beta.101.patch",
     "@tanstack/virtual-core@3.17.3": "patches/@tanstack%2Fvirtual-core@3.17.3.patch",
-    "@cloudflare/vitest-pool-workers@0.12.6": "patches/@cloudflare%2Fvitest-pool-workers@0.12.6.patch",
     "@ff-labs/fff-bun@0.10.1": "patches/@ff-labs%2Ffff-bun@0.10.1.patch"
   }
 }

packages/ai/AGENTS.md

@@ -80,7 +80,7 @@ Route defaults are request-shaping defaults such as `headers`, `limits`, `genera
 
 The four-axis decomposition is the reason DeepSeek, TogetherAI, Cerebras, Baseten, Fireworks, and DeepInfra all reuse `OpenAIChat.protocol` verbatim — each provider deployment is a 5-15 line `Route.make(...)` call instead of a 300-400 line route clone. Bug fixes in one protocol propagate to every consumer of that protocol in a single commit.
 
-When a provider ships a non-HTTP transport (OpenAI's WebSocket Responses backend, hypothetical bidirectional streaming APIs), the seam is `Transport` — `WebSocketTransport.jsonTransport.with(...)` constructs an IO template whose `prepare` receives the route endpoint/auth at compile time, builds a WebSocket URL and message, and whose `frames` yields decoded text from the socket. Same protocol and endpoint source, different transport.
+When a provider supports multiple physical transports, selection remains execution policy below its semantic route. `OpenResponsesChannel.transport(...)` owns the provider-neutral Responses WebSocket concept: it prepares one final request, executes HTTP by default, strips WebSocket-disallowed fields, and passes a generic channel exchange to a per-call `WebSocketChannelExecutor` when supplied. Provider-specific Responses routes opt in with handshake and connection-age policy. `Route.streamPrepared` owns decoding and acknowledges channel completion only after successful full consumption.
 
 ### URL Construction
 
@@ -106,7 +106,7 @@ const proxied = gateway.model("openai/gpt-4o-mini")
 Keep provider facades small and explicit:
 
 - Use branded `ProviderID.make(...)` and `ModelID.make(...)` where ids are constructed directly.
-- Use `model` for the default API path and named methods for provider-native alternatives such as OpenAI `responses`, `responsesWebSocket`, and `chat`.
+- Use `model` for the default API path and named methods for provider-native alternatives such as OpenAI `responses` and `chat`.
 - Put provider-specific setup on `.configure(...)`; do not add `model(id, overrides)` as a duplicate construction path.
 - Export lower-level `routes` arrays separately only when advanced internal wiring needs them.
 - Prefer `apiKey` as provider-specific sugar and `auth` as the explicit override; keep them mutually exclusive in provider option types with `ProviderAuthOption`.
@@ -124,11 +124,10 @@ import { model } from "@opencode-ai/ai/providers/openai/responses"
 
 const selected = model("gpt-5", {
   apiKey,
-  transport: "websocket",
 })
 ```
 
-Keep semantic APIs as separate entrypoints, such as OpenAI `chat` and `responses`. Keep transport choices inside the semantic entrypoint settings, so OpenAI Responses HTTP and WebSocket share one entrypoint. Provider facades may still expose named selectors such as `responsesWebSocket` for direct typed call sites; the package-like contract maps its settings to those selectors before returning an executable `LanguageModel`.
+Keep semantic APIs as separate entrypoints, such as OpenAI `chat` and `responses`. Transport is execution policy: OpenAI Responses uses HTTP by default and may receive a per-call WebSocket channel executor through `StreamOptions` without changing model or route identity.
 
 Do not expose `Route` in provider package settings. Route composition stays an implementation detail behind `model(...)`.
 
@@ -154,14 +153,16 @@ packages/ai/src/
     auth-options.ts         ProviderAuthOption shape, AuthOptions.bearer, AtLeastOne helper
     framing.ts              Framing type + Framing.sse
     transport/              transport implementations
-      index.ts              Transport type + HttpTransport / WebSocketTransport namespaces
+      index.ts              Transport execution types + HttpTransport / WebSocketTransport namespaces
+      websocket-channel.ts  generic sequential channel executor/driver contract
       http.ts               HttpTransport.httpJson — POST + framing
-      websocket.ts          WebSocketTransport.json + WebSocketExecutor service
+      websocket.ts          direct one-request channel executor + raw socket adapter
   protocols/
     shared.ts               ProviderShared toolkit used inside protocol impls
     openai-chat.ts          protocol + route (compose OpenAIChat.protocol)
     open-responses.ts         provider-neutral Responses protocol baseline
-    openai-responses.ts       OpenAI tools/events/transports composed over OpenResponses
+    open-responses-channel.ts provider-neutral Responses WebSocket transport factory
+    openai-responses.ts       OpenAI tools/events and channel policy composed over OpenResponses
     anthropic-messages.ts
     gemini.ts
     bedrock-converse.ts

packages/ai/README.md

@@ -315,7 +315,6 @@ import { model } from "@opencode-ai/ai/providers/openai/responses"
 
 const selected = model("gpt-5", {
   apiKey: process.env.OPENAI_API_KEY,
-  transport: "websocket",
   headers: { "x-application": "opencode" },
   limits: { context: 200_000, output: 64_000 },
 })
@@ -332,7 +331,7 @@ OpenAI Chat and OpenAI Responses are separate semantic entrypoints:
 - `@opencode-ai/ai/providers/google-vertex/responses`
 - `@opencode-ai/ai/providers/google-vertex/messages`
 
-Responses HTTP versus WebSocket is a scoped `transport` setting on the OpenAI Responses entrypoint, not another entrypoint. Azure follows the same Chat/Responses split at `providers/azure/chat` and `providers/azure/responses`. Generic OpenAI-compatible Chat remains at `providers/openai-compatible`; the Responses adapter at `providers/openai-compatible/responses` uses the provider-neutral Open Responses protocol. OpenAI Responses extends that baseline with OpenAI tools, event variants, metadata, defaults, and transports. Generic Anthropic Messages-compatible providers use `providers/anthropic-compatible`, which the named Anthropic provider composes. Google Gemini and Amazon Bedrock expose their single native API through their existing provider paths.
+OpenAI Responses has one semantic route and uses HTTP by default. Advanced callers may supply a per-call WebSocket channel executor through `StreamOptions`; transport policy does not change provider settings, model identity, or route identity. The provider-neutral Open Responses implementation owns the reusable WebSocket request and event contract, while each provider opts in with its own handshake and connection policy. Azure follows the same Chat/Responses split at `providers/azure/chat` and `providers/azure/responses`. Generic OpenAI-compatible Chat remains at `providers/openai-compatible`; the Responses adapter at `providers/openai-compatible/responses` uses the provider-neutral Open Responses protocol. OpenAI Responses extends that baseline with OpenAI tools, event variants, metadata, and defaults. Generic Anthropic Messages-compatible providers use `providers/anthropic-compatible`, which the named Anthropic provider composes. Google Gemini and Amazon Bedrock expose their single native API through their existing provider paths.
 
 Vertex Gemini, Vertex Chat, Vertex Responses, and Vertex Messages are separate API entrypoints. All accept `project`, `location`, and an optional `accessToken`; when no explicit token or auth override is supplied they lazily use Google Application Default Credentials. Vertex Gemini instead selects express mode when `apiKey` or `GOOGLE_VERTEX_API_KEY` is present. Vertex Chat targets MaaS models through the OpenAI-compatible Chat Completions endpoint, while Vertex Responses targets Grok models and defaults `store` to `false` as required by Vertex. `providers/google-vertex` remains the default alias for `providers/google-vertex/gemini`.
 

packages/ai/STATUS.md

@@ -1,6 +1,6 @@
 # LLM Provider Parity Status
 
-Last reviewed: 2026-07-24
+Last reviewed: 2026-08-07
 
 This file tracks the gap between the native `@opencode-ai/ai` package and the AI SDK provider packages that opencode still depends on for many catalog/runtime paths.
 
@@ -16,8 +16,7 @@ This file tracks the gap between the native `@opencode-ai/ai` package and the AI
 | Native slice                       | Source                                                                                                                            | Current state                                                                                                                                                            | Main gaps                                                                                                                                                                                                                                                 |
 | ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | OpenAI Chat                        | `src/protocols/openai-chat.ts`, `src/providers/openai.ts`                                                                         | Usable. Streams text, reasoning deltas, tool calls, usage, images, and common generation controls.                                                                       | No typed structured-output / `response_format` path. Limited typed OpenAI option surface compared with SDK escape hatches.                                                                                                                                |
-| OpenAI Responses HTTP              | `src/protocols/open-responses.ts`, `src/protocols/openai-responses.ts`, `src/providers/openai.ts`                                 | Usable. Extends the Open Responses baseline with hosted-tool event surfacing, reasoning replay metadata, GPT-5 defaults, and cache usage.                                | No explicit `previous_response_id` path. Typed options cover only a subset of Responses fields. Structured output is still mostly synthetic-tool based.                                                                                                   |
-| OpenAI Responses WebSocket         | `src/protocols/openai-responses.ts`, `src/route/transport/websocket.ts`                                                           | Present as `OpenAI.responsesWebSocket(...)`.                                                                                                                             | Runner/catalog support explicitly must not downgrade WebSocket routes; broader runtime selection is not complete.                                                                                                                                         |
+| OpenAI Responses                   | `src/protocols/open-responses.ts`, `src/protocols/openai-responses.ts`, `src/providers/openai.ts`                                 | Usable over HTTP by default, with optional per-call WebSocket channel execution on the same model and route identity.                                                    | No incremental `previous_response_id` path or persistent Session channel manager yet. Typed options cover only a subset of Responses fields. Structured output is still mostly synthetic-tool based.                                                      |
 | OpenAI-compatible Chat             | `src/protocols/openai-compatible-chat.ts`, `src/providers/openai-compatible.ts`                                                   | Usable for generic Chat and several profiles: Baseten, Cerebras, DeepInfra, DeepSeek, Fireworks, Groq, TogetherAI.                                                       | Family quirks are mostly endpoint defaults, not full typed behavior.                                                                                                                                                                                      |
 | Open Responses-compatible          | `src/protocols/open-responses.ts`, `src/protocols/openai-compatible-responses.ts`, `src/providers/openai-compatible-responses.ts` | Usable for deployments that implement the provider-neutral Open Responses protocol. The deployment adapter does not inherit OpenAI tools, events, metadata, or defaults. | No named family profiles or recorded deployment coverage yet.                                                                                                                                                                                             |
 | Anthropic-compatible Messages      | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic-compatible.ts`                                                    | Usable for deployments that implement the Anthropic Messages wire protocol. Named Anthropic composes this base; MiniMax M3 has recorded text and tool-loop coverage.     | No named compatible family profiles yet.                                                                                                                                                                                                                  |
@@ -48,19 +47,19 @@ Other `aisdk:` packages, including Google Vertex, Azure, and Bedrock, currently
 
 ## AI SDK Package Parity Matrix
 
-| AI SDK package                    | Intended native target                                         | Status           | Biggest gaps                                                                                                                                                                                                        |
-| --------------------------------- | -------------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `@ai-sdk/openai`                  | `OpenAI.chat`, `OpenAI.responses`, `OpenAI.responsesWebSocket` | Partial / usable | Add complete typed option coverage, structured output strategy, explicit Responses continuation support, and runner route selection between Chat/Responses/WebSocket.                                               |
-| `@ai-sdk/openai-compatible`       | Generic OpenAI-compatible Chat and Responses                   | Partial / usable | Decide per-family namespace/profile behavior and runner API selection for providers that support Responses versus Chat only.                                                                                        |
-| `@ai-sdk/anthropic`               | `AnthropicMessages`                                            | Partial / usable | Finish Messages API parity for headers/betas/metadata/newer fields and document hosted-tool continuation expectations.                                                                                              |
-| `@ai-sdk/google`                  | Gemini Developer API                                           | Partial / usable | Add typed options for safety, response schema/modalities, cached content, grounding/search/code execution, and non-text output modes where supported.                                                               |
-| `@ai-sdk/google-vertex`           | Vertex Gemini namespace/facade                                 | Partial / usable | Add runner/catalog mapping, recorded coverage, and broader provider-option parity.                                                                                                                                  |
-| `@ai-sdk/google-vertex/anthropic` | Anthropic Messages over Vertex namespace/facade                | Partial / usable | Add runner/catalog mapping, recorded coverage, and Vertex-specific hosted-tool parity.                                                                                                                              |
-| `@ai-sdk/google-vertex/maas`      | Vertex Chat                                                    | Partial / usable | Add runner/catalog mapping, recorded coverage, and MaaS family-specific request parity.                                                                                                                             |
-| `@ai-sdk/google-vertex/xai`       | Vertex Chat / Responses                                        | Partial / usable | Decide Chat/Responses selection for catalog models, add runner mapping and recorded coverage, and review xAI-specific request options.                                                                              |
-| `@ai-sdk/azure`                   | Azure OpenAI Chat/Responses facade                             | Partial          | Map runner/catalog metadata to native Azure, handle resourceName/baseURL/apiVersion variants, add AAD/token auth story, and verify Chat vs Responses deployment selection.                                          |
-| `@ai-sdk/amazon-bedrock`          | Bedrock Converse                                               | Partial          | Add default AWS credential chain/profile support, region/inference-profile model ID handling, provider option parity via `additionalModelRequestFields`, guardrails/performance config, and runner/catalog mapping. |
-| `@ai-sdk/amazon-bedrock/mantle`   | Bedrock Mantle OpenAI-compatible Chat/Responses namespace      | Partial / usable | Add default AWS credential chain/profile support; native catalog mapping currently requires bearer auth or explicit static credentials.                                                                             |
+| AI SDK package                    | Intended native target                                    | Status           | Biggest gaps                                                                                                                                                                                                        |
+| --------------------------------- | --------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@ai-sdk/openai`                  | `OpenAI.chat`, `OpenAI.responses`                         | Partial / usable | Add complete typed option coverage, structured output strategy, explicit Responses continuation support, and runner execution policy for optional WebSocket channels.                                               |
+| `@ai-sdk/openai-compatible`       | Generic OpenAI-compatible Chat and Responses              | Partial / usable | Decide per-family namespace/profile behavior and runner API selection for providers that support Responses versus Chat only.                                                                                        |
+| `@ai-sdk/anthropic`               | `AnthropicMessages`                                       | Partial / usable | Finish Messages API parity for headers/betas/metadata/newer fields and document hosted-tool continuation expectations.                                                                                              |
+| `@ai-sdk/google`                  | Gemini Developer API                                      | Partial / usable | Add typed options for safety, response schema/modalities, cached content, grounding/search/code execution, and non-text output modes where supported.                                                               |
+| `@ai-sdk/google-vertex`           | Vertex Gemini namespace/facade                            | Partial / usable | Add runner/catalog mapping, recorded coverage, and broader provider-option parity.                                                                                                                                  |
+| `@ai-sdk/google-vertex/anthropic` | Anthropic Messages over Vertex namespace/facade           | Partial / usable | Add runner/catalog mapping, recorded coverage, and Vertex-specific hosted-tool parity.                                                                                                                              |
+| `@ai-sdk/google-vertex/maas`      | Vertex Chat                                               | Partial / usable | Add runner/catalog mapping, recorded coverage, and MaaS family-specific request parity.                                                                                                                             |
+| `@ai-sdk/google-vertex/xai`       | Vertex Chat / Responses                                   | Partial / usable | Decide Chat/Responses selection for catalog models, add runner mapping and recorded coverage, and review xAI-specific request options.                                                                              |
+| `@ai-sdk/azure`                   | Azure OpenAI Chat/Responses facade                        | Partial          | Map runner/catalog metadata to native Azure, handle resourceName/baseURL/apiVersion variants, add AAD/token auth story, and verify Chat vs Responses deployment selection.                                          |
+| `@ai-sdk/amazon-bedrock`          | Bedrock Converse                                          | Partial          | Add default AWS credential chain/profile support, region/inference-profile model ID handling, provider option parity via `additionalModelRequestFields`, guardrails/performance config, and runner/catalog mapping. |
+| `@ai-sdk/amazon-bedrock/mantle`   | Bedrock Mantle OpenAI-compatible Chat/Responses namespace | Partial / usable | Add default AWS credential chain/profile support; native catalog mapping currently requires bearer auth or explicit static credentials.                                                                             |
 
 ## Highest-Risk Gaps
 
@@ -78,24 +77,24 @@ Other `aisdk:` packages, including Google Vertex, Azure, and Bedrock, currently
 
 These are implementation/API slices, not separate npm packages.
 
-| API slice                     | Package-like entrypoint                                     | Purpose                                                                      |
-| ----------------------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------- |
-| OpenAI Chat                   | `@opencode-ai/ai/providers/openai/chat`                     | OpenAI `/chat/completions` semantics.                                        |
-| OpenAI Responses              | `@opencode-ai/ai/providers/openai/responses`                | OpenAI `/responses` semantics with HTTP/WebSocket selected through settings. |
-| OpenAI-compatible Chat        | `@opencode-ai/ai/providers/openai-compatible`               | Generic OpenAI-compatible `/chat/completions`.                               |
-| Open Responses-compatible     | `@opencode-ai/ai/providers/openai-compatible/responses`     | Generic provider-neutral `/responses`.                                       |
-| Anthropic-compatible Messages | `@opencode-ai/ai/providers/anthropic-compatible`            | Generic Anthropic-compatible `/messages`.                                    |
-| Anthropic Messages            | `@opencode-ai/ai/providers/anthropic`                       | Anthropic Messages API.                                                      |
-| Gemini Developer API          | `@opencode-ai/ai/providers/google`                          | Google AI Studio Gemini API.                                                 |
-| Vertex Gemini                 | `@opencode-ai/ai/providers/google-vertex/gemini`            | Vertex Gemini API; `providers/google-vertex` is the default alias.           |
-| Vertex Chat                   | `@opencode-ai/ai/providers/google-vertex/chat`              | Vertex OpenAI-compatible Chat Completions for MaaS models.                   |
-| Vertex Responses              | `@opencode-ai/ai/providers/google-vertex/responses`         | Vertex Open Responses for Grok models.                                       |
-| Vertex Messages               | `@opencode-ai/ai/providers/google-vertex/messages`          | Vertex-hosted Anthropic Messages API.                                        |
-| Bedrock Converse              | `@opencode-ai/ai/providers/amazon-bedrock`                  | AWS Bedrock Converse API.                                                    |
-| Bedrock Mantle Chat           | `@opencode-ai/ai/providers/amazon-bedrock/mantle/chat`      | AWS Bedrock Mantle OpenAI-compatible Chat API.                               |
-| Bedrock Mantle Responses      | `@opencode-ai/ai/providers/amazon-bedrock/mantle/responses` | AWS Bedrock Mantle OpenAI-compatible Responses API.                          |
-| Azure OpenAI Chat             | `@opencode-ai/ai/providers/azure/chat`                      | Azure specialization of OpenAI Chat.                                         |
-| Azure OpenAI Responses        | `@opencode-ai/ai/providers/azure/responses`                 | Azure specialization of OpenAI Responses.                                    |
+| API slice                     | Package-like entrypoint                                     | Purpose                                                                                    |
+| ----------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
+| OpenAI Chat                   | `@opencode-ai/ai/providers/openai/chat`                     | OpenAI `/chat/completions` semantics.                                                      |
+| OpenAI Responses              | `@opencode-ai/ai/providers/openai/responses`                | OpenAI `/responses` semantics with HTTP default and optional per-call WebSocket execution. |
+| OpenAI-compatible Chat        | `@opencode-ai/ai/providers/openai-compatible`               | Generic OpenAI-compatible `/chat/completions`.                                             |
+| Open Responses-compatible     | `@opencode-ai/ai/providers/openai-compatible/responses`     | Generic provider-neutral `/responses`.                                                     |
+| Anthropic-compatible Messages | `@opencode-ai/ai/providers/anthropic-compatible`            | Generic Anthropic-compatible `/messages`.                                                  |
+| Anthropic Messages            | `@opencode-ai/ai/providers/anthropic`                       | Anthropic Messages API.                                                                    |
+| Gemini Developer API          | `@opencode-ai/ai/providers/google`                          | Google AI Studio Gemini API.                                                               |
+| Vertex Gemini                 | `@opencode-ai/ai/providers/google-vertex/gemini`            | Vertex Gemini API; `providers/google-vertex` is the default alias.                         |
+| Vertex Chat                   | `@opencode-ai/ai/providers/google-vertex/chat`              | Vertex OpenAI-compatible Chat Completions for MaaS models.                                 |
+| Vertex Responses              | `@opencode-ai/ai/providers/google-vertex/responses`         | Vertex Open Responses for Grok models.                                                     |
+| Vertex Messages               | `@opencode-ai/ai/providers/google-vertex/messages`          | Vertex-hosted Anthropic Messages API.                                                      |
+| Bedrock Converse              | `@opencode-ai/ai/providers/amazon-bedrock`                  | AWS Bedrock Converse API.                                                                  |
+| Bedrock Mantle Chat           | `@opencode-ai/ai/providers/amazon-bedrock/mantle/chat`      | AWS Bedrock Mantle OpenAI-compatible Chat API.                                             |
+| Bedrock Mantle Responses      | `@opencode-ai/ai/providers/amazon-bedrock/mantle/responses` | AWS Bedrock Mantle OpenAI-compatible Responses API.                                        |
+| Azure OpenAI Chat             | `@opencode-ai/ai/providers/azure/chat`                      | Azure specialization of OpenAI Chat.                                                       |
+| Azure OpenAI Responses        | `@opencode-ai/ai/providers/azure/responses`                 | Azure specialization of OpenAI Responses.                                                  |
 
 ## Suggested Next Work Slices
 

packages/ai/example/call-sites.md

@@ -67,7 +67,6 @@ Examples:
 ```ts
 OpenAI.responses("gpt-4o")
 OpenAI.chat("gpt-4o")
-OpenAI.responsesWebSocket("gpt-4o")
 
 Azure.configure({ resourceName, apiKey }).responses("my-deployment")
 AmazonBedrock.configure({ region, credentials }).model("anthropic.claude-3-5-sonnet-20241022-v2:0")
@@ -250,11 +249,6 @@ const openAIChat = Route.make({
   auth: Auth.envBearer("OPENAI_API_KEY"),
 })
 
-const openAIResponsesWebSocket = openAIResponses.with({
-  id: "openai-responses-websocket",
-  transport: WebSocketTransport.json,
-})
-
 const openAIConfig = (input: OpenAIConfig) => ({
   endpoint: input.endpoint,
   auth: input.auth ?? (input.apiKey ? Auth.bearer(input.apiKey) : undefined),
@@ -266,13 +260,11 @@ const openAIConfig = (input: OpenAIConfig) => ({
 
 const configureOpenAI = (input: OpenAIConfig = {}) => {
   const responses = openAIResponses.with(openAIConfig(input))
-  const responsesWebSocket = openAIResponsesWebSocket.with(openAIConfig(input))
   const chat = openAIChat.with(openAIConfig(input))
 
   return {
     id: openAIProvider,
     responses: responses.model,
-    responsesWebSocket: responsesWebSocket.model,
     chat: chat.model,
     model: responses.model,
     configure: configureOpenAI,
@@ -342,22 +334,19 @@ const response =
   )
 ```
 
-For direct provider-facade calls, HTTP versus WebSocket is represented as named
-route selectors, not as model or request overrides. Same protocol, different
-transport, different route:
+For direct provider-facade calls, Responses has one semantic model and route:
 
 ```ts
 OpenAI.responses("gpt-4o")
-OpenAI.responsesWebSocket("gpt-4o")
 ```
 
-The package-like OpenAI Responses entrypoint instead keeps transport scoped to
-Responses settings while preserving the same `model(...)` contract:
+The package-like OpenAI Responses entrypoint has the same transport-neutral
+`model(...)` contract:
 
 ```ts
 import { model } from "@opencode-ai/ai/providers/openai/responses"
 
-model("gpt-4o", { apiKey, transport: "websocket" })
+model("gpt-4o", { apiKey })
 ```
 
 Vertex keeps Gemini, Chat, Responses, and Messages as separate package-like entrypoints,
@@ -387,11 +376,9 @@ import { model } from "@opencode-ai/ai/providers/google-vertex/messages"
 model("claude-sonnet-4-6", { project, location: "global" })
 ```
 
-The client should not require a different public layer just because a selected
-route uses WebSocket. Use one `LLMClient.layer` with HTTP and WebSocket runtime
-capabilities available; routes that do not need WebSocket simply never touch it.
-If a WebSocket route is selected in an environment without WebSocket support,
-fail with a typed transport configuration error.
+The client does not require a different public layer for WebSocket execution.
+Responses routes use HTTP by default, and callers may pass a channel executor per
+call. Routes without channel support simply ignore that execution capability.
 
 Azure is a route specialization with auth/path/default changes plus input
 mapping. The public API configures the Azure resource once, then selects
@@ -497,18 +484,13 @@ generic dynamic resolver:
 
 ```ts
 const model =
-  providerID === "azure"
-    ? Azure.configure(resolvedAzureConfig).responses(apiModelID)
-    : endpoint.websocket
-      ? OpenAI.responsesWebSocket(apiModelID)
-      : OpenAI.responses(apiModelID)
+  providerID === "azure" ? Azure.configure(resolvedAzureConfig).responses(apiModelID) : OpenAI.responses(apiModelID)
 ```
 
 That boundary can branch on durable config/catalog metadata and call typed
-provider APIs directly. A direct provider-facade boundary maps metadata like
-`endpoint.websocket` to `OpenAI.responsesWebSocket(apiModelID)`. A package-loading
-boundary passes `transport: "websocket"` to the OpenAI Responses entrypoint.
-The client runtime only executes the route carried by the resulting model.
+provider APIs directly. Transport selection remains execution policy: a Session
+or other caller may pass a WebSocket channel executor per call without changing
+the model constructed by this boundary.
 
 ## Competitive Shape
 
@@ -544,9 +526,8 @@ App boundary = explicit durable-config -> typed-provider call
   id.
 - No `model(id, overrides)` escape hatch. Model selection takes the model id;
   endpoint/auth/deployment customization happens by configuring the route first.
-- No transport override on an executable model or request. Direct provider
-  facades use `responses` versus `responsesWebSocket`; the package-like Responses
-  entrypoint maps its scoped `transport` setting before constructing the model.
+- No transport setting on a provider or executable model. OpenAI Responses uses
+  HTTP by default and accepts an optional per-call channel executor as execution policy.
 - No separate public `LLMClient.layerWithWebSocket`. The runtime should expose one
   client layer with the available transport capabilities.
 - No executable `ModelRef`. The executable handle is `LanguageModel`; durable model
@@ -580,12 +561,10 @@ App boundary = explicit durable-config -> typed-provider call
 - [x] Make unconfigured transports reusable constants such as
       `HttpTransport.sseJson`; keep transport functions only for configured/fresh
       state construction.
-- [x] Collapse the public WebSocket runtime split so one `LLMClient.layer`
-      exposes available transport capabilities and selected routes fail with typed
-      transport config errors when a required capability is missing.
+- [x] Collapse the public WebSocket runtime split so one `LLMClient.layer` accepts
+      optional per-call channel execution without changing route identity.
 - [x] Convert OpenAI provider APIs to provider-facade shape:
-      `OpenAI.configure(config).responses(id)`, `.chat(id)`, and
-      `.responsesWebSocket(id)`.
+      `OpenAI.configure(config).responses(id)` and `.chat(id)`.
 - [x] Convert Azure to a configured facade where resource/base URL/api version
       setup happens before selecting deployment ids.
 - [x] Split Cloudflare products into separate facades such as
@@ -599,10 +578,8 @@ App boundary = explicit durable-config -> typed-provider call
 - [ ] Decide whether a tiny `Provider.define(...)` helper is warranted after two
       or three provider conversions; start with plain objects if duplication is not
       yet painful.
-- [x] Update `packages/opencode/src/session/llm/native-request.ts` to construct
-      executable models at the session boundary with explicit provider facade
-      calls, mapping catalog metadata such as `endpoint.websocket` to the correct
-      named route selector.
+- [x] Keep executable model construction transport-neutral at the Session boundary;
+      Session-scoped execution policy supplies channel capability separately.
 - [ ] Update tests so direct route/provider tests assert route values are carried
       by executable models, and opencode/native tests assert boundary-based route
       selection.

packages/ai/example/tutorial.ts

@@ -1,6 +1,6 @@
 import { Config, Effect, Formatter, Layer, Schema, Stream } from "effect"
 import { LLM, LLMClient, LLMRequest, Message, ProviderID, Tool, ToolRuntime } from "@opencode-ai/ai"
-import { Route, Auth, Endpoint, Framing, Protocol, RequestExecutor, WebSocketExecutor } from "@opencode-ai/ai/route"
+import { Route, Auth, Endpoint, Framing, Protocol, RequestExecutor } from "@opencode-ai/ai/route"
 import { OpenAI } from "@opencode-ai/ai/providers"
 
 /**
@@ -213,8 +213,7 @@ const FakeEcho = {
 // enabled at a time so the tutorial can demonstrate generate, stream, or
 // tool-loop behavior without spending tokens on every example.
 const requestExecutorLayer = RequestExecutor.fetchLayer
-const llmDeps = Layer.mergeAll(requestExecutorLayer, WebSocketExecutor.layer)
-const llmClientLayer = LLMClient.layer.pipe(Layer.provide(llmDeps))
+const llmClientLayer = LLMClient.layer.pipe(Layer.provide(requestExecutorLayer))
 
 const program = Effect.gen(function* () {
   // yield* generateOnce
@@ -222,6 +221,6 @@ const program = Effect.gen(function* () {
   // yield* generateStructuredObject
   // yield* generateDynamicObject.pipe(Effect.andThen((response) => Effect.sync(() => console.log(response.object))))
   yield* streamWithTools
-}).pipe(Effect.provide(Layer.mergeAll(llmDeps, llmClientLayer)))
+}).pipe(Effect.provide(Layer.mergeAll(requestExecutorLayer, llmClientLayer)))
 
 Effect.runPromise(program)

packages/ai/src/protocols/index.ts

@@ -7,3 +7,4 @@ export * as OpenAICompatibleChat from "./openai-compatible-chat.js"
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js"
 export * as OpenAIResponses from "./openai-responses.js"
 export * as OpenResponses from "./open-responses.js"
+export * as OpenResponsesChannel from "./open-responses-channel.js"

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

@@ -0,0 +1,191 @@
+import { Effect, Schema, Stream } from "effect"
+import { Headers } from "effect/unstable/http"
+import { Framing } from "../route/framing.js"
+import {
+  HttpTransport,
+  WebSocketTransport,
+  type Transport,
+  type WebSocketChannelDriver,
+  type WebSocketChannelExchange,
+} from "../route/transport/index.js"
+import * as ProviderShared from "./shared.js"
+import { OpenResponses } from "./open-responses.js"
+
+const WebSocketResponseCreate = Schema.StructWithRest(Schema.Struct({ type: Schema.tag("response.create") }), [
+  Schema.Record(Schema.String, Schema.Unknown),
+])
+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
+  readonly name: string
+  readonly rotateAfterMs?: number
+  readonly headers?: (headers: Headers.Headers) => Headers.Headers
+  readonly driver?: (input: {
+    readonly request: Readonly<Record<string, unknown>>
+    readonly message: string
+    readonly base: WebSocketChannelDriver
+  }) => WebSocketChannelDriver
+}
+
+export interface Prepared {
+  readonly http: HttpTransport.HttpPrepared<string>
+  readonly channel?: {
+    readonly url: string
+    readonly headers: Headers.Headers
+    readonly rotateAfterMs?: number
+    readonly driver: WebSocketChannelDriver
+  }
+}
+
+const message = (body: unknown) =>
+  Effect.gen(function* () {
+    if (!ProviderShared.isRecord(body))
+      return yield* ProviderShared.invalidRequest("Open Responses WebSocket body must be a JSON object")
+    const { stream: _stream, stream_options: _streamOptions, background: _background, ...request } = body
+    const decoded = yield* decodeMessage({ ...request, type: "response.create" })
+    return { request: decoded, message: encodeMessage(decoded) }
+  })
+
+const driver = (options: Options, body: string): WebSocketChannelDriver => {
+  let responseID: string | undefined
+  let terminal = false
+  return {
+    create: () =>
+      Effect.sync(() => {
+        responseID = undefined
+        terminal = false
+        return { message: body, mode: "full" }
+      }),
+    observe: (_create, frame) =>
+      Effect.gen(function* () {
+        const event = yield* decodeEvent(frame).pipe(
+          Effect.mapError(() =>
+            ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame),
+          ),
+        )
+        if (terminal)
+          return yield* ProviderShared.eventError(
+            options.id,
+            `${options.name} emitted ${event.type} after a terminal event`,
+            frame,
+          )
+        if (event.type === "error") {
+          terminal = true
+          yield* OpenResponses.decodeKnownErrorEvent(event).pipe(
+            Effect.mapError(() =>
+              ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame),
+            ),
+          )
+          return {
+            type: "provider-failure",
+            error: OpenResponses.providerFailure(options.id, event, `${options.name} stream error`),
+          }
+        }
+        if (event.type === "response.failed") {
+          terminal = true
+          if (responseID && event.response?.id && event.response.id !== responseID)
+            return yield* ProviderShared.eventError(
+              options.id,
+              `${options.name} response ID changed during execution`,
+              frame,
+            )
+          return {
+            type: "provider-failure",
+            error: OpenResponses.providerFailure(options.id, event, `${options.name} response failed`),
+          }
+        }
+        if (event.type === "response.created") {
+          const created = event.response?.id
+          if (responseID)
+            return yield* ProviderShared.eventError(
+              options.id,
+              `${options.name} emitted duplicate response.created`,
+              frame,
+            )
+          if (!created)
+            return yield* ProviderShared.eventError(
+              options.id,
+              `${options.name} response.created is missing response.id`,
+              frame,
+            )
+          responseID = created
+          return { type: "frame", frame }
+        }
+        if (!responseID)
+          return yield* ProviderShared.eventError(
+            options.id,
+            `${options.name} emitted ${event.type} before response.created`,
+            frame,
+          )
+        if (event.response?.id && event.response.id !== responseID)
+          return yield* ProviderShared.eventError(
+            options.id,
+            `${options.name} response ID changed during execution`,
+            frame,
+          )
+        if (event.type === "response.completed") {
+          terminal = true
+          return { type: "completed", frame }
+        }
+        if (event.type === "response.incomplete") {
+          terminal = true
+          return { type: "incomplete", frame }
+        }
+        return { type: "frame", frame }
+      }),
+  }
+}
+
+export const transport = <Body>(options: Options): Transport<Body, Prepared, string> => {
+  const http = HttpTransport.sseJson.with<Body>()
+  return {
+    id: http.id,
+    prepare: (input) =>
+      Effect.gen(function* () {
+        const parts = yield* HttpTransport.jsonRequestParts(input)
+        const headers = Headers.remove(options.headers?.(parts.headers) ?? parts.headers, "content-length")
+        const channel = input.webSocket
+          ? yield* Effect.gen(function* () {
+              const create = yield* message(parts.jsonBody)
+              const base = driver(options, create.message)
+              return {
+                url: yield* WebSocketTransport.toWebSocketUrl(parts.url),
+                headers,
+                rotateAfterMs: options.rotateAfterMs,
+                driver: options.driver?.({ request: create.request, message: create.message, base }) ?? base,
+              }
+            })
+          : undefined
+        return {
+          http: {
+            request: ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),
+            framing: Framing.sse,
+            middleware: input.middleware,
+          },
+          channel,
+        }
+      }),
+    execute: (prepared, request, runtime, executeOptions) => {
+      if (!executeOptions?.webSocket || !prepared.channel) return http.execute(prepared.http, request, runtime)
+      const exchange: WebSocketChannelExchange = {
+        id: request.id ?? "request",
+        connect: {
+          url: prepared.channel.url,
+          headers: prepared.channel.headers,
+          rotateAfterMs: prepared.channel.rotateAfterMs,
+        },
+        fallback: () =>
+          Stream.unwrap(
+            http.execute(prepared.http, request, runtime).pipe(Effect.map((execution) => execution.frames)),
+          ),
+        driver: prepared.channel.driver,
+      }
+      return executeOptions.webSocket.execute(exchange)
+    },
+  }
+}
+
+export const OpenResponsesChannel = { transport } as const

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

@@ -211,11 +211,43 @@ export type StreamItem = Schema.Schema.Type<typeof StreamItem>
 // event-level `error` envelope, so accept all three shapes here.
 // https://www.openresponses.org/specification
 const OpenResponsesErrorPayload = Schema.Struct({
+  type: optionalNull(Schema.String),
   code: optionalNull(Schema.String),
   message: optionalNull(Schema.String),
   param: optionalNull(Schema.String),
 })
 
+const WebSocketErrorHeader = Schema.Union([Schema.String, Schema.Number, Schema.Boolean])
+export const WebSocketErrorEvent = Schema.StructWithRest(
+  Schema.Struct({
+    type: Schema.tag("error"),
+    status: Schema.optional(Schema.Number),
+    status_code: Schema.optional(Schema.Number),
+    code: optionalNull(Schema.String),
+    message: Schema.optional(Schema.String),
+    param: optionalNull(Schema.String),
+    error: optionalNull(OpenResponsesErrorPayload),
+    headers: Schema.optional(Schema.Record(Schema.String, WebSocketErrorHeader)),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
+const decodeWebSocketErrorEvent = Schema.decodeUnknownEffect(WebSocketErrorEvent)
+
+export const decodeKnownErrorEvent = (event: Event) =>
+  decodeWebSocketErrorEvent({
+    ...event,
+    status: typeof event.status === "number" ? event.status : undefined,
+    status_code: typeof event.status_code === "number" ? event.status_code : undefined,
+    headers: ProviderShared.isRecord(event.headers)
+      ? Object.fromEntries(
+          Object.entries(event.headers).filter(
+            (entry): entry is [string, string | number | boolean] =>
+              typeof entry[1] === "string" || typeof entry[1] === "number" || typeof entry[1] === "boolean",
+          ),
+        )
+      : undefined,
+  })
+
 export const Event = Schema.StructWithRest(
   Schema.Struct({
     type: Schema.String,
@@ -240,6 +272,9 @@ export const Event = Schema.StructWithRest(
     message: Schema.optional(Schema.String),
     param: optionalNull(Schema.String),
     error: optionalNull(OpenResponsesErrorPayload),
+    status: Schema.optional(Schema.Unknown),
+    status_code: Schema.optional(Schema.Unknown),
+    headers: Schema.optional(Schema.Unknown),
   }),
   [Schema.Record(Schema.String, Schema.Unknown)],
 )
@@ -632,9 +667,9 @@ export type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
 const NO_EVENTS: StepResult["1"] = []
 
 // `response.completed` / `response.incomplete` are clean finishes that emit a
-// `finish` event; `response.failed` is a hard failure. All three end the stream,
-// so keep this set aligned with `step` and the protocol's terminal predicate.
-const TERMINAL_TYPES = new Set(["response.completed", "response.incomplete", "response.failed"])
+// `finish` event; `response.failed` and `error` are hard failures. All four end
+// the stream, so keep this set aligned with `step` and the protocol's terminal predicate.
+const TERMINAL_TYPES = new Set(["error", "response.completed", "response.incomplete", "response.failed"])
 export const terminal = (event: Event) => TERMINAL_TYPES.has(event.type)
 
 const onOutputTextDelta = (state: ParserState, event: Event, id: string): StepResult => {
@@ -966,16 +1001,24 @@ const providerErrorMessage = (event: Event, fallback: string): string => {
   return message || code || fallback
 }
 
-const providerError = (state: ParserState, event: Event, fallback: string) => {
+export const providerFailure = (id: string, event: Event, fallback: string) => {
   const code = event.code || event.error?.code || event.response?.error?.code || undefined
   const message = providerErrorMessage(event, fallback)
+  const status =
+    typeof event.status === "number"
+      ? event.status
+      : typeof event.status_code === "number"
+        ? event.status_code
+        : undefined
   return new AIError({
-    module: state.id,
+    module: id,
     method: "stream",
-    reason: classifyProviderFailure({ message, code }),
+    reason: classifyProviderFailure({ message, code, status }),
   })
 }
 
+const providerError = (state: ParserState, event: Event, fallback: string) => providerFailure(state.id, event, fallback)
+
 export const step = (state: ParserState, event: Event) => {
   if (event.type === "response.output_text.delta" || event.type === "response.output_text.done") {
     if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
@@ -1015,7 +1058,11 @@ export const step = (state: ParserState, event: Event) => {
   if (event.type === "response.completed" || event.type === "response.incomplete")
     return Effect.succeed(onResponseFinish(state, event))
   if (event.type === "response.failed") return providerError(state, event, `${state.name} response failed`)
-  if (event.type === "error") return providerError(state, event, `${state.name} stream error`)
+  if (event.type === "error")
+    return decodeKnownErrorEvent(event).pipe(
+      Effect.mapError(() => ProviderShared.eventError(state.id, `${state.name} returned a malformed error event`)),
+      Effect.flatMap(() => providerError(state, event, `${state.name} stream error`)),
+    )
   return Effect.succeed<StepResult>([state, NO_EVENTS])
 }
 

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

@@ -0,0 +1,164 @@
+import { AIError, TransportReason } from "../schema/index.js"
+import type { ChannelCheckpoint, ChannelObservation, WebSocketChannelDriver } from "../route/transport/index.js"
+import { Effect, Option, Schema } from "effect"
+import * as ProviderShared from "./shared.js"
+import { OpenResponses } from "./open-responses.js"
+
+const PROTOCOL = "openai-responses.websocket.v1"
+const VERSION = 1
+const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)
+
+interface CheckpointValue {
+  readonly version: typeof VERSION
+  readonly responseID: string
+  readonly request: Readonly<Record<string, unknown>>
+  readonly output: ReadonlyArray<unknown>
+}
+
+export interface DriverInput {
+  readonly id: string
+  readonly name: string
+  readonly request: Readonly<Record<string, unknown>>
+  readonly message: string
+  readonly base: WebSocketChannelDriver
+}
+
+const checkpointValue = (checkpoint: ChannelCheckpoint | undefined): CheckpointValue | undefined => {
+  if (checkpoint?.protocol !== PROTOCOL || !ProviderShared.isRecord(checkpoint.value)) return undefined
+  if (checkpoint.value.version !== VERSION) return undefined
+  if (typeof checkpoint.value.responseID !== "string" || checkpoint.value.responseID.trim().length === 0)
+    return undefined
+  if (!ProviderShared.isRecord(checkpoint.value.request) || !Array.isArray(checkpoint.value.output)) return undefined
+  return {
+    version: VERSION,
+    responseID: checkpoint.value.responseID,
+    request: checkpoint.value.request,
+    output: checkpoint.value.output,
+  }
+}
+
+const canonical = (value: unknown): string => {
+  if (value === undefined) return "undefined"
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`
+  if (!ProviderShared.isRecord(value)) return ProviderShared.encodeJson(value)
+  return `{${Object.keys(value)
+    .sort()
+    .map((key) => `${ProviderShared.encodeJson(key)}:${canonical(value[key])}`)
+    .join(",")}}`
+}
+
+const json = (value: unknown) => {
+  if (typeof value !== "string") return value
+  return Option.getOrElse(Schema.decodeUnknownOption(ProviderShared.Json)(value), () => value)
+}
+
+const comparable = (value: unknown) => {
+  if (!ProviderShared.isRecord(value)) return value
+  if (value.type === "message" && value.role === "assistant")
+    return {
+      role: "assistant",
+      content: value.content,
+      ...(value.phase === undefined ? {} : { phase: value.phase }),
+    }
+  if (value.type === "function_call")
+    return {
+      type: value.type,
+      call_id: value.call_id,
+      name: value.name,
+      arguments: json(value.arguments),
+    }
+  if (value.type === "reasoning")
+    return {
+      type: value.type,
+      summary: value.summary,
+      encrypted_content: value.encrypted_content,
+    }
+  return value
+}
+
+const invariant = (request: Readonly<Record<string, unknown>>) => {
+  const { type: _type, input: _input, previous_response_id: _previousResponseID, ...rest } = request
+  return rest
+}
+
+const incremental = (
+  request: Readonly<Record<string, unknown>>,
+  checkpoint: CheckpointValue,
+): ReadonlyArray<unknown> | undefined => {
+  const input = request.input
+  const previousInput = checkpoint.request.input
+  if (!Array.isArray(input) || !Array.isArray(previousInput)) return undefined
+  if (canonical(invariant(request)) !== canonical(invariant(checkpoint.request))) return undefined
+  const baseline = [...previousInput, ...checkpoint.output]
+  if (input.length <= baseline.length) return undefined
+  if (!baseline.every((item, index) => canonical(comparable(item)) === canonical(comparable(input[index]))))
+    return undefined
+  return input.slice(baseline.length)
+}
+
+const code = (event: OpenResponses.Event) => event.code || event.error?.code || event.response?.error?.code || undefined
+
+const rejected = (
+  input: DriverInput,
+  observation: Extract<ChannelObservation, { readonly type: "provider-failure" }>,
+  recovery: "retry-full" | "rotate-and-retry-full",
+): ChannelObservation => ({
+  type: "rejected",
+  recovery,
+  error: new AIError({
+    module: input.id,
+    method: "stream",
+    reason: new TransportReason({
+      message: observation.error.message,
+      transport: "websocket",
+      operation: "read",
+      phase: "receive",
+      delivery: "rejected",
+      recovery,
+    }),
+  }),
+})
+
+export const driver = (input: DriverInput): WebSocketChannelDriver => {
+  const { previous_response_id: _previousResponseID, ...request } = input.request
+  let output: unknown[] = []
+  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 }
+        return {
+          message: ProviderShared.encodeJson({ ...request, input: delta, previous_response_id: previous.responseID }),
+          mode: "incremental" as const,
+        }
+      }),
+    observe: (create, frame) =>
+      Effect.gen(function* () {
+        const event = yield* decodeEvent(frame).pipe(
+          Effect.mapError(() => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame)),
+        )
+        const observation = yield* input.base.observe(create, frame)
+        if (event.type === "response.output_item.done" && event.item) output.push(event.item)
+        if (observation.type === "provider-failure") {
+          const rejection = code(event)
+          if (rejection === "previous_response_not_found") return rejected(input, observation, "retry-full")
+          if (rejection === "websocket_connection_limit_reached")
+            return rejected(input, observation, "rotate-and-retry-full")
+        }
+        if (observation.type !== "completed") return observation
+        const responseID = event.response?.id
+        if (!responseID || responseID.trim().length === 0) return observation
+        return {
+          ...observation,
+          checkpoint: {
+            protocol: PROTOCOL,
+            value: { version: VERSION, responseID, request, output: output.slice() } satisfies CheckpointValue,
+          },
+        }
+      }),
+  }
+}
+
+export const OpenAIResponsesChannel = { driver } as const

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

@@ -1,18 +1,23 @@
 import { Effect, Encoding, Schema } from "effect"
+import { Headers } from "effect/unstable/http"
 import { Route } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
-import { HttpTransport, WebSocketTransport } from "../route/transport/index.js"
+import { HttpTransport } from "../route/transport/index.js"
 import { LLMEvent, LLMRequest, type JsonSchema, type ToolDefinition } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { optionalArray, ProviderShared } from "./shared.js"
 import { Lifecycle } from "./utils/lifecycle.js"
 import { OpenAIImage } from "./utils/openai-image.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
+import { OpenResponsesChannel } from "./open-responses-channel.js"
+import { OpenAIResponsesChannel } from "./openai-responses-channel.js"
 
 const ADAPTER = "openai-responses"
 const NAME = "OpenAI Responses"
+const WEBSOCKET_PROTOCOL_HEADER = "responses_websockets=2026-02-06"
+const WEBSOCKET_ROTATE_AFTER_MS = 55 * 60 * 1000
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = OpenResponses.PATH
 
@@ -57,16 +62,6 @@ const OpenAIResponsesBody = Schema.Struct({
 })
 export type OpenAIResponsesBody = Schema.Schema.Type<typeof OpenAIResponsesBody>
 
-const OpenAIResponsesWebSocketMessage = Schema.StructWithRest(
-  Schema.Struct({
-    type: Schema.tag("response.create"),
-    ...OpenAIResponsesCoreFields,
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
-type OpenAIResponsesWebSocketMessage = Schema.Schema.Type<typeof OpenAIResponsesWebSocketMessage>
-const encodeWebSocketMessage = Schema.encodeSync(Schema.fromJsonString(OpenAIResponsesWebSocketMessage))
-
 const extension = {
   id: ADAPTER,
   name: NAME,
@@ -249,6 +244,13 @@ const endpoint = Endpoint.path<OpenAIResponsesBody>(PATH, { baseURL: DEFAULT_BAS
 const auth = Auth.none
 
 export const httpTransport = HttpTransport.sseJson.with<OpenAIResponsesBody>()
+export const transport = OpenResponsesChannel.transport<OpenAIResponsesBody>({
+  id: ADAPTER,
+  name: NAME,
+  rotateAfterMs: WEBSOCKET_ROTATE_AFTER_MS,
+  headers: (headers) => Headers.set(headers, "openai-beta", headers["openai-beta"] ?? WEBSOCKET_PROTOCOL_HEADER),
+  driver: (input) => OpenAIResponsesChannel.driver({ id: ADAPTER, name: NAME, ...input }),
+})
 
 export const route = Route.make({
   id: ADAPTER,
@@ -257,36 +259,7 @@ export const route = Route.make({
   protocol,
   endpoint,
   auth,
-  transport: httpTransport,
-  defaults: { providerOptions: { openai: { store: false } } },
-})
-
-const decodeWebSocketMessage = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIResponsesWebSocketMessage))
-
-const webSocketMessage = (body: OpenAIResponsesBody | Record<string, unknown>) =>
-  Effect.gen(function* () {
-    if (!ProviderShared.isRecord(body))
-      return yield* ProviderShared.invalidRequest("OpenAI Responses WebSocket body must be a JSON object")
-    const { stream: _stream, ...message } = body
-    return yield* decodeWebSocketMessage({ ...message, type: "response.create" })
-  })
-
-export const webSocketTransport = WebSocketTransport.jsonTransport.with<
-  OpenAIResponsesBody,
-  OpenAIResponsesWebSocketMessage
->({
-  toMessage: webSocketMessage,
-  encodeMessage: encodeWebSocketMessage,
-})
-
-export const webSocketRoute = Route.make({
-  id: `${ADAPTER}-websocket`,
-  provider: "openai",
-  providerMetadataKey: "openai",
-  protocol,
-  endpoint,
-  auth,
-  transport: webSocketTransport,
+  transport,
   defaults: { providerOptions: { openai: { store: false } } },
 })
 

packages/ai/src/provider-error.ts

@@ -67,6 +67,7 @@ const SERVER_CODES = new Set([
   "overloaded_error",
   "server_error",
   "server_is_overloaded",
+  "slow_down",
   "serviceunavailableexception",
 ])
 const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error", "validationexception"])

packages/ai/src/providers/openai.ts

@@ -12,7 +12,7 @@ export type { OpenAIImageOptions } from "../protocols/openai-images.js"
 
 export const id = ProviderID.make("openai")
 
-export const routes = [OpenAIResponses.route, OpenAIResponses.webSocketRoute, OpenAIChat.route]
+export const routes = [OpenAIResponses.route, OpenAIChat.route]
 
 // This provider facade wraps the lower-level Responses and Chat model factories
 // with OpenAI-specific conveniences: typed options, API-key sugar, env fallback,
@@ -63,7 +63,6 @@ export interface Settings extends ProviderPackage.Settings {
   readonly organization?: string
   readonly project?: string
   readonly queryParams?: Readonly<Record<string, string>>
-  readonly transport?: "http" | "websocket"
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
@@ -82,17 +81,12 @@ const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Co
 
 export const configure = (input: Config = {}) => {
   const responsesRoute = configuredRoute(OpenAIResponses.route, input)
-  const responsesWebSocketRoute = configuredRoute(OpenAIResponses.webSocketRoute, input)
   const chatRoute = configuredRoute(OpenAIChat.route, input)
   const modelDefaults = defaults(input)
   const responses = (id: string | ModelID) =>
     responsesRoute
       .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
       .model<OpenAIProviderOptionsInput>({ id })
-  const responsesWebSocket = (id: string | ModelID) =>
-    responsesWebSocketRoute
-      .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
-      .model<OpenAIProviderOptionsInput>({ id })
   const chat = (id: string | ModelID) =>
     chatRoute.with(withOpenAIOptions(id, modelDefaults)).model<OpenAIProviderOptionsInput>({ id })
   const image = (modelID: string | ModelID) =>
@@ -111,7 +105,6 @@ export const configure = (input: Config = {}) => {
     id,
     model: responses,
     responses,
-    responsesWebSocket,
     chat,
     image,
     configure,
@@ -138,10 +131,7 @@ const config = (settings: Settings): Config => {
 }
 
 export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
-  const configured = configure(config(settings))
-  if (settings.transport === undefined || settings.transport === "http") return configured.responses(modelID)
-  if (settings.transport === "websocket") return configured.responsesWebSocket(modelID)
-  throw new Error(`Unsupported OpenAI Responses transport: ${String(settings.transport)}`)
+  return configure(config(settings)).responses(modelID)
 }
 
 export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
@@ -149,6 +139,5 @@ export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptio
   settings,
 ) => configure(config(settings)).chat(modelID)
 export const responses = provider.responses
-export const responsesWebSocket = provider.responsesWebSocket
 export const chat = provider.chat
 export const image = provider.image

packages/ai/src/route/client.ts

@@ -1,12 +1,10 @@
 import { Cause, Context, Effect, Layer, Schema, Stream } from "effect"
-import * as Option from "effect/Option"
 import { Auth } from "./auth.js"
 import { Endpoint, type EndpointPatch } from "./endpoint.js"
 import { RequestExecutor } from "./executor.js"
 import { Framing } from "./framing.js"
 import { HttpTransport } from "./transport/index.js"
-import type { HttpMiddleware, Transport, TransportRuntime } from "./transport/index.js"
-import { WebSocketExecutor } 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 * as ProviderShared from "../protocols/shared.js"
@@ -58,6 +56,7 @@ export interface Route<Body, Prepared = unknown> {
     prepared: Prepared,
     request: LLMRequest,
     runtime: TransportRuntime,
+    options?: StreamOptions,
   ) => Stream.Stream<LLMEvent, AIError>
 }
 
@@ -157,6 +156,7 @@ export interface Interface {
 
 export interface StreamOptions {
   readonly http?: HttpMiddleware
+  readonly webSocket?: WebSocketChannelExecutor
 }
 
 export interface StreamMethod {
@@ -314,23 +314,29 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
           encodeBody,
           headers: routeInput.headers,
           middleware: options?.http,
+          webSocket: options?.webSocket,
         }),
-      streamPrepared: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => {
+      streamPrepared: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime, options?: StreamOptions) => {
         const route = `${request.model.provider}/${request.model.route.id}`
-        const events = routeInput.transport
-          .frames(prepared, request, runtime)
-          .pipe(
-            Stream.mapEffect(decodeEvent(route)),
-            protocol.stream.terminal ? Stream.takeUntil(protocol.stream.terminal) : (stream) => stream,
-          )
-        return events.pipe(
-          Stream.mapAccumEffect(
-            () => protocol.stream.initial(request),
-            protocol.stream.step,
-            protocol.stream.onHalt ? { onHalt: protocol.stream.onHalt } : undefined,
+        return Stream.unwrap(
+          routeInput.transport.execute(prepared, request, runtime, options).pipe(
+            Effect.map((execution) => {
+              const events = execution.frames.pipe(
+                Stream.mapEffect(decodeEvent(route)),
+                protocol.stream.terminal ? Stream.takeUntil(protocol.stream.terminal) : (stream) => stream,
+              )
+              const stream = events.pipe(
+                Stream.mapAccumEffect(
+                  () => protocol.stream.initial(request),
+                  protocol.stream.step,
+                  protocol.stream.onHalt ? { onHalt: protocol.stream.onHalt } : undefined,
+                ),
+                Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))),
+                requireTerminalEvent(route),
+              )
+              return execution.complete ? stream.pipe(Stream.onEnd(execution.complete)) : stream
+            }),
           ),
-          Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))),
-          requireTerminalEvent(route),
         )
       },
     } satisfies Route<Body, Prepared>
@@ -413,7 +419,7 @@ const streamRequestWith = (runtime: TransportRuntime) => (request: LLMRequest, o
   Stream.unwrap(
     Effect.gen(function* () {
       const compiled = yield* compile(request, options)
-      return compiled.route.streamPrepared(compiled.prepared, compiled.request, runtime)
+      return compiled.route.streamPrepared(compiled.prepared, compiled.request, runtime, options)
     }),
   )
 
@@ -451,7 +457,6 @@ export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer
   Effect.gen(function* () {
     const stream = streamRequestWith({
       http: yield* RequestExecutor.Service,
-      webSocket: Option.getOrUndefined(yield* Effect.serviceOption(WebSocketExecutor.Service)),
     })
     return Service.of({ stream, generate: generateWith(stream) })
   }),

packages/ai/src/route/executor.ts

@@ -34,44 +34,8 @@ export type HttpMiddleware = (
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/AI/RequestExecutor") {}
 
-const BODY_LIMIT = 16_384
-const REDACTED = "<redacted>"
-
-// One source of truth for what counts as a sensitive name across headers,
-// URL query keys, and field names embedded inside request/response bodies.
-//
-// `SENSITIVE_NAME` is used as both a substring matcher (for free-form header
-// names like `Authorization` / `X-API-Key`) and as the body-field alternation
-// list. `SHORT_QUERY_NAME` covers anchored short keys like `?key=…` / `?sig=…`
-// that are too generic to redact substring-style without false positives.
-const SENSITIVE_NAME_SOURCE =
-  "authorization|api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|token|secret|credential|signature|x-amz-signature"
-const SENSITIVE_NAME = new RegExp(SENSITIVE_NAME_SOURCE, "i")
-const SHORT_QUERY_NAME = /^(key|sig)$/i
-const SENSITIVE_BODY_FIELD = new RegExp(`(?:${SENSITIVE_NAME_SOURCE}|key)`, "i")
-const REDACT_JSON_FIELD = new RegExp(`("(?:${SENSITIVE_BODY_FIELD.source})"\\s*:\\s*)"[^"]*"`, "gi")
-const REDACT_QUERY_FIELD = new RegExp(`((?:${SENSITIVE_BODY_FIELD.source})=)[^&\\s"]+`, "gi")
-
-const isSensitiveHeaderName = (name: string) => SENSITIVE_NAME.test(name)
-
-const isSensitiveQueryName = (name: string) => isSensitiveHeaderName(name) || SHORT_QUERY_NAME.test(name)
-
-const redactHeaders = (headers: Headers.Headers, redactedNames: ReadonlyArray<string | RegExp>) =>
-  Object.fromEntries(
-    Object.entries(Headers.redact(headers, [...redactedNames, SENSITIVE_NAME])).map(([name, value]) => [
-      name,
-      String(value),
-    ]),
-  )
-
-const redactUrl = (value: string) => {
-  if (!URL.canParse(value)) return REDACTED
-  const url = new URL(value)
-  url.searchParams.forEach((_, key) => {
-    if (isSensitiveQueryName(key)) url.searchParams.set(key, REDACTED)
-  })
-  return url.toString()
-}
+const headerDetails = (headers: Headers.Headers) =>
+  Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, String(value)]))
 
 const normalizedHeaders = (headers: Headers.Headers) =>
   Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]))
@@ -144,58 +108,22 @@ const rateLimitDetails = (headers: Record<string, string>, retryAfter: number |
   })
 }
 
-const requestDetails = (request: HttpClientRequest.HttpClientRequest, redactedNames: ReadonlyArray<string | RegExp>) =>
+const requestDetails = (request: HttpClientRequest.HttpClientRequest) =>
   new HttpRequestDetails({
     method: request.method,
-    url: redactUrl(request.url),
-    headers: redactHeaders(request.headers, redactedNames),
+    url: request.url,
+    headers: headerDetails(request.headers),
   })
 
-const responseDetails = (
-  response: HttpClientResponse.HttpClientResponse,
-  redactedNames: ReadonlyArray<string | RegExp>,
-) =>
+const responseDetails = (response: HttpClientResponse.HttpClientResponse) =>
   new HttpResponseDetails({
     status: response.status,
-    headers: redactHeaders(response.headers, redactedNames),
+    headers: headerDetails(response.headers),
   })
 
-const secretValues = (request: HttpClientRequest.HttpClientRequest) => {
-  const values = new Set<string>()
-  const add = (value: string) => {
-    if (value.length < 4) return
-    values.add(value)
-    values.add(encodeURIComponent(value))
-  }
-
-  Object.entries(request.headers).forEach(([name, value]) => {
-    if (!isSensitiveHeaderName(name)) return
-    add(value)
-    const bearer = /^Bearer\s+(.+)$/i.exec(value)?.[1]
-    if (bearer) add(bearer)
-  })
-
-  if (!URL.canParse(request.url)) return values
-  new URL(request.url).searchParams.forEach((value, key) => {
-    if (isSensitiveQueryName(key)) add(value)
-  })
-  return values
-}
-
-// Two passes: structural (redact `"name": "value"` and `name=value` patterns
-// for any field name that looks sensitive) plus literal (replace any actual
-// secret values we sent in the request, in case the response echoes one back).
-const redactBody = (body: string, secrets: ReadonlySet<string>) =>
-  Array.from(secrets).reduce(
-    (text, secret) => text.split(secret).join(REDACTED),
-    body.replace(REDACT_JSON_FIELD, `$1"${REDACTED}"`).replace(REDACT_QUERY_FIELD, `$1${REDACTED}`),
-  )
-
-const responseBody = (body: string | void, secrets: ReadonlySet<string>) => {
+const responseBody = (body: string | void) => {
   if (body === undefined) return {}
-  const redacted = redactBody(body, secrets)
-  if (redacted.length <= BODY_LIMIT) return { body: redacted }
-  return { body: redacted.slice(0, BODY_LIMIT), bodyTruncated: true }
+  return { body }
 }
 
 const decodeProviderBody = Schema.decodeUnknownOption(
@@ -207,52 +135,49 @@ const decodeProviderBody = Schema.decodeUnknownOption(
   ),
 )
 
-const providerMessage = (status: number, body: { readonly body?: string }) => {
-  if (body.body && body.body.length <= 500) {
-    const decoded = Option.getOrUndefined(decodeProviderBody(body.body))
-    return `Provider request failed with HTTP ${status}: ${decoded?.error?.message ?? decoded?.message ?? body.body}`
-  }
-  return `Provider request failed with HTTP ${status}`
+const providerMessage = (status: number, body: string | void) => {
+  const decoded = body === undefined ? undefined : Option.getOrUndefined(decodeProviderBody(body))
+  return (
+    [decoded?.error?.message, decoded?.message].find((message) => message?.trim()) ??
+    `Provider request failed with HTTP ${status}`
+  )
 }
 
 const responseHttp = (input: {
   readonly request: HttpClientRequest.HttpClientRequest
   readonly response: HttpClientResponse.HttpClientResponse
-  readonly redactedNames: ReadonlyArray<string | RegExp>
   readonly body: ReturnType<typeof responseBody>
   readonly requestId?: string | undefined
   readonly rateLimit?: HttpRateLimitDetails | undefined
 }) =>
   new HttpContext({
-    request: requestDetails(input.request, input.redactedNames),
-    response: responseDetails(input.response, input.redactedNames),
+    request: requestDetails(input.request),
+    response: responseDetails(input.response),
     ...input.body,
     requestId: input.requestId,
     rateLimit: input.rateLimit,
   })
 
 const statusError =
-  (request: HttpClientRequest.HttpClientRequest, redactedNames: ReadonlyArray<string | RegExp>) =>
-  (response: HttpClientResponse.HttpClientResponse) =>
+  (request: HttpClientRequest.HttpClientRequest) => (response: HttpClientResponse.HttpClientResponse) =>
     Effect.gen(function* () {
       if (response.status < 400) return response
       const body = yield* response.text.pipe(Effect.catch(() => Effect.void))
       const headers = normalizedHeaders(response.headers)
       const retryAfter = retryAfterMs(headers)
       const rateLimit = rateLimitDetails(headers, retryAfter)
-      const details = responseBody(body, secretValues(request))
+      const details = responseBody(body)
       return yield* new AIError({
         module: "RequestExecutor",
         method: "execute",
         reason: classifyProviderFailure({
           status: response.status,
-          message: providerMessage(response.status, details),
+          message: providerMessage(response.status, body),
           retryAfterMs: retryAfter,
           rateLimit,
           http: responseHttp({
             request,
             response,
-            redactedNames,
             body: details,
             requestId: requestId(headers),
             rateLimit,
@@ -262,10 +187,10 @@ const statusError =
     })
 
 // Classifies an HTTP failure captured outside the executor (for example by the
-// AI SDK's own fetch) onto the same reason types and redacted HttpContext that
+// AI SDK's own fetch) onto the same reason types and HttpContext that
 // executor-driven requests produce. The originating request is not available on
 // that path, so the method is assumed (language model calls are always POST),
-// request headers are empty, and only structural body redaction applies.
+// request headers are empty.
 export const classifyHttpFailure = (input: {
   readonly message: string
   readonly url: string
@@ -277,7 +202,7 @@ export const classifyHttpFailure = (input: {
   const headers = normalizedHeaders(Headers.fromInput(input.responseHeaders))
   const retryAfter = retryAfterMs(headers)
   const rateLimit = rateLimitDetails(headers, retryAfter)
-  const details = responseBody(input.responseBody ?? undefined, new Set<string>())
+  const details = responseBody(input.responseBody)
   return classifyProviderFailure({
     message: input.message,
     status: input.status,
@@ -285,11 +210,11 @@ export const classifyHttpFailure = (input: {
     retryAfterMs: retryAfter,
     rateLimit,
     http: new HttpContext({
-      request: new HttpRequestDetails({ method: "POST", url: redactUrl(input.url), headers: {} }),
+      request: new HttpRequestDetails({ method: "POST", url: input.url, headers: {} }),
       response:
         input.status === undefined
           ? undefined
-          : new HttpResponseDetails({ status: input.status, headers: redactHeaders(Headers.fromInput(headers), []) }),
+          : new HttpResponseDetails({ status: input.status, headers: headerDetails(Headers.fromInput(headers)) }),
       ...details,
       requestId: requestId(headers),
       rateLimit,
@@ -319,7 +244,6 @@ const httpError = (input: {
   readonly error: unknown
   readonly request: HttpClientRequest.HttpClientRequest
   readonly operation: HttpOperation
-  readonly redactedNames: ReadonlyArray<string | RegExp>
 }) => {
   const request = HttpClientError.isHttpClientError(input.error) ? input.error.request : input.request
   const transportError = (failure: { readonly message: string; readonly code?: string | undefined }) =>
@@ -331,8 +255,8 @@ const httpError = (input: {
         transport: "http",
         operation: input.operation,
         code: failure.code,
-        url: redactUrl(request.url),
-        http: new HttpContext({ request: requestDetails(request, input.redactedNames) }),
+        url: request.url,
+        http: new HttpContext({ request: requestDetails(request) }),
       }),
     })
 
@@ -343,7 +267,7 @@ const httpError = (input: {
   const native = nativeTransportFailure(source)
   const code = native?.code
   const raw = native?.message ?? (input.error instanceof Error ? input.error.message : undefined)
-  const detail = raw ? redactBody(raw, secretValues(request)) : undefined
+  const detail = raw
   const message = code && detail && !detail.includes(code) ? `${code}: ${detail}` : detail
 
   if (Cause.isTimeoutError(input.error) || Cause.isTimeoutError(source))
@@ -369,10 +293,9 @@ export const stream = (
 ): Stream.Stream<Uint8Array, AIError> =>
   Stream.unwrap(
     Effect.gen(function* () {
-      const redactedNames = yield* Headers.CurrentRedactedNames
       const response = yield* executor.execute(request, middleware)
       return response.stream.pipe(
-        Stream.mapError((error) => httpError({ error, request: response.request, operation: "read", redactedNames })),
+        Stream.mapError((error) => httpError({ error, request: response.request, operation: "read" })),
       )
     }),
   )
@@ -383,19 +306,18 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
     const http = yield* HttpClient.HttpClient
     const executeOnce = (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) =>
       Effect.gen(function* () {
-        const redactedNames = yield* Headers.CurrentRedactedNames
         if (!middleware)
           return yield* http.execute(request).pipe(
-            Effect.mapError((error) => httpError({ error, request, operation: "request", redactedNames })),
-            Effect.flatMap(statusError(request, redactedNames)),
+            Effect.mapError((error) => httpError({ error, request, operation: "request" })),
+            Effect.flatMap(statusError(request)),
           )
 
         const response = yield* middleware(request, (input) =>
           http
             .execute(input)
             .pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause))))),
-        ).pipe(Effect.mapError((error) => httpError({ error, request, operation: "request", redactedNames })))
-        return yield* statusError(response.request, redactedNames)(response)
+        ).pipe(Effect.mapError((error) => httpError({ error, request, operation: "request" })))
+        return yield* statusError(response.request)(response)
       })
     return Service.of({
       execute: executeOnce,

packages/ai/src/route/index.ts

@@ -16,11 +16,28 @@ export { AuthOptions } from "./auth-options.js"
 export { Endpoint } from "./endpoint.js"
 export { Framing } from "./framing.js"
 export { Protocol } from "./protocol.js"
-export { HttpTransport, WebSocketExecutor, WebSocketTransport } from "./transport/index.js"
+export { HttpTransport, WebSocketTransport } from "./transport/index.js"
 export * as Transport from "./transport/index.js"
 export type { Definition as AuthShape, AuthInput, Credential, CredentialError } from "./auth.js"
 export type { ApiKeyMode, AuthOverride, ProviderAuthOption } from "./auth-options.js"
 export type { Definition as EndpointFn, EndpointInput } from "./endpoint.js"
 export type { Definition as FramingDef } from "./framing.js"
 export type { Protocol as ProtocolDef } from "./protocol.js"
-export type { HttpHandler, HttpMiddleware, Transport as TransportDef, TransportRuntime } from "./transport/index.js"
+export type {
+  ChannelCheckpoint,
+  ChannelCreate,
+  ChannelObservation,
+  HttpHandler,
+  HttpMiddleware,
+  Transport as TransportDef,
+  TransportExecuteOptions,
+  TransportExecution,
+  TransportRuntime,
+  WebSocketConnection,
+  WebSocketChannelDriver,
+  WebSocketChannelExchange,
+  WebSocketChannelExecution,
+  WebSocketChannelExecutor,
+  WebSocketConnector,
+  WebSocketRequest,
+} from "./transport/index.js"

packages/ai/src/route/transport/http.ts

@@ -87,8 +87,10 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
         middleware: prepareInput.middleware,
       }
     }),
-  frames: (prepared, _request, runtime) =>
-    prepared.framing.frame(RequestExecutor.stream(runtime.http, prepared.request, prepared.middleware)),
+  execute: (prepared, _request, runtime) =>
+    Effect.succeed({
+      frames: prepared.framing.frame(RequestExecutor.stream(runtime.http, prepared.request, prepared.middleware)),
+    }),
 })
 
 export const sseJson = {

packages/ai/src/route/transport/index.ts

@@ -1,19 +1,33 @@
-import type { Effect, Stream } from "effect"
+import type { Effect, Scope, Stream } from "effect"
 import { Endpoint } from "../endpoint.js"
 import { Auth } from "../auth.js"
 import type { HttpMiddleware, Interface as RequestExecutorInterface } from "../executor.js"
-import type { Interface as WebSocketExecutorInterface } from "./websocket.js"
+import type { WebSocketChannelExecutor } from "./websocket-channel.js"
 import type { AIError, LLMRequest } from "../../schema/index.js"
 
 export interface TransportRuntime {
   readonly http: RequestExecutorInterface
-  readonly webSocket?: WebSocketExecutorInterface
+}
+
+export interface TransportExecution<Frame> {
+  readonly frames: Stream.Stream<Frame, AIError>
+  /** Optional successful-consumption acknowledgement. HTTP leaves this absent. */
+  readonly complete?: Effect.Effect<void>
+}
+
+export interface TransportExecuteOptions {
+  readonly webSocket?: WebSocketChannelExecutor
 }
 
 export interface Transport<Body, Prepared, Frame> {
   readonly id: string
   readonly prepare: (input: TransportPrepareInput<Body>) => Effect.Effect<Prepared, AIError>
-  readonly frames: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime) => Stream.Stream<Frame, AIError>
+  readonly execute: (
+    prepared: Prepared,
+    request: LLMRequest,
+    runtime: TransportRuntime,
+    options?: TransportExecuteOptions,
+  ) => Effect.Effect<TransportExecution<Frame>, AIError, Scope.Scope>
 }
 
 export interface TransportPrepareInput<Body> {
@@ -24,8 +38,19 @@ export interface TransportPrepareInput<Body> {
   readonly encodeBody: (body: Body) => string
   readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
   readonly middleware?: HttpMiddleware
+  readonly webSocket?: WebSocketChannelExecutor
 }
 
 export * as HttpTransport from "./http.js"
 export type { HttpHandler, HttpMiddleware } from "../executor.js"
-export { WebSocketExecutor, WebSocketTransport } from "./websocket.js"
+export type {
+  ChannelCheckpoint,
+  ChannelCreate,
+  ChannelObservation,
+  WebSocketChannelDriver,
+  WebSocketChannelExchange,
+  WebSocketChannelExecution,
+  WebSocketChannelExecutor,
+} from "./websocket-channel.js"
+export type { WebSocketConnection, WebSocketConnector, WebSocketRequest } from "./websocket.js"
+export { WebSocketTransport } from "./websocket.js"

packages/ai/src/route/transport/websocket-channel.ts

@@ -0,0 +1,50 @@
+import type { Effect, Scope, Stream } from "effect"
+import type { Headers } from "effect/unstable/http"
+import type { AIError } from "../../schema/index.js"
+
+export interface WebSocketChannelExecutor {
+  readonly execute: (
+    exchange: WebSocketChannelExchange,
+  ) => Effect.Effect<WebSocketChannelExecution, AIError, Scope.Scope>
+}
+
+export interface WebSocketChannelExecution {
+  readonly frames: Stream.Stream<string, AIError>
+  /** Commits staged state after the decoded Route stream ends successfully. */
+  readonly complete: Effect.Effect<void>
+}
+
+export interface WebSocketChannelExchange {
+  readonly id: string
+  readonly connect: {
+    readonly url: string
+    readonly headers: Headers.Headers
+    /** Provider-safe connection age after which Core should rotate before sending. */
+    readonly rotateAfterMs?: number
+  }
+  readonly fallback: () => Stream.Stream<string, AIError>
+  readonly driver: WebSocketChannelDriver
+}
+
+export interface WebSocketChannelDriver {
+  readonly create: (checkpoint: ChannelCheckpoint | undefined) => Effect.Effect<ChannelCreate, AIError>
+  readonly observe: (create: ChannelCreate, frame: string) => Effect.Effect<ChannelObservation, AIError>
+}
+
+export interface ChannelCreate {
+  readonly message: string
+  readonly mode: "full" | "incremental"
+}
+
+export type ChannelObservation =
+  | { readonly type: "frame"; readonly frame: string }
+  | { readonly type: "completed"; readonly frame: string; readonly checkpoint?: ChannelCheckpoint }
+  | { readonly type: "incomplete"; readonly frame: string }
+  | { readonly type: "provider-failure"; readonly error: AIError }
+  | { readonly type: "rejected"; readonly error: AIError; readonly recovery: "retry-full" }
+  | { readonly type: "rejected"; readonly error: AIError; readonly recovery: "rotate-and-retry-full" }
+
+export interface ChannelCheckpoint {
+  readonly protocol: string
+  readonly value: unknown
+}

packages/ai/src/route/transport/websocket.ts

@@ -1,8 +1,15 @@
-import { Cause, Context, Effect, Layer, Queue, Stream } from "effect"
+import { Cause, Effect, Queue, Stream } from "effect"
 import { Headers } from "effect/unstable/http"
+import { Socket } from "effect/unstable/socket"
 import { AIError, TransportReason, type TransportOperation } from "../../schema/index.js"
 import * as HttpTransport from "./http.js"
 import type { Transport } from "./index.js"
+import type {
+  ChannelObservation,
+  WebSocketChannelDriver,
+  WebSocketChannelExchange,
+  WebSocketChannelExecutor,
+} from "./websocket-channel.js"
 
 export interface WebSocketRequest {
   readonly url: string
@@ -15,24 +22,29 @@ export interface WebSocketConnection {
   readonly close: Effect.Effect<void, never>
 }
 
-export interface Interface {
+export interface WebSocketConnector {
   readonly open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>
 }
 
-type WebSocketConstructorWithHeaders = new (
+type WebSocketConstructorWithHeaders = (
   url: string,
   options?: { readonly headers?: Headers.Headers },
 ) => globalThis.WebSocket
 
-export class Service extends Context.Service<Service, Interface>()("@opencode/AI/WebSocketExecutor") {}
-
+const MAX_FRAME_BYTES = 16 * 1024 * 1024
 const transportError = (
   method: string,
   message: string,
-  input: { readonly operation: TransportOperation; readonly url?: string; readonly code?: string },
+  input: {
+    readonly operation: TransportOperation
+    readonly url?: string
+    readonly code?: string
+    readonly phase?: TransportReason["phase"]
+    readonly delivery?: TransportReason["delivery"]
+  },
 ) =>
   new AIError({
-    module: "WebSocketExecutor",
+    module: "WebSocketConnector",
     method,
     reason: new TransportReason({
       message,
@@ -40,9 +52,33 @@ const transportError = (
       operation: input.operation,
       url: input.url,
       code: input.code,
+      phase: input.phase,
+      delivery: input.delivery,
     }),
   })
 
+const annotateTransportError = (
+  error: AIError,
+  input: { readonly phase: TransportReason["phase"]; readonly delivery: TransportReason["delivery"] },
+) =>
+  error.reason._tag === "Transport"
+    ? new AIError({
+        module: error.module,
+        method: error.method,
+        reason: new TransportReason({
+          message: error.reason.message,
+          transport: error.reason.transport,
+          operation: error.reason.operation,
+          code: error.reason.code,
+          url: error.reason.url,
+          http: error.reason.http,
+          phase: input.phase,
+          delivery: input.delivery,
+          recovery: error.reason.recovery,
+        }),
+      })
+    : error
+
 const eventMessage = (event: Event) => {
   if ("message" in event && typeof event.message === "string") return event.message
   return event.type
@@ -63,6 +99,8 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
         url: input.url,
         operation: "request",
         code: "closed",
+        phase: "connect",
+        delivery: "not-sent",
       }),
     )
   }
@@ -89,6 +127,8 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
           transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, {
             url: input.url,
             operation: "request",
+            phase: "connect",
+            delivery: "not-sent",
           }),
         ),
       )
@@ -101,6 +141,8 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
             url: input.url,
             operation: "request",
             code: String(event.code),
+            phase: "connect",
+            delivery: "not-sent",
           }),
         ),
       )
@@ -112,7 +154,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
   })
 }
 
-const webSocketUrl = (value: string) =>
+export const toWebSocketUrl = (value: string) =>
   Effect.try({
     try: () => {
       const url = new URL(value)
@@ -131,21 +173,31 @@ const webSocketUrl = (value: string) =>
         url: value,
         operation: "request",
         code: "invalid-url",
+        phase: "prepare",
+        delivery: "not-sent",
       }),
   })
 
 export const open = (input: WebSocketRequest) =>
-  Effect.try({
-    try: () =>
-      new (globalThis.WebSocket as unknown as WebSocketConstructorWithHeaders)(input.url, { headers: input.headers }),
-    catch: (error) =>
-      transportError("open", error instanceof Error ? error.message : "Failed to construct WebSocket", {
-        url: input.url,
-        operation: "request",
-      }),
-  }).pipe(Effect.flatMap((ws) => fromWebSocket(ws, input)))
-
-export const layer: Layer.Layer<Service> = Layer.succeed(Service, Service.of({ open }))
+  Effect.gen(function* () {
+    const constructor = yield* Socket.WebSocketConstructor
+    const ws = yield* Effect.try({
+      try: () =>
+        // Platform implementations may extend Effect's browser-compatible constructor with handshake options.
+        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+        (constructor as unknown as WebSocketConstructorWithHeaders)(input.url, {
+          headers: input.headers,
+        }),
+      catch: (error) =>
+        transportError("open", error instanceof Error ? error.message : "Failed to construct WebSocket", {
+          url: input.url,
+          operation: "request",
+          phase: "connect",
+          delivery: "not-sent",
+        }),
+    })
+    return yield* fromWebSocket(ws, input)
+  })
 
 export const fromWebSocket = (
   ws: globalThis.WebSocket,
@@ -155,16 +207,52 @@ export const fromWebSocket = (
     yield* waitOpen(ws, input)
     const messages = yield* Queue.bounded<string | Uint8Array, AIError | Cause.Done<void>>(128)
 
+    const oversized = (message: string | Uint8Array) =>
+      typeof message === "string" ? new Blob([message]).size > MAX_FRAME_BYTES : message.byteLength > MAX_FRAME_BYTES
+    const rejectOversized = (message: string | Uint8Array) => {
+      if (!oversized(message)) return false
+      Queue.failCauseUnsafe(
+        messages,
+        Cause.fail(
+          transportError("message", "WebSocket message exceeds the 16 MiB limit", {
+            url: input.url,
+            operation: "read",
+            code: "message-too-large",
+            phase: "receive",
+          }),
+        ),
+      )
+      if (ws.readyState === globalThis.WebSocket.OPEN) ws.close(1009, "Message too large")
+      return true
+    }
+    const offer = (message: string | Uint8Array) => {
+      if (rejectOversized(message)) return
+      if (Queue.offerUnsafe(messages, message)) return
+      Queue.failCauseUnsafe(
+        messages,
+        Cause.fail(
+          transportError("message", "WebSocket inbound queue overflow", {
+            url: input.url,
+            operation: "read",
+            code: "queue-overflow",
+            phase: "receive",
+          }),
+        ),
+      )
+    }
+
     const onMessage = (event: MessageEvent) => {
-      if (typeof event.data === "string") return Queue.offerUnsafe(messages, event.data)
+      if (typeof event.data === "string") return offer(event.data)
       const binary = binaryMessage(event.data)
-      if (binary) return Queue.offerUnsafe(messages, binary)
+      if (binary) return offer(binary)
       Queue.failCauseUnsafe(
         messages,
         Cause.fail(
           transportError("message", "Unsupported WebSocket message payload", {
             url: input.url,
             operation: "read",
+            code: "message",
+            phase: "receive",
           }),
         ),
       )
@@ -176,12 +264,13 @@ export const fromWebSocket = (
           transportError("message", `WebSocket error: ${eventMessage(event)}`, {
             url: input.url,
             operation: "read",
+            code: "message",
+            phase: "receive",
           }),
         ),
       )
     }
     const onClose = (event: CloseEvent) => {
-      if (event.code === 1000 || event.code === 1005) return Queue.endUnsafe(messages)
       Queue.failCauseUnsafe(
         messages,
         Cause.fail(
@@ -189,6 +278,7 @@ export const fromWebSocket = (
             url: input.url,
             operation: "read",
             code: String(event.code),
+            phase: "close",
           }),
         ),
       )
@@ -205,13 +295,26 @@ export const fromWebSocket = (
 
     return {
       sendText: (message) =>
-        Effect.try({
-          try: () => ws.send(message),
-          catch: (error) =>
-            transportError("sendText", error instanceof Error ? error.message : "Failed to send WebSocket message", {
-              url: input.url,
-              operation: "write",
-            }),
+        Effect.suspend(() => {
+          if (ws.readyState !== globalThis.WebSocket.OPEN)
+            return Effect.fail(
+              transportError("sendText", `WebSocket is not open (state ${ws.readyState})`, {
+                url: input.url,
+                operation: "write",
+                phase: "send",
+                delivery: "not-sent",
+              }),
+            )
+          return Effect.try({
+            try: () => ws.send(message),
+            catch: (error) =>
+              transportError("sendText", error instanceof Error ? error.message : "Failed to send WebSocket message", {
+                url: input.url,
+                operation: "write",
+                phase: "send",
+                delivery: "not-sent",
+              }),
+          })
         }),
       messages: Stream.fromQueue(messages),
       close: cleanup.pipe(
@@ -228,6 +331,57 @@ export const fromWebSocket = (
 export const messageText = (message: string | Uint8Array, decoder: TextDecoder) =>
   typeof message === "string" ? message : decoder.decode(message)
 
+const observationFrame = (observation: ChannelObservation) => {
+  if (observation.type === "frame" || observation.type === "completed" || observation.type === "incomplete")
+    return Effect.succeed(observation.frame)
+  return Effect.fail(observation.error)
+}
+
+const observationTerminal = (observation: ChannelObservation) => observation.type !== "frame"
+
+export const makeDirect = (connector: WebSocketConnector): WebSocketChannelExecutor => ({
+  execute: (exchange) =>
+    Effect.gen(function* () {
+      const connection = yield* Effect.acquireRelease(
+        connector
+          .open(exchange.connect)
+          .pipe(Effect.mapError((error) => annotateTransportError(error, { phase: "connect", delivery: "not-sent" }))),
+        (connection) => connection.close,
+      )
+      const create = yield* exchange.driver.create(undefined)
+      yield* connection.sendText(create.message)
+      const decoder = new TextDecoder()
+      let observed = false
+      return {
+        frames: connection.messages.pipe(
+          Stream.map((message) => {
+            observed = true
+            return messageText(message, decoder)
+          }),
+          Stream.mapError((error) =>
+            annotateTransportError(error, {
+              phase: error.reason._tag === "Transport" && error.reason.phase === "close" ? "close" : "receive",
+              delivery: observed ? "accepted" : "ambiguous",
+            }),
+          ),
+          Stream.mapEffect((frame) => exchange.driver.observe(create, frame)),
+          Stream.takeUntil(observationTerminal),
+          Stream.mapEffect(observationFrame),
+        ),
+        complete: Effect.void,
+      }
+    }),
+})
+
+export const direct: Effect.Effect<WebSocketChannelExecutor, never, Socket.WebSocketConstructor> = Effect.gen(
+  function* () {
+    const constructor = yield* Socket.WebSocketConstructor
+    return makeDirect({
+      open: (input) => open(input).pipe(Effect.provideService(Socket.WebSocketConstructor, constructor)),
+    })
+  },
+)
+
 export interface JsonPrepared {
   readonly url: string
   readonly headers: Headers.Headers
@@ -254,33 +408,44 @@ export const json = <Body, Message>(input: JsonInput<Body, Message>): JsonTransp
         ...prepareInput,
       })
       return {
-        url: yield* webSocketUrl(parts.url),
+        url: yield* toWebSocketUrl(parts.url),
         headers: parts.headers,
         message: input.encodeMessage(yield* input.toMessage(parts.jsonBody)),
       }
     }),
-  frames: (prepared, _request, runtime) => {
-    const webSocket = runtime.webSocket
+  execute: (prepared, request, _runtime, options) => {
+    const webSocket = options?.webSocket
     if (!webSocket) {
-      return Stream.fail(
-        transportError("json", "WebSocket JSON transport requires WebSocketExecutor.Service", {
+      return Effect.fail(
+        transportError("json", "WebSocket JSON transport requires StreamOptions.webSocket", {
           url: prepared.url,
           operation: "request",
           code: "unavailable",
+          phase: "prepare",
+          delivery: "not-sent",
         }),
       )
     }
-    const decoder = new TextDecoder()
-    return Stream.unwrap(
-      Effect.gen(function* () {
-        const connection = yield* Effect.acquireRelease(
-          webSocket.open({ url: prepared.url, headers: prepared.headers }),
-          (connection) => connection.close,
-        )
-        yield* connection.sendText(prepared.message)
-        return connection.messages.pipe(Stream.map((message) => messageText(message, decoder)))
-      }),
-    )
+    const driver: WebSocketChannelDriver = {
+      create: () => Effect.succeed({ message: prepared.message, mode: "full" }),
+      observe: (_create, frame) => Effect.succeed({ type: "frame", frame }),
+    }
+    const exchange: WebSocketChannelExchange = {
+      id: request.id ?? "request",
+      connect: { url: prepared.url, headers: prepared.headers },
+      fallback: () =>
+        Stream.fail(
+          transportError("fallback", "WebSocket JSON transport does not provide HTTP fallback", {
+            url: prepared.url,
+            operation: "request",
+            code: "websocket",
+            phase: "fallback",
+            delivery: "not-sent",
+          }),
+        ),
+      driver,
+    }
+    return webSocket.execute(exchange)
   },
 })
 
@@ -289,15 +454,13 @@ export const jsonTransport = {
   with: json,
 } as const
 
-export const WebSocketExecutor = {
-  Service,
-  layer,
-  open,
-  fromWebSocket,
-  messageText,
-} as const
-
 export const WebSocketTransport = {
   json,
   jsonTransport,
+  direct,
+  makeDirect,
+  open,
+  fromWebSocket,
+  messageText,
+  toWebSocketUrl,
 } as const

packages/ai/src/schema/errors.ts

@@ -106,6 +106,13 @@ export class TransportReason extends Schema.Class<TransportReason>("AI.Error.Tra
   code: Schema.optional(Schema.String),
   url: Schema.optional(Schema.String),
   http: Schema.optional(HttpContext),
+  phase: Schema.optional(
+    Schema.Literals(["prepare", "queue", "connect", "send", "receive", "decode", "complete", "fallback", "close"]),
+  ),
+  delivery: Schema.optional(Schema.Literals(["not-sent", "rejected", "ambiguous", "accepted"])),
+  recovery: Schema.optional(
+    Schema.Literals(["retry-connect", "retry-full", "rotate-and-retry-full", "fallback-http", "fail"]),
+  ),
 }) {}
 
 export class InvalidProviderOutputReason extends Schema.Class<InvalidProviderOutputReason>(

packages/ai/test/executor.test.ts

@@ -1,12 +1,13 @@
 import { describe, expect } from "bun:test"
-import { Effect, Layer, Ref, Stream } from "effect"
+import { Deferred, Effect, Fiber, Layer, Ref, Stream } from "effect"
 import { Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { LLM, AIError } from "../src/index.js"
-import { LLMClient, RequestExecutor } from "../src/route.js"
+import { LLMClient, RequestExecutor, WebSocketTransport, type WebSocketChannelExecutor } from "../src/route.js"
 import * as OpenAIChat from "../src/protocols/openai-chat.js"
-import { dynamicResponse, systemError } from "./lib/http.js"
+import * as OpenAI from "../src/providers/openai.js"
+import { dynamicResponse, fixedResponse, systemError } from "./lib/http.js"
 import { deltaChunk } from "./lib/openai-chunks.js"
-import { sseRaw } from "./lib/sse.js"
+import { sseEvents, sseRaw } from "./lib/sse.js"
 import { it } from "./lib/effect.js"
 
 const request = HttpClientRequest.post("https://provider.test/v1/chat?api_key=secret&key=secret&debug=1").pipe(
@@ -65,6 +66,7 @@ const expectAIError = (error: unknown) => {
 }
 
 const errorHttp = (error: AIError) => ("http" in error.reason ? error.reason.http : undefined)
+const largeProviderMessage = `Upstream request failed: ${"validation failed; ".repeat(1_000)}`
 
 describe("RequestExecutor", () => {
   it.effect("parses response body failures at the executor seam", () =>
@@ -75,11 +77,11 @@ describe("RequestExecutor", () => {
       expectAIError(error)
       expect(error.reason).toMatchObject({
         _tag: "Transport",
-        message: "ECONNRESET: disconnected <redacted> <redacted>",
+        message: "ECONNRESET: disconnected query-secret-123 header-secret-456",
         transport: "http",
         operation: "read",
         code: "ECONNRESET",
-        url: "https://provider.test/v1/chat?api_key=%3Credacted%3E&debug=1",
+        url: "https://provider.test/v1/chat?api_key=query-secret-123&debug=1",
       })
     }).pipe(
       Effect.provide(
@@ -152,12 +154,12 @@ describe("RequestExecutor", () => {
       expectAIError(error)
       expect(error.reason).toMatchObject({
         _tag: "Transport",
-        message: "ECONNRESET: proxy disconnected <redacted>",
-        url: "https://proxy.test/v1/chat?api_key=%3Credacted%3E",
+        message: "ECONNRESET: proxy disconnected proxy-secret",
+        url: "https://proxy.test/v1/chat?api_key=proxy-secret",
         http: {
           request: {
-            url: "https://proxy.test/v1/chat?api_key=%3Credacted%3E",
-            headers: { authorization: "<redacted>" },
+            url: "https://proxy.test/v1/chat?api_key=proxy-secret",
+            headers: { authorization: "Bearer proxy-secret" },
           },
         },
       })
@@ -217,9 +219,47 @@ describe("RequestExecutor", () => {
       expectAIError(error)
       expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
       expect("classification" in error.reason ? error.reason.classification : undefined).toBeUndefined()
+      expect(error.reason.message).toBe("Provider request failed with HTTP 400")
     }).pipe(Effect.provide(responsesLayer([new Response("invalid parameter", { status: 400 })]))),
   )
 
+  it.effect("preserves structured provider messages from large error bodies", () =>
+    Effect.gen(function* () {
+      const executor = yield* RequestExecutor.Service
+      const error = yield* executor.execute(request).pipe(Effect.flip)
+
+      expectAIError(error)
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: largeProviderMessage })
+      expect(errorHttp(error)?.body).toContain(largeProviderMessage)
+      expect(errorHttp(error)?.bodyTruncated).toBeUndefined()
+    }).pipe(
+      Effect.provide(
+        responsesLayer([
+          new Response(
+            JSON.stringify({
+              model: "gpt-5.6-sol",
+              error: { type: "invalid_request", message: largeProviderMessage },
+            }),
+            { status: 400 },
+          ),
+        ]),
+      ),
+    ),
+  )
+
+  it.effect("falls back when structured provider messages are empty", () =>
+    Effect.gen(function* () {
+      const executor = yield* RequestExecutor.Service
+      const error = yield* executor.execute(request).pipe(Effect.flip)
+
+      expectAIError(error)
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidRequest",
+        message: "Provider request failed with HTTP 400",
+      })
+    }).pipe(Effect.provide(responsesLayer([new Response('{"error":{"message":"  "}}', { status: 400 })]))),
+  )
+
   it.effect("classifies provider rate limits hidden behind HTTP 400", () =>
     Effect.gen(function* () {
       const classify = (body: string) =>
@@ -253,7 +293,7 @@ describe("RequestExecutor", () => {
     }),
   )
 
-  it.effect("returns redacted diagnostics for rate limits", () =>
+  it.effect("returns complete diagnostics for rate limits", () =>
     Effect.gen(function* () {
       const executor = yield* RequestExecutor.Service
       const error = yield* executor.execute(request).pipe(Effect.flip)
@@ -268,15 +308,15 @@ describe("RequestExecutor", () => {
             requestId: "req_123",
             request: {
               method: "POST",
-              url: "https://provider.test/v1/chat?api_key=%3Credacted%3E&key=%3Credacted%3E&debug=1",
-              headers: { authorization: "<redacted>", "x-safe": "visible" },
+              url: "https://provider.test/v1/chat?api_key=secret&key=secret&debug=1",
+              headers: { authorization: "Bearer secret", "x-safe": "visible" },
             },
             response: {
               status: 429,
               headers: {
                 "retry-after-ms": "0",
                 "x-request-id": "req_123",
-                "x-api-key": "<redacted>",
+                "x-api-key": "secret",
               },
             },
           },
@@ -295,14 +335,14 @@ describe("RequestExecutor", () => {
     ),
   )
 
-  it.effect("honors current redacted header names in diagnostics", () =>
+  it.effect("preserves configured header names in diagnostics", () =>
     Effect.gen(function* () {
       const executor = yield* RequestExecutor.Service
       const error = yield* executor.execute(request).pipe(Effect.flip)
 
       expectAIError(error)
-      expect(errorHttp(error)?.request.headers["x-safe"]).toBe("<redacted>")
-      expect(errorHttp(error)?.response?.headers["x-safe"]).toBe("<redacted>")
+      expect(errorHttp(error)?.request.headers["x-safe"]).toBe("visible")
+      expect(errorHttp(error)?.response?.headers["x-safe"]).toBe("response-secret")
     }).pipe(
       Effect.provide(responsesLayer([new Response("bad", { status: 400, headers: { "x-safe": "response-secret" } })])),
       Effect.provideService(Headers.CurrentRedactedNames, ["x-safe"]),
@@ -421,15 +461,15 @@ describe("RequestExecutor", () => {
     }),
   )
 
-  it.effect("truncates large authentication error bodies", () =>
+  it.effect("preserves large authentication error bodies", () =>
     Effect.gen(function* () {
       const executor = yield* RequestExecutor.Service
       const error = yield* executor.execute(request).pipe(Effect.flip)
 
       expectAIError(error)
       expect(error.reason).toMatchObject({ _tag: "Authentication" })
-      expect(errorHttp(error)?.bodyTruncated).toBe(true)
-      expect(errorHttp(error)?.body).toHaveLength(16_384)
+      expect(errorHttp(error)?.bodyTruncated).toBeUndefined()
+      expect(errorHttp(error)?.body).toHaveLength(20_000)
     }).pipe(
       Effect.provide(
         responsesLayer([
@@ -440,16 +480,15 @@ describe("RequestExecutor", () => {
     ),
   )
 
-  it.effect("redacts common secret fields in response bodies", () =>
+  it.effect("preserves response body fields", () =>
     Effect.gen(function* () {
       const executor = yield* RequestExecutor.Service
       const error = yield* executor.execute(request).pipe(Effect.flip)
 
       expectAIError(error)
-      expect(errorHttp(error)?.body).toContain('"key":"<redacted>"')
-      expect(errorHttp(error)?.body).toContain("api_key=<redacted>")
-      expect(errorHttp(error)?.body).not.toContain("body-secret")
-      expect(errorHttp(error)?.body).not.toContain("query-secret")
+      expect(errorHttp(error)?.body).toBe(
+        '{"error":{"message":"bad","key":"body-secret","detail":"api_key=query-secret"}}',
+      )
     }).pipe(
       Effect.provide(
         responsesLayer([
@@ -461,16 +500,13 @@ describe("RequestExecutor", () => {
     ),
   )
 
-  it.effect("redacts echoed request secret values in response bodies", () =>
+  it.effect("preserves echoed request values in response bodies", () =>
     Effect.gen(function* () {
       const executor = yield* RequestExecutor.Service
       const error = yield* executor.execute(secretRequest).pipe(Effect.flip)
 
       expectAIError(error)
-      expect(errorHttp(error)?.body).toContain("provider echoed <redacted>")
-      expect(errorHttp(error)?.body).toContain("authorization <redacted>")
-      expect(errorHttp(error)?.body).not.toContain("query-secret-123")
-      expect(errorHttp(error)?.body).not.toContain("header-secret-456")
+      expect(errorHttp(error)?.body).toBe("provider echoed query-secret-123 and authorization header-secret-456")
     }).pipe(
       Effect.provide(
         responsesLayer([
@@ -511,3 +547,146 @@ describe("RequestExecutor", () => {
     }),
   )
 })
+
+describe("WebSocket channel execution", () => {
+  const model = OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses("gpt-4.1-mini")
+  const request = LLM.request({ model, prompt: "Say hello." })
+  const frames = [
+    JSON.stringify({ type: "response.output_text.delta", item_id: "msg_1", delta: "Hi" }),
+    JSON.stringify({ type: "response.completed", response: { id: "resp_1" } }),
+  ]
+
+  it.effect("runs a channel driver through the direct executor", () =>
+    Effect.gen(function* () {
+      const sent = yield* Ref.make("")
+      const closed = yield* Ref.make(false)
+      const observed = yield* Ref.make(0)
+      const webSocket = WebSocketTransport.makeDirect({
+        open: () =>
+          Effect.succeed({
+            sendText: (message) => Ref.set(sent, message),
+            messages: Stream.make("one", "done", "late"),
+            close: Ref.set(closed, true),
+          }),
+      })
+      const received = yield* Effect.scoped(
+        Effect.gen(function* () {
+          const execution = yield* webSocket.execute({
+            id: "exchange_1",
+            connect: { url: "wss://api.openai.test/v1/responses", headers: Headers.empty },
+            fallback: () => Stream.empty,
+            driver: {
+              create: () => Effect.succeed({ message: "create", mode: "full" }),
+              observe: (_create, frame) =>
+                Ref.update(observed, (value) => value + 1).pipe(
+                  Effect.as(
+                    frame === "done" ? { type: "completed" as const, frame } : { type: "frame" as const, frame },
+                  ),
+                ),
+            },
+          })
+          return yield* Stream.runCollect(execution.frames)
+        }),
+      )
+
+      expect(Array.from(received)).toEqual(["one", "done"])
+      expect(yield* Ref.get(sent)).toBe("create")
+      expect(yield* Ref.get(observed)).toBe(2)
+      expect(yield* Ref.get(closed)).toBe(true)
+    }),
+  )
+
+  it.effect("rejects a closed socket before attempting to send", () =>
+    Effect.gen(function* () {
+      class ClosedBeforeSend extends EventTarget {
+        readyState = globalThis.WebSocket.OPEN
+        sends = 0
+        send() {
+          this.sends++
+        }
+        close() {}
+      }
+      const socket = new ClosedBeforeSend()
+      const connection = yield* WebSocketTransport.fromWebSocket(
+        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+        socket as unknown as globalThis.WebSocket,
+        { url: "wss://api.openai.test/v1/responses", headers: Headers.empty },
+      )
+      socket.readyState = globalThis.WebSocket.CLOSED
+
+      const error = yield* connection.sendText("create").pipe(Effect.flip)
+
+      expect(error.reason).toMatchObject({ _tag: "Transport", phase: "send", delivery: "not-sent" })
+      expect(socket.sends).toBe(0)
+      yield* connection.close
+    }),
+  )
+
+  it.effect("uses HTTP when no per-call WebSocket executor is provided", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(sseEvents(...frames))))
+
+      expect(response.text).toBe("Hi")
+    }),
+  )
+
+  it.effect("commits channel execution only after complete consumption", () =>
+    Effect.gen(function* () {
+      const commits = yield* Ref.make(0)
+      const executor = (input: Stream.Stream<string, AIError>): WebSocketChannelExecutor => ({
+        execute: () =>
+          Effect.succeed({
+            frames: input,
+            complete: Ref.update(commits, (value) => value + 1),
+          }),
+      })
+
+      const response = yield* LLMClient.generate(request, {
+        webSocket: executor(Stream.fromArray(frames)),
+      }).pipe(Effect.provide(fixedResponse("")))
+      expect(response.text).toBe("Hi")
+      expect(yield* Ref.get(commits)).toBe(1)
+
+      yield* LLMClient.generate(request, { webSocket: executor(Stream.make("not-json")) }).pipe(
+        Effect.provide(fixedResponse("")),
+        Effect.flip,
+      )
+      expect(yield* Ref.get(commits)).toBe(1)
+
+      yield* LLMClient.stream(request, { webSocket: executor(Stream.fromArray(frames)) }).pipe(
+        Stream.take(1),
+        Stream.runDrain,
+        Effect.provide(fixedResponse("")),
+      )
+      expect(yield* Ref.get(commits)).toBe(1)
+    }),
+  )
+
+  it.effect("does not commit interrupted channel execution", () =>
+    Effect.gen(function* () {
+      const commits = yield* Ref.make(0)
+      const started = yield* Deferred.make<void>()
+      const executor: WebSocketChannelExecutor = {
+        execute: () =>
+          Effect.succeed({
+            frames: Stream.fromEffect(
+              Deferred.succeed(started, undefined).pipe(
+                Effect.as(JSON.stringify({ type: "response.created", response: { id: "resp_1" } })),
+              ),
+            ).pipe(Stream.concat(Stream.never)),
+            complete: Ref.update(commits, (value) => value + 1),
+          }),
+      }
+      const fiber = yield* LLMClient.stream(request, { webSocket: executor }).pipe(
+        Stream.runDrain,
+        Effect.provide(fixedResponse("")),
+        Effect.forkChild({ startImmediately: true }),
+      )
+
+      yield* Deferred.await(started)
+      yield* Fiber.interrupt(fiber)
+
+      expect(yield* Ref.get(commits)).toBe(0)
+    }),
+  )
+})

packages/ai/test/exports.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { AIError, ImageInput, LanguageModel, LLM, LLMClient, Provider } from "@opencode-ai/ai"
-import { Route, Protocol } from "@opencode-ai/ai/route"
+import { Route, Protocol, WebSocketTransport } from "@opencode-ai/ai/route"
 import { Provider as ProviderSubpath } from "@opencode-ai/ai/provider"
 import {
   CloudflareAIGateway,
@@ -16,6 +16,7 @@ import {
   OpenAICompatibleResponses,
   OpenAIResponses,
   OpenResponses,
+  OpenResponsesChannel,
 } from "@opencode-ai/ai/protocols"
 import * as AnthropicMessages from "@opencode-ai/ai/protocols/anthropic-messages"
 import { TestLLM } from "@opencode-ai/ai/testing"
@@ -36,6 +37,7 @@ describe("public exports", () => {
   test("route barrel exposes route-authoring APIs", () => {
     expect(Route.make).toBeFunction()
     expect(Protocol.make).toBeFunction()
+    expect(WebSocketTransport.makeDirect).toBeFunction()
   })
 
   test("provider barrels expose user-facing facades", async () => {
@@ -43,7 +45,6 @@ describe("public exports", () => {
 
     expect(OpenAI.model).toBeFunction()
     expect(OpenAI.provider.responses).toBe(OpenAI.responses)
-    expect(OpenAI.provider.responsesWebSocket).toBe(OpenAI.responsesWebSocket)
     expect(OpenAI.configure({ apiKey: "fixture" }).responses).toBeFunction()
     expect(OpenAICompatible.deepseek.model).toBeFunction()
     expect(
@@ -65,10 +66,10 @@ describe("public exports", () => {
     expect(OpenAIChat.route.id).toBe("openai-chat")
     expect(OpenAICompatibleChat.route.id).toBe("openai-compatible-chat")
     expect(OpenResponses.protocol.id).toBe("open-responses")
+    expect(OpenResponsesChannel.transport).toBeFunction()
     expect(OpenAICompatibleResponses.route.id).toBe("openai-compatible-responses")
     expect(OpenAICompatibleResponses.route.protocol).toBe("open-responses")
     expect(OpenAIResponses.route.id).toBe("openai-responses")
-    expect(OpenAIResponses.webSocketRoute.id).toBe("openai-responses-websocket")
     expect(AnthropicMessages.route.id).toBe("anthropic-messages")
   })
 })

packages/ai/test/lib/http.ts

@@ -1,9 +1,8 @@
 import { Effect, Layer, Ref } from "effect"
 import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { LLMClient, RequestExecutor, WebSocketExecutor } from "../../src/route.js"
+import { LLMClient, RequestExecutor } from "../../src/route.js"
 import type { Service as LLMClientService } from "../../src/route/client.js"
 import type { Service as RequestExecutorService } from "../../src/route/executor.js"
-import type { Service as WebSocketExecutorService } from "../../src/route/transport/websocket.js"
 
 export type HandlerInput = {
   readonly request: HttpClientRequest.HttpClientRequest
@@ -34,7 +33,7 @@ const handlerLayer = (handler: Handler): Layer.Layer<HttpClient.HttpClient> =>
     ),
   )
 
-export type RuntimeEnv = RequestExecutorService | WebSocketExecutorService | LLMClientService
+export type RuntimeEnv = RequestExecutorService | LLMClientService
 
 export interface SystemError extends Error {
   readonly code: string
@@ -44,9 +43,8 @@ export const systemError = (code: string, message: string): SystemError => Objec
 
 export const runtimeLayer = (layer: Layer.Layer<HttpClient.HttpClient>): Layer.Layer<RuntimeEnv> => {
   const requestExecutorLayer = RequestExecutor.layer.pipe(Layer.provide(layer))
-  const deps = Layer.mergeAll(requestExecutorLayer, WebSocketExecutor.layer)
-  const llmClientLayer = LLMClient.layer.pipe(Layer.provide(deps))
-  return Layer.mergeAll(deps, llmClientLayer)
+  const llmClientLayer = LLMClient.layer.pipe(Layer.provide(requestExecutorLayer))
+  return Layer.mergeAll(requestExecutorLayer, llmClientLayer)
 }
 
 const SSE_HEADERS = { "content-type": "text/event-stream" } as const

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

@@ -69,10 +69,10 @@ describe("provider error classification", () => {
 
   test("classifies V1 overloaded provider codes", () => {
     expect(
-      ['{"code":"resource_exhausted"}', '{"code":"service_unavailable"}'].map(
+      ['{"code":"resource_exhausted"}', '{"code":"service_unavailable"}', '{"code":"slow_down"}'].map(
         (message) => classifyProviderFailure({ message })._tag,
       ),
-    ).toEqual(["ProviderInternal", "ProviderInternal"])
+    ).toEqual(["ProviderInternal", "ProviderInternal", "ProviderInternal"])
   })
 
   test("classifies transient client statuses as provider internal", () => {

packages/ai/test/provider-options/openai.types.ts

@@ -1,13 +1,18 @@
 import { LLM } from "../../src/index.js"
 import { OpenAI } from "../../src/providers.js"
 
-const model = OpenAI.responses("gpt-5")
+const selected = OpenAI.responses("gpt-5")
 
-LLM.request({ model, prompt: "Hello", providerOptions: { openai: { reasoningEffort: "high" } } })
+LLM.request({ model: selected, prompt: "Hello", providerOptions: { openai: { reasoningEffort: "high" } } })
 
 LLM.request({
-  model,
+  model: selected,
   prompt: "Hello",
   // @ts-expect-error OpenAI reasoning effort must be a string.
   providerOptions: { openai: { reasoningEffort: 1 } },
 })
+
+OpenAI.configure({
+  // @ts-expect-error Transport is execution policy, not provider configuration.
+  transport: "websocket",
+})

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

@@ -80,11 +80,6 @@ describe("provider package entrypoints", () => {
     expect(selected.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
   })
 
-  test("selects transport without changing the semantic API", () => {
-    expect(model("gpt-5", { apiKey: "fixture" }).route.id).toBe("openai-responses")
-    expect(model("gpt-5", { apiKey: "fixture", transport: "websocket" }).route.id).toBe("openai-responses-websocket")
-  })
-
   test("maps OpenAI-compatible Responses settings onto the executable model", async () => {
     const OpenAICompatibleResponses = await import("@opencode-ai/ai/providers/openai-compatible/responses")
     const selected = OpenAICompatibleResponses.model("custom-model", {

packages/ai/test/provider/anthropic-messages.recorded.test.ts

@@ -39,7 +39,7 @@ describe("Anthropic Messages sad-path recorded", () => {
 
       expect(error).toBeInstanceOf(AIError)
       expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
-      expect(error.message).toContain("HTTP 400")
+      expect(error.reason.message).toContain("`tool_use` ids were found without `tool_result` blocks")
     }),
   )
 })

packages/ai/test/provider/anthropic-messages.test.ts

@@ -1098,8 +1098,7 @@ describe("Anthropic Messages route", () => {
       )
 
       expect(error).toBeInstanceOf(AIError)
-      expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
-      expect(error.message).toContain("HTTP 400")
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "Bad request" })
     }),
   )
 

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

@@ -1275,8 +1275,7 @@ describe("OpenAI Chat route", () => {
       )
 
       expect(error).toBeInstanceOf(AIError)
-      expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
-      expect(error.message).toContain("HTTP 400")
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "Bad request" })
     }),
   )
 

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

@@ -1,9 +1,10 @@
 import { describe, expect } from "bun:test"
-import { ConfigProvider, Effect, Layer, Stream } from "effect"
+import { ConfigProvider, Effect, Layer, Ref, Stream } from "effect"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
 import {
   LLM,
   AIError,
+  HttpOptions,
   LLMEvent,
   LLMRequest,
   Message,
@@ -11,14 +12,23 @@ import {
   ToolCallPart,
   ToolDefinition,
   ToolResultPart,
+  TransportReason,
   Usage,
 } from "../../src/index.js"
-import { Auth, LLMClient, RequestExecutor, WebSocketExecutor } from "../../src/route.js"
+import {
+  Auth,
+  LLMClient,
+  RequestExecutor,
+  WebSocketTransport,
+  type ChannelObservation,
+  type WebSocketChannelDriver,
+} from "../../src/route.js"
 import { compileRequest } from "../../src/route/client.js"
 import * as Azure from "../../src/providers/azure.js"
 import * as OpenAI from "../../src/providers/openai.js"
 import * as XAI from "../../src/providers/xai.js"
 import * as OpenAIResponses from "../../src/protocols/openai-responses.js"
+import { OpenAIResponsesChannel } from "../../src/protocols/openai-responses-channel.js"
 import * as ProviderShared from "../../src/protocols/shared.js"
 import { continuationRequest, nativeOpenAIResponsesContinuation } from "../continuation-scenarios.js"
 import { it } from "../lib/effect.js"
@@ -31,6 +41,47 @@ const model = OpenAIResponses.route
 
 const xaiModel = XAI.configure({ apiKey: "test", baseURL: "https://api.x.ai/v1" }).responses("grok-4.5")
 
+const baseChannelDriver = (message: string): WebSocketChannelDriver => ({
+  create: () => Effect.succeed({ message, mode: "full" }),
+  observe: (_create, frame): Effect.Effect<ChannelObservation, AIError> => {
+    const event = ProviderShared.decodeJson(frame)
+    if (!ProviderShared.isRecord(event)) return Effect.die("Expected event")
+    if (event.type === "response.completed") return Effect.succeed({ type: "completed", frame })
+    if (event.type === "response.incomplete") return Effect.succeed({ type: "incomplete", frame })
+    if (event.type === "error" || event.type === "response.failed")
+      return Effect.succeed({
+        type: "provider-failure",
+        error: new AIError({
+          module: "test",
+          method: "stream",
+          reason: new TransportReason({
+            message: "provider rejected request",
+            transport: "websocket",
+            operation: "read",
+            phase: "receive",
+          }),
+        }),
+      })
+    return Effect.succeed({ type: "frame", frame })
+  },
+})
+
+const continuationDriver = (request: Readonly<Record<string, unknown>>) => {
+  const message = ProviderShared.encodeJson(request)
+  return OpenAIResponsesChannel.driver({
+    id: "openai-responses",
+    name: "OpenAI Responses",
+    request,
+    message,
+    base: baseChannelDriver(message),
+  })
+}
+
+const checkpoint = (observation: ChannelObservation) => {
+  if (observation.type !== "completed" || !observation.checkpoint) throw new Error("Expected checkpoint")
+  return observation.checkpoint
+}
+
 const request = LLM.request({
   id: "req_1",
   model,
@@ -216,19 +267,19 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("prepares OpenAI Responses WebSocket target", () =>
+  it.effect("prepares one OpenAI Responses route for either transport", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
         LLMRequest.update(request, {
-          model: OpenAIResponses.webSocketRoute
+          model: OpenAIResponses.route
             .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
             .model({ id: "gpt-4.1-mini" }),
         }),
       )
 
-      expect(prepared.route).toBe("openai-responses-websocket")
+      expect(prepared.route).toBe("openai-responses")
       expect(prepared.protocol).toBe("openai-responses")
-      expect(prepared.metadata).toEqual({ transport: "websocket-json" })
+      expect(prepared.metadata).toEqual({ transport: "http-json" })
       expect(prepared.body).toMatchObject({ model: "gpt-4.1-mini", store: false, stream: true })
     }),
   )
@@ -236,47 +287,60 @@ describe("OpenAI Responses route", () => {
   it.effect("streams OpenAI Responses over WebSocket", () =>
     Effect.gen(function* () {
       const sent: string[] = []
-      const opened: Array<{ readonly url: string; readonly authorization: string | undefined }> = []
+      const opened: Array<{
+        readonly url: string
+        readonly authorization: string | undefined
+        readonly protocol: string | undefined
+      }> = []
       let closed = false
-      const deps = Layer.mergeAll(
-        Layer.succeed(
-          RequestExecutor.Service,
-          RequestExecutor.Service.of({
-            execute: () => Effect.die("unexpected HTTP request"),
-          }),
-        ),
-        Layer.succeed(
-          WebSocketExecutor.Service,
-          WebSocketExecutor.Service.of({
-            open: (input) =>
-              Effect.succeed({
-                sendText: (message) =>
-                  Effect.sync(() => {
-                    opened.push({ url: input.url, authorization: input.headers.authorization })
-                    sent.push(message)
-                  }),
-                messages: Stream.fromArray([
-                  ProviderShared.encodeJson({ type: "response.output_text.delta", item_id: "msg_1", delta: "Hi" }),
-                  ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_ws" } }),
-                ]),
-                close: Effect.sync(() => {
-                  closed = true
-                }),
-              }),
-          }),
-        ),
+      const deps = Layer.succeed(
+        RequestExecutor.Service,
+        RequestExecutor.Service.of({
+          execute: () => Effect.die("unexpected HTTP request"),
+        }),
       )
+      const webSocket = WebSocketTransport.makeDirect({
+        open: (input) =>
+          Effect.succeed({
+            sendText: (message) =>
+              Effect.sync(() => {
+                opened.push({
+                  url: input.url,
+                  authorization: input.headers.authorization,
+                  protocol: input.headers["openai-beta"],
+                })
+                sent.push(message)
+              }),
+            messages: Stream.fromArray([
+              ProviderShared.encodeJson({ type: "response.created", response: { id: "resp_ws" } }),
+              ProviderShared.encodeJson({ type: "response.output_text.delta", item_id: "msg_1", delta: "Hi" }),
+              ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_ws" } }),
+            ]),
+            close: Effect.sync(() => {
+              closed = true
+            }),
+          }),
+      })
       const response = yield* LLMClient.generate(
         LLM.request({
-          model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responsesWebSocket(
-            "gpt-4.1-mini",
-          ),
+          model: OpenAI.configure({
+            baseURL: "https://api.openai.test/v1/",
+            apiKey: "test",
+            headers: { "openai-beta": "custom-protocol" },
+          }).responses("gpt-4.1-mini"),
           prompt: "Say hello.",
         }),
+        { webSocket },
       ).pipe(Effect.provide(LLMClient.layer.pipe(Layer.provide(deps))))
 
       expect(response.text).toBe("Hi")
-      expect(opened).toEqual([{ url: "wss://api.openai.test/v1/responses", authorization: "Bearer test" }])
+      expect(opened).toEqual([
+        {
+          url: "wss://api.openai.test/v1/responses",
+          authorization: "Bearer test",
+          protocol: "custom-protocol",
+        },
+      ])
       expect(closed).toBe(true)
       expect(sent).toHaveLength(1)
       expect(JSON.parse(sent[0])).toEqual({
@@ -288,15 +352,524 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
+  it.effect("rejects out-of-order and mismatched WebSocket response events", () =>
+    Effect.gen(function* () {
+      const streams = [
+        Stream.fromArray([
+          ProviderShared.encodeJson({ type: "response.output_text.delta", item_id: "late", delta: "Late" }),
+          ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_old" } }),
+        ]),
+        Stream.fromArray([
+          ProviderShared.encodeJson({ type: "response.created", response: { id: "resp_new" } }),
+          ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_old" } }),
+        ]),
+      ]
+      const webSocket = WebSocketTransport.makeDirect({
+        open: () =>
+          Effect.succeed({
+            sendText: () => Effect.void,
+            messages: streams.shift() ?? Stream.die("unexpected WebSocket open"),
+            close: Effect.void,
+          }),
+      })
+      const deps = Layer.succeed(
+        RequestExecutor.Service,
+        RequestExecutor.Service.of({ execute: () => Effect.die("unexpected HTTP request") }),
+      )
+      const model = OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses(
+        "gpt-4.1-mini",
+      )
+
+      const errors = yield* Effect.forEach(["late", "mismatch"], (prompt) =>
+        LLMClient.generate(LLM.request({ model, prompt }), { webSocket }).pipe(
+          Effect.provide(LLMClient.layer.pipe(Layer.provide(deps))),
+          Effect.flip,
+        ),
+      )
+
+      expect(errors.map((error) => error.reason._tag)).toEqual(["InvalidProviderOutput", "InvalidProviderOutput"])
+      expect(errors[0]?.message).toContain("before response.created")
+      expect(errors[1]?.message).toContain("response ID changed")
+    }),
+  )
+
+  it.effect("continues a tool call with only the new tool 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)
+      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" } }),
+        ),
+      )
+      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)
+
+      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 promoted steer after the completed assistant 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)
+      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" }],
+          },
+        }),
+      )
+      const saved = checkpoint(
+        yield* first.observe(
+          create,
+          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)
+
+      expect(continued.mode).toBe("incremental")
+      expect(ProviderShared.decodeJson(continued.message)).toMatchObject({
+        previous_response_id: "resp_1",
+        input: [steer],
+      })
+    }),
+  )
+
+  it.effect("continues store-false reasoning without replaying the output-only item ID", () =>
+    Effect.gen(function* () {
+      const firstInput = [{ role: "user", content: [{ type: "input_text", text: "Think" }] }]
+      const request = { type: "response.create", model: "gpt-5.2", store: false, input: firstInput }
+      const first = continuationDriver(request)
+      const create = yield* first.create(undefined)
+      yield* first.observe(
+        create,
+        ProviderShared.encodeJson({
+          type: "response.output_item.done",
+          item: {
+            type: "reasoning",
+            id: "rs_1",
+            summary: [{ type: "summary_text", text: "Thought" }],
+            encrypted_content: "encrypted",
+          },
+        }),
+      )
+      const saved = checkpoint(
+        yield* first.observe(
+          create,
+          ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_1" } }),
+        ),
+      )
+      const next = continuationDriver({
+        ...request,
+        input: [
+          ...firstInput,
+          {
+            type: "reasoning",
+            summary: [{ type: "summary_text", text: "Thought" }],
+            encrypted_content: "encrypted",
+          },
+          { role: "user", content: [{ type: "input_text", text: "Continue" }] },
+        ],
+      })
+
+      const continued = yield* next.create(saved)
+
+      expect(continued.mode).toBe("incremental")
+      expect(ProviderShared.decodeJson(continued.message)).toMatchObject({
+        previous_response_id: "resp_1",
+        input: [{ role: "user", content: [{ type: "input_text", text: "Continue" }] }],
+      })
+    }),
+  )
+
+  it.effect("uses a full request when any non-input invariant changes", () =>
+    Effect.gen(function* () {
+      const request = {
+        type: "response.create",
+        model: "gpt-5.2",
+        store: false,
+        metadata: { source: "one" },
+        input: [{ role: "user", content: [{ type: "input_text", text: "First" }] }],
+      }
+      const first = continuationDriver(request)
+      const create = yield* first.create(undefined)
+      const saved = checkpoint(
+        yield* first.observe(
+          create,
+          ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_1" } }),
+        ),
+      )
+      const appended = [...request.input, { role: "user", content: [{ type: "input_text", text: "Second" }] }]
+      const changes = [
+        { ...request, model: "gpt-5.3", input: appended },
+        { ...request, instructions: "Changed", input: appended },
+        { ...request, tools: [{ type: "function", name: "other" }], input: appended },
+        { ...request, temperature: 0.5, input: appended },
+        { ...request, metadata: { source: "two" }, input: appended },
+        {
+          ...request,
+          input: [{ role: "user", content: [{ type: "input_text", text: "Rewritten history" }] }, appended[1]],
+        },
+      ]
+
+      const creates = yield* Effect.forEach(changes, (changed) => continuationDriver(changed).create(saved))
+
+      expect(creates.map((item) => item.mode)).toEqual(changes.map(() => "full"))
+      expect(
+        creates
+          .map((item) => ProviderShared.decodeJson(item.message))
+          .every((item) => ProviderShared.isRecord(item) && !("previous_response_id" in item)),
+      ).toBe(true)
+    }),
+  )
+
+  it.effect("stages no checkpoint for incomplete or ID-less completion", () =>
+    Effect.gen(function* () {
+      const driver = continuationDriver({ type: "response.create", model: "gpt-5.2", input: [] })
+      const create = yield* driver.create(undefined)
+
+      const completed = yield* driver.observe(
+        create,
+        ProviderShared.encodeJson({ type: "response.completed", response: {} }),
+      )
+      expect(completed).toMatchObject({ type: "completed" })
+      expect(completed).not.toHaveProperty("checkpoint")
+      expect(
+        yield* driver.observe(create, ProviderShared.encodeJson({ type: "response.incomplete", response: {} })),
+      ).toMatchObject({ type: "incomplete" })
+    }),
+  )
+
+  it.effect("classifies explicit continuation rejection for runner-owned recovery", () =>
+    Effect.gen(function* () {
+      const driver = continuationDriver({ type: "response.create", model: "gpt-5.2", input: [] })
+      const create = yield* driver.create(undefined)
+      const missing = yield* driver.observe(
+        create,
+        ProviderShared.encodeJson({
+          type: "error",
+          error: { code: "previous_response_not_found", message: "Missing response" },
+        }),
+      )
+      const limit = yield* driver.observe(
+        create,
+        ProviderShared.encodeJson({
+          type: "error",
+          error: { code: "websocket_connection_limit_reached", message: "Rotate" },
+        }),
+      )
+
+      expect(missing).toMatchObject({
+        type: "rejected",
+        recovery: "retry-full",
+        error: { reason: { _tag: "Transport", delivery: "rejected", recovery: "retry-full" } },
+      })
+      expect(limit).toMatchObject({
+        type: "rejected",
+        recovery: "rotate-and-retry-full",
+        error: {
+          reason: { _tag: "Transport", delivery: "rejected", recovery: "rotate-and-retry-full" },
+        },
+      })
+    }),
+  )
+
+  it.effect("builds WebSocket and HTTP fallback from the same final request", () =>
+    Effect.gen(function* () {
+      const attempts = yield* Ref.make(0)
+      const message = yield* Ref.make("")
+      const body = yield* Ref.make("")
+      const response = yield* LLMClient.generate(
+        LLM.request({
+          model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses("gpt-4.1-mini"),
+          prompt: "Say hello.",
+          http: {
+            body: {
+              model: "overlaid-model",
+              metadata: { source: "overlay" },
+              stream_options: { include_usage: true },
+              background: true,
+            },
+            headers: { "x-request": "request" },
+            query: { mode: "test" },
+          },
+        }),
+        {
+          webSocket: {
+            execute: (exchange) =>
+              Effect.gen(function* () {
+                expect(exchange.connect.rotateAfterMs).toBe(55 * 60 * 1000)
+                expect(exchange.connect.headers["openai-beta"]).toBe("responses_websockets=2026-02-06")
+                expect(exchange.connect.headers["content-length"]).toBeUndefined()
+                yield* exchange.driver
+                  .create(undefined)
+                  .pipe(Effect.flatMap((create) => Ref.set(message, create.message)))
+                return { frames: exchange.fallback(), complete: Effect.void }
+              }),
+          },
+        },
+      ).pipe(
+        Effect.provide(
+          dynamicResponse((input) =>
+            Effect.gen(function* () {
+              yield* Ref.update(attempts, (value) => value + 1)
+              yield* Ref.set(body, input.text)
+              expect(input.request.url).toBe("https://api.openai.test/v1/responses?mode=test")
+              expect(input.request.headers.authorization).toBe("Bearer test")
+              expect(input.request.headers["x-request"]).toBe("request")
+              return input.respond(sseEvents({ type: "response.completed", response: {} }), {
+                headers: { "content-type": "text/event-stream" },
+              })
+            }),
+          ),
+        ),
+      )
+
+      const httpBody = JSON.parse(yield* Ref.get(body))
+      const { stream: _stream, stream_options: _streamOptions, background: _background, ...shared } = httpBody
+      expect(response.finishReason?.normalized).toBe("stop")
+      expect(yield* Ref.get(attempts)).toBe(1)
+      expect(JSON.parse(yield* Ref.get(message))).toEqual({ type: "response.create", ...shared })
+      expect(httpBody).toMatchObject({
+        model: "overlaid-model",
+        metadata: { source: "overlay" },
+        stream: true,
+        stream_options: { include_usage: true },
+        background: true,
+      })
+    }),
+  )
+
+  it.effect("uses exactly one HTTP request when no WebSocket executor is supplied", () =>
+    Effect.gen(function* () {
+      const attempts = yield* Ref.make(0)
+      yield* LLMClient.generate(
+        LLMRequest.update(request, { http: new HttpOptions({ body: { input: "raw-http-input" } }) }),
+      ).pipe(
+        Effect.provide(
+          dynamicResponse((input) =>
+            Effect.gen(function* () {
+              yield* Ref.update(attempts, (value) => value + 1)
+              expect(JSON.parse(input.text).input).toBe("raw-http-input")
+              return input.respond(sseEvents({ type: "response.completed", response: {} }), {
+                headers: { "content-type": "text/event-stream" },
+              })
+            }),
+          ),
+        ),
+      )
+
+      expect(yield* Ref.get(attempts)).toBe(1)
+    }),
+  )
+
+  it.effect("closes a direct WebSocket execution after partial consumption", () =>
+    Effect.gen(function* () {
+      const closed = yield* Ref.make(false)
+      const webSocket = WebSocketTransport.makeDirect({
+        open: () =>
+          Effect.succeed({
+            sendText: () => Effect.void,
+            messages: Stream.fromArray([
+              ProviderShared.encodeJson({ type: "response.created", response: { id: "resp_ws" } }),
+              ProviderShared.encodeJson({ type: "response.output_text.delta", item_id: "msg_1", delta: "Hi" }),
+              ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_ws" } }),
+            ]),
+            close: Ref.set(closed, true),
+          }),
+      })
+
+      yield* LLMClient.stream(
+        LLM.request({
+          model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses("gpt-4.1-mini"),
+          prompt: "Say hello.",
+        }),
+        { webSocket },
+      ).pipe(
+        Stream.take(1),
+        Stream.runDrain,
+        Effect.provide(
+          LLMClient.layer.pipe(
+            Layer.provide(
+              Layer.succeed(
+                RequestExecutor.Service,
+                RequestExecutor.Service.of({ execute: () => Effect.die("unexpected HTTP request") }),
+              ),
+            ),
+          ),
+        ),
+      )
+
+      expect(yield* Ref.get(closed)).toBe(true)
+    }),
+  )
+
+  it.effect("terminates WebSocket control events without waiting for the socket to close", () =>
+    Effect.gen(function* () {
+      const events = [
+        { type: "error", error: { code: "slow_down", message: "Try later" } },
+        {
+          type: "error",
+          status_code: 429,
+          message: "Rate limited",
+          headers: { "retry-after": 1, "x-request-id": "request", cached: false, invalid: [] },
+        },
+        {
+          type: "response.failed",
+          response: { error: { code: "server_error", message: "Unavailable" } },
+        },
+        { type: "error", status: "not-a-status", message: "Malformed status" },
+      ]
+
+      const errors = yield* Effect.forEach(events, (event) =>
+        LLMClient.generate(
+          LLM.request({
+            model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses(
+              "gpt-4.1-mini",
+            ),
+            prompt: "Say hello.",
+          }),
+          {
+            webSocket: WebSocketTransport.makeDirect({
+              open: () =>
+                Effect.succeed({
+                  sendText: () => Effect.void,
+                  messages: Stream.make(ProviderShared.encodeJson(event)).pipe(Stream.concat(Stream.never)),
+                  close: Effect.void,
+                }),
+            }),
+          },
+        ).pipe(
+          Effect.provide(
+            LLMClient.layer.pipe(
+              Layer.provide(
+                Layer.succeed(
+                  RequestExecutor.Service,
+                  RequestExecutor.Service.of({ execute: () => Effect.die("unexpected HTTP request") }),
+                ),
+              ),
+            ),
+          ),
+          Effect.flip,
+        ),
+      )
+
+      expect(errors.map((error) => error.reason._tag)).toEqual([
+        "ProviderInternal",
+        "RateLimit",
+        "ProviderInternal",
+        "UnknownProvider",
+      ])
+    }),
+  )
+
+  it.effect("marks post-send WebSocket failures with delivery state", () =>
+    Effect.gen(function* () {
+      const failure = new AIError({
+        module: "test",
+        method: "receive",
+        reason: new TransportReason({
+          message: "socket closed",
+          transport: "websocket",
+          operation: "read",
+          phase: "close",
+        }),
+      })
+      const streams = [
+        Stream.fail(failure),
+        Stream.make(ProviderShared.encodeJson({ type: "response.created", response: { id: "resp_observed" } })).pipe(
+          Stream.concat(Stream.fail(failure)),
+        ),
+      ]
+      const deps = Layer.succeed(
+        RequestExecutor.Service,
+        RequestExecutor.Service.of({ execute: () => Effect.die("unexpected HTTP request") }),
+      )
+      const webSocket = WebSocketTransport.makeDirect({
+        open: () =>
+          Effect.succeed({
+            sendText: () => Effect.void,
+            messages: streams.shift() ?? Stream.die("unexpected WebSocket open"),
+            close: Effect.void,
+          }),
+      })
+      const model = OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses(
+        "gpt-4.1-mini",
+      )
+
+      const errors = yield* Effect.forEach(["first", "second"], (prompt) =>
+        LLMClient.generate(LLM.request({ model, prompt }), { webSocket }).pipe(
+          Effect.provide(LLMClient.layer.pipe(Layer.provide(deps))),
+          Effect.flip,
+        ),
+      )
+
+      expect(errors.map((error) => error.reason)).toEqual([
+        expect.objectContaining({ _tag: "Transport", phase: "close", delivery: "ambiguous" }),
+        expect.objectContaining({ _tag: "Transport", phase: "close", delivery: "accepted" }),
+      ])
+    }),
+  )
+
   it.effect("fails immediately when WebSocket is already closed", () =>
     Effect.gen(function* () {
-      const error = yield* WebSocketExecutor.fromWebSocket(
+      const error = yield* WebSocketTransport.fromWebSocket(
         // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- fromWebSocket reads readyState before touching WebSocket methods on this branch.
         { readyState: globalThis.WebSocket.CLOSED } as globalThis.WebSocket,
         { url: "wss://api.openai.test/v1/responses", headers: Headers.empty },
       ).pipe(Effect.flip)
 
       expect(error.message).toContain("closed before opening")
+      expect(error.reason).toMatchObject({ _tag: "Transport", phase: "connect", delivery: "not-sent" })
     }),
   )
 
@@ -329,7 +902,7 @@ describe("OpenAI Responses route", () => {
       yield* LLMClient.generate(
         LLMRequest.update(request, {
           model: Azure.configure({
-            baseURL: "https://opencode-test.openai.azure.com/openai/v1/",
+            baseURL: "https://opencode-test.openai.azure.com/openai/",
             apiKey: "azure-key",
             headers: { authorization: "Bearer stale" },
           }).responses("gpt-4.1-mini"),
@@ -2037,8 +2610,7 @@ describe("OpenAI Responses route", () => {
       )
 
       expect(error).toBeInstanceOf(AIError)
-      expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
-      expect(error.message).toContain("HTTP 400")
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "Bad request" })
     }),
   )
 })

packages/ai/test/recorded-test.ts

@@ -2,12 +2,11 @@ import { HttpRecorder } from "@opencode-ai/http-recorder"
 import { Layer } from "effect"
 import * as path from "node:path"
 import { fileURLToPath } from "node:url"
-import { LLMClient, RequestExecutor, WebSocketExecutor } from "../src/route.js"
+import { LLMClient, RequestExecutor } from "../src/route.js"
 import { ImageClient } from "../src/image-client.js"
 import type { Service as ImageClientService } from "../src/image-client.js"
 import type { Service as LLMClientService } from "../src/route/client.js"
 import type { Service as RequestExecutorService } from "../src/route/executor.js"
-import type { Service as WebSocketExecutorService } from "../src/route/transport/websocket.js"
 import {
   recordedEffectGroup,
   type RecordedCaseOptions as RunnerCaseOptions,
@@ -17,7 +16,7 @@ import {
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const FIXTURES_DIR = path.resolve(__dirname, "fixtures", "recordings")
 
-type RecordedEnv = RequestExecutorService | WebSocketExecutorService | LLMClientService | ImageClientService
+type RecordedEnv = RequestExecutorService | LLMClientService | ImageClientService
 
 type RecordedTestsOptions = RecordedGroupOptions & {
   readonly options?: HttpRecorder.RecorderOptions
@@ -82,11 +81,10 @@ export const recordedTests = (options: RecordedTestsOptions) =>
           }),
         ),
       )
-      const deps = Layer.mergeAll(requestExecutor, WebSocketExecutor.layer)
       return Layer.mergeAll(
-        deps,
-        LLMClient.layer.pipe(Layer.provide(deps)),
-        ImageClient.layer.pipe(Layer.provide(deps)),
+        requestExecutor,
+        LLMClient.layer.pipe(Layer.provide(requestExecutor)),
+        ImageClient.layer.pipe(Layer.provide(requestExecutor)),
       )
     },
   })

packages/ai/test/schema.test.ts

@@ -11,6 +11,7 @@ import {
   LanguageModel,
   ModelID,
   ProviderID,
+  TransportReason,
   Usage,
 } from "../src/schema/index.js"
 import { ProviderShared } from "../src/protocols/shared.js"
@@ -108,3 +109,25 @@ test("AI errors expose the shared runtime tag", async () => {
     await Effect.runPromise(Effect.fail(error).pipe(Effect.catchTag("AI.Error", () => Effect.succeed("caught")))),
   ).toBe("caught")
 })
+
+test("transport errors serialize execution facts", () => {
+  const reason = new TransportReason({
+    message: "connection closed",
+    transport: "websocket",
+    operation: "read",
+    phase: "receive",
+    delivery: "ambiguous",
+    recovery: "fail",
+  })
+
+  expect(Schema.encodeSync(TransportReason)(reason)).toEqual({
+    _tag: "Transport",
+    message: "connection closed",
+    transport: "websocket",
+    operation: "read",
+    phase: "receive",
+    delivery: "ambiguous",
+    recovery: "fail",
+  })
+  expect(Schema.decodeUnknownSync(TransportReason)(Schema.encodeSync(TransportReason)(reason))).toEqual(reason)
+})

packages/app/e2e/regression/session-request-docks.spec.ts

@@ -87,7 +87,7 @@ test("shows a pending permission dock", async ({ page }) => {
         permission: "bash",
         patterns: ["git status", "git diff"],
         metadata: {},
-        always: ["git *"],
+        always: [],
       },
     ],
   })

packages/app/src/components/dialog-fork.tsx

@@ -11,9 +11,6 @@ import { extractPromptFromParts } from "@/utils/prompt"
 import type { TextPart as SDKTextPart } from "@/types"
 import { base64Encode } from "@opencode-ai/core/util/encode"
 import { useLanguage } from "@/context/language"
-import { useServerSDK } from "@/context/server-sdk"
-import { sessionHref } from "@/utils/session-route"
-import { ServerConnection } from "@/context/servers"
 
 interface ForkableMessage {
   id: string
@@ -30,7 +27,6 @@ export const DialogFork: Component = () => {
   const navigate = useNavigate()
   const sync = useSync()
   const sdk = useSDK()
-  const serverSDK = useServerSDK()
   const prompt = usePrompt()
   const dialog = useDialog()
   const language = useLanguage()
@@ -77,7 +73,7 @@ export const DialogFork: Component = () => {
       .then((forked) => {
         dialog.close()
         prompt.set(restored, undefined, { dir, id: forked.id })
-        navigate(sessionHref(ServerConnection.key(serverSDK.server), forked.id))
+        navigate(`/${dir}/session/${forked.id}`)
       })
       .catch((err: unknown) => {
         const message = err instanceof Error ? err.message : String(err)

packages/app/src/components/settings-v2/providers.tsx

@@ -4,7 +4,7 @@ import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { ProviderIcon } from "@opencode-ai/ui/provider-icon"
 import { showToast } from "@/utils/toast"
 import { popularProviders, useProviders } from "@/hooks/use-providers"
-import { createMemo, type Component, For, Show, createEffect } from "solid-js"
+import { createMemo, type Component, For, Show } from "solid-js"
 import { useLanguage } from "@/context/language"
 import { useServerSDK } from "@/context/server-sdk"
 import { useServerSync } from "@/context/server-sync"
@@ -14,7 +14,6 @@ import { SettingsServerScope } from "../settings-server-picker"
 import { InlineServerSelect } from "./parts/server-select"
 import { SettingsListV2 } from "./parts/list"
 import "./settings-v2.css"
-import { useData } from "@/context/server"
 
 type ProviderSource = "env" | "api" | "config" | "custom"
 type ProviderItem = ReturnType<ReturnType<typeof useProviders>["connected"]>[number]
@@ -36,7 +35,6 @@ export const SettingsProvidersV2: Component<{
   directory: string | undefined
   onBack?: () => void
 }> = (props) => {
-  const data = useData()
   const dialog = useDialog()
   const language = useLanguage()
   const serverSdk = useServerSDK()

packages/app/src/context/global-sync/bootstrap.ts

@@ -17,7 +17,6 @@ import type {
   ReferenceListInput,
   ReferenceListOutput,
   ReferenceInfo,
-  QuestionRequest,
   SessionApi,
   SessionInfo,
 } from "@opencode-ai/client/promise"
@@ -112,7 +111,6 @@ type LocationApi = { readonly get: (input?: LocationGetInput) => Promise<Locatio
 
 type McpApi = ServerApi["mcp"]
 type PermissionApi = ServerApi["permission"]
-type QuestionApi = ServerApi["question"]
 type VcsApi = ServerApi["vcs"]
 
 export const loadProjectsQuery = (scope: ServerScope, projects: ProjectApi, worktrees: WorktreeApi) =>
@@ -303,7 +301,6 @@ export async function bootstrapDirectory(input: {
     readonly mcp: McpApi
     readonly permission: PermissionApi
     readonly project: ProjectApi
-    readonly question: QuestionApi
     readonly reference: ReferenceListApi
     readonly session: SessionApi
     readonly vcs: VcsApi
@@ -394,40 +391,6 @@ export async function bootstrapDirectory(input: {
             )
           }),
       ),
-    () =>
-      retry(() =>
-        input.api.question.request
-          .list({ location: { directory: input.directory } })
-          .then((result) => result.data)
-          .then((questions) => {
-            const ids = questions.map((question) => question.sessionID)
-            const grouped = groupBySession(
-              questions.filter((question) => !!question.id && !!question.sessionID) as QuestionRequest[],
-            )
-            const warm = input.session
-              ? Promise.all(ids.map((sessionID) => input.session!.resolve(sessionID))).then(() => undefined)
-              : warmSessions({ ids, store: input.store, setStore: input.setStore, api: input.api.session })
-            return warm.then(() =>
-              batch(() => {
-                const current = input.session?.data.question ?? input.store.question
-                for (const sessionID of Object.keys(current)) {
-                  if (grouped[sessionID]) continue
-                  if (input.session?.get(sessionID)?.location.directory !== input.directory) continue
-                  if (input.session) input.session.set("question", sessionID, [])
-                  if (!input.session) input.setStore("question", sessionID, [])
-                }
-                for (const [sessionID, questions] of Object.entries(grouped)) {
-                  const value = reconcile(
-                    questions.filter((q) => !!q?.id).sort((a, b) => cmp(a.id, b.id)),
-                    { key: "id" },
-                  )
-                  if (input.session) input.session.set("question", sessionID, value)
-                  if (!input.session) input.setStore("question", sessionID, value)
-                }
-              }),
-            )
-          }),
-      ),
     () => Promise.resolve(input.loadSessions(input.directory)),
     input.mcp &&
       (() => input.queryClient.fetchQuery(loadMcpQuery(input.scope, directoryKey(input.directory), input.api.mcp))),

packages/app/src/context/global-sync/child-store.ts

@@ -250,7 +250,6 @@ export function createChildStoreManager(input: {
             session_diff: {},
             todo: {},
             permission: {},
-            question: {},
             get mcp_ready() {
               return !mcpQuery.isLoading
             },

packages/app/src/context/global-sync/event-reducer.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { Message, Part, Project } from "@/types"
-import type { PermissionRequest, QuestionRequest, SessionInfo } from "@opencode-ai/client/promise"
+import type { PermissionRequest, SessionInfo } from "@opencode-ai/client/promise"
 import { createStore } from "solid-js/store"
 import type { State } from "./types"
 import { applyDirectoryEvent, applyGlobalEvent, cleanupDroppedSessionCaches } from "./event-reducer"
@@ -45,19 +45,6 @@ const permissionRequest = (id: string, sessionID: string, title = id) =>
     save: [],
   }) as PermissionRequest
 
-const questionRequest = (id: string, sessionID: string, title = id) =>
-  ({
-    id,
-    sessionID,
-    questions: [
-      {
-        question: title,
-        header: title,
-        options: [{ label: title, description: title }],
-      },
-    ],
-  }) as QuestionRequest
-
 const baseState = (input: Partial<State> = {}) =>
   ({
     status: "complete",
@@ -75,7 +62,6 @@ const baseState = (input: Partial<State> = {}) =>
     session_diff: {},
     todo: {},
     permission: {},
-    question: {},
     mcp: {},
     lsp: [],
     vcs: undefined,
@@ -220,7 +206,6 @@ describe("applyDirectoryEvent", () => {
         session_diff: { ses_1: [] },
         todo: { ses_1: [] },
         permission: { ses_1: [] },
-        question: { ses_1: [] },
         session_status: { ses_1: { type: "busy" } },
       }),
     )
@@ -241,7 +226,6 @@ describe("applyDirectoryEvent", () => {
     expect(store.session_diff.ses_1).toBeUndefined()
     expect(store.todo.ses_1).toBeUndefined()
     expect(store.permission.ses_1).toBeUndefined()
-    expect(store.question.ses_1).toBeUndefined()
     expect(store.session_status.ses_1).toBeUndefined()
   })
 
@@ -282,7 +266,6 @@ describe("applyDirectoryEvent", () => {
           session_diff: { [item.info.id]: [] },
           todo: { [item.info.id]: [] },
           permission: { [item.info.id]: [] },
-          question: { [item.info.id]: [] },
           session_status: { [item.info.id]: { type: "busy" } },
         }),
       )
@@ -306,7 +289,6 @@ describe("applyDirectoryEvent", () => {
       expect(store.session_diff[item.info.id]).toBeUndefined()
       expect(store.todo[item.info.id]).toBeUndefined()
       expect(store.permission[item.info.id]).toBeUndefined()
-      expect(store.question[item.info.id]).toBeUndefined()
       expect(store.session_status[item.info.id]).toBeUndefined()
     }
   })
@@ -325,7 +307,6 @@ describe("applyDirectoryEvent", () => {
         session_diff: { [dropped.id]: [] },
         todo: { [dropped.id]: [] },
         permission: { [dropped.id]: [] },
-        question: { [dropped.id]: [] },
         session_status: { [dropped.id]: { type: "busy" } },
       }),
     )
@@ -349,7 +330,6 @@ describe("applyDirectoryEvent", () => {
     expect(store.session_diff[dropped.id]).toBeUndefined()
     expect(store.todo[dropped.id]).toBeUndefined()
     expect(store.permission[dropped.id]).toBeUndefined()
-    expect(store.question[dropped.id]).toBeUndefined()
     expect(store.session_status[dropped.id]).toBeUndefined()
     expect(todos).toEqual([dropped.id])
   })
@@ -486,12 +466,11 @@ describe("applyDirectoryEvent", () => {
     expect(store.part[messageID]).toBeUndefined()
   })
 
-  test("tracks permission and question request lifecycles", () => {
+  test("tracks permission request lifecycles", () => {
     const sessionID = "ses_1"
     const [store, setStore] = createStore(
       baseState({
         permission: { [sessionID]: [permissionRequest("perm_1", sessionID), permissionRequest("perm_3", sessionID)] },
-        question: { [sessionID]: [questionRequest("q_1", sessionID), questionRequest("q_3", sessionID)] },
       }),
     )
 
@@ -524,36 +503,6 @@ describe("applyDirectoryEvent", () => {
       loadLsp() {},
     })
     expect(store.permission[sessionID]?.map((x) => x.id)).toEqual(["perm_1", "perm_3"])
-
-    applyDirectoryEvent({
-      event: { type: "question.asked", properties: questionRequest("q_2", sessionID) },
-      store,
-      setStore,
-      push() {},
-      directory: "/tmp",
-      loadLsp() {},
-    })
-    expect(store.question[sessionID]?.map((x) => x.id)).toEqual(["q_1", "q_2", "q_3"])
-
-    applyDirectoryEvent({
-      event: { type: "question.asked", properties: questionRequest("q_2", sessionID, "updated") },
-      store,
-      setStore,
-      push() {},
-      directory: "/tmp",
-      loadLsp() {},
-    })
-    expect(store.question[sessionID]?.find((x) => x.id === "q_2")?.questions[0]?.header).toBe("updated")
-
-    applyDirectoryEvent({
-      event: { type: "question.rejected", properties: { sessionID, requestID: "q_2" } },
-      store,
-      setStore,
-      push() {},
-      directory: "/tmp",
-      loadLsp() {},
-    })
-    expect(store.question[sessionID]?.map((x) => x.id)).toEqual(["q_1", "q_3"])
   })
 
   test("updates vcs branch in store and cache", () => {

packages/app/src/context/global-sync/event-reducer.ts

@@ -2,13 +2,7 @@ import { Binary } from "@opencode-ai/core/util/binary"
 import { Worktree } from "@opencode-ai/schema/worktree"
 import { produce, reconcile, type SetStoreFunction, type Store } from "solid-js/store"
 import type { Message, Part, Project, Todo } from "@/types"
-import type {
-  FileDiffInfo,
-  PermissionRequest,
-  QuestionRequest,
-  SessionInfo,
-  SessionStatus,
-} from "@opencode-ai/client/promise"
+import type { FileDiffInfo, PermissionRequest, SessionInfo, SessionStatus } from "@opencode-ai/client/promise"
 import type { State, VcsCache } from "./types"
 import { trimSessions } from "./session-trim"
 import { dropSessionCaches } from "./session-cache"
@@ -27,9 +21,6 @@ const SESSION_CONTENT_EVENTS = new Set([
   "message.part.delta",
   "permission.asked",
   "permission.replied",
-  "question.asked",
-  "question.replied",
-  "question.rejected",
 ])
 
 export function applyGlobalEvent(input: {
@@ -86,7 +77,6 @@ export function cleanupDroppedSessionCaches(
     ...Object.keys(store.session_diff),
     ...Object.keys(store.todo),
     ...Object.keys(store.permission),
-    ...Object.keys(store.question),
     ...Object.keys(store.session_status),
     ...Object.values(store.part)
       .map((parts) => parts?.find((part) => !!part?.sessionID)?.sessionID)
@@ -438,43 +428,6 @@ export function applyDirectoryEvent(input: {
       )
       break
     }
-    case "question.asked": {
-      const question = event.properties as QuestionRequest
-      const questions = input.store.question[question.sessionID]
-      if (!questions) {
-        input.setStore("question", question.sessionID, [question])
-        break
-      }
-      const result = Binary.search(questions, question.id, (q) => q.id)
-      if (result.found) {
-        input.setStore("question", question.sessionID, result.index, reconcile(question))
-        break
-      }
-      input.setStore(
-        "question",
-        question.sessionID,
-        produce((draft) => {
-          draft.splice(result.index, 0, question)
-        }),
-      )
-      break
-    }
-    case "question.replied":
-    case "question.rejected": {
-      const props = event.properties as { sessionID: string; requestID: string }
-      const questions = input.store.question[props.sessionID]
-      if (!questions) break
-      const result = Binary.search(questions, props.requestID, (q) => q.id)
-      if (!result.found) break
-      input.setStore(
-        "question",
-        props.sessionID,
-        produce((draft) => {
-          draft.splice(result.index, 1)
-        }),
-      )
-      break
-    }
     case "lsp.updated": {
       input.loadLsp()
       break

packages/app/src/context/global-sync/session-cache.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { Message, Part, Todo } from "@/types"
-import type { FormInfo, PermissionRequest, QuestionRequest, SessionStatus } from "@opencode-ai/client/promise"
+import type { FormInfo, PermissionRequest, SessionStatus } from "@opencode-ai/client/promise"
 import type { FileDiffInfo } from "@opencode-ai/client/promise"
 import { dropSessionCaches, pickSessionCacheEvictions } from "./session-cache"
 
@@ -33,7 +33,6 @@ describe("app session cache", () => {
       session_message: Record<string, never[] | undefined>
       part: Record<string, Part[] | undefined>
       permission: Record<string, PermissionRequest[] | undefined>
-      question: Record<string, QuestionRequest[] | undefined>
       form: Record<string, FormInfo[] | undefined>
       part_text_accum_delta: Record<string, string | undefined>
     } = {
@@ -44,7 +43,6 @@ describe("app session cache", () => {
       session_message: {},
       part: { msg_1: [part("prt_1", "ses_1", "msg_1")] },
       permission: { ses_1: [] as PermissionRequest[] },
-      question: { ses_1: [] as QuestionRequest[] },
       form: { ses_1: [] as FormInfo[] },
       part_text_accum_delta: { prt_1: "streamed text" },
     }
@@ -58,7 +56,6 @@ describe("app session cache", () => {
     expect(store.session_diff.ses_1).toBeUndefined()
     expect(store.session_status.ses_1).toBeUndefined()
     expect(store.permission.ses_1).toBeUndefined()
-    expect(store.question.ses_1).toBeUndefined()
     expect(store.form.ses_1).toBeUndefined()
   })
 
@@ -72,7 +69,6 @@ describe("app session cache", () => {
       session_message: Record<string, never[] | undefined>
       part: Record<string, Part[] | undefined>
       permission: Record<string, PermissionRequest[] | undefined>
-      question: Record<string, QuestionRequest[] | undefined>
       form: Record<string, FormInfo[] | undefined>
       part_text_accum_delta: Record<string, string | undefined>
     } = {
@@ -83,7 +79,6 @@ describe("app session cache", () => {
       session_message: {},
       part: { [m.id]: [part("prt_1", "ses_1", m.id)] },
       permission: {},
-      question: {},
       form: {},
       part_text_accum_delta: {},
     }

packages/app/src/context/global-sync/session-cache.ts

@@ -1,5 +1,5 @@
 import type { Message, Part, Todo } from "@/types"
-import type { FormInfo, PermissionRequest, QuestionRequest, SessionStatus } from "@opencode-ai/client/promise"
+import type { FormInfo, PermissionRequest, SessionStatus } from "@opencode-ai/client/promise"
 import type { FileDiffInfo } from "@opencode-ai/client/promise"
 import type { SessionMessageInfo } from "@opencode-ai/client/promise"
 
@@ -13,7 +13,6 @@ type SessionCache = {
   session_message: Record<string, SessionMessageInfo[] | undefined>
   part: Record<string, Part[] | undefined>
   permission: Record<string, PermissionRequest[] | undefined>
-  question: Record<string, QuestionRequest[] | undefined>
   form?: Record<string, FormInfo[] | undefined>
   part_text_accum_delta: Record<string, string | undefined>
 }
@@ -38,7 +37,6 @@ export function dropSessionCaches(store: SessionCache, sessionIDs: Iterable<stri
     delete store.session_diff[sessionID]
     delete store.session_status[sessionID]
     delete store.permission[sessionID]
-    delete store.question[sessionID]
     if (store.form) delete store.form[sessionID]
   }
 }

packages/app/src/context/global-sync/types.ts

@@ -2,7 +2,6 @@ import type { Agent, Config, LspStatus, Message, Part, Path, Todo, VcsInfo } fro
 import type {
   FileDiffInfo,
   PermissionRequest,
-  QuestionRequest,
   ReferenceInfo,
   SessionInfo,
   SessionStatus,
@@ -50,9 +49,6 @@ export type State = {
   permission: {
     [sessionID: string]: PermissionRequest[]
   }
-  question: {
-    [sessionID: string]: QuestionRequest[]
-  }
   mcp_ready: boolean
   mcp: {
     [name: string]: McpServer["status"]

packages/app/src/context/global.tsx

@@ -7,7 +7,6 @@ import { useServerHealth } from "@/utils/server-health"
 import { createServerSdkContext } from "./server-sdk"
 import { createServerSyncContext } from "./server-sync"
 import { getOwner } from "solid-js/web"
-import { createServerData } from "@opencode-ai/client/solid"
 import type { ServerScope } from "@/utils/server-scope"
 import { createServerPermissionState } from "./permission"
 import { createServerNotificationState } from "./notification"
@@ -103,12 +102,6 @@ function createServerController(
   const sync = createServerSyncContext(sdk)
   const permission = createServerPermissionState({ sdk, sync })
   const notification = createServerNotificationState({ sdk, sync, key: connKey })
-  const data = createServerData({
-    api: () => sdk.api,
-    event: sdk.event,
-    connection: sdk.connection,
-    directory: "",
-  })
 
   function enrich(project: { worktree: string; expanded: boolean }) {
     const [childStore] = sync.child(project.worktree, { bootstrap: false })
@@ -141,7 +134,6 @@ function createServerController(
     (conn?.type === "sidecar" && conn.variant === "base") || (conn?.type === "http" && isLocalHost(conn.http.url))
 
   return {
-    data,
     sdk,
     sync,
     isLocal,

packages/app/src/context/notification.tsx

@@ -278,7 +278,7 @@ export function createServerNotificationState(input: { sdk: ServerSDK; sync: Ser
     })
   }
 
-  const unsub = input.sdk.eventByDir.listen((e) => {
+  const unsub = input.sdk.event.listen((e) => {
     const event = e.details
     if (
       event.type !== "session.execution.succeeded" &&

packages/app/src/context/permission.tsx

@@ -52,7 +52,7 @@ function hasPermissionPromptRules(permission: unknown) {
   return Object.values(config).some(isNonAllowRule)
 }
 
-type PermissionEvent = Parameters<Parameters<ServerSDK["eventByDir"]["listen"]>[0]>[0]
+type PermissionEvent = Parameters<Parameters<ServerSDK["event"]["listen"]>[0]>[0]
 
 export function createServerPermissionState(input: { sdk: ServerSDK; sync: ServerSync }) {
   const [store, setStore, _, ready] = persisted(
@@ -197,7 +197,7 @@ export function createServerPermissionState(input: { sdk: ServerSDK; sync: Serve
     void respondPending(event.properties, e.name)
   }
 
-  const unsubscribe = input.sdk.eventByDir.listen((event) => {
+  const unsubscribe = input.sdk.event.listen((event) => {
     if (ready()) {
       handlePermission(event)
       return

packages/app/src/context/server-sdk.test.ts

@@ -1,6 +1,18 @@
 import { describe, expect, test } from "bun:test"
 import type { OpenCodeEvent } from "@opencode-ai/client/promise"
-import { adaptServerEvent } from "./server-sdk"
+import { adaptServerEvent, coalesceServerEvents, enqueueServerEvent, resumeStreamAfterPageShow } from "./server-sdk"
+
+describe("resumeStreamAfterPageShow", () => {
+  test("restarts a stream only after a back-forward cache restore", () => {
+    let starts = 0
+    const start = () => starts++
+
+    resumeStreamAfterPageShow({ persisted: false } as PageTransitionEvent, start)
+    resumeStreamAfterPageShow({ persisted: true } as PageTransitionEvent, start)
+
+    expect(starts).toBe(1)
+  })
+})
 
 describe("adaptServerEvent", () => {
   test("preserves current permission requests", () => {
@@ -31,3 +43,57 @@ describe("adaptServerEvent", () => {
     })
   })
 })
+
+describe("current event buffering", () => {
+  const delta = (id: string, value: string, ordinal = 0) => ({
+    directory: "/repo",
+    payload: adaptServerEvent({
+      id,
+      created: 1,
+      type: "session.text.delta",
+      location: { directory: "/repo" },
+      data: { sessionID: "ses", assistantMessageID: "msg", ordinal, delta: value },
+    } as OpenCodeEvent),
+  })
+
+  test("merges adjacent text deltas for the same message and ordinal", () => {
+    const result = coalesceServerEvents([delta("evt_1", "hello "), delta("evt_2", "world")])
+
+    expect(result).toHaveLength(1)
+    expect(result[0]?.payload.current).toMatchObject({ id: "evt_2", data: { delta: "hello world" } })
+    expect(result[0]?.payload.properties).toMatchObject({ delta: "hello world" })
+  })
+
+  test("coalesces current tool input deltas by tool ID", () => {
+    const current = (eventID: string, id: string, delta: string) =>
+      adaptServerEvent({
+        id: eventID,
+        created: 1,
+        type: "session.tool.input.delta",
+        location: { directory: "/repo" },
+        data: { sessionID: "ses", assistantMessageID: "msg", id, delta },
+      } as OpenCodeEvent)
+    const result = coalesceServerEvents([
+      { directory: "/repo", payload: current("evt_1", "call_1", "{") },
+      { directory: "/repo", payload: current("evt_2", "call_1", "}") },
+      { directory: "/repo", payload: current("evt_3", "call_2", "[]") },
+    ])
+
+    expect(result).toHaveLength(2)
+    expect(result[0]?.payload.current).toMatchObject({ id: "evt_2", data: { id: "call_1", delta: "{}" } })
+    expect(result[1]?.payload.current).toMatchObject({ id: "evt_3", data: { id: "call_2", delta: "[]" } })
+  })
+
+  test("preserves boundaries between distinct delta streams", () => {
+    const events = [delta("evt_1", "a"), delta("evt_2", "b", 1), delta("evt_3", "c")]
+
+    expect(coalesceServerEvents(events).map((event) => event.payload.current?.id)).toEqual(["evt_1", "evt_2", "evt_3"])
+  })
+
+  test("preserves current event order when enqueuing", () => {
+    const events: Parameters<typeof enqueueServerEvent>[0] = []
+    ;[delta("evt_1", "a"), delta("evt_2", "b", 1)].forEach((event) => enqueueServerEvent(events, event))
+
+    expect(events.map((event) => event.payload.current?.id)).toEqual(["evt_1", "evt_2"])
+  })
+})

packages/app/src/context/server-sdk.tsx

@@ -1,8 +1,9 @@
 import type { OpenCodeEvent } from "@opencode-ai/client/promise"
-import { createClientConnection, type ClientConnectionStatus } from "@opencode-ai/client/solid"
 import type { Event } from "@/types"
 import { createGlobalEmitter } from "@solid-primitives/event-bus"
-import { type Accessor, onCleanup } from "solid-js"
+import { makeEventListener } from "@solid-primitives/event-listener"
+import { type Accessor, batch, onCleanup, onMount } from "solid-js"
+import { createStore } from "solid-js/store"
 import { createApiForServer, type ServerApi } from "@/utils/server"
 import { usePlatform } from "./platform"
 import { ServerConnection } from "./servers"
@@ -11,15 +12,85 @@ import { ServerScope } from "@/utils/server-scope"
 import { useServer } from "./server"
 
 export type ServerEvent = Event & { id?: string; current?: OpenCodeEvent }
+type QueuedServerEvent = { directory: string; payload: ServerEvent }
+type CurrentDelta = Extract<
+  OpenCodeEvent,
+  { type: "session.text.delta" | "session.reasoning.delta" | "session.tool.input.delta" | "session.compaction.delta" }
+>
 
 export function adaptServerEvent(event: OpenCodeEvent): ServerEvent {
   return { id: event.id, type: event.type, properties: event.data, current: event } as ServerEvent
 }
 
+export function enqueueServerEvent(queue: QueuedServerEvent[], event: QueuedServerEvent) {
+  queue.push(event)
+  return true
+}
+
+export function coalesceServerEvents(events: QueuedServerEvent[]) {
+  const output: QueuedServerEvent[] = []
+  events.forEach((event) => {
+    const current = currentDelta(event.payload.current)
+    if (current) {
+      const previous = output[output.length - 1]
+      const prior = currentDelta(previous?.payload.current)
+      if (
+        previous &&
+        prior &&
+        previous.directory === event.directory &&
+        currentDeltaKey(prior) === currentDeltaKey(current)
+      ) {
+        const fragment = currentDeltaFragment(prior) + currentDeltaFragment(current)
+        const data =
+          current.type === "session.compaction.delta"
+            ? { ...current.data, text: fragment }
+            : { ...current.data, delta: fragment }
+        output[output.length - 1] = {
+          directory: event.directory,
+          payload: {
+            ...event.payload,
+            properties: data,
+            current: { ...current, data } as CurrentDelta,
+          } as ServerEvent,
+        }
+        return
+      }
+      output.push(event)
+      return
+    }
+    output.push(event)
+  })
+  return output
+}
+
+function currentDelta(event: OpenCodeEvent | undefined): CurrentDelta | undefined {
+  if (
+    event?.type === "session.text.delta" ||
+    event?.type === "session.reasoning.delta" ||
+    event?.type === "session.tool.input.delta" ||
+    event?.type === "session.compaction.delta"
+  )
+    return event
+}
+
+function currentDeltaKey(event: CurrentDelta) {
+  if (event.type === "session.tool.input.delta")
+    return `${event.type}:${event.data.sessionID}:${event.data.assistantMessageID}:${event.data.id}`
+  if (event.type === "session.compaction.delta") return `${event.type}:${event.data.sessionID}`
+  return `${event.type}:${event.data.sessionID}:${event.data.assistantMessageID}:${event.data.ordinal}`
+}
+
+function currentDeltaFragment(event: CurrentDelta) {
+  return event.type === "session.compaction.delta" ? event.data.text : event.data.delta
+}
+
+export function resumeStreamAfterPageShow(event: PageTransitionEvent, start: () => unknown) {
+  if (!event.persisted) return
+  start()
+}
+
 type ServerEventEmitter = ReturnType<typeof createGlobalEmitter<{ [key: string]: ServerEvent }>>
-type CurrentEventMap = { [Type in OpenCodeEvent["type"]]: Extract<OpenCodeEvent, { type: Type }> }
-type CurrentEventEmitter = ReturnType<typeof createGlobalEmitter<CurrentEventMap>>
-export type ServerConnectionStatus = ClientConnectionStatus
+export type ServerConnectionStatus = "connecting" | "connected" | "reconnecting"
 type ServerSDKBase = {
   server: ServerConnection.Any
   scope: ServerScope
@@ -30,51 +101,231 @@ type ServerSDKBase = {
     attempt: Accessor<number>
     error: Accessor<string | undefined>
   }
-  eventByDir: {
+  event: {
     on: ServerEventEmitter["on"]
     listen: ServerEventEmitter["listen"]
   }
-  event: {
-    on: CurrentEventEmitter["on"]
-    listen: CurrentEventEmitter["listen"]
-  }
 }
 
 function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerScope): ServerSDKBase {
   const platform = usePlatform()
-  const api = createApiForServer({ server: server.http, fetch: platform.fetch })
-  const dirEmitter = createGlobalEmitter<{ [key: string]: ServerEvent }>()
-  const emitter = createGlobalEmitter<CurrentEventMap>()
+  const abort = new AbortController()
 
-  const connection = createClientConnection(api, {
-    flushInterval: 16,
-    pageLifecycle: true,
-    onEvent(event) {
-      emitter.emit(event.type, event)
-      dirEmitter.emit(event.location?.directory ?? "global", adaptServerEvent(event))
-    },
-    log: {
-      info(message, data) {
-        if (message !== "event stream disconnected") return
-        console.info("[global-sdk] event stream disconnected", { url: server.http.url, ...data })
-      },
-    },
+  const eventFetch = (() => {
+    if (!platform.fetch || !server) return
+    try {
+      const url = new URL(server.http.url)
+      const loopback = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1"
+      if (url.protocol === "http:" && !loopback) return platform.fetch
+    } catch {
+      return
+    }
+  })()
+
+  const eventApi = createApiForServer({ server: server.http, fetch: eventFetch })
+  const emitter = createGlobalEmitter<{
+    [key: string]: ServerEvent
+  }>()
+
+  type Queued = QueuedServerEvent
+  const FLUSH_FRAME_MS = 16
+  const STREAM_YIELD_MS = 8
+  const CONNECT_TIMEOUT_MS = 2_000
+  const RECONNECT_DELAY_MS = 1_000
+
+  let queue: Queued[] = []
+  let buffer: Queued[] = []
+  let timer: ReturnType<typeof setTimeout> | undefined
+  let last = 0
+
+  function flush() {
+    if (timer) clearTimeout(timer)
+    timer = undefined
+
+    if (queue.length === 0) return
+
+    const events = queue
+    queue = buffer
+    buffer = events
+    queue.length = 0
+
+    last = Date.now()
+    const output = coalesceServerEvents(events)
+    batch(() => {
+      output.forEach((event) => emitter.emit(event.directory, event.payload))
+    })
+
+    buffer.length = 0
+  }
+
+  function schedule() {
+    if (timer) return
+    const elapsed = Date.now() - last
+    timer = setTimeout(flush, Math.max(0, FLUSH_FRAME_MS - elapsed))
+  }
+
+  function publish(event: OpenCodeEvent) {
+    const directory = event.location?.directory ?? "global"
+    if (enqueueServerEvent(queue, { directory, payload: adaptServerEvent(event) })) schedule()
+  }
+
+  function wait(delay: number, signal: AbortSignal) {
+    return new Promise<void>((resolve) => {
+      const timer = setTimeout(done, delay)
+      signal.addEventListener("abort", done, { once: true })
+      function done() {
+        clearTimeout(timer)
+        signal.removeEventListener("abort", done)
+        resolve()
+      }
+    })
+  }
+  let attempt: AbortController | undefined
+  let run: Promise<void> | undefined
+  let started = false
+  let generation = 0
+  const [connection, setConnection] = createStore<{
+    status: ServerConnectionStatus
+    attempt: number
+    error?: string
+  }>({ status: "connecting", attempt: 0 })
+
+  async function connect(signal: AbortSignal): Promise<{ error: unknown; connectedAt: number | undefined }> {
+    let connectedAt: number | undefined
+
+    // Bound the initial handshake and tie this request to the stream lifetime.
+    const request = new AbortController()
+    const cancel = () => request.abort(signal.reason)
+    const timeout = setTimeout(() => request.abort(new Error("Timed out connecting to server")), CONNECT_TIMEOUT_MS)
+    signal.addEventListener("abort", cancel, { once: true })
+
+    try {
+      // Open the event stream and validate its initial handshake.
+      const iterator = eventApi.event.subscribe({ signal: request.signal })[Symbol.asyncIterator]()
+      const first = await iterator.next()
+
+      if (signal.aborted) return { error: undefined, connectedAt }
+      if (first.done) {
+        const error =
+          request.signal.reason instanceof Error ? request.signal.reason : new Error("Event stream disconnected")
+        return { error, connectedAt }
+      }
+      if (first.value.type !== "server.connected")
+        return { error: new Error("Event stream did not start with server.connected"), connectedAt }
+
+      // Publish the connected state before forwarding live events.
+      clearTimeout(timeout)
+      publish(first.value)
+      connectedAt = Date.now()
+      setConnection({ status: "connected", attempt: 0, error: undefined })
+
+      // Forward events until the stream closes or this connection is cancelled.
+      let yielded = Date.now()
+      while (!signal.aborted) {
+        const event = await iterator.next()
+        if (signal.aborted) return { error: undefined, connectedAt }
+        if (event.done) return { error: new Error("Event stream disconnected"), connectedAt }
+        publish(event.value)
+        if (Date.now() - yielded < STREAM_YIELD_MS) continue
+        yielded = Date.now()
+        await wait(0, signal)
+      }
+      return { error: undefined, connectedAt }
+    } catch (error) {
+      return { error, connectedAt }
+    } finally {
+      request.abort()
+      clearTimeout(timeout)
+      signal.removeEventListener("abort", cancel)
+    }
+  }
+
+  async function runStream(active: number) {
+    let retries = 0
+    // oxlint-disable-next-line no-unmodified-loop-condition -- stop() changes the lifecycle flags and aborts the active request
+    while (!abort.signal.aborted && started && generation === active) {
+      setConnection({ status: retries === 0 ? "connecting" : "reconnecting", attempt: retries, error: undefined })
+      const controller = new AbortController()
+      attempt = controller
+      const onAbort = () => controller.abort()
+      abort.signal.addEventListener("abort", onAbort)
+      const result = await connect(controller.signal)
+      abort.signal.removeEventListener("abort", onAbort)
+
+      if (abort.signal.aborted || !started || generation !== active) {
+        if (attempt === controller) attempt = undefined
+        return
+      }
+      if (result.connectedAt !== undefined && Date.now() - result.connectedAt >= 1_000) retries = 0
+      retries += 1
+      const message =
+        result.error === undefined
+          ? undefined
+          : result.error instanceof Error
+            ? result.error.message
+            : String(result.error)
+      console.info("[global-sdk] event stream disconnected", {
+        url: server.http.url,
+        fetch: eventFetch ? "platform" : "webview",
+        attempt: retries,
+        error: message,
+      })
+      setConnection({ status: "reconnecting", attempt: retries, error: message })
+      await wait(RECONNECT_DELAY_MS, controller.signal)
+      if (attempt === controller) attempt = undefined
+    }
+  }
+
+  function start() {
+    if (started) return run
+    started = true
+    const active = ++generation
+    const previous = run
+    const current = (async () => {
+      if (previous) await previous
+      await runStream(active)
+    })().finally(() => {
+      if (run !== current) return
+      run = undefined
+      flush()
+    })
+    run = current
+    return run
+  }
+
+  function stop() {
+    started = false
+    generation++
+    attempt?.abort()
+  }
+
+  onMount(() => {
+    makeEventListener(window, "pagehide", stop)
+    makeEventListener(window, "pageshow", (event) => resumeStreamAfterPageShow(event, start))
+    void start()
   })
 
   onCleanup(() => {
-    dirEmitter.clear()
+    stop()
+    abort.abort()
+    if (timer) clearTimeout(timer)
+    timer = undefined
+    queue = []
+    buffer = []
     emitter.clear()
   })
 
+  const api = createApiForServer({ server: server.http, fetch: platform.fetch })
+
   return {
     server,
     scope,
     url: server.http.url,
     api,
-    connection,
-    eventByDir: {
-      on: dirEmitter.on.bind(dirEmitter),
-      listen: dirEmitter.listen.bind(dirEmitter),
+    connection: {
+      status: () => connection.status,
+      attempt: () => connection.attempt,
+      error: () => connection.error,
     },
     event: {
       on: emitter.on.bind(emitter),
@@ -114,7 +365,7 @@ export type DirectorySDK = {
 function createDirSdkContext(directory: string, serverSDK: ServerSDKBase): DirectorySDK {
   const emitter = createGlobalEmitter<SDKEventMap>()
 
-  const unsub = serverSDK.eventByDir.on(directory, (event) => {
+  const unsub = serverSDK.event.on(directory, (event) => {
     emitter.emit(event.type, event)
   })
   onCleanup(unsub)

packages/app/src/context/server-session.ts

@@ -10,7 +10,7 @@ import type {
   SessionMessageInfo,
 } from "@opencode-ai/client/promise"
 import type { Message, Part, Todo } from "@/types"
-import type { FileDiffInfo, PermissionRequest, QuestionRequest, SessionStatus } from "@opencode-ai/client/promise"
+import type { FileDiffInfo, PermissionRequest, SessionStatus } from "@opencode-ai/client/promise"
 import { batch } from "solid-js"
 import { createStore, produce, reconcile } from "solid-js/store"
 import { rootSession } from "@/utils/session-route"
@@ -198,7 +198,6 @@ export function createServerSession(
     session_diff: {} as Record<string, FileDiffInfo[]>,
     todo: {} as Record<string, Todo[]>,
     permission: {} as Record<string, PermissionRequest[]>,
-    question: {} as Record<string, QuestionRequest[]>,
     form: {} as Record<string, FormInfo[]>,
     pending: {} as Record<string, SessionInboxInfo[]>,
     input: {} as Record<string, string[]>,
@@ -281,9 +280,6 @@ export function createServerSession(
         ...Object.entries(data.permission)
           .filter(([, items]) => items.length > 0)
           .map(([sessionID]) => sessionID),
-        ...Object.entries(data.question)
-          .filter(([, items]) => items.length > 0)
-          .map(([sessionID]) => sessionID),
         ...Object.entries(data.form)
           .filter(([, items]) => items.length > 0)
           .map(([sessionID]) => sessionID),
@@ -529,9 +525,6 @@ export function createServerSession(
       ...Object.entries(data.permission)
         .filter(([, items]) => items.length > 0)
         .map(([sessionID]) => sessionID),
-      ...Object.entries(data.question)
-        .filter(([, items]) => items.length > 0)
-        .map(([sessionID]) => sessionID),
       ...Object.entries(data.form)
         .filter(([, items]) => items.length > 0)
         .map(([sessionID]) => sessionID),
@@ -1339,36 +1332,6 @@ export function createServerSession(
         )
         return
       }
-      case "question.asked": {
-        const question = event.properties as QuestionRequest
-        const questions = data.question[question.sessionID]
-        if (!questions) {
-          setData("question", question.sessionID, [question])
-          return
-        }
-        const result = Binary.search(questions, question.id, (item) => item.id)
-        if (result.found) setData("question", question.sessionID, result.index, reconcile(question))
-        if (!result.found)
-          setData(
-            "question",
-            question.sessionID,
-            produce((draft) => void draft.splice(result.index, 0, question)),
-          )
-        return
-      }
-      case "question.replied":
-      case "question.rejected": {
-        const props = event.properties as { sessionID: string; requestID: string }
-        setData(
-          "question",
-          props.sessionID,
-          produce((draft) => {
-            if (!draft) return
-            const result = Binary.search(draft, props.requestID, (item) => item.id)
-            if (result.found) draft.splice(result.index, 1)
-          }),
-        )
-      }
     }
   }
 

packages/app/src/context/server-sync.tsx

@@ -54,7 +54,7 @@ import { createServerSession, type ServerSession } from "./server-session"
 import { createCatalogSync } from "./server-sync/catalog"
 import { createConnectionSync } from "./server-sync/connection"
 import { usePlatform } from "./platform"
-import { useData, useServer } from "./server"
+import { useServer } from "./server"
 
 export function shouldRefreshWorkspaceSessions(event: ServerEvent) {
   const type = event.current?.type ?? event.type
@@ -568,7 +568,7 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     return event
   }
 
-  const unsub = serverSDK.eventByDir.listen((e) => {
+  const unsub = serverSDK.event.listen((e) => {
     const directory = e.name
     const key = directoryKey(directory)
     const event = e.details

packages/app/src/context/server.tsx

@@ -22,8 +22,3 @@ export const { use: useServer, provider: ServerProvider } = createSimpleContext(
     }
   },
 })
-
-export const useData = () => {
-  const server = useServer()
-  return server.ctx.data
-}

packages/app/src/pages/session.tsx

@@ -101,7 +101,7 @@ import { diffs as list } from "@/utils/diffs"
 import { Persist, persisted } from "@/utils/persist"
 import { extractPromptFromParts } from "@/utils/prompt"
 import { formatServerError, isLocalSessionNotFoundError, isSessionNotFoundError } from "@/utils/server-errors"
-import { requireServerKey, sessionHref } from "@/utils/session-route"
+import { legacySessionHref, requireServerKey, sessionHref } from "@/utils/session-route"
 import { useUsageExceededDialogs } from "./session/usage-exceeded-dialogs"
 import { createSessionLineage } from "./session/session-lineage"
 
@@ -2128,12 +2128,9 @@ export default function Page() {
               const id = controller.data.parentID()
               if (!id) return
               navigate(
-                sessionHref(
-                  controller.identity.params.serverKey
-                    ? requireServerKey(controller.identity.params.serverKey)
-                    : ServerConnection.key(serverSDK.server),
-                  id,
-                ),
+                controller.identity.params.serverKey
+                  ? sessionHref(requireServerKey(controller.identity.params.serverKey), id)
+                  : legacySessionHref(sdk().directory, id),
               )
             },
             setPromptRef: (el) => {

packages/app/src/pages/session/composer/session-permission-dock.tsx

@@ -37,16 +37,14 @@ export function SessionPermissionDock(props: {
             <Button variant="ghost" size="normal" onClick={() => props.onDecide("reject")} disabled={props.responding}>
               {language.t("ui.permission.deny")}
             </Button>
-            <Show when={props.request.save?.length}>
-              <Button
-                variant="secondary"
-                size="normal"
-                onClick={() => props.onDecide("always")}
-                disabled={props.responding}
-              >
-                {language.t("ui.permission.allowAlways")}
-              </Button>
-            </Show>
+            <Button
+              variant="secondary"
+              size="normal"
+              onClick={() => props.onDecide("always")}
+              disabled={props.responding}
+            >
+              {language.t("ui.permission.allowAlways")}
+            </Button>
             <Button variant="primary" size="normal" onClick={() => props.onDecide("once")} disabled={props.responding}>
               {language.t("ui.permission.allowOnce")}
             </Button>

packages/app/src/pages/session/timeline/controller.tsx

@@ -15,15 +15,13 @@ import { useSDK } from "@/context/sdk"
 import { useSync } from "@/context/sync"
 import { useTabs } from "@/context/tabs"
 import type { SessionController } from "@/pages/session/session-controller"
-import { requireServerKey, sessionHref } from "@/utils/session-route"
-import { useServerSDK } from "@/context/server-sdk"
+import { legacySessionHref, requireServerKey, sessionHref } from "@/utils/session-route"
 import { sessionTitle } from "@/utils/session-title"
 import { downloadSessionExport, fetchSessionExport, sessionExportFilename } from "@/utils/session-export"
 import { showToast } from "@/utils/toast"
 import { timelineChildTitle, timelineRemovedSessionIDs } from "./controller-projection"
 import { createTimelineProjection } from "./projection"
 import { useServer } from "@/context/server"
-import { ServerConnection } from "@/context/servers"
 
 const emptyMessages: Message[] = []
 const emptyParts: Part[] = []
@@ -48,7 +46,6 @@ export function createTimelineController(input: {
 }) {
   const navigate = useNavigate()
   const sdk = useSDK()
-  const serverSDK = useServerSDK()
   const sync = useSync()
   const server = useServer()
   const settings = useSettings()
@@ -149,22 +146,19 @@ export function createTimelineController(input: {
     if (!id || pending.unshare || !shareEnabled()) return
   }
   const href = (id: string) =>
-    sessionHref(
-      input.session.identity.params.serverKey
-        ? requireServerKey(input.session.identity.params.serverKey)
-        : ServerConnection.key(serverSDK.server),
-      id,
-    )
+    input.session.identity.params.serverKey
+      ? sessionHref(requireServerKey(input.session.identity.params.serverKey), id)
+      : legacySessionHref(sdk().directory, id)
   const navigateAfterRemoval = (id: string, parent?: string, next?: string) => {
     if (input.session.identity.params.id !== id) return
     if (parent) return navigate(href(parent))
     if (next) return navigate(href(next))
-    return tabs.newDraft({
-      server: input.session.identity.params.serverKey
-        ? requireServerKey(input.session.identity.params.serverKey)
-        : ServerConnection.key(serverSDK.server),
-      directory: sdk().directory,
-    })
+    if (input.session.identity.params.serverKey)
+      return tabs.newDraft({
+        server: requireServerKey(input.session.identity.params.serverKey),
+        directory: sdk().directory,
+      })
+    navigate(`/${input.session.identity.params.dir}/session`)
   }
   const exportSession = async (id: string) => {
     try {

packages/cli/package.json

@@ -38,8 +38,10 @@
     "immer": "11.1.4",
     "jsonc-parser": "3.3.1",
     "open": "10.1.2",
-    "semver": "catalog:",
     "solid-js": "catalog:",
+    "tree-sitter-bash": "0.25.0",
+    "tree-sitter-powershell": "0.25.10",
+    "web-tree-sitter": "0.25.10",
     "uqr": "0.1.3",
     "ws": "8.21.0"
   },
@@ -48,7 +50,6 @@
     "@opencode-ai/protocol": "workspace:*",
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
-    "@types/semver": "catalog:",
     "@typescript/native-preview": "catalog:",
     "@lydell/node-pty-darwin-arm64": "1.2.0-beta.12",
     "@lydell/node-pty-darwin-x64": "1.2.0-beta.12",

packages/cli/script/app-assets.ts

@@ -1,7 +1,7 @@
 import { $ } from "bun"
-import { readdir } from "node:fs/promises"
 import path from "node:path"
 import { brotliCompressSync, constants } from "node:zlib"
+import { collectFiles } from "./files"
 
 export async function buildAppArchive(channel: string, options?: { skipBuild?: boolean }) {
   if (options?.skipBuild) return compress({})
@@ -9,8 +9,10 @@ export async function buildAppArchive(channel: string, options?: { skipBuild?: b
   await $`bun run build`.cwd(root).env({ ...process.env, OPENCODE_CHANNEL: channel })
   const assets = Object.fromEntries(
     await Promise.all(
-      (await files(path.join(root, "dist")))
+      (await collectFiles(path.join(root, "dist")))
+        .map((key) => key.replaceAll(path.sep, "/"))
         .filter((key) => !key.endsWith(".map"))
+        .toSorted()
         .map(async (key) => {
           const source = path.join(root, "dist", key)
           const body = Buffer.from(await Bun.file(source).arrayBuffer())
@@ -31,16 +33,3 @@ function compress(assets: object) {
 function isText(key: string) {
   return key === "_headers" || /\.(?:css|html|js|json|svg|txt|webmanifest|xml)$/.test(key)
 }
-
-async function files(root: string, current = root): Promise<string[]> {
-  return (
-    await Promise.all(
-      (await readdir(current, { withFileTypes: true })).map((entry) => {
-        const target = path.join(current, entry.name)
-        return entry.isDirectory() ? files(root, target) : [path.relative(root, target).replaceAll(path.sep, "/")]
-      }),
-    )
-  )
-    .flat()
-    .toSorted()
-}

packages/cli/script/build-node.ts

@@ -12,6 +12,7 @@ import { collectNodeAssets, copyNodeAssets, hashNodeAssets, seaAssetMap } from "
 import { mainConfig } from "../vite.node.config"
 import { nodeExecArgv, nodeTarget, type NodeTarget } from "../src/node/target"
 import { buildAppArchive } from "./app-assets"
+import { verifyArtifact } from "./verify-artifact"
 
 const NODE_VERSION = "26.4.0"
 const dir = path.resolve(import.meta.dirname, "..")
@@ -91,6 +92,7 @@ for (const target of targets) {
   await copyNodeAssets(assets)
   await build(mainConfig(input))
   await assertTextImportsInlined("dist-node/opencode.mjs")
+  if (bundleOnly) await verifyArtifact("dist-node/opencode.mjs")
 
   const host = target.platform === process.platform && target.arch === process.arch
   if (host) {
@@ -139,6 +141,7 @@ for (const target of targets) {
       2,
     )}\n`,
   )
+  await verifyArtifact(path.join(outdir, name))
   if (host) await smoke(output)
 }
 

packages/cli/script/build.ts

@@ -8,6 +8,7 @@ import { createSolidTransformPlugin } from "@opentui/solid/bun-plugin"
 import type { BunPlugin } from "bun"
 import pkg from "../package.json"
 import { buildAppArchive } from "./app-assets"
+import { verifyArtifact, verifySimulationGraph } from "./verify-artifact"
 
 const dir = path.resolve(import.meta.dirname, "..")
 const binary = "opencode2"
@@ -76,6 +77,16 @@ const appAssetsPlugin: BunPlugin = {
 }
 
 for (const item of targets) {
+  const simulationInputs = new Set<string>()
+  const simulationGraphPlugin: BunPlugin = {
+    name: "opencode-simulation-graph",
+    setup(build) {
+      build.onLoad(
+        { filter: /packages[/\\]simulation[/\\]src[/\\](frontend[/\\](simulation|server)|control-server)\.ts$/ },
+        (args) => void simulationInputs.add(args.path),
+      )
+    },
+  }
   const parcelWatcherPackage = `@parcel/watcher-${item.os}-${item.arch}${item.os === "linux" ? `-${item.abi ?? "glibc"}` : ""}`
   const parcelWatcherPlugin: BunPlugin = {
     name: "parcel-watcher-binding",
@@ -92,7 +103,7 @@ for (const item of targets) {
   const result = await Bun.build({
     entrypoints: ["./src/index.ts"],
     tsconfig: "./tsconfig.json",
-    plugins: [appAssetsPlugin, solidPlugin, parcelWatcherPlugin],
+    plugins: [appAssetsPlugin, solidPlugin, parcelWatcherPlugin, simulationGraphPlugin],
     external: ["node-gyp"],
     format: "esm",
     minify: true,
@@ -123,6 +134,7 @@ for (const item of targets) {
     for (const log of result.logs) console.error(log)
     process.exit(1)
   }
+  verifySimulationGraph(simulationInputs)
 
   await Bun.write(
     path.join(outdir, name, "package.json"),
@@ -139,6 +151,7 @@ for (const item of targets) {
       2,
     ),
   )
+  await verifyArtifact(path.join(outdir, name))
 }
 
 function targetName(item: (typeof allTargets)[number]) {

packages/cli/script/files.ts

@@ -0,0 +1,13 @@
+import { readdir } from "node:fs/promises"
+import path from "node:path"
+
+export async function collectFiles(root: string, current = root): Promise<string[]> {
+  return (
+    await Promise.all(
+      (await readdir(current, { withFileTypes: true })).map(async (entry) => {
+        const target = path.join(current, entry.name)
+        return entry.isDirectory() ? collectFiles(root, target) : [path.relative(root, target)]
+      }),
+    )
+  ).flat()
+}

packages/cli/script/node-assets.ts

@@ -1,9 +1,10 @@
 import { createHash } from "node:crypto"
-import { copyFile, mkdir, readdir, readFile, stat } from "node:fs/promises"
+import { copyFile, mkdir, readFile, stat } from "node:fs/promises"
 import path from "node:path"
 import { fileURLToPath } from "node:url"
 import { getNodeAssets } from "@opentui/core/node-assets"
-import { attentionSoundAssets, type NodeTarget, photonWasmAsset } from "../src/node/target"
+import { attentionSoundAssets, type NodeTarget, photonWasmAsset, shellParserWasmAssets } from "../src/node/target"
+import { collectFiles } from "./files"
 
 const dir = path.resolve(import.meta.dirname, "..")
 
@@ -16,17 +17,6 @@ export type NodeAsset = {
   readonly source: string
 }
 
-async function files(root: string, current = root): Promise<string[]> {
-  return (
-    await Promise.all(
-      (await readdir(current, { withFileTypes: true })).map((entry) => {
-        const target = path.join(current, entry.name)
-        return entry.isDirectory() ? files(root, target) : [path.relative(root, target)]
-      }),
-    )
-  ).flat()
-}
-
 export async function collectNodeAssets(target: NodeTarget) {
   const ptyEntry = fileURLToPath(import.meta.resolve(target.nodePtyPackage))
   const ptyRoot = path.resolve(path.dirname(ptyEntry), "..")
@@ -43,11 +33,15 @@ export async function collectNodeAssets(target: NodeTarget) {
       key: photonWasmAsset,
       source: fileURLToPath(import.meta.resolve(photonWasmAsset)),
     },
+    ...Object.values(shellParserWasmAssets).map((key) => ({
+      key,
+      source: fileURLToPath(import.meta.resolve(key)),
+    })),
     ...attentionSoundAssets.map((key) => ({
       key,
       source: path.resolve(dir, "../ui/src/assets/audio", path.basename(key)),
     })),
-    ...(await files(ptyRoot))
+    ...(await collectFiles(ptyRoot))
       .filter((relative) => !relative.endsWith(".map") && !relative.endsWith(".pdb"))
       .map((relative) => ({
         key: `${target.nodePtyPackage}/${relative}`,
@@ -81,5 +75,7 @@ export async function copyNodeAssets(assets: readonly NodeAsset[]) {
 
 export async function seaAssetMap() {
   const root = path.join(dir, "dist-node", "assets")
-  return Object.fromEntries((await files(root)).map((key) => [key.replaceAll(path.sep, "/"), path.join(root, key)]))
+  return Object.fromEntries(
+    (await collectFiles(root)).map((key) => [key.replaceAll(path.sep, "/"), path.join(root, key)]),
+  )
 }

packages/cli/script/verify-artifact.ts

@@ -0,0 +1,65 @@
+import { stat } from "node:fs/promises"
+import path from "node:path"
+import { collectFiles } from "./files"
+
+const forbidden = [
+  "@napi-rs/canvas",
+  "@fontsource/commit-mono",
+  "@fontsource/noto-sans",
+  "SimulationPng",
+  "frontend/png",
+  "Failed to register screenshot font",
+  "commit-mono-latin-400-normal",
+  "noto-sans-symbols-symbols-400-normal",
+  "noto-sans-math-math-400-normal",
+  "CommitMono-400-Regular.otf",
+  "NotoSansSymbols.ttf",
+  "src/frontend/png.ts",
+  "skia.darwin-",
+  "skia.linux-",
+  "skia.win32-",
+]
+const overlap = Math.max(...forbidden.map((value) => value.length)) - 1
+
+export async function verifyArtifact(target: string) {
+  const files = await artifactFiles(target)
+  if (files.length === 0) throw new Error(`Artifact contains no published files: ${target}`)
+  for (const file of files) await scan(file)
+}
+
+export function verifySimulationGraph(inputs: Iterable<string>) {
+  const modules = Array.from(inputs, (input) => input.replaceAll("\\", "/"))
+  const required = [
+    "/packages/simulation/src/frontend/simulation.ts",
+    "/packages/simulation/src/frontend/server.ts",
+    "/packages/simulation/src/control-server.ts",
+  ]
+  const missing = required.filter((input) => !modules.some((module) => module.endsWith(input)))
+  if (missing.length > 0) throw new Error(`Build graph is missing simulation bridge inputs: ${missing.join(", ")}`)
+  const leaked = modules.find((module) => module.includes("/packages/simulation/src/frontend/png."))
+  if (leaked) throw new Error(`Build graph contains Drive-only rendering input: ${leaked}`)
+}
+
+async function artifactFiles(target: string): Promise<string[]> {
+  if ((await stat(target)).isFile()) return [target]
+  return (await collectFiles(target)).map((file) => path.join(target, file))
+}
+
+async function scan(file: string) {
+  let trailing = ""
+  const reader = Bun.file(file).stream().getReader()
+  while (true) {
+    const chunk = await reader.read()
+    if (chunk.done) return
+    const text = trailing + Buffer.from(chunk.value).toString("latin1")
+    const leaked = forbidden.find((marker) => text.includes(marker))
+    if (leaked) throw new Error(`Artifact file ${file} contains forbidden simulation payload: ${leaked}`)
+    trailing = text.slice(-overlap)
+  }
+}
+
+if (import.meta.main) {
+  const target = process.argv[2]
+  if (!target) throw new Error("Usage: bun run script/verify-artifact.ts <file-or-directory>")
+  await verifyArtifact(target)
+}

packages/cli/src/acp/permission.ts

@@ -47,7 +47,7 @@ export async function replyPermission(input: {
         locations: permissionLocations(toolName, toolInput, input.event.data.resources, input.cwd, previews),
         ...(previews.length > 0 ? { content: previews } : {}),
       },
-      options: input.event.data.save?.length ? options : options.filter((option) => option.optionId !== "always"),
+      options,
     })
     .catch(() => undefined)
   const selected = result?.outcome.outcome === "selected" ? result.outcome.optionId : undefined

packages/cli/src/node/target.ts

@@ -29,6 +29,11 @@ export function nodeTarget(platform: string, arch: string) {
 }
 
 export const photonWasmAsset = "@silvia-odwyer/photon-node/photon_rs_bg.wasm"
+export const shellParserWasmAssets = {
+  runtime: "web-tree-sitter/tree-sitter.wasm",
+  bash: "tree-sitter-bash/tree-sitter-bash.wasm",
+  powershell: "tree-sitter-powershell/tree-sitter-powershell.wasm",
+} as const
 export const nodeExecArgv = ["--experimental-ffi", "--use-system-ca", "--disable-warning=ExperimentalWarning"] as const
 
 export const attentionSoundAssets = [

packages/cli/src/services/updater-action.ts

@@ -0,0 +1,50 @@
+export type Policy = boolean | "notify"
+export type Action = "none" | "upgrade"
+
+const maximumComponent = "9007199254740991"
+const versionPattern =
+  /^v?([0-9]+)\.([0-9]+)\.([0-9]+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/
+
+export function action(current: string, latest: string, policy: Policy): Action {
+  if (policy === false) return "none"
+  const currentVersion = parseReleaseVersion(current)
+  const latestVersion = parseReleaseVersion(latest)
+  if (!currentVersion || !latestVersion || sameRelease(currentVersion, latestVersion)) return "none"
+  // Major upgrades are never installed automatically.
+  if (currentVersion.major !== latestVersion.major) return "none"
+  return "upgrade"
+}
+
+function parseReleaseVersion(input: string) {
+  if (input.length > 256) return
+  const match = input.trim().match(versionPattern)
+  if (!match) return
+  if ([match[1], match[2], match[3]].some(invalidComponent)) return
+  if (
+    match[4]
+      ?.split(".")
+      .some((identifier) => identifier.length > 1 && identifier.startsWith("0") && /^[0-9]+$/.test(identifier))
+  )
+    return
+  return {
+    major: match[1],
+    core: `${match[1]}.${match[2]}.${match[3]}`,
+    prerelease: match[4]?.split(".") ?? [],
+  }
+}
+
+function sameRelease(current: NonNullable<ReturnType<typeof parseReleaseVersion>>, latest: typeof current) {
+  if (current.core !== latest.core || current.prerelease.length !== latest.prerelease.length) return false
+  return current.prerelease.every((identifier, index) => {
+    const other = latest.prerelease[index]
+    if (identifier === other) return true
+    // semver compares oversized numeric prerelease identifiers after numeric coercion.
+    return /^[0-9]+$/.test(identifier) && /^[0-9]+$/.test(other) && Number(identifier) === Number(other)
+  })
+}
+
+function invalidComponent(value: string) {
+  if (value.length > 1 && value.startsWith("0")) return true
+  if (value.length !== maximumComponent.length) return value.length > maximumComponent.length
+  return value > maximumComponent
+}

packages/cli/src/services/updater.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test"
-import { action, decodePolicy } from "./updater"
+import { action } from "./updater-action"
+import { decodePolicy } from "./updater"
 
 describe("updater", () => {
   test("reads autoupdate from JSONC", () => {
@@ -30,4 +31,48 @@ describe("updater", () => {
   test("upgrades when latest is lower (rollback)", () => {
     expect(action("1.2.4", "1.2.3", true)).toBe("upgrade")
   })
+
+  test("accepts strict release version variants", () => {
+    expect(action("v1.2.3", " 1.2.4\n", true)).toBe("upgrade")
+    expect(action("1.2.3-alpha.1", "1.2.3-alpha.2", true)).toBe("upgrade")
+    expect(action("0.0.0-next-17403", "0.0.0-next-17403.2", true)).toBe("upgrade")
+    expect(action("1.2.3+old", "1.2.3+new", true)).toBe("none")
+    expect(action("v1.2.3+old", "1.2.3", true)).toBe("none")
+  })
+
+  test("preserves strict validity", () => {
+    const invalid = [
+      "=1.2.3",
+      "V1.2.3",
+      "1.2",
+      "1.2.3.4",
+      "01.2.3",
+      "1.02.3",
+      "1.2.03",
+      "1.2.3-01",
+      "1.2.3-",
+      "1.2.3+",
+      "1.2.3-alpha..1",
+      "1.2.3_alpha",
+      "9007199254740992.0.0",
+      "0.9007199254740992.0",
+      "0.0.9007199254740992",
+    ]
+    invalid.forEach((version) => expect(action("1.2.3", version, true), version).toBe("none"))
+  })
+
+  test("handles numeric limits without losing precision", () => {
+    expect(action("9007199254740991.0.0", "9007199254740991.0.1", true)).toBe("upgrade")
+    expect(action("9007199254740990.0.0", "9007199254740991.0.0", true)).toBe("none")
+  })
+
+  test("preserves equality for oversized numeric prerelease identifiers", () => {
+    expect(action("1.0.0-9007199254740992", "1.0.0-9007199254740993", true)).toBe("none")
+    expect(action("1.0.0-9007199254740991", "1.0.0-9007199254740992", true)).toBe("upgrade")
+  })
+
+  test("rejects versions longer than semver's limit before trimming", () => {
+    expect(action("1.2.3", `${" ".repeat(251)}1.2.3`, true)).toBe("none")
+    expect(action("1.2.3", `1.2.4+${"a".repeat(250)}`, true)).toBe("upgrade")
+  })
 })

packages/cli/src/services/updater.ts

@@ -5,12 +5,10 @@ import { Context, Duration, Effect, FileSystem, Layer } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { parse, type ParseError } from "jsonc-parser"
 import path from "node:path"
-import semver from "semver"
+import { action, type Policy } from "./updater-action"
 
 declare const OPENCODE_CLI_NAME: string | undefined
 
-export type Policy = boolean | "notify"
-export type Action = "none" | "upgrade"
 type Method = "npm" | "pnpm" | "bun" | "yarn"
 
 const packageName =
@@ -34,14 +32,6 @@ export function decodePolicy(text: string): Policy | undefined {
   if (typeof value === "boolean" || value === "notify") return value
 }
 
-export function action(current: string, latest: string, policy: Policy): Action {
-  if (policy === false) return "none"
-  if (!semver.valid(current) || !semver.valid(latest) || semver.eq(latest, current)) return "none"
-  // Major upgrades are never installed automatically.
-  if (semver.major(latest) !== semver.major(current)) return "none"
-  return "upgrade"
-}
-
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -166,3 +156,4 @@ export const layer = Layer.effect(
 )
 
 export * as Updater from "./updater"
+export { action, type Action, type Policy } from "./updater-action"

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

@@ -49,7 +49,6 @@ describe("acp permission behavior", () => {
         send(
           permissionAsked("ses_allow", "perm_always", {
             action: "read",
-            save: ["/workspace/file.ts"],
             metadata: { path: "/workspace/file.ts" },
             source: { type: "tool", messageID: "msg_allow", id: "call_always" },
           }),
@@ -85,10 +84,10 @@ describe("acp permission behavior", () => {
         },
         options: [
           { optionId: "once", kind: "allow_once", name: "Allow once" },
+          { optionId: "always", kind: "allow_always", name: "Always allow" },
           { optionId: "reject", kind: "reject_once", name: "Reject" },
         ],
       })
-      expect(permissionRequests[0]?.options.map((option) => option.optionId)).toEqual(["once", "reject"])
       expect(permissionRequests[1]).toMatchObject({
         sessionId: "ses_allow",
         toolCall: {
@@ -558,7 +557,6 @@ function permissionAsked(
   input: {
     readonly action?: string
     readonly metadata?: Record<string, unknown>
-    readonly save?: string[]
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
   } = {},
 ) {
@@ -567,7 +565,6 @@ function permissionAsked(
     sessionID,
     action: input.action ?? "shell",
     resources: ["*"],
-    ...(input.save ? { save: input.save } : {}),
     metadata: input.metadata ?? { command: "printf hello" },
     ...(input.source ? { source: input.source } : {}),
   })

packages/cli/test/drive/mini-interactive.drive.mjs

@@ -1,371 +0,0 @@
-import { Effect } from "effect"
-import { defineScript, Llm } from "opencode-drive"
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
-
-export default defineScript({
-  launch: "manual",
-  config: { autoupdate: false },
-  run: ({ artifacts, llm, server }) =>
-    Effect.gen(function* () {
-      yield* Effect.promise(() => configureServicePort(artifacts))
-      yield* server.launch()
-
-      const registration = yield* Effect.promise(() => serviceRegistration(artifacts))
-      const root = path.resolve(import.meta.dir, "../../../..")
-      const preload = Bun.resolveSync("@opentui/solid/preload", path.join(root, "packages/cli"))
-      const session = `mini-stage2-${process.pid}`
-      const snapshots = path.join(artifacts, "mini-stage2")
-      const explicitDirectory = path.join(artifacts, "explicit-model")
-      yield* Effect.promise(() =>
-        Promise.all([snapshots, explicitDirectory].map((dir) => mkdir(dir, { recursive: true }))),
-      )
-      /** @param {string} directory @param {string | undefined} model */
-      const mini = (directory, model) => [
-        "env",
-        `PWD=${directory}`,
-        `OPENCODE_PASSWORD=${registration.password}`,
-        `OPENCODE_CONFIG_DIR=${path.join(artifacts, "files/.opencode")}`,
-        `OPENCODE_TEST_HOME=${artifacts}`,
-        `XDG_CACHE_HOME=${path.join(artifacts, "home/.cache")}`,
-        `XDG_CONFIG_HOME=${path.join(artifacts, "home/.config")}`,
-        `XDG_DATA_HOME=${path.join(artifacts, "logs")}`,
-        `XDG_STATE_HOME=${path.join(artifacts, "home/.local/state")}`,
-        "OPENCODE_DISABLE_AUTOUPDATE=1",
-        "OPENCODE_DIRECT_TRACE=1",
-        process.execPath,
-        "--conditions=browser",
-        `--preload=${preload}`,
-        path.join(root, "packages/cli/src/index.ts"),
-        "mini",
-        "--server",
-        registration.url,
-        ...(model ? ["--model", model] : []),
-      ]
-
-      yield* llm.queue(
-        Llm.toolCall({
-          index: 0,
-          id: "mini-shell",
-          name: "shell",
-          input: { command: "printf 'drive-mini-tool-output\\n'" },
-        }),
-        Llm.finish("tool-calls"),
-      )
-      yield* llm.queue(Llm.text("drive mini response complete", { delay: 5, chunkSize: 4 }))
-
-      const journey = Effect.gen(function* () {
-        yield* Effect.uninterruptible(
-          Effect.promise(() =>
-            tmux([
-              "new-session",
-              "-d",
-              "-s",
-              session,
-              "-x",
-              "140",
-              "-y",
-              "30",
-              "--",
-              ...mini(path.join(artifacts, "files"), undefined),
-            ]),
-          ),
-        )
-        yield* Effect.promise(() => tmux(["set-option", "-t", session, "remain-on-exit", "on"]))
-
-        const first = yield* Effect.promise(() => waitForPane(session, "OpenCode"))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "01-first-paint.txt"), first))
-        if (first.includes("drive mini response complete"))
-          throw new Error("response rendered before prompt submission")
-
-        yield* Effect.promise(() => waitForPane(session, "Default model", 15_000))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-p"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Commands"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "model"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Switch model"))
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Select model"))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Simulated Model", 15_000))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "Escape"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Ask anything..."))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "exercise the mini frontend"]))
-        yield* Effect.sleep(100)
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        const completed = yield* Effect.promise(() => waitForPane(session, "drive mini response complete", 20_000))
-        if (!completed.includes("drive-mini-tool-output")) throw new Error("shell tool output was not rendered")
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "02-tool-and-response.txt"), completed))
-
-        yield* Effect.sleep(500)
-        const resizeOutput = path.join(snapshots, "03-resize-output.ansi")
-        yield* Effect.promise(() => tmux(["pipe-pane", "-t", session, `cat > ${JSON.stringify(resizeOutput)}`]))
-        yield* Effect.promise(() => tmux(["resize-window", "-t", session, "-x", "72", "-y", "22"]))
-        yield* Effect.promise(() =>
-          waitForFile(
-            resizeOutput,
-            (value) => value.includes("drive mini response complete") && value.includes("drive-mini-tool-output"),
-          ),
-        )
-        yield* Effect.promise(() => tmux(["pipe-pane", "-t", session]))
-        const resized = yield* Effect.promise(() => captureVisiblePane(session))
-        if (!resized.includes("drive-mini-tool-output")) throw new Error("resize replay lost shell tool output")
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "03-resize-replay.txt"), resized))
-
-        yield* llm.queue(
-          Llm.toolCall({
-            index: 0,
-            id: "mini-question",
-            name: "question",
-            input: {
-              questions: [
-                {
-                  header: "Drive form",
-                  question: "Choose the Mini Form answer",
-                  options: [{ label: "Accepted", description: "Continue the run" }],
-                  multiple: false,
-                },
-              ],
-            },
-          }),
-          Llm.finish("tool-calls"),
-        )
-        yield* llm.queue(Llm.text("drive mini form complete"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "exercise the form"]))
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForPane(session, "Choose the Mini Form answer", 20_000))
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForPane(session, "drive mini form complete", 20_000))
-
-        yield* llm.queue(
-          Llm.toolCall({
-            index: 0,
-            id: "mini-slow-shell",
-            name: "shell",
-            input: { command: "sleep 10" },
-          }),
-          Llm.finish("tool-calls"),
-        )
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "interrupt this turn"]))
-        yield* Effect.sleep(100)
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForPane(session, "$ sleep 10"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "Escape"]))
-        const armed = yield* Effect.promise(() => waitForPane(session, "esc again"))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "04-interrupt-armed.txt"), armed))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "Escape"]))
-        const interrupted = yield* Effect.promise(() => waitForPane(session, "Step interrupted", 10_000))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "05-interrupted.txt"), interrupted))
-
-        yield* Effect.promise(async () => {
-          if (!(await paneAlive(session))) throw new Error("Mini exited while interrupting an active turn")
-        })
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForPane(session, "EXIT  Press ctrl+"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForDeadPane(session))
-        const status = yield* Effect.promise(() => paneDeadStatus(session))
-        if (status !== 0) throw new Error(`Mini exited with status ${status}`)
-        const exited = yield* Effect.promise(() => capturePane(session))
-        if (!exited.includes("Continue") || !exited.includes("opencode mini -s"))
-          throw new Error("Mini exit splash was not rendered before teardown")
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "06-exit-teardown.txt"), exited))
-
-        yield* Effect.promise(() => tmux(["clear-history", "-t", session]))
-        yield* Effect.promise(() =>
-          tmux(["respawn-pane", "-k", "-t", session, "--", ...mini(explicitDirectory, "simulation/gpt-sim-model")]),
-        )
-        const explicitModel = yield* Effect.promise(() => waitForPane(session, "Simulated Model", 15_000))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "07-explicit-model.txt"), explicitModel))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForPane(session, "EXIT  Press ctrl+"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForDeadPane(session))
-        if ((yield* Effect.promise(() => paneDeadStatus(session))) !== 0)
-          throw new Error("Explicit-model Mini did not exit cleanly")
-
-        yield* Effect.promise(async () => {
-          for (const failure of [
-            {
-              args: ["--model", "simulation/definitely-missing"],
-              capture: "08-unavailable-model.txt",
-              expected: "Model unavailable: simulation/definitely-missing",
-            },
-            {
-              args: ["--agent", "definitely-missing"],
-              capture: "09-unavailable-agent.txt",
-              expected: 'Agent not found: "definitely-missing"',
-            },
-          ]) {
-            const child = Bun.spawn(
-              [
-                process.execPath,
-                path.join(root, "packages/cli/src/index.ts"),
-                "run",
-                "--server",
-                registration.url,
-                ...failure.args,
-                "optimistic selection check",
-              ],
-              {
-                cwd: path.join(root, "packages/cli"),
-                env: {
-                  ...process.env,
-                  PWD: path.join(artifacts, "files"),
-                  OPENCODE_PASSWORD: registration.password,
-                  OPENCODE_CONFIG_DIR: path.join(artifacts, "files/.opencode"),
-                  OPENCODE_DISABLE_AUTOUPDATE: "1",
-                },
-                stdin: "ignore",
-                stdout: "pipe",
-                stderr: "pipe",
-              },
-            )
-            const [exitCode, stdout, stderr] = await Promise.all([
-              child.exited,
-              new Response(child.stdout).text(),
-              new Response(child.stderr).text(),
-            ])
-            await Bun.write(path.join(snapshots, failure.capture), stdout + stderr)
-            if (exitCode !== 1) throw new Error(`${failure.expected} run exited with status ${exitCode}`)
-            if (!stderr.includes(failure.expected))
-              throw new Error(`Selection failure was not diagnosed by execution: ${stderr}`)
-          }
-        })
-      })
-
-      yield* journey.pipe(Effect.ensuring(Effect.promise(() => tmux(["kill-session", "-t", session], true))))
-    }),
-})
-
-/** @param {string[]} args */
-async function tmux(args, allowFailure = false) {
-  const child = Bun.spawn(["tmux", ...args], { stdout: "pipe", stderr: "pipe" })
-  let timedOut = false
-  const timeout = setTimeout(() => {
-    timedOut = true
-    child.kill("SIGKILL")
-  }, 5_000)
-  const [status, stdout, stderr] = await Promise.all([
-    child.exited,
-    new Response(child.stdout).text(),
-    new Response(child.stderr).text(),
-  ])
-  clearTimeout(timeout)
-  if (timedOut) throw new Error(`tmux ${args[0]} timed out`)
-  if (status !== 0 && !allowFailure) throw new Error(`tmux ${args[0]} failed: ${stderr || stdout}`)
-  return stdout
-}
-
-/** @param {string} session */
-function capturePane(session) {
-  return tmux(["capture-pane", "-p", "-t", session, "-S", "-"])
-}
-
-/** @param {string} session */
-function captureVisiblePane(session) {
-  return tmux(["capture-pane", "-p", "-t", session])
-}
-
-/** @param {string} session @param {string} text @param {number} [timeout] */
-async function waitForVisiblePane(session, text, timeout = 5_000) {
-  const deadline = Date.now() + timeout
-  let last = ""
-  while (Date.now() < deadline) {
-    last = await captureVisiblePane(session)
-    if (last.includes(text)) return last
-    if (!(await paneAlive(session))) throw new Error(`Mini exited before rendering ${JSON.stringify(text)}:\n${last}`)
-    await Bun.sleep(50)
-  }
-  throw new Error(`Timed out waiting for visible ${JSON.stringify(text)}:\n${last}`)
-}
-
-/** @param {string} session */
-async function paneAlive(session) {
-  return (await tmux(["display-message", "-p", "-t", session, "#{pane_dead}"], true)).trim() === "0"
-}
-
-/** @param {string} session */
-async function paneDeadStatus(session) {
-  return Number((await tmux(["display-message", "-p", "-t", session, "#{pane_dead_status}"])).trim())
-}
-
-/**
- * @param {string} session
- * @param {string} text
- * @param {number} [timeout]
- * @param {(() => Promise<void>) | undefined} [trigger]
- */
-async function waitForPane(session, text, timeout = 5_000, trigger) {
-  const deadline = Date.now() + timeout
-  let last = ""
-  while (Date.now() < deadline) {
-    await trigger?.()
-    last = await capturePane(session)
-    if (last.includes(text)) return last
-    if (!(await paneAlive(session))) throw new Error(`Mini exited before rendering ${JSON.stringify(text)}:\n${last}`)
-    await Bun.sleep(50)
-  }
-  throw new Error(`Timed out waiting for ${JSON.stringify(text)}:\n${last}`)
-}
-
-/** @param {string} session */
-async function waitForDeadPane(session) {
-  for (let attempt = 0; attempt < 100; attempt++) {
-    if (!(await paneAlive(session))) return
-    await Bun.sleep(50)
-  }
-  throw new Error("Mini did not tear down after the exit sequence")
-}
-
-/**
- * @param {string} file
- * @param {(value: string) => boolean} accept
- */
-async function waitForFile(file, accept) {
-  let value = ""
-  for (let attempt = 0; attempt < 100; attempt++) {
-    value = await Bun.file(file)
-      .text()
-      .catch(() => "")
-    if (accept(value)) return value
-    await Bun.sleep(50)
-  }
-  throw new Error("resize did not replay committed transcript output")
-}
-
-/** @param {string} artifacts */
-async function configureServicePort(artifacts) {
-  const probe = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response() })
-  const port = probe.port
-  await probe.stop(true)
-  if (!port) throw new Error("Failed to allocate a Drive service port")
-  const file = path.join(artifacts, "files/.opencode/service-local.json")
-  await mkdir(path.dirname(file), { recursive: true })
-  await Bun.write(file, JSON.stringify({ port }))
-}
-
-/** @param {string} artifacts */
-async function serviceRegistration(artifacts) {
-  const directory = path.join(artifacts, "home/.local/state/opencode")
-  for (let attempt = 0; attempt < 200; attempt++) {
-    for (const name of ["service-local.json", "service.json"]) {
-      const value = await Bun.file(path.join(directory, name))
-        .json()
-        .catch(() => undefined)
-      if (isRegistration(value)) return value
-    }
-    await Bun.sleep(50)
-  }
-  throw new Error("Drive service registration was not written")
-}
-
-/** @param {unknown} value */
-function isRegistration(value) {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "url" in value &&
-    typeof value.url === "string" &&
-    "password" in value &&
-    typeof value.password === "string"
-  )
-}

packages/cli/test/drive/run-smoke.drive.mjs

@@ -1,87 +0,0 @@
-import { defineScript } from "opencode-drive"
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
-
-export default defineScript({
-  launch: "manual",
-  setup({ config }) {
-    config.autoupdate = false
-  },
-  async run({ artifacts, llm, server }) {
-    await configureServicePort(artifacts)
-    llm.queue(llm.text("drive noninteractive smoke ok"))
-    await server.launch()
-
-    const registration = await serviceRegistration(artifacts)
-    const root = path.resolve(import.meta.dir, "../../../..")
-    const directory = path.join(artifacts, "files")
-    const child = Bun.spawn(
-      [
-        process.execPath,
-        path.join(root, "packages/cli/src/index.ts"),
-        "run",
-        "--server",
-        registration.url,
-        "drive smoke",
-      ],
-      {
-        cwd: path.join(root, "packages/cli"),
-        env: {
-          ...process.env,
-          PWD: directory,
-          OPENCODE_PASSWORD: registration.password,
-          OPENCODE_CONFIG_DIR: path.join(directory, ".opencode"),
-          OPENCODE_DISABLE_AUTOUPDATE: "1",
-        },
-        stdin: "ignore",
-        stdout: "pipe",
-        stderr: "pipe",
-      },
-    )
-    const [exitCode, stdout, stderr] = await Promise.all([
-      child.exited,
-      new Response(child.stdout).text(),
-      new Response(child.stderr).text(),
-    ])
-    if (exitCode !== 0) throw new Error(`run exited ${exitCode}: ${stderr}`)
-    if (stdout !== "drive noninteractive smoke ok\n") throw new Error(`unexpected run output: ${stdout}`)
-  },
-})
-
-/** @param {string} artifacts */
-async function configureServicePort(artifacts) {
-  const probe = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response() })
-  const port = probe.port
-  await probe.stop(true)
-  if (!port) throw new Error("Failed to allocate a Drive service port")
-  const file = path.join(artifacts, "files/.opencode/service-local.json")
-  await mkdir(path.dirname(file), { recursive: true })
-  await Bun.write(file, JSON.stringify({ port }))
-}
-
-/** @param {string} artifacts */
-async function serviceRegistration(artifacts) {
-  const directory = path.join(artifacts, "home/.local/state/opencode")
-  for (let attempt = 0; attempt < 200; attempt++) {
-    for (const name of ["service-local.json", "service.json"]) {
-      const value = await Bun.file(path.join(directory, name))
-        .json()
-        .catch(() => undefined)
-      if (isRegistration(value)) return value
-    }
-    await Bun.sleep(50)
-  }
-  throw new Error("Drive service registration was not written")
-}
-
-/** @param {unknown} value */
-function isRegistration(value) {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "url" in value &&
-    typeof value.url === "string" &&
-    "password" in value &&
-    typeof value.password === "string"
-  )
-}

packages/cli/test/node-assets.test.ts

@@ -1,10 +1,17 @@
 import { expect, test } from "bun:test"
+import { fileURLToPath } from "node:url"
 import { collectNodeAssets } from "../script/node-assets"
-import { nodeTarget } from "../src/node/target"
+import { nodeTarget, shellParserWasmAssets } from "../src/node/target"
 
 test("collects each SEA asset key once", async () => {
   const assets = await collectNodeAssets(nodeTarget(process.platform, process.arch))
   const keys = assets.map((asset) => asset.key)
 
   expect(new Set(keys).size).toBe(keys.length)
+  expect(assets.filter((asset) => asset.key === shellParserWasmAssets.runtime)).toEqual([
+    {
+      key: shellParserWasmAssets.runtime,
+      source: fileURLToPath(import.meta.resolve(shellParserWasmAssets.runtime)),
+    },
+  ])
 })

packages/cli/test/run/noninteractive.test.ts

@@ -240,8 +240,6 @@ async function run(input: {
   })()
   spyOn(sdk.event, "subscribe").mockImplementation(() => stream)
   spyOn(sdk.permission, "list").mockImplementation(() => ok([]) as never)
-  spyOn(sdk.question, "list").mockImplementation(() => ok([]) as never)
-  spyOn(sdk.question, "reject").mockImplementation(() => ok(undefined) as never)
   spyOn(sdk.form, "list").mockImplementation(
     (request) => ok(input.pendingForms?.filter((item) => item.sessionID === request.sessionID) ?? []) as never,
   )
@@ -435,8 +433,6 @@ describe("runNonInteractivePrompt", () => {
     expect(sdk.form.request.list).toHaveBeenCalledWith({
       location: { directory: "/work tree", workspace: "wrk_1" },
     })
-    expect(sdk.question.list).not.toHaveBeenCalled()
-    expect(sdk.question.reject).not.toHaveBeenCalled()
   })
 
   test("attach mode cancels only session-owned forms", async () => {

packages/cli/vite.node.config.ts

@@ -3,7 +3,8 @@ import { readFile } from "node:fs/promises"
 import { createRequire } from "node:module"
 import { defineConfig, type Plugin, type UserConfig } from "vite"
 import solid from "vite-plugin-solid"
-import { nodeExecArgv, nodeTarget, type NodeTarget, photonWasmAsset } from "./src/node/target"
+import { nodeExecArgv, nodeTarget, type NodeTarget, photonWasmAsset, shellParserWasmAssets } from "./src/node/target"
+import { verifySimulationGraph } from "./script/verify-artifact"
 
 const dir = import.meta.dirname
 
@@ -48,6 +49,15 @@ function runtimeRequirePlugin(): Plugin {
   }
 }
 
+function simulationGraphPlugin(): Plugin {
+  return {
+    name: "opencode:simulation-graph",
+    generateBundle() {
+      verifySimulationGraph(this.getModuleIds())
+    },
+  }
+}
+
 function fffNodePlugin(): Plugin {
   return {
     name: "opencode:fff-node",
@@ -212,6 +222,9 @@ process.env.OTUI_ASSET_ROOT = __ocAssetRoot
 process.env.OPENCODE_NODE_PTY_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.nodePtyEntryAsset)})
 process.env.OPENCODE_PARCEL_WATCHER_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.parcelWatcherAsset)})
 process.env.OPENCODE_PHOTON_WASM_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(photonWasmAsset)})
+process.env.OPENCODE_TREE_SITTER_WASM_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(shellParserWasmAssets.runtime)})
+process.env.OPENCODE_TREE_SITTER_BASH_WASM_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(shellParserWasmAssets.bash)})
+process.env.OPENCODE_TREE_SITTER_POWERSHELL_WASM_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(shellParserWasmAssets.powershell)})
 process.env.FFF_BINARY_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.fffAsset)})
 process.env.OPENCODE_FFF_FFI_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.fffFfiAsset)})
 try {
@@ -237,6 +250,7 @@ export function mainConfig(input: NodeBuildInput): UserConfig {
       rawTextPlugin(),
       runtimeRequirePlugin(),
       fffNodePlugin(),
+      simulationGraphPlugin(),
       solid({
         solid: {
           generate: "universal",
@@ -252,6 +266,7 @@ export function mainConfig(input: NodeBuildInput): UserConfig {
       OPENCODE_CHANNEL: JSON.stringify(input.channel),
       OPENCODE_LIBC: input.target.platform === "linux" ? JSON.stringify("glibc") : "undefined",
       FFF_LIBC: input.target.platform === "linux" ? JSON.stringify("gnu") : "undefined",
+      "process.env.WS_NO_BUFFER_UTIL": JSON.stringify("1"),
     },
     ssr: { noExternal: true },
     build: {
@@ -261,7 +276,6 @@ export function mainConfig(input: NodeBuildInput): UserConfig {
       emptyOutDir: false,
       minify: true,
       rollupOptions: {
-        external: [/^@opencode-ai\/simulation(?:\/|$)/],
         output: output("opencode.mjs", nodePrelude(input)),
       },
     },

packages/client/package.json

@@ -20,7 +20,6 @@
     "./promise": "./src/promise/index.ts",
     "./promise/api": "./src/promise/api.ts",
     "./service": "./src/promise/service.ts",
-    "./solid": "./src/solid/index.ts",
     "./effect": "./src/effect/index.ts",
     "./effect/api": "./src/effect/api.ts",
     "./effect/service": "./src/effect/service.ts"
@@ -37,15 +36,11 @@
     "@opencode-ai/protocol": "workspace:*"
   },
   "peerDependencies": {
-    "effect": "4.0.0-beta.101",
-    "solid-js": ">=1.9.0"
+    "effect": "4.0.0-beta.101"
   },
   "peerDependenciesMeta": {
     "effect": {
       "optional": true
-    },
-    "solid-js": {
-      "optional": true
     }
   },
   "devDependencies": {
@@ -54,7 +49,6 @@
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
     "@typescript/native-preview": "catalog:",
-    "effect": "catalog:",
-    "solid-js": "catalog:"
+    "effect": "catalog:"
   }
 }

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

@@ -32,7 +32,6 @@ import type { FileSystem } from "@opencode-ai/schema/filesystem"
 import type { Command } from "@opencode-ai/schema/command"
 import type { OpenCodeEvent } from "@opencode-ai/protocol/groups/event"
 import type { Pty } from "@opencode-ai/schema/pty"
-import type { Question } from "@opencode-ai/schema/question"
 import type { Reference } from "@opencode-ai/schema/reference"
 import type { Worktree } from "@opencode-ai/schema/worktree"
 import type { Vcs } from "@opencode-ai/schema/vcs"
@@ -1307,7 +1306,6 @@ export type Endpoint15_3Input = {
   readonly action: string
   readonly resources: ReadonlyArray<string>
   readonly save?: ReadonlyArray<string> | undefined
-  readonly opaque?: boolean | undefined
   readonly metadata?: { readonly [x: string]: unknown } | undefined
   readonly source?: Permission.Source | undefined
   readonly agent?: Agent.ID | undefined
@@ -1504,69 +1502,38 @@ export interface ShellApi<E = never> {
 export type Endpoint22_0Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint22_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Question.Request> }
-export type QuestionRequestListOperation<E = never> = (
-  input?: Endpoint22_0Input,
-) => Effect.Effect<Endpoint22_0Output, E>
-
-export type Endpoint22_1Input = { readonly sessionID: Session.ID }
-export type Endpoint22_1Output = ReadonlyArray<Question.Request>
-export type QuestionListOperation<E = never> = (input: Endpoint22_1Input) => Effect.Effect<Endpoint22_1Output, E>
-
-export type Endpoint22_2Input = {
-  readonly sessionID: Session.ID
-  readonly requestID: Question.ID
-  readonly answers: ReadonlyArray<Question.Answer>
-}
-export type Endpoint22_2Output = void
-export type QuestionReplyOperation<E = never> = (input: Endpoint22_2Input) => Effect.Effect<Endpoint22_2Output, E>
-
-export type Endpoint22_3Input = { readonly sessionID: Session.ID; readonly requestID: Question.ID }
-export type Endpoint22_3Output = void
-export type QuestionRejectOperation<E = never> = (input: Endpoint22_3Input) => Effect.Effect<Endpoint22_3Output, E>
-
-export interface QuestionApi<E = never> {
-  readonly request: { readonly list: QuestionRequestListOperation<E> }
-  readonly list: QuestionListOperation<E>
-  readonly reply: QuestionReplyOperation<E>
-  readonly reject: QuestionRejectOperation<E>
-}
-
-export type Endpoint23_0Input = {
-  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-}
-export type Endpoint23_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Reference.Info> }
-export type ReferenceListOperation<E = never> = (input?: Endpoint23_0Input) => Effect.Effect<Endpoint23_0Output, E>
+export type Endpoint22_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Reference.Info> }
+export type ReferenceListOperation<E = never> = (input?: Endpoint22_0Input) => Effect.Effect<Endpoint22_0Output, E>
 
 export interface ReferenceApi<E = never> {
   readonly list: ReferenceListOperation<E>
 }
 
-export type Endpoint24_0Input = { readonly projectID: Project.ID }
-export type Endpoint24_0Output = Worktree.List
-export type WorktreeListOperation<E = never> = (input: Endpoint24_0Input) => Effect.Effect<Endpoint24_0Output, E>
+export type Endpoint23_0Input = { readonly projectID: Project.ID }
+export type Endpoint23_0Output = Worktree.List
+export type WorktreeListOperation<E = never> = (input: Endpoint23_0Input) => Effect.Effect<Endpoint23_0Output, E>
 
-export type Endpoint24_1Input = {
+export type Endpoint23_1Input = {
   readonly projectID: Project.ID
   readonly strategy: Worktree.StrategyID
   readonly from?: AbsolutePath | undefined
   readonly directory: AbsolutePath
   readonly name?: string | undefined
 }
-export type Endpoint24_1Output = Worktree.Info
-export type WorktreeCreateOperation<E = never> = (input: Endpoint24_1Input) => Effect.Effect<Endpoint24_1Output, E>
+export type Endpoint23_1Output = Worktree.Info
+export type WorktreeCreateOperation<E = never> = (input: Endpoint23_1Input) => Effect.Effect<Endpoint23_1Output, E>
 
-export type Endpoint24_2Input = {
+export type Endpoint23_2Input = {
   readonly projectID: Project.ID
   readonly directory: AbsolutePath
   readonly force: boolean
 }
-export type Endpoint24_2Output = void
-export type WorktreeRemoveOperation<E = never> = (input: Endpoint24_2Input) => Effect.Effect<Endpoint24_2Output, E>
+export type Endpoint23_2Output = void
+export type WorktreeRemoveOperation<E = never> = (input: Endpoint23_2Input) => Effect.Effect<Endpoint23_2Output, E>
 
-export type Endpoint24_3Input = { readonly projectID: Project.ID }
-export type Endpoint24_3Output = void
-export type WorktreeRefreshOperation<E = never> = (input: Endpoint24_3Input) => Effect.Effect<Endpoint24_3Output, E>
+export type Endpoint23_3Input = { readonly projectID: Project.ID }
+export type Endpoint23_3Output = void
+export type WorktreeRefreshOperation<E = never> = (input: Endpoint23_3Input) => Effect.Effect<Endpoint23_3Output, E>
 
 export interface WorktreeApi<E = never> {
   readonly list: WorktreeListOperation<E>
@@ -1575,25 +1542,25 @@ export interface WorktreeApi<E = never> {
   readonly refresh: WorktreeRefreshOperation<E>
 }
 
-export type Endpoint25_0Input = {
+export type Endpoint24_0Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint25_0Output = { readonly location: Location.Info; readonly data: Vcs.Info }
-export type VcsGetOperation<E = never> = (input?: Endpoint25_0Input) => Effect.Effect<Endpoint25_0Output, E>
+export type Endpoint24_0Output = { readonly location: Location.Info; readonly data: Vcs.Info }
+export type VcsGetOperation<E = never> = (input?: Endpoint24_0Input) => Effect.Effect<Endpoint24_0Output, E>
 
-export type Endpoint25_1Input = {
+export type Endpoint24_1Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint25_1Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Vcs.FileStatus> }
-export type VcsStatusOperation<E = never> = (input?: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>
+export type Endpoint24_1Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Vcs.FileStatus> }
+export type VcsStatusOperation<E = never> = (input?: Endpoint24_1Input) => Effect.Effect<Endpoint24_1Output, E>
 
-export type Endpoint25_2Input = {
+export type Endpoint24_2Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly mode: Vcs.Mode
   readonly context?: number | undefined
 }
-export type Endpoint25_2Output = { readonly location: Location.Info; readonly data: ReadonlyArray<FileDiff.Info> }
-export type VcsDiffOperation<E = never> = (input: Endpoint25_2Input) => Effect.Effect<Endpoint25_2Output, E>
+export type Endpoint24_2Output = { readonly location: Location.Info; readonly data: ReadonlyArray<FileDiff.Info> }
+export type VcsDiffOperation<E = never> = (input: Endpoint24_2Input) => Effect.Effect<Endpoint24_2Output, E>
 
 export interface VcsApi<E = never> {
   readonly get: VcsGetOperation<E>
@@ -1601,20 +1568,20 @@ export interface VcsApi<E = never> {
   readonly diff: VcsDiffOperation<E>
 }
 
-export type Endpoint26_0Output = ReadonlyArray<Location.Ref>
-export type DebugLocationListOperation<E = never> = () => Effect.Effect<Endpoint26_0Output, E>
+export type Endpoint25_0Output = ReadonlyArray<Location.Ref>
+export type DebugLocationListOperation<E = never> = () => Effect.Effect<Endpoint25_0Output, E>
 
-export type Endpoint26_1Input = {
+export type Endpoint25_1Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint26_1Output = void
-export type DebugLocationEvictOperation<E = never> = (input?: Endpoint26_1Input) => Effect.Effect<Endpoint26_1Output, E>
+export type Endpoint25_1Output = void
+export type DebugLocationEvictOperation<E = never> = (input?: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>
 
 export interface DebugApi<E = never> {
   readonly location: { readonly list: DebugLocationListOperation<E>; readonly evict: DebugLocationEvictOperation<E> }
 }
 
-export type Endpoint27_0Output =
+export type Endpoint26_0Output =
   | { readonly status: "required" | "completed" }
   | {
       readonly status: "running"
@@ -1625,36 +1592,36 @@ export type Endpoint27_0Output =
       }
     }
   | { readonly status: "error"; readonly error: string }
-export type MigrationV1StatusOperation<E = never> = () => Effect.Effect<Endpoint27_0Output, E>
+export type MigrationV1StatusOperation<E = never> = () => Effect.Effect<Endpoint26_0Output, E>
 
 export interface MigrationApi<E = never> {
   readonly v1: { readonly status: MigrationV1StatusOperation<E> }
 }
 
-export type Endpoint28_0Input = {
+export type Endpoint27_0Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint28_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<WebSearch.Provider> }
-export type WebsearchProvidersOperation<E = never> = (input?: Endpoint28_0Input) => Effect.Effect<Endpoint28_0Output, E>
+export type Endpoint27_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<WebSearch.Provider> }
+export type WebsearchProvidersOperation<E = never> = (input?: Endpoint27_0Input) => Effect.Effect<Endpoint27_0Output, E>
 
-export type Endpoint28_1Input = {
+export type Endpoint27_1Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly query: string
   readonly providerID?: WebSearch.ID | undefined
 }
-export type Endpoint28_1Output = { readonly location: Location.Info; readonly data: WebSearch.Response }
-export type WebsearchQueryOperation<E = never> = (input: Endpoint28_1Input) => Effect.Effect<Endpoint28_1Output, E>
+export type Endpoint27_1Output = { readonly location: Location.Info; readonly data: WebSearch.Response }
+export type WebsearchQueryOperation<E = never> = (input: Endpoint27_1Input) => Effect.Effect<Endpoint27_1Output, E>
 
 export interface WebsearchApi<E = never> {
   readonly providers: WebsearchProvidersOperation<E>
   readonly query: WebsearchQueryOperation<E>
 }
 
-export type Endpoint29_0Input = {
+export type Endpoint28_0Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint29_0Output = ReadonlyArray<Config.Entry>
-export type ConfigGetOperation<E = never> = (input?: Endpoint29_0Input) => Effect.Effect<Endpoint29_0Output, E>
+export type Endpoint28_0Output = ReadonlyArray<Config.Entry>
+export type ConfigGetOperation<E = never> = (input?: Endpoint28_0Input) => Effect.Effect<Endpoint28_0Output, E>
 
 export interface ConfigApi<E = never> {
   readonly get: ConfigGetOperation<E>
@@ -1683,7 +1650,6 @@ export interface AppApi<E = never> {
   readonly event: EventApi<E>
   readonly pty: PtyApi<E>
   readonly shell: ShellApi<E>
-  readonly question: QuestionApi<E>
   readonly reference: ReferenceApi<E>
   readonly worktree: WorktreeApi<E>
   readonly vcs: VcsApi<E>

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

@@ -200,38 +200,30 @@ import type {
   Endpoint21_5Output,
   Endpoint22_0Input,
   Endpoint22_0Output,
-  Endpoint22_1Input,
-  Endpoint22_1Output,
-  Endpoint22_2Input,
-  Endpoint22_2Output,
-  Endpoint22_3Input,
-  Endpoint22_3Output,
   Endpoint23_0Input,
   Endpoint23_0Output,
+  Endpoint23_1Input,
+  Endpoint23_1Output,
+  Endpoint23_2Input,
+  Endpoint23_2Output,
+  Endpoint23_3Input,
+  Endpoint23_3Output,
   Endpoint24_0Input,
   Endpoint24_0Output,
   Endpoint24_1Input,
   Endpoint24_1Output,
   Endpoint24_2Input,
   Endpoint24_2Output,
-  Endpoint24_3Input,
-  Endpoint24_3Output,
-  Endpoint25_0Input,
   Endpoint25_0Output,
   Endpoint25_1Input,
   Endpoint25_1Output,
-  Endpoint25_2Input,
-  Endpoint25_2Output,
   Endpoint26_0Output,
-  Endpoint26_1Input,
-  Endpoint26_1Output,
+  Endpoint27_0Input,
   Endpoint27_0Output,
+  Endpoint27_1Input,
+  Endpoint27_1Output,
   Endpoint28_0Input,
   Endpoint28_0Output,
-  Endpoint28_1Input,
-  Endpoint28_1Output,
-  Endpoint29_0Input,
-  Endpoint29_0Output,
 } from "../api/api.js"
 import { ClientError } from "./client-error.js"
 
@@ -970,7 +962,6 @@ const Endpoint15_3 = (raw: RawClient["server.permission"]) => (input: Endpoint15
         action: input["action"],
         resources: input["resources"],
         save: input["save"],
-        opaque: input["opaque"],
         metadata: input["metadata"],
         source: input["source"],
         agent: input["agent"],
@@ -1159,145 +1150,110 @@ const adaptGroup21 = (raw: RawClient["server.shell"]) => ({
   remove: Endpoint21_5(raw),
 })
 
-const Endpoint22_0 = (raw: RawClient["server.question"]) => (input?: Endpoint22_0Input) =>
+const Endpoint22_0 = (raw: RawClient["server.reference"]) => (input?: Endpoint22_0Input) =>
   preserveEffect<Endpoint22_0Output>()(
-    raw["question.request.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
-  )
-
-const Endpoint22_1 = (raw: RawClient["server.question"]) => (input: Endpoint22_1Input) =>
-  preserveEffect<Endpoint22_1Output>()(
-    raw["session.question.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
-      Effect.mapError(mapClientError),
-      Effect.map((value) => value.data),
-    ),
-  )
-
-const Endpoint22_2 = (raw: RawClient["server.question"]) => (input: Endpoint22_2Input) =>
-  preserveEffect<Endpoint22_2Output>()(
-    raw["session.question.reply"]({
-      params: { sessionID: input["sessionID"], requestID: input["requestID"] },
-      payload: { answers: input["answers"] },
-    }).pipe(Effect.mapError(mapClientError)),
-  )
-
-const Endpoint22_3 = (raw: RawClient["server.question"]) => (input: Endpoint22_3Input) =>
-  preserveEffect<Endpoint22_3Output>()(
-    raw["session.question.reject"]({ params: { sessionID: input["sessionID"], requestID: input["requestID"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
-  )
-
-const adaptGroup22 = (raw: RawClient["server.question"]) => ({
-  request: { list: Endpoint22_0(raw) },
-  list: Endpoint22_1(raw),
-  reply: Endpoint22_2(raw),
-  reject: Endpoint22_3(raw),
-})
-
-const Endpoint23_0 = (raw: RawClient["server.reference"]) => (input?: Endpoint23_0Input) =>
-  preserveEffect<Endpoint23_0Output>()(
     raw["reference.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const adaptGroup23 = (raw: RawClient["server.reference"]) => ({ list: Endpoint23_0(raw) })
+const adaptGroup22 = (raw: RawClient["server.reference"]) => ({ list: Endpoint22_0(raw) })
 
-const Endpoint24_0 = (raw: RawClient["server.worktree"]) => (input: Endpoint24_0Input) =>
-  preserveEffect<Endpoint24_0Output>()(
+const Endpoint23_0 = (raw: RawClient["server.worktree"]) => (input: Endpoint23_0Input) =>
+  preserveEffect<Endpoint23_0Output>()(
     raw["worktree.list"]({ params: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint24_1 = (raw: RawClient["server.worktree"]) => (input: Endpoint24_1Input) =>
-  preserveEffect<Endpoint24_1Output>()(
+const Endpoint23_1 = (raw: RawClient["server.worktree"]) => (input: Endpoint23_1Input) =>
+  preserveEffect<Endpoint23_1Output>()(
     raw["worktree.create"]({
       params: { projectID: input["projectID"] },
       payload: { strategy: input["strategy"], from: input["from"], directory: input["directory"], name: input["name"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint24_2 = (raw: RawClient["server.worktree"]) => (input: Endpoint24_2Input) =>
-  preserveEffect<Endpoint24_2Output>()(
+const Endpoint23_2 = (raw: RawClient["server.worktree"]) => (input: Endpoint23_2Input) =>
+  preserveEffect<Endpoint23_2Output>()(
     raw["worktree.remove"]({
       params: { projectID: input["projectID"] },
       payload: { directory: input["directory"], force: input["force"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint24_3 = (raw: RawClient["server.worktree"]) => (input: Endpoint24_3Input) =>
-  preserveEffect<Endpoint24_3Output>()(
+const Endpoint23_3 = (raw: RawClient["server.worktree"]) => (input: Endpoint23_3Input) =>
+  preserveEffect<Endpoint23_3Output>()(
     raw["worktree.refresh"]({ params: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const adaptGroup24 = (raw: RawClient["server.worktree"]) => ({
-  list: Endpoint24_0(raw),
-  create: Endpoint24_1(raw),
-  remove: Endpoint24_2(raw),
-  refresh: Endpoint24_3(raw),
+const adaptGroup23 = (raw: RawClient["server.worktree"]) => ({
+  list: Endpoint23_0(raw),
+  create: Endpoint23_1(raw),
+  remove: Endpoint23_2(raw),
+  refresh: Endpoint23_3(raw),
 })
 
-const Endpoint25_0 = (raw: RawClient["server.vcs"]) => (input?: Endpoint25_0Input) =>
-  preserveEffect<Endpoint25_0Output>()(
+const Endpoint24_0 = (raw: RawClient["server.vcs"]) => (input?: Endpoint24_0Input) =>
+  preserveEffect<Endpoint24_0Output>()(
     raw["vcs.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint25_1 = (raw: RawClient["server.vcs"]) => (input?: Endpoint25_1Input) =>
-  preserveEffect<Endpoint25_1Output>()(
+const Endpoint24_1 = (raw: RawClient["server.vcs"]) => (input?: Endpoint24_1Input) =>
+  preserveEffect<Endpoint24_1Output>()(
     raw["vcs.status"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint25_2 = (raw: RawClient["server.vcs"]) => (input: Endpoint25_2Input) =>
-  preserveEffect<Endpoint25_2Output>()(
+const Endpoint24_2 = (raw: RawClient["server.vcs"]) => (input: Endpoint24_2Input) =>
+  preserveEffect<Endpoint24_2Output>()(
     raw["vcs.diff"]({ query: { location: input["location"], mode: input["mode"], context: input["context"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
-const adaptGroup25 = (raw: RawClient["server.vcs"]) => ({
-  get: Endpoint25_0(raw),
-  status: Endpoint25_1(raw),
-  diff: Endpoint25_2(raw),
+const adaptGroup24 = (raw: RawClient["server.vcs"]) => ({
+  get: Endpoint24_0(raw),
+  status: Endpoint24_1(raw),
+  diff: Endpoint24_2(raw),
 })
 
-const Endpoint26_0 = (raw: RawClient["server.debug"]) => () =>
-  preserveEffect<Endpoint26_0Output>()(raw["debug.location"]({}).pipe(Effect.mapError(mapClientError)))
+const Endpoint25_0 = (raw: RawClient["server.debug"]) => () =>
+  preserveEffect<Endpoint25_0Output>()(raw["debug.location"]({}).pipe(Effect.mapError(mapClientError)))
 
-const Endpoint26_1 = (raw: RawClient["server.debug"]) => (input?: Endpoint26_1Input) =>
-  preserveEffect<Endpoint26_1Output>()(
+const Endpoint25_1 = (raw: RawClient["server.debug"]) => (input?: Endpoint25_1Input) =>
+  preserveEffect<Endpoint25_1Output>()(
     raw["debug.location.evict"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const adaptGroup26 = (raw: RawClient["server.debug"]) => ({
-  location: { list: Endpoint26_0(raw), evict: Endpoint26_1(raw) },
+const adaptGroup25 = (raw: RawClient["server.debug"]) => ({
+  location: { list: Endpoint25_0(raw), evict: Endpoint25_1(raw) },
 })
 
-const Endpoint27_0 = (raw: RawClient["server.migration"]) => () =>
-  preserveEffect<Endpoint27_0Output>()(raw["migration.v1.status"]({}).pipe(Effect.mapError(mapClientError)))
+const Endpoint26_0 = (raw: RawClient["server.migration"]) => () =>
+  preserveEffect<Endpoint26_0Output>()(raw["migration.v1.status"]({}).pipe(Effect.mapError(mapClientError)))
 
-const adaptGroup27 = (raw: RawClient["server.migration"]) => ({ v1: { status: Endpoint27_0(raw) } })
+const adaptGroup26 = (raw: RawClient["server.migration"]) => ({ v1: { status: Endpoint26_0(raw) } })
 
-const Endpoint28_0 = (raw: RawClient["server.websearch"]) => (input?: Endpoint28_0Input) =>
-  preserveEffect<Endpoint28_0Output>()(
+const Endpoint27_0 = (raw: RawClient["server.websearch"]) => (input?: Endpoint27_0Input) =>
+  preserveEffect<Endpoint27_0Output>()(
     raw["websearch.providers"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint28_1 = (raw: RawClient["server.websearch"]) => (input: Endpoint28_1Input) =>
-  preserveEffect<Endpoint28_1Output>()(
+const Endpoint27_1 = (raw: RawClient["server.websearch"]) => (input: Endpoint27_1Input) =>
+  preserveEffect<Endpoint27_1Output>()(
     raw["websearch.query"]({
       query: { location: input["location"] },
       payload: { query: input["query"], providerID: input["providerID"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const adaptGroup28 = (raw: RawClient["server.websearch"]) => ({
-  providers: Endpoint28_0(raw),
-  query: Endpoint28_1(raw),
+const adaptGroup27 = (raw: RawClient["server.websearch"]) => ({
+  providers: Endpoint27_0(raw),
+  query: Endpoint27_1(raw),
 })
 
-const Endpoint29_0 = (raw: RawClient["server.config"]) => (input?: Endpoint29_0Input) =>
-  preserveEffect<Endpoint29_0Output>()(
+const Endpoint28_0 = (raw: RawClient["server.config"]) => (input?: Endpoint28_0Input) =>
+  preserveEffect<Endpoint28_0Output>()(
     raw["config.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const adaptGroup29 = (raw: RawClient["server.config"]) => ({ get: Endpoint29_0(raw) })
+const adaptGroup28 = (raw: RawClient["server.config"]) => ({ get: Endpoint28_0(raw) })
 
 const adaptClient = (raw: RawClient) => ({
   health: adaptGroup0(raw["server.health"]),
@@ -1322,14 +1278,13 @@ const adaptClient = (raw: RawClient) => ({
   event: adaptGroup19(raw["server.event"]),
   pty: adaptGroup20(raw["server.pty"]),
   shell: adaptGroup21(raw["server.shell"]),
-  question: adaptGroup22(raw["server.question"]),
-  reference: adaptGroup23(raw["server.reference"]),
-  worktree: adaptGroup24(raw["server.worktree"]),
-  vcs: adaptGroup25(raw["server.vcs"]),
-  debug: adaptGroup26(raw["server.debug"]),
-  migration: adaptGroup27(raw["server.migration"]),
-  websearch: adaptGroup28(raw["server.websearch"]),
-  config: adaptGroup29(raw["server.config"]),
+  reference: adaptGroup22(raw["server.reference"]),
+  worktree: adaptGroup23(raw["server.worktree"]),
+  vcs: adaptGroup24(raw["server.vcs"]),
+  debug: adaptGroup25(raw["server.debug"]),
+  migration: adaptGroup26(raw["server.migration"]),
+  websearch: adaptGroup27(raw["server.websearch"]),
+  config: adaptGroup28(raw["server.config"]),
 })
 
 export const make = (options?: { readonly baseUrl?: URL | string }) =>

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

@@ -194,14 +194,6 @@ import type {
   ShellOutputOutput,
   ShellRemoveInput,
   ShellRemoveOutput,
-  QuestionRequestListInput,
-  QuestionRequestListOutput,
-  QuestionListInput,
-  QuestionListOutput,
-  QuestionReplyInput,
-  QuestionReplyOutput,
-  QuestionRejectInput,
-  QuestionRejectOutput,
   ReferenceListInput,
   ReferenceListOutput,
   WorktreeListInput,
@@ -1390,7 +1382,6 @@ export function make(options: ClientOptions) {
               action: input["action"],
               resources: input["resources"],
               save: input["save"],
-              opaque: input["opaque"],
               metadata: input["metadata"],
               source: input["source"],
               agent: input["agent"],
@@ -1661,56 +1652,6 @@ export function make(options: ClientOptions) {
           requestOptions,
         ),
     },
-    question: {
-      request: {
-        list: (input?: QuestionRequestListInput, requestOptions?: RequestOptions) =>
-          request<QuestionRequestListOutput>(
-            {
-              method: "GET",
-              path: `/api/question/request`,
-              query: { location: input?.["location"] },
-              successStatus: 200,
-              declaredStatuses: [401, 400],
-              empty: false,
-            },
-            requestOptions,
-          ),
-      },
-      list: (input: QuestionListInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: QuestionListOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/question`,
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      reply: (input: QuestionReplyInput, requestOptions?: RequestOptions) =>
-        request<QuestionReplyOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reply`,
-            body: { answers: input["answers"] },
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      reject: (input: QuestionRejectInput, requestOptions?: RequestOptions) =>
-        request<QuestionRejectOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reject`,
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-    },
     reference: {
       list: (input?: ReferenceListInput, requestOptions?: RequestOptions) =>
         request<ReferenceListOutput>(

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

@@ -324,12 +324,6 @@ export type Pty = {
   exitCode?: number
 }
 
-export type QuestionOption = { label: string; description: string }
-
-export type QuestionTool = { messageID: string; id: string }
-
-export type QuestionAnswer = Array<string>
-
 export type FormMetadata1 = { [x: string]: any }
 
 export type FormWhen1 = { key: string; op: "eq" | "neq"; value: string | number | boolean }
@@ -910,15 +904,6 @@ export type ShellDeleted = {
   data: { id: string }
 }
 
-export type QuestionRejected = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "question.rejected"
-  location?: LocationRef
-  data: { sessionID: string; requestID: string }
-}
-
 export type FormCancelled = {
   id: string
   created: number
@@ -1377,7 +1362,6 @@ export type PermissionRequest = {
   action: string
   resources: Array<string>
   save?: Array<string>
-  opaque?: boolean
   metadata?: { [x: string]: JsonValue }
   source?: PermissionSource
 }
@@ -1394,7 +1378,6 @@ export type PermissionAsked = {
     action: string
     resources: Array<string>
     save?: Array<string>
-    opaque?: boolean
     metadata?: { [x: string]: any }
     source?: PermissionSource
   }
@@ -1427,23 +1410,6 @@ export type PtyUpdated = {
   data: { info: Pty }
 }
 
-export type QuestionInfo = {
-  question: string
-  header: string
-  options: Array<QuestionOption>
-  multiple?: boolean
-  custom?: boolean
-}
-
-export type QuestionReplied = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "question.replied"
-  location?: LocationRef
-  data: { sessionID: string; requestID: string; answers: Array<QuestionAnswer> }
-}
-
 export type FormStringField1 = {
   key: string
   title?: string
@@ -1684,17 +1650,6 @@ export type FormReplied = {
   data: { id: string; sessionID: string; answer: FormAnswer }
 }
 
-export type QuestionAsked = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "question.asked"
-  location?: LocationRef
-  data: { id: string; sessionID: string; questions: Array<QuestionInfo>; tool?: QuestionTool }
-}
-
-export type QuestionRequest = { id: string; sessionID: string; questions: Array<QuestionInfo>; tool?: QuestionTool }
-
 export type FormField1 =
   | FormStringField1
   | FormNumberField1
@@ -1880,6 +1835,7 @@ export type ConfigEntry =
           }
         }
         experimental?: {
+          portable_shell_scanner?: boolean
           subagent_depth?: number
           policies?: Array<{ action: "provider.use"; resource: string; effect: "allow" | "deny" }>
         }
@@ -2116,9 +2072,6 @@ export type V2Event =
   | ShellCreated
   | ShellExited
   | ShellDeleted
-  | QuestionAsked
-  | QuestionReplied
-  | QuestionRejected
   | FormCreated
   | FormReplied
   | FormCancelled
@@ -2298,14 +2251,6 @@ export type ShellNotFoundError = { readonly _tag: "ShellNotFoundError"; readonly
 export const isShellNotFoundError = (value: unknown): value is ShellNotFoundError =>
   typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ShellNotFoundError"
 
-export type QuestionNotFoundError = {
-  readonly _tag: "QuestionNotFoundError"
-  readonly requestID: string
-  readonly message: string
-}
-export const isQuestionNotFoundError = (value: unknown): value is QuestionNotFoundError =>
-  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "QuestionNotFoundError"
-
 export type WorktreeError = {
   readonly name: "WorktreeError"
   readonly data: { readonly message: string; readonly forceRequired?: boolean | undefined }
@@ -5232,7 +5177,6 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
-    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
@@ -5242,7 +5186,6 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
-    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
@@ -5252,7 +5195,6 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
-    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
@@ -5262,27 +5204,15 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
-    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
   }["save"]
-  readonly opaque?: {
-    readonly id?: string | null
-    readonly action: string
-    readonly resources: ReadonlyArray<string>
-    readonly save?: ReadonlyArray<string>
-    readonly opaque?: boolean
-    readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
-    readonly agent?: string | null
-  }["opaque"]
   readonly metadata?: {
     readonly id?: string | null
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
-    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
@@ -5292,7 +5222,6 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
-    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
@@ -5302,7 +5231,6 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
-    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
@@ -5611,36 +5539,6 @@ export type ShellRemoveInput = {
 
 export type ShellRemoveOutput = void
 
-export type QuestionRequestListInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-}
-
-export type QuestionRequestListOutput = {
-  location: { directory: string; workspaceID?: string; project: { id: string; directory: string; canonical: string } }
-  data: Array<QuestionRequest>
-}
-
-export type QuestionListInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
-
-export type QuestionListOutput = { data: Array<QuestionRequest> }["data"]
-
-export type QuestionReplyInput = {
-  readonly sessionID: { readonly sessionID: string; readonly requestID: string }["sessionID"]
-  readonly requestID: { readonly sessionID: string; readonly requestID: string }["requestID"]
-  readonly answers: { readonly answers: ReadonlyArray<ReadonlyArray<string>> }["answers"]
-}
-
-export type QuestionReplyOutput = void
-
-export type QuestionRejectInput = {
-  readonly sessionID: { readonly sessionID: string; readonly requestID: string }["sessionID"]
-  readonly requestID: { readonly sessionID: string; readonly requestID: string }["requestID"]
-}
-
-export type QuestionRejectOutput = void
-
 export type ReferenceListInput = {
   readonly location?: {
     readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined

packages/client/src/solid/connection.ts

@@ -1,269 +0,0 @@
-import { batch, onCleanup, onMount } from "solid-js"
-import { createStore } from "solid-js/store"
-import type { OpenCodeClient, OpenCodeEvent } from "../promise"
-
-export type ClientConnectionStatus = "connected" | "connecting" | "reconnecting"
-export type ClientConnectionEvent = {
-  readonly type: "client.connection"
-  readonly created: number
-  readonly data: {
-    readonly status: "connecting" | "connected" | "disconnected" | "reconnecting"
-    readonly attempt: number
-    readonly error?: string
-  }
-}
-
-export type ClientConnectionOptions = {
-  readonly reconnect?: (signal: AbortSignal) => Promise<OpenCodeClient>
-  readonly onEvent: (event: OpenCodeEvent) => void
-  readonly flushInterval?: number
-  readonly pageLifecycle?: boolean
-  readonly log?: {
-    readonly debug?: (message: string, data?: Readonly<Record<string, unknown>>) => void
-    readonly info?: (message: string, data?: Readonly<Record<string, unknown>>) => void
-  }
-}
-
-const connectTimeout = 2_000
-const reconnectDelay = 1_000
-const connectionHistoryLimit = 50
-
-type CurrentDelta = Extract<
-  OpenCodeEvent,
-  { type: "session.text.delta" | "session.reasoning.delta" | "session.tool.input.delta" | "session.compaction.delta" }
->
-
-export function coalesceClientEvents(events: OpenCodeEvent[]) {
-  return events.reduce<OpenCodeEvent[]>((output, event) => {
-    const current = currentDelta(event)
-    const previous = output[output.length - 1]
-    const prior = currentDelta(previous)
-    if (
-      !current ||
-      !prior ||
-      previous?.location?.directory !== event.location?.directory ||
-      currentDeltaKey(prior) !== currentDeltaKey(current)
-    ) {
-      output.push(event)
-      return output
-    }
-    const fragment = currentDeltaFragment(prior) + currentDeltaFragment(current)
-    output[output.length - 1] = {
-      ...current,
-      data:
-        current.type === "session.compaction.delta"
-          ? { ...current.data, text: fragment }
-          : { ...current.data, delta: fragment },
-    } as CurrentDelta
-    return output
-  }, [])
-}
-
-function currentDelta(event: OpenCodeEvent | undefined): CurrentDelta | undefined {
-  if (
-    event?.type === "session.text.delta" ||
-    event?.type === "session.reasoning.delta" ||
-    event?.type === "session.tool.input.delta" ||
-    event?.type === "session.compaction.delta"
-  )
-    return event
-}
-
-function currentDeltaKey(event: CurrentDelta) {
-  if (event.type === "session.tool.input.delta")
-    return `${event.type}:${event.data.sessionID}:${event.data.assistantMessageID}:${event.data.id}`
-  if (event.type === "session.compaction.delta") return `${event.type}:${event.data.sessionID}`
-  return `${event.type}:${event.data.sessionID}:${event.data.assistantMessageID}:${event.data.ordinal}`
-}
-
-function currentDeltaFragment(event: CurrentDelta) {
-  return event.type === "session.compaction.delta" ? event.data.text : event.data.delta
-}
-
-export function createClientConnection(initialApi: OpenCodeClient, options: ClientConnectionOptions) {
-  const abort = new AbortController()
-  const history: ClientConnectionEvent[] = []
-  const [connection, setConnection] = createStore<{
-    status: ClientConnectionStatus
-    attempt: number
-    error?: string
-  }>({ status: "connecting", attempt: 0 })
-  let api = initialApi
-  let pending: OpenCodeEvent[] = []
-  let flushTimer: ReturnType<typeof setTimeout> | undefined
-  let stream: AbortController | undefined
-  let run: Promise<void> | undefined
-  let started = false
-  let generation = 0
-
-  function record(status: ClientConnectionEvent["data"]["status"], attempt: number, error?: string) {
-    history.push({ type: "client.connection", created: Date.now(), data: { status, attempt, error } })
-    if (history.length > connectionHistoryLimit) history.shift()
-  }
-
-  function publish(event: OpenCodeEvent) {
-    pending.push(event)
-    if (flushTimer) return
-    flushTimer = setTimeout(() => {
-      flushTimer = undefined
-      const events = pending
-      pending = []
-      batch(() => coalesceClientEvents(events).forEach(options.onEvent))
-    }, options.flushInterval ?? 10)
-  }
-
-  async function connect(signal: AbortSignal, attempt: number) {
-    let connectedAt: number | undefined
-    const request = new AbortController()
-    const cancel = () => request.abort(signal.reason)
-    const timeout = setTimeout(() => request.abort(new Error("Timed out connecting to server")), connectTimeout)
-    signal.addEventListener("abort", cancel, { once: true })
-
-    try {
-      record(attempt === 0 ? "connecting" : "reconnecting", attempt)
-      options.log?.info?.("event stream connecting", { attempt })
-      const iterator = api.event.subscribe({ signal: request.signal })[Symbol.asyncIterator]()
-      const first = await iterator.next()
-      if (signal.aborted) return { error: undefined, connectedAt }
-      if (first.done)
-        return {
-          error: request.signal.reason instanceof Error ? request.signal.reason : new Error("Event stream disconnected"),
-          connectedAt,
-        }
-      if (first.value.type !== "server.connected")
-        return { error: new Error("Event stream did not start with server.connected"), connectedAt }
-
-      clearTimeout(timeout)
-      record("connected", attempt)
-      connectedAt = Date.now()
-      options.log?.info?.("event stream connected")
-      publish(first.value)
-      setConnection({ status: "connected", attempt: 0, error: undefined })
-
-      while (!signal.aborted) {
-        const event = await iterator.next()
-        if (signal.aborted) return { error: undefined, connectedAt }
-        if (event.done) return { error: new Error("Event stream disconnected"), connectedAt }
-        if ("durable" in event.value)
-          options.log?.debug?.("event", {
-            type: event.value.type,
-            aggregateID: event.value.durable.aggregateID,
-            seq: event.value.durable.seq,
-          })
-        publish(event.value)
-      }
-      return { error: undefined, connectedAt }
-    } catch (error) {
-      return { error, connectedAt }
-    } finally {
-      request.abort()
-      clearTimeout(timeout)
-      signal.removeEventListener("abort", cancel)
-    }
-  }
-
-  async function runStream(active: number) {
-    let attempt = 0
-    while (!abort.signal.aborted && started && generation === active) {
-      setConnection({ status: attempt === 0 ? "connecting" : "reconnecting", attempt, error: undefined })
-      const controller = new AbortController()
-      stream = controller
-      const cancel = () => controller.abort(abort.signal.reason)
-      abort.signal.addEventListener("abort", cancel)
-      const result = await connect(controller.signal, attempt)
-      abort.signal.removeEventListener("abort", cancel)
-      if (abort.signal.aborted || !started || generation !== active) return
-      if (result.connectedAt !== undefined && Date.now() - result.connectedAt >= reconnectDelay) attempt = 0
-      attempt += 1
-      const message = errorMessage(result.error)
-      record("disconnected", attempt, message)
-      options.log?.info?.("event stream disconnected", { attempt, error: message })
-      setConnection({ status: "reconnecting", attempt, error: message })
-
-      if (options.reconnect) {
-        const next = await options.reconnect(controller.signal).catch((error) => {
-          if (!controller.signal.aborted)
-            options.log?.info?.("server resolution failed", { attempt, error: errorMessage(error) })
-        })
-        if (abort.signal.aborted || controller.signal.aborted || !started || generation !== active) return
-        if (next) {
-          api = next
-          if (attempt === 1) continue
-        }
-      }
-      await wait(reconnectDelay, controller.signal)
-    }
-  }
-
-  function start() {
-    if (started) return run
-    started = true
-    const active = ++generation
-    const previous = run
-    const current = (async () => {
-      if (previous) await previous
-      await runStream(active)
-    })().finally(() => {
-      if (run !== current) return
-      run = undefined
-    })
-    run = current
-    return run
-  }
-
-  function stop() {
-    started = false
-    generation += 1
-    stream?.abort()
-  }
-
-  onMount(() => {
-    if (options.pageLifecycle) {
-      const pagehide = () => stop()
-      const pageshow = (event: PageTransitionEvent) => {
-        if (event.persisted) void start()
-      }
-      window.addEventListener("pagehide", pagehide)
-      window.addEventListener("pageshow", pageshow)
-      onCleanup(() => {
-        window.removeEventListener("pagehide", pagehide)
-        window.removeEventListener("pageshow", pageshow)
-      })
-    }
-    void start()
-  })
-
-  onCleanup(() => {
-    stop()
-    abort.abort()
-    if (flushTimer) clearTimeout(flushTimer)
-    pending = []
-  })
-
-  return {
-    status: () => connection.status,
-    attempt: () => connection.attempt,
-    error: () => connection.error,
-    internal: {
-      history: () => history.slice(),
-    },
-  }
-}
-
-function errorMessage(error: unknown) {
-  if (error === undefined) return undefined
-  if (error instanceof Error) return error.message
-  return String(error)
-}
-
-function wait(delay: number, signal: AbortSignal) {
-  return new Promise<void>((resolve) => {
-    const timer = setTimeout(done, delay)
-    signal.addEventListener("abort", done, { once: true })
-    function done() {
-      clearTimeout(timer)
-      signal.removeEventListener("abort", done)
-      resolve()
-    }
-  })
-}

packages/client/src/solid/index.ts

@@ -1,2 +0,0 @@
-export * from "./data"
-export * from "./connection"

packages/client/test/solid-connection.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { OpenCodeEvent } from "../src/promise"
-import { coalesceClientEvents } from "../src/solid/connection"
-
-describe("coalesceClientEvents", () => {
-  const delta = (id: string, value: string, ordinal = 0) =>
-    ({
-      id,
-      created: 1,
-      type: "session.text.delta",
-      location: { directory: "/repo" },
-      data: { sessionID: "ses", assistantMessageID: "msg", ordinal, delta: value },
-    }) as OpenCodeEvent
-
-  test("merges adjacent deltas for the same stream", () => {
-    const result = coalesceClientEvents([delta("evt_1", "hello "), delta("evt_2", "world")])
-    expect(result).toHaveLength(1)
-    expect(result[0]).toMatchObject({ id: "evt_2", data: { delta: "hello world" } })
-  })
-
-  test("coalesces tool input deltas by tool ID", () => {
-    const current = (eventID: string, id: string, value: string) =>
-      ({
-        id: eventID,
-        created: 1,
-        type: "session.tool.input.delta",
-        location: { directory: "/repo" },
-        data: { sessionID: "ses", assistantMessageID: "msg", id, delta: value },
-      }) as OpenCodeEvent
-    const result = coalesceClientEvents([
-      current("evt_1", "call_1", "{"),
-      current("evt_2", "call_1", "}"),
-      current("evt_3", "call_2", "[]"),
-    ])
-    expect(result).toHaveLength(2)
-    expect(result[0]).toMatchObject({ id: "evt_2", data: { id: "call_1", delta: "{}" } })
-    expect(result[1]).toMatchObject({ id: "evt_3", data: { id: "call_2", delta: "[]" } })
-  })
-
-  test("preserves boundaries between distinct delta streams", () => {
-    const events = [delta("evt_1", "a"), delta("evt_2", "b", 1), delta("evt_3", "c")]
-    expect(coalesceClientEvents(events).map((event) => event.id)).toEqual(["evt_1", "evt_2", "evt_3"])
-  })
-})

packages/core/package.json

@@ -53,6 +53,12 @@
       "node": "./src/image/photon-wasm.node.ts",
       "default": "./src/image/photon-wasm.bun.ts"
     },
+    "#shell-parser-wasm": {
+      "workerd": "./src/shell/parser-wasm.workerd.ts",
+      "bun": "./src/shell/parser-wasm.bun.ts",
+      "node": "./src/shell/parser-wasm.node.ts",
+      "default": "./src/shell/parser-wasm.bun.ts"
+    },
     "#process-lock-ffi": {
       "workerd": "./src/util/process-lock-ffi.workerd.ts",
       "bun": "./src/util/process-lock-ffi.bun.ts",
@@ -131,7 +137,10 @@
     "ignore": "7.0.5",
     "jsonc-parser": "3.3.1",
     "mime-types": "3.0.2",
+    "tree-sitter-bash": "0.25.0",
+    "tree-sitter-powershell": "0.25.10",
     "venice-ai-sdk-provider": "2.1.1",
+    "web-tree-sitter": "0.25.10",
     "which": "6.0.1",
     "zod": "catalog:"
   }

packages/core/script/build.ts

@@ -19,7 +19,7 @@ const result = await Bun.build({
   target: "node",
   format: "esm",
   packages: "external",
-  external: ["#sqlite", "#pty", "#fff", "#photon-wasm", "#process-lock-ffi", "#v1-migration"],
+  external: ["#sqlite", "#pty", "#fff", "#photon-wasm", "#shell-parser-wasm", "#process-lock-ffi", "#v1-migration"],
   plugins: [
     {
       name: "bundle-shell-scan",

packages/core/src/aisdk.ts

@@ -321,7 +321,7 @@ function modelFromLanguage(info: Info, language: LanguageModelV3) {
     transport: {
       id: "ai-sdk",
       prepare: (input) => Effect.succeed(input.body),
-      frames: () => Stream.empty,
+      execute: () => Effect.succeed({ frames: Stream.empty }),
     },
     defaults: {
       headers: info.headers,

packages/core/src/config/normalize.ts

@@ -401,6 +401,15 @@ function normalizeExperimental(
       unsupportedExperimental.forEach((key) =>
         unsupportedIfPresent(experimental, key, ["experimental", key], diagnostics),
       )
+      if (own(experimental, "portable_shell_scanner")) {
+        const value = decodeEncoded(
+          ConfigExperimental.Info.fields.portable_shell_scanner,
+          experimental.portable_shell_scanner,
+          ["experimental", "portable_shell_scanner"],
+          diagnostics,
+        )
+        if (value !== undefined) result.portable_shell_scanner = value
+      }
       if (own(experimental, "subagent_depth")) {
         const value = decodeEncoded(
           ConfigExperimental.Info.fields.subagent_depth,

packages/core/src/effect/app-node-platform.ts

@@ -1,4 +1,6 @@
 import { LLMClient, RequestExecutor } from "@opencode-ai/ai/route"
+import { NodeSocket } from "@effect/platform-node"
+import { Socket } from "effect/unstable/socket"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { httpClient } from "@opencode-ai/util/effect/app-node-platform"
 
@@ -10,4 +12,10 @@ export const requestExecutor = makeGlobalNode({
 
 export const llmClient = makeGlobalNode({ service: LLMClient.Service, layer: LLMClient.layer, deps: [requestExecutor] })
 
+export const webSocketConstructor = makeGlobalNode({
+  service: Socket.WebSocketConstructor,
+  layer: NodeSocket.layerWebSocketConstructorWS,
+  deps: [],
+})
+
 export * as LayerNodePlatform from "./app-node-platform.js"

packages/core/src/location-services.ts

@@ -27,13 +27,13 @@ import { Plugin } from "./plugin.js"
 import { PluginSupervisor } from "./plugin/supervisor.js"
 import { Worktree } from "./worktree.js"
 import { Pty } from "./pty.js"
-import { Question } from "./question.js"
 import { Shell } from "./shell.js"
 import { Reference } from "./reference.js"
 import { WebSearch } from "./websearch.js"
 import { ReferenceInstructions } from "./reference/instructions.js"
 import { SessionRunnerLLM } from "./session/runner/llm.js"
 import { SessionRunnerModel } from "./session/runner/model.js"
+import { SessionModelTransport } from "./session/model-transport.js"
 import { SessionCompaction } from "./session/compaction.js"
 import { SessionTitle } from "./session/title.js"
 import { Skill } from "./skill.js"
@@ -86,13 +86,13 @@ const locationServiceNodes = [
   ReferenceInstructions.node,
   InstructionEntry.node,
   Form.node,
-  Question.node,
   Generate.node,
   SessionGenerateNode.node,
   ReadToolFileSystem.node,
   McpTool.node,
   SessionInstructions.node,
   SessionRunnerModel.node,
+  SessionModelTransport.node,
   SessionCompaction.node,
   SessionTitle.node,
   Snapshot.node,

packages/core/src/permission.ts

@@ -1,7 +1,7 @@
 export * as Permission from "./permission.js"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Deferred, Effect, Layer, Schema, Struct } from "effect"
+import { Context, Deferred, Effect, Layer, Schema } from "effect"
 import { Permission } from "@opencode-ai/schema/permission"
 import { Bus } from "./bus.js"
 import { Location } from "./location.js"
@@ -23,6 +23,15 @@ export type ID = typeof ID.Type
 export const Source = Permission.Source
 export type Source = typeof Source.Type
 
+const RequestFields = {
+  sessionID: Permission.Request.fields.sessionID,
+  action: Permission.Request.fields.action,
+  resources: Permission.Request.fields.resources,
+  save: Permission.Request.fields.save,
+  metadata: Permission.Request.fields.metadata,
+  source: Permission.Request.fields.source,
+}
+
 export const Request = Permission.Request
 export type Request = typeof Request.Type
 
@@ -31,7 +40,7 @@ export type Reply = typeof Reply.Type
 
 export const AssertInput = Schema.Struct({
   id: ID.pipe(Schema.optional),
-  ...Struct.omit(Permission.Request.fields, ["id"]),
+  ...RequestFields,
   agent: Agent.ID.pipe(Schema.optional),
 }).annotate({ identifier: "Permission.AssertInput" })
 export type AssertInput = typeof AssertInput.Type
@@ -85,16 +94,6 @@ export function evaluate(action: string, resource: string, ...rulesets: Permissi
   )
 }
 
-function evaluateOpaque(action: string, rules: Permission.Ruleset): Permission.Rule {
-  return (
-    rules.findLast((rule) => Wildcard.match(action, rule.action) && rule.resource === "*") ?? {
-      action,
-      resource: "*",
-      effect: "ask",
-    }
-  )
-}
-
 export function merge(...rulesets: Permission.Ruleset[]): Permission.Ruleset {
   return rulesets.flat()
 }
@@ -179,13 +178,6 @@ const layer = Layer.effect(
     })
 
     function denied(input: AssertInput, rules: Permission.Ruleset) {
-      if (input.opaque)
-        return rules.some(
-          (rule) =>
-            rule.effect === "deny" &&
-            Wildcard.match(input.action, rule.action) &&
-            input.resources.some((resource) => resource === "*" || Wildcard.match(resource, rule.resource)),
-        )
       return input.resources.some((resource) => evaluate(input.action, resource, rules).effect === "deny")
     }
 
@@ -195,27 +187,9 @@ const layer = Layer.effect(
 
     const evaluateInput = Effect.fnUntraced(function* (input: AssertInput) {
       const rules = yield* configured(input.sessionID, input.agent)
-      if (input.resources.length === 0) return { effect: "deny" as const, rules }
       if (denied(input, rules)) return { effect: "deny" as const, rules }
-      if (
-        input.opaque &&
-        rules.some(
-          (rule) => rule.effect !== "allow" && rule.resource !== "*" && Wildcard.match(input.action, rule.action),
-        )
-      )
-        return { effect: "ask" as const, rules }
-      const saved = yield* savedRules()
-      if (
-        input.opaque &&
-        input.resources.every((resource) =>
-          saved.some((rule) => Wildcard.match(input.action, rule.action) && rule.resource === resource),
-        )
-      )
-        return { effect: "allow" as const, rules: [...rules, ...saved] }
-      const all = [...rules, ...saved]
-      const effects = input.opaque
-        ? [evaluateOpaque(input.action, all).effect]
-        : input.resources.map((resource) => evaluate(input.action, resource, all).effect)
+      const all = [...rules, ...(yield* savedRules())]
+      const effects = input.resources.map((resource) => evaluate(input.action, resource, all).effect)
       const effect: Permission.Effect = effects.includes("deny") ? "deny" : effects.includes("ask") ? "ask" : "allow"
       return { effect, rules: all }
     })
@@ -226,8 +200,7 @@ const layer = Layer.effect(
         sessionID: input.sessionID,
         action: input.action,
         resources: input.resources,
-        save: input.opaque ? input.resources : input.save,
-        opaque: input.opaque,
+        save: input.save,
         metadata: input.metadata,
         source: input.source,
       }
@@ -326,11 +299,21 @@ const layer = Layer.effect(
           pending.delete(input.requestID)
           if (input.reply !== "always" || !existing.request.save?.length) return
 
+          const rememberedRules = yield* savedRules()
           for (const [id, item] of pending) {
-            const result = yield* evaluateInput({ ...item.request, agent: item.agent }).pipe(
+            const input = { ...item.request }
+            const rules = yield* configured(item.request.sessionID, item.agent).pipe(
               Effect.catchTag("Session.NotFoundError", () => Effect.succeed(undefined)),
             )
-            if (!result || result.effect !== "allow") continue
+            if (!rules) continue
+            if (denied(input, rules)) continue
+            const effective = [...rules, ...rememberedRules]
+            if (
+              !item.request.resources.every(
+                (resource) => evaluate(item.request.action, resource, effective).effect === "allow",
+              )
+            )
+              continue
             yield* bus.publish(Permission.Event.Replied, {
               sessionID: item.request.sessionID,
               requestID: item.request.id,

packages/core/src/plugin/hooks.ts

@@ -28,6 +28,10 @@ interface Failures extends Record<keyof Domains, unknown> {
 type Callback<Event, Error> = (event: Event) => Effect.Effect<void, Error>
 
 export interface Interface {
+  readonly has: <Domain extends keyof Domains>(
+    domain: Domain,
+    name: keyof Domains[Domain] & keyof Failures[Domain],
+  ) => Effect.Effect<boolean>
   readonly register: <Domain extends keyof Domains, Name extends keyof Domains[Domain] & keyof Failures[Domain]>(
     domain: Domain,
     name: Name,
@@ -74,7 +78,9 @@ const layer = Layer.effect(
       return event
     })
 
-    return Service.of({ register, trigger })
+    const has: Interface["has"] = (domain, name) => Effect.sync(() => callbacks.has(key(domain, name)))
+
+    return Service.of({ has, register, trigger })
   }),
 )
 

packages/core/src/plugin/provider/google-vertex.ts

@@ -26,6 +26,7 @@ function resolveLocation(options: Record<string, any>) {
 
 function vertexEndpoint(location: string) {
   if (location === "global") return "aiplatform.googleapis.com"
+  if (location === "eu" || location === "us") return `aiplatform.${location}.rep.googleapis.com`
   return `${location}-aiplatform.googleapis.com`
 }
 
@@ -111,13 +112,18 @@ export const GoogleVertexPlugin = define({
         if (evt.package !== "@ai-sdk/google-vertex") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/google-vertex"))
         const project = resolveProject(evt.options)
-        const location = resolveLocation(evt.options)
+        const location = String(resolveLocation(evt.options))
         const options = { ...evt.options }
         delete options.fetch
         evt.sdk = mod.createVertex({
           ...options,
           project,
           location,
+          ...((location === "eu" || location === "us") && project && !options.apiKey && !options.baseURL
+            ? {
+                baseURL: `https://${vertexEndpoint(location)}/v1beta1/projects/${project}/locations/${location}/publishers/google`,
+              }
+            : {}),
         })
       }),
     )

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

@@ -5,7 +5,6 @@ import { App } from "../../app.js"
 import { Credential } from "../../credential.js"
 import { Bus } from "../../bus.js"
 import { Integration } from "../../integration.js"
-import { Model } from "../../model.js"
 import { OauthCallbackPage } from "../../oauth/page.js"
 import { Provider } from "../../provider.js"
 import type { PluginInternal } from "../internal.js"
@@ -203,10 +202,10 @@ export const OpenAIPlugin = define({
       if (!item) return
       item.provider.settings = Provider.mergeOverlay(item.provider.settings, { baseURL: codexBaseURL })
       const account = chatgpt.metadata?.accountID
-      item.provider.headers = Provider.mergeHeaders(
-        item.provider.headers,
-        typeof account === "string" ? { "chatgpt-account-id": account } : undefined,
-      )
+      item.provider.headers = Provider.mergeHeaders(item.provider.headers, {
+        originator: "opencode",
+        ...(typeof account === "string" ? { "chatgpt-account-id": account } : {}),
+      })
       for (const model of item.models.values()) {
         // ChatGPT-plan tokens only authorize codex-eligible models, and the
         // subscription covers usage, so hide the rest and zero the cost.
@@ -230,17 +229,6 @@ export const OpenAIPlugin = define({
         })
       }
     })
-    yield* ctx.session.hook("http.request", (evt) =>
-      Effect.sync(() => {
-        if (!chatgpt || evt.model.providerID !== Provider.ID.openai) return
-        const url = new URL(evt.request.url)
-        evt.request.headers.set("originator", "opencode")
-        evt.request.headers.set("session-id", evt.sessionID)
-        if (url.origin !== "https://api.openai.com") return
-        evt.request = new Request(`${codexBaseURL}${url.pathname.replace(/^\/v1/, "")}${url.search}`, evt.request)
-      }),
-    )
-
     const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())))
     yield* bus.subscribe(Integration.Event.ConnectionUpdated).pipe(
       Stream.filter((event) => event.data.integrationID === Integration.ID.make("openai")),

packages/core/src/plugin/websearch/index.ts

@@ -1,5 +1,11 @@
 import { WebSearchExa } from "./exa.js"
 import { WebSearchFirecrawl } from "./firecrawl.js"
 import { WebSearchParallel } from "./parallel.js"
+import { WebSearchTavily } from "./tavily.js"
 
-export const WebSearchPlugins = [WebSearchExa.Plugin, WebSearchFirecrawl.Plugin, WebSearchParallel.Plugin] as const
+export const WebSearchPlugins = [
+  WebSearchExa.Plugin,
+  WebSearchFirecrawl.Plugin,
+  WebSearchParallel.Plugin,
+  WebSearchTavily.Plugin,
+] as const

packages/core/src/plugin/websearch/tavily.ts

@@ -0,0 +1,85 @@
+export * as WebSearchTavily from "./tavily.js"
+
+import { define } from "@opencode-ai/plugin/effect/plugin"
+import { Duration, Effect, Schema, Scope } from "effect"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { App } from "../../app.js"
+
+export const endpoint = "https://api.tavily.com/search"
+
+const SearchRequest = Schema.Struct({
+  query: Schema.String,
+  search_depth: Schema.Literal("basic"),
+  chunks_per_source: Schema.Number,
+  max_results: Schema.Number,
+})
+
+const SearchResponse = Schema.Struct({
+  results: Schema.Array(
+    Schema.Struct({
+      title: Schema.String,
+      url: Schema.String,
+      content: Schema.String,
+    }),
+  ),
+})
+
+export const Plugin = define<HttpClient.HttpClient | Scope.Scope>({
+  id: "opencode.websearch.tavily",
+  effect: Effect.fn("WebSearchTavily.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient
+    yield* ctx.integration.transform((draft) => {
+      draft.update("tavily", (integration) => (integration.name = "Tavily"))
+      draft.method.update({
+        integrationID: "tavily",
+        method: { type: "key" },
+      })
+      draft.method.update({
+        integrationID: "tavily",
+        method: { type: "env", names: ["TAVILY_API_KEY"] },
+      })
+    })
+    yield* ctx.websearch.transform((draft) => {
+      draft.add({
+        id: "tavily",
+        name: "Tavily",
+        execute: (input) =>
+          Effect.gen(function* () {
+            const connection = yield* ctx.integration.connection.active("tavily")
+            const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined
+            const request = yield* HttpClientRequest.post(endpoint).pipe(
+              HttpClientRequest.acceptJson,
+              HttpClientRequest.setHeaders({
+                "User-Agent": App.useragent(ctx.app),
+                "X-Client-Name": "opencode2",
+                ...(credential?.type === "key"
+                  ? { Authorization: `Bearer ${credential.key}` }
+                  : { "X-Tavily-Access-Mode": "keyless" }),
+              }),
+              HttpClientRequest.schemaBodyJson(SearchRequest)({
+                query: input.query,
+                search_depth: "basic",
+                chunks_per_source: 3,
+                max_results: 8,
+              }),
+            )
+            const response = yield* Effect.gen(function* () {
+              const httpResponse = yield* HttpClient.filterStatusOk(http).execute(request)
+              return yield* HttpClientResponse.schemaBodyJson(SearchResponse)(httpResponse)
+            }).pipe(
+              Effect.timeoutOrElse({
+                duration: Duration.seconds(25),
+                orElse: () => Effect.fail(new Error("Tavily web search request timed out")),
+              }),
+            )
+            return response.results.map((item) => ({
+              url: item.url,
+              title: item.title,
+              ...(item.content ? { content: item.content } : {}),
+              time: {},
+            }))
+          }),
+      })
+    })
+  }),
+})