feat(core): route subagent models by role

Co-authored-by: Michael Hart <mhart@cloudflare.com>

.changeset/calm-moves-cache.md

@@ -0,0 +1,5 @@
+---
+"@opencode-ai/core": patch
+---
+
+Preserve prompt cache prefixes when sessions move between locations with unchanged instructions.

.changeset/promise-plugin-adapter.md

@@ -0,0 +1,5 @@
+---
+"@opencode-ai/plugin": patch
+---
+
+Derive Promise plugin API request and response conversion from the canonical protocol schemas.

.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

@@ -0,0 +1,9 @@
+---
+"@opencode-ai/core": minor
+"@opencode-ai/schema": minor
+"@opencode-ai/protocol": minor
+"@opencode-ai/client": minor
+---
+
+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.

.gitattributes

@@ -1,3 +1,4 @@
 packages/core/migration/**/snapshot.json linguist-generated
 packages/core/src/database/migration.gen.ts linguist-generated
+packages/core/src/models-dev/snapshot.txt linguist-generated
 packages/core/src/**/*.txt text eol=lf

.github/TEAM_MEMBERS

@@ -10,6 +10,7 @@ kitlangton
 kommander
 ludvigrask
 MrMushrooooom
+neriousy
 nexxeln
 R44VC0RP
 rekram1-node

.github/workflows/generate.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - dev
+      - v2
 
 jobs:
   generate:

.github/workflows/publish.yml

@@ -6,7 +6,6 @@ on:
     branches:
       - ci
       - dev
-      - v2
       - beta
       - fix/npm-native-binary-install
       - snapshot-*
@@ -75,7 +74,7 @@ jobs:
   build-cli:
     needs: version
     runs-on: blacksmith-4vcpu-ubuntu-2404
-    if: github.repository == 'anomalyco/opencode'
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
         with:
@@ -91,7 +90,7 @@ jobs:
           opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}
 
       - name: Build legacy CLI
-        if: github.ref_name != 'v2'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         run: ./packages/opencode/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
         env:
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
@@ -109,7 +108,7 @@ jobs:
           GH_TOKEN: ${{ steps.committer.outputs.token }}
 
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        if: github.ref_name != 'v2'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         with:
           name: opencode-cli
           path: |
@@ -117,22 +116,76 @@ jobs:
             packages/opencode/dist/opencode-linux*
 
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        if: github.ref_name != 'v2'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         with:
           name: opencode-cli-windows
           path: packages/opencode/dist/opencode-windows*
 
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
-          name: opencode-preview-cli
+          name: opencode-preview-cli-unsigned
           path: packages/cli/dist/cli-*
 
     outputs:
       version: ${{ needs.version.outputs.version }}
 
+  sign-cli-macos:
+    needs: build-cli
+    runs-on: macos-26
+    if: github.repository == 'anomalyco/opencode'
+    steps:
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
+
+      - uses: apple-actions/import-codesign-certs@8f3fb608891dd2244cdab3d69cd68c0d37a7fe93 # v2.0.0
+        with:
+          keychain: build
+          p12-file-base64: ${{ secrets.APPLE_CERTIFICATE }}
+          p12-password: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+
+      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        with:
+          name: opencode-preview-cli-unsigned
+          path: packages/cli/dist
+
+      - name: Sign macOS CLI binaries
+        run: |
+          identity=$(security find-identity -v -p codesigning build.keychain | sed -n 's/.*"\(Developer ID Application:.*\)"/\1/p' | head -n 1)
+          if [ -z "$identity" ]; then
+            echo "Developer ID Application identity not found"
+            exit 1
+          fi
+
+          found=0
+          for file in packages/cli/dist/cli-darwin-*/bin/opencode2; do
+            if [ ! -f "$file" ]; then
+              continue
+            fi
+            found=1
+            codesign \
+              --force \
+              --timestamp \
+              --options runtime \
+              --entitlements packages/cli/script/entitlements.plist \
+              --sign "$identity" \
+              "$file"
+            codesign --verify --deep --strict --verbose=4 "$file"
+            codesign --display --requirements - "$file"
+          done
+
+          if [ "$found" -eq 0 ]; then
+            echo "No macOS CLI binaries found"
+            exit 1
+          fi
+
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: opencode-preview-cli
+          path: packages/cli/dist/cli-*
+          if-no-files-found: error
+
   build-node-cli:
     needs: version
-    if: github.repository == 'anomalyco/opencode'
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
     strategy:
       fail-fast: false
       matrix:
@@ -184,7 +237,7 @@ jobs:
       - build-cli
       - version
     runs-on: blacksmith-4vcpu-windows-2025
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2'
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2' && github.ref_name != 'beta'
     env:
       AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
       AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
@@ -281,7 +334,6 @@ jobs:
 
   build-electron:
     needs:
-      - build-cli
       - version
     if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2'
     continue-on-error: false
@@ -378,16 +430,14 @@ jobs:
         env:
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
-          OPENCODE_CLI_ARTIFACT: ${{ (runner.os == 'Windows' && 'opencode-cli-windows') || 'opencode-cli' }}
-          RUST_TARGET: ${{ matrix.settings.target }}
-          GH_TOKEN: ${{ github.token }}
-          GITHUB_RUN_ID: ${{ github.run_id }}
+          OPENCODE_CLI_TARGET: ${{ matrix.settings.target }}
 
       - name: Build
         run: bun run build
         working-directory: packages/desktop
         env:
           NODE_OPTIONS: --max-old-space-size=4096
+          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
           SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
           SENTRY_ORG: ${{ vars.SENTRY_ORG }}
@@ -396,6 +446,7 @@ jobs:
           VITE_SENTRY_DSN: ${{ vars.WEB_SENTRY_DSN }}
           VITE_SENTRY_ENVIRONMENT: ${{ (github.ref_name == 'beta' && 'beta') || 'production' }}
           VITE_SENTRY_RELEASE: desktop@${{ needs.version.outputs.version }}
+          OPENCODE_CLI_TARGET: ${{ matrix.settings.target }}
 
       - name: Package
         if: needs.version.outputs.release
@@ -405,8 +456,7 @@ jobs:
         env:
           OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
           GH_TOKEN: ${{ steps.committer.outputs.token }}
-          CSC_LINK: ${{ secrets.APPLE_CERTIFICATE }}
-          CSC_KEY_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          CSC_KEYCHAIN: build.keychain
           APPLE_API_KEY: ${{ runner.temp }}/apple-api-key.p8
           APPLE_API_KEY_ID: ${{ secrets.APPLE_API_KEY }}
           APPLE_API_ISSUER: ${{ secrets.APPLE_API_ISSUER }}
@@ -471,6 +521,7 @@ jobs:
     needs:
       - version
       - build-cli
+      - sign-cli-macos
       - build-node-cli
       - sign-cli-windows
       - build-electron
@@ -500,29 +551,31 @@ jobs:
           registry-url: "https://registry.npmjs.org"
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'v2'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         with:
           name: opencode-cli
           path: packages/opencode/dist
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'v2'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         with:
           name: opencode-cli-windows
           path: packages/opencode/dist
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'v2'
+        if: github.ref_name != 'v2' && github.ref_name != 'beta'
         with:
           name: opencode-cli-signed-windows
           path: packages/opencode/dist
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        if: github.ref_name != 'beta'
         with:
           name: opencode-preview-cli
           path: packages/cli/dist
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        if: github.ref_name != 'beta'
         with:
           pattern: opencode-node-cli-*
           path: packages/cli/dist/node

.github/workflows/test.yml

@@ -55,6 +55,12 @@ jobs:
           git config --global user.email "bot@opencode.ai"
           git config --global user.name "opencode"
 
+      - name: Install ffmpeg
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install --yes ffmpeg
+
       - name: Cache Turbo
         uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:

.opencode/command/ai-deps.md

@@ -2,7 +2,7 @@
 description: "Bump AI sdk dependencies minor / patch versions only"
 ---
 
-Please read @package.json and @packages/opencode/package.json.
+Please read @package.json and @packages/core/package.json.
 
 Your job is to look into AI SDK dependencies, figure out if they have versions that can be upgraded (minor or patch versions ONLY no major ignore major changes).
 

.opencode/command/commit.md

@@ -6,15 +6,7 @@ subtask: true
 
 commit and push
 
-make sure it includes a prefix like
-docs:
-tui:
-core:
-ci:
-ignore:
-wip:
-
-For anything in the packages/web use the docs: prefix.
+Use `type(scope): summary` with one of these types: `feat`, `fix`, `docs`, `chore`, `refactor`, or `test`. The scope is optional.
 
 prefer to explain WHY something was done from an end user perspective instead of
 WHAT was done.

.opencode/command/rmslop.md

@@ -2,7 +2,7 @@
 description: Remove AI code slop
 ---
 
-Check the diff against dev, and remove all AI generated slop introduced in this branch.
+Check the diff against `origin/v2`, and remove all AI generated slop introduced in this branch.
 
 This includes:
 

.opencode/glossary/he.md

@@ -0,0 +1,48 @@
+# he Glossary
+
+## Sources
+
+- Hebrew Academy approved IT terminology: https://terms.hebrew-academy.org.il/Millonim/ShowMillon?KodMillon=192
+- Firefox Hebrew localization corpus: https://github.com/mozilla-l10n/firefox-l10n/tree/main/he
+- KDE Hebrew localization team and corpus: https://l10n.kde.org/team-infos.php?teamcode=he
+- Community-maintained VS Code Hebrew language pack: https://github.com/AMAARETS/vscode-language-pack-he
+- Microsoft Hebrew developer documentation for Git terminology: https://learn.microsoft.com/he-il/power-platform/alm/tutorials/github-actions-deploy
+- W3C guidance for bidirectional text: https://www.w3.org/International/articles/strings-and-bidi/
+
+## Do Not Translate (Locale Additions)
+
+- `OpenCode` (preserve casing in prose and UI copy)
+- `API`, `MCP`, `LSP`, `OAuth`, `Git`, model names, and provider names
+- Commands, flags, keyboard shortcuts, file paths, URLs, identifiers, hashes, and code literals
+- Keep `commit` and `diff` when they name the exact Git artifact or operation
+
+## Preferred Terms
+
+| English / Context | Preferred     | Notes                                                                     |
+| ----------------- | ------------- | ------------------------------------------------------------------------- |
+| session           | `הפעלה`       | Use `שיחה` only when the source specifically means a chat or conversation |
+| workspace         | `סביבת עבודה` |                                                                           |
+| terminal          | `מסוף`        | Prefer the established Hebrew term over transliteration                   |
+| command           | `פקודה`       |                                                                           |
+| provider          | `ספק`         | Use `ספק מודלים` where the bare noun is ambiguous                         |
+| model             | `מודל`        |                                                                           |
+| API key           | `מפתח API`    | Keep the acronym in Latin letters                                         |
+| plugin            | `תוסף`        |                                                                           |
+| repository        | `מאגר`        | Use `מאגר Git` where context is ambiguous                                 |
+| branch            | `ענף`         |                                                                           |
+| context           | `הקשר`        | Use `חלון הקשר` for context window                                        |
+| tokens            | `אסימונים`    |                                                                           |
+
+## Guidance
+
+- Prefer natural modern Israeli Hebrew over word-for-word translation or obscure coined terms.
+- Use short action verbs for controls and translate complete phrases in context.
+- Keep recognized developer acronyms and exact Git vocabulary in Latin script instead of phonetic transliteration.
+- Treat embedded code, paths, commands, shortcuts, hashes, model IDs, and other Latin technical artifacts as LTR content inside the RTL interface.
+- Keep recurring concepts consistent and do not collapse session, chat, run, and launch into one Hebrew term.
+
+## Avoid
+
+- Avoid transliterations such as `טרמינל`, `פלאגין`, and `קומנד` when `מסוף`, `תוסף`, and `פקודה` are clear.
+- Avoid translating `commit` as `התחייבות`.
+- Avoid inventing Hebrew expansions for `API`, `MCP`, or `LSP`.

.opencode/plugins/tui/discovery-smoke.ts

@@ -1,13 +0,0 @@
-import type { Context } from "../../../packages/plugin/src/tui/context"
-
-export default {
-  id: "test.tui-discovery-smoke",
-  setup(_context: Context) {
-    // context.ui.toast.show({
-    //   title: "TUI plugin discovery works",
-    //   message: "Loaded .opencode/plugins/tui/discovery-smoke.ts",
-    //   variant: "success",
-    //   duration: 30_000,
-    // })
-  },
-}

.opencode/skills/effect/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: effect
-description: Work with Effect v4 / effect-smol TypeScript code in this repo
+description: Work with Effect v4 TypeScript code in this repo
 ---
 
 # Effect
@@ -9,10 +9,10 @@ This codebase uses Effect for typed, composable TypeScript services, schemas, an
 
 ## Source Of Truth
 
-Use the current Effect v4 / effect-smol source, not memory or older Effect v2/v3 examples.
+Use the current Effect v4 source, not memory or older Effect v2/v3 examples.
 
-1. If `.opencode/references/effect-smol` is missing, clone `https://github.com/Effect-TS/effect-smol` there. Do this in the project, not in the skill folder.
-2. Search `.opencode/references/effect-smol` for exact APIs, examples, tests, and naming patterns before answering or implementing Effect-specific code.
+1. If `.opencode/references/effect` is missing, clone `https://github.com/Effect-TS/effect` there. Do this in the project, not in the skill folder.
+2. Search `.opencode/references/effect` for exact APIs, examples, tests, and naming patterns before answering or implementing Effect-specific code.
 3. Also inspect existing repo code for local house style before introducing new patterns.
 4. Prefer answers and implementations backed by specific source files or nearby repo examples.
 
@@ -27,12 +27,12 @@ Use the current Effect v4 / effect-smol source, not memory or older Effect v2/v3
 - Keep layer composition explicit. Avoid broad hidden provisioning that makes missing dependencies hard to see.
 - In tests, prefer the repo's existing Effect test helpers and live tests for filesystem, git, child process, locks, or timing behavior.
 - Do not introduce `any`, non-null assertions, unchecked casts, or older Effect APIs just to satisfy types.
-- Do not answer from memory. Verify against `.opencode/references/effect-smol` or nearby code first.
+- Do not answer from memory. Verify against `.opencode/references/effect` or nearby code first.
 
 ## Testing Patterns
 
-- Use `testEffect(...)` from `packages/opencode/test/lib/effect.ts` for tests that exercise Effect services, layers, runtime context, scoped resources, or platform integrations.
+- Use `testEffect(...)` from `packages/core/test/lib/effect.ts` for tests that exercise Effect services, layers, runtime context, scoped resources, or platform integrations.
 - Use `it.live(...)` for filesystem, git repositories, HTTP servers, sockets, child processes, locks, real time, and other live platform behavior.
-- Run tests from package directories such as `packages/opencode`; never run package tests from the repo root.
+- Run tests from package directories such as `packages/core`; never run package tests from the repo root.
 - Prefer explicit test layers over ad hoc managed runtimes. Keep dependency provisioning visible in the test file.
 - Use scoped fixtures and finalizers for resources that must be cleaned up, including temporary directories, flags, databases, fibers, servers, and global state.

.opencode/skills/ideal-pseudocode/SKILL.md

@@ -1,68 +0,0 @@
----
-name: ideal-pseudocode
-description: Function-by-function refactoring loop driven by ideal pseudocode. Use when the user says "ideal pseudocode", asks to make a function read like its pseudocode, or wants a dense module cleaned up one function at a time.
----
-
-# Ideal Pseudocode
-
-Clean up one function at a time by writing the pseudocode it _should_ read as, naming every delta between that and the real code, and closing only the gaps the user approves.
-
-## Loop
-
-One function per round. Never touch code before the user picks a direction.
-
-1. **Pick the target** with the user — usually the next function up or down the call chain from the last round.
-2. **Read the current code** fresh from disk. It may have unsaved or parallel edits; ask before overwriting anything unexpected.
-3. **Distill.** Write the function's ideal pseudocode in a `ts`-fenced code block — TypeScript-flavored for syntax highlighting, but pseudocode: comments over mechanics, one line per idea, every arm of a loop visible as an arm. For a dense or unfamiliar function, first show the _current_ structure as pseudocode, then the ideal.
-4. **Name the deltas.** A numbered list; each delta is one concrete gap: control flow smuggled through combinators, a flag-typed parameter, colliding names, side-effect plumbing drowning a loop body, twin functions differing only by a filter. For each, give an honest cost/benefit and a decisive recommendation — including "leave it" when the density has reasons (state the reasons).
-5. **Verify before proposing.** Any API the proposal builds on (a combinator, schedule, matcher) gets checked against the installed version's source, not memory.
-6. **Get buy-in, then apply.** Minimal edits. Quarantine irreducible ugliness inside a small helper whose name is the pseudocode line it implements. Collapse shallow sibling functions into one deep function only when the distinguishing argument is a domain noun, not a behavior switch.
-7. **Validate.** Typecheck and the focused test suites from the package directory; rerun timing-sensitive tests repeatedly. Flag any semantic change the restructure introduced, even when tests pass.
-8. **Offer the next target** and stop.
-
-## Style
-
-- Keep each round tight: pseudocode block, deltas, recommendation, one question.
-- State mutation belongs in one visible place (usually the loop tail), never spread across error channels or callback closures.
-- Prefer early return and `if` chains for control flow; matchers are for producing values.
-- Compare names against the question each caller is actually asking; rename toward the domain noun.
-
-## Example round
-
-Every round should read like this (abridged from a real one, on an Effect step-runner):
-
-> `runStep` it is. The ideal pseudocode:
->
-> ```ts
-> // One logical step: one settled model call, however many attempts it takes.
-> // An attempt can end without settling in two ways:
-> //   transient provider failure -> retry the same call, same assistant message
-> //   compaction rewrote history -> rebuild the request and call again
-> function runStep(session, promotable, step) {
->   while (true) {
->     const result = callModel(session, promotable, step)
->
->     if (result.completed) return result
->
->     if (result.retryable) {
->       wait(retrySchedule) // exhausted -> publish Step.Failed, fail drain
->       promotable = none // never re-promote on a second attempt
->       continue
->     }
->
->     // compaction restarted the step: fresh request from rewritten history
->     promotable = none
->     step = result.step
->   }
-> }
-> ```
->
-> Comparing against the real thing, three deltas:
->
-> 1. **The retry arm doesn't live in the loop.** In the pseudocode, retry is just another loop arm. In the real code it's smuggled through the error channel: `Effect.tapError` mutating loop variables via `Effect.sync` closures, then `Effect.retryOrElse` re-running a suspended call. Four mutable variables mutated from three different places — the state flow is invisible unless you already know the trick.
-> 2. **`recoverOverflow: typeof compaction.compact | undefined`** — a function-typed parameter used as a one-shot armed/disarmed flag. The callee already closes over `compaction`; a boolean says what it is.
-> 3. **`assistantMessageID`** exists solely to resume the same durable message across retries — fine, but only legible once the retry arm is visible in the loop.
->
-> The unifying move for (1): a schedule driver, so a retryable failure becomes a caught value handled in the loop body exactly like the compaction arm. One honest trade: it's more manual than the blessed combinator — but the manual version is the loop the combinator was hiding, and the loop already exists for restarts. Two restart mechanisms, one control structure.
->
-> Want me to apply it — unified loop, simplified schedule input, boolean `recoverOverflow`?

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

@@ -1,254 +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/jlongster/opencode-drive/refs/heads/main/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/jlongster/opencode-drive/refs/heads/main/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/jlongster/opencode-drive/refs/heads/main/examples/simple.ts
-- https://raw.githubusercontent.com/jlongster/opencode-drive/refs/heads/main/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
-```
-

.opencode/skills/rtl-aware-development/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: rtl-aware-development
+description: OpenCode Desktop should be RTL-aware. Use when implementing or reviewing RTL/LTR behavior in the web app, desktop app, CSS, menus, scrolling, resizing, icons, mixed-direction text, or Electron title bars.
+---
+
+# RTL-Aware Development
+
+Treat direction as independent from language. Test English in both directions as well as real RTL and mixed-script content.
+
+## Guidelines
+
+- Set `lang` and `dir` on the document, and propagate direction through component providers used by portaled menus and popovers. Do not change the selected locale merely to force RTL.
+- Keep DOM and focus order semantic. Flexbox and Grid already follow `dir`; do not add `row-reverse`, CSS `order`, or reversed markup just to mirror a layout.
+- Prefer logical CSS for semantic layout. Reserve physical coordinates for pointer positions, canvas geometry, native window controls, and other genuinely physical placement.
+
+```css
+/* Avoid */
+padding-left: 12px;
+right: 0;
+border-right: 1px solid;
+text-align: left;
+
+/* Prefer */
+padding-inline-start: 12px;
+inset-inline-end: 0;
+border-inline-end: 1px solid;
+text-align: start;
+```
+
+- Isolate mixed-direction text. Use `dir="auto"` or `<bdi>` for unknown text; keep code, URLs, IDs, and filesystem paths LTR without forcing the surrounding component LTR.
+
+```html
+<span class="file-row"><bdi dir="auto">README.md</bdi></span> <bdi dir="ltr"><code>C:\src\app.ts</code></bdi>
+```
+
+- Mirror directional meaning, not every image. Back/forward, previous/next, disclosure, indentation, and directional progress may need mirroring. Do not mirror brands, clocks, media controls, charts, or text. Reverse physical gradients, `translateX`, SVG transforms, and animation deltas explicitly.
+- Map interactions through direction. `clientX` remains physical; resizing a logical edge needs an RTL-aware delta. Logical previous/next keyboard controls may swap ArrowLeft/ArrowRight. Follow the relevant WAI-ARIA widget pattern.
+- Do not assume LTR scrolling. RTL `scrollLeft` can start at `0` and become negative. Prefer `scrollIntoView({ inline: "nearest" })` or a tested direction-normalizing helper.
+- For Electron title bars, prefer native caption controls and use `titleBarOverlay` plus `env(titlebar-area-*)` for the safe content rectangle. Keep Windows/macOS native-control avoidance and `trafficLightPosition` physical; keep app navigation inside that rectangle logical. Mark interactive titlebar children `app-region: no-drag`.
+- Verify behavior, not screenshots alone. Check computed styles, pseudo-element geometry, hit zones, focus order, keyboard behavior, submenu direction, zoom/scaling, and both LTR and RTL scroll endpoints.
+
+## Test Matrix
+
+- English + LTR
+- English + forced RTL
+- A real RTL locale + RTL
+- Mixed RTL/LTR content, long labels, numbers, code, and paths
+- Keyboard, pointer resize, scrolling, menus/submenus, and Electron titlebar controls in both directions
+
+## References
+
+- [RTL Styling 101, Ahmad Shadeed](https://rtlstyling.com/posts/rtl-styling/)
+- [CSS-Tricks: RTL Styling 101](https://css-tricks.com/rtl-styling-101/)
+- [CSS-Tricks: CSS Logical Properties and Values](https://css-tricks.com/css-logical-properties-and-values/)
+- [W3C: Structural markup and right-to-left text](https://www.w3.org/International/questions/qa-html-dir)
+- [W3C: Inline bidirectional markup](https://www.w3.org/International/articles/inline-bidi-markup/)
+- [MDN: CSS logical properties and values](https://developer.mozilla.org/en-US/docs/Web/CSS/Guides/Logical_properties_and_values)
+- [MDN: `dir`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/dir)
+- [MDN: `scrollLeft`](https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollLeft)
+- [web.dev: Logical properties](https://web.dev/learn/css/logical-properties/)
+- [Electron: Custom title bar](https://www.electronjs.org/docs/latest/tutorial/custom-title-bar)
+- [WAI-ARIA: Window splitter pattern](https://www.w3.org/WAI/ARIA/apg/patterns/windowsplitter/)
+- [Kobalte: I18n Provider](https://kobalte.dev/docs/core/components/i18n-provider/)

.opencode/tool/github-triage.ts

@@ -4,7 +4,7 @@ import { tool } from "@opencode-ai/plugin"
 const TEAM = {
   tui: ["kommander", "simonklee"],
   desktop_web: ["Hona", "Brendonovich"],
-  core: ["jlongster", "rekram1-node", "nexxeln", "kitlangton"],
+  core: ["jlongster", "rekram1-node", "neriousy", "nexxeln", "kitlangton"],
   inference: ["fwang", "MrMushrooooom", "starptech"],
   windows: ["Hona"],
 } as const

AGENTS.md

@@ -1,8 +1,9 @@
-- After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`. Do not edit `src/generated` or `src/generated-effect` directly.
+- After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`. Do not edit generated client files directly.
 - Keep runtime dependencies directed from Schema to Core and Protocol, then from Core and Protocol to Server. Client runtime code may depend on Schema and Protocol but never Core or Server; `sdk-next` composes Client, Core, and Server.
-- Do not modify `packages/opencode` unless the user explicitly asks for V1 work. `packages/opencode` is the V1 implementation and is present for reference only. New implementation changes should land in the V2 package set: `packages/core`, `packages/cli`, `packages/server`, `packages/protocol`, `packages/schema`, and related generated client surfaces when required.
-- The default branch in this repo is `dev`.
-- Local `main` ref may not exist; use `dev` or `origin/dev` for diffs.
+- Current implementation changes belong in `packages/core`, `packages/cli`, `packages/server`, `packages/protocol`, `packages/schema`, and related generated client surfaces when required.
+- The default branch in this repo is `v2`.
+- Base all new branches and worktrees on `v2`, or `origin/v2` when the local `v2` ref is unavailable. Do not base them on `dev`.
+- Local `main` ref may not exist; use `v2` or `origin/v2` for diffs.
 
 ## Live V2 TUI Testing
 
@@ -11,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/`.
@@ -151,23 +166,23 @@ const table = sqliteTable("session", {
 
 - Avoid mocks as much as possible, you shouldn't be using globalThis.\* at all unless it's the only option.
 - Test actual implementation, do not duplicate logic into tests
-- Tests cannot run from repo root (guard: `do-not-run-tests-from-root`); run from package dirs like `packages/opencode`.
+- Tests cannot run from repo root (guard: `do-not-run-tests-from-root`); run from package directories such as `packages/core`.
 
 ## Type Checking
 
-- Always run `bun typecheck` from package directories (e.g., `packages/opencode`), never `tsc` directly.
+- Always run `bun typecheck` from package directories (for example, `packages/core`), never `tsc` directly.
 
 ## V2 Session Core
 
 - Keep durable events minimal: record irreducible new facts and do not repeat state derivable by folding the ordered aggregate history. Enrich projections and read models with previous or derived state when consumers need self-contained views.
-- Keep durable prompt admission separate from model execution. `SessionV2.prompt(...)` admits one durable `session_pending` row before scheduling advisory `SessionExecution.wake(sessionID)` unless `resume: false` requests admit-only behavior. The serialized runner promotes admitted inputs into visible user messages at safe boundaries, consuming the pending row in the same event transaction; `session_pending` stores only unconsumed work.
-- Reusing a Session ID adopts the existing Session. Reusing a prompt message ID reconciles an exact retry only when Session, prompt, and delivery mode match; conflicting reuse fails. Retry of an already-promoted input reconciles against the projected message and the durable admitted event rather than a retained row.
+- Keep durable prompt admission separate from model execution. `Session.prompt(...)` publishes `session.inbox.enqueued`, whose projection inserts one durable `session_inbox` row, before scheduling advisory `SessionExecution.wake(sessionID)` unless `resume: false` requests admit-only behavior. Delivery publishes `session.inbox.delivered`; its projection consumes the inbox row and inserts the visible message in the same transaction. `session_inbox` stores only unconsumed work.
+- Reusing a Session ID adopts the existing Session. While a user or synthetic inbox item is pending, reusing its ID reconciles only when Session, type, complete payload, metadata, and delivery match; conflicting reuse fails. Once delivered, retry reconciliation for those message-producing items uses the projected message and does not require retained enqueue history or the original delivery mode. Control items keep their operation-specific conflict behavior.
 - Keep `SessionExecution` process-global and Session-ID based. Its local implementation owns the process-local Session coordinator and discovers placement through `SessionStore` plus `LocationServiceMap.get(session.location)` only when a drain starts; no layer should take a Session ID. V2 interruption targets the active process-local ownership chain for that Session; interruption of a known but idle or locally unowned Session is a no-op, while the public API rejects an unknown Session.
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
-- Preserve one explicit `llm.stream(request)` call per Physical Attempt and reload projected history before durable continuation. Most Steps have one Physical Attempt; overflow-triggered compaction recovery may rebuild one Step for a second attempt. Do not bridge through legacy `SessionPrompt.loop(...)` or delegate orchestration to an in-memory tool loop.
-- Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. Advisory wakes drain eligible durable inbox rows only; post-crash continuation recovery requires a separate explicit design before it may retry provider work. A drain has no durable identity or transcript boundary.
-- Keep delivery vocabulary explicit. Prompts steer by default and promote at the next safe step boundary while the current drain requires continuation. An explicit `queue` input remains pending until the Session would otherwise become idle; promote one queued input at that boundary, then reevaluate continuation before promoting another. Promoting any new user input resets the selected agent's step allowance; a batch of steers resets it once.
+- Preserve one explicit `llm.stream(request)` call per Physical Attempt and reload projected history before durable continuation. A logical Step may use generic pre-output retries, one full-context retry after continuation rejection, incomplete-stream continuation, or one overflow-compaction rebuild. Generic retries retain the logical step number and do not consume another agent-step allowance. Do not delegate orchestration to an in-memory tool loop.
+- Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. A write-ahead execution claim marks a process-local busy period for restart recovery: terminal completion, failure, or user interruption releases it, while shutdown interruption and process death preserve it. Startup recovery resumes claimed top-level Sessions with durable per-execution attempt accounting. The claim is a recovery marker, not clustered ownership, fencing, or an exactly-once guarantee.
+- Keep delivery vocabulary explicit. Prompts steer by default. Steers deliver in enqueue order at safe step boundaries, stopping before compaction or move control items. At an idle boundary, steers take priority; otherwise exactly one queued item delivers before the runner reevaluates continuation. Inbox items may be cancelled or changed between queue and steer before delivery. Promoting new user input resets the selected agent's step allowance; a batch of steers resets it once.
 - One step is one logical LLM call; its durable record covers only the model-visible span. Do not write "provider turn", and do not use bare "turn" for a single call: "turn" is reserved for the future assistant-turn unit containing all steps from prompt promotion until the session would go idle.
-- Keep EventV2 replay owner claims separate from clustered Session execution ownership.
+- Keep event replay ownership separate from clustered Session execution ownership.
 - Keep the Instructions algebra and built-ins in `src/instructions`; keep instruction producers with their observed domains, and keep Session History selection plus `InstructionState` and `InstructionEntry` persistence Session-owned. `InstructionDiscovery` observes ambient global and upward-project instructions. The runner composes built-ins, discovery, guidance, and entries explicitly in `loadInstructions`; there is no instruction registry.
-- `session.instructions.updated` stores only changed source keys and content hashes. Blob values live once in `instruction_blob`; `instruction_state` is a rebuildable fold cache, never primary state. Render initial instructions and chronological updates from values during request assembly. Completed compaction moves the instruction epoch; Session movement and committed revert clear it. Unavailable sources retain the last value and block only the initial complete delta.
+- `session.instructions.updated` stores changed source keys and content hashes and may freeze rendered chronological update text. Blob values live once in `instruction_blob`; the projected `instruction_state` row is the normal boundary-processing source of current and initial values. Request assembly renders the epoch baseline from stored values, while later frozen updates enter history as durable System messages. Completed compaction moves the instruction epoch; Session movement retains it so destination instruction changes are chronological, while committed revert clears it. Forks adopt the parent's newest instruction values even when copied message history ends at an earlier boundary. Unavailable sources retain the last value and block only the initial complete delta.

CONTRIBUTING.md

@@ -1,299 +1,112 @@
 # Contributing to OpenCode
 
-We want to make it easy for you to contribute to OpenCode. Here are the most common type of changes that get merged:
+The changes most likely to be accepted are:
 
 - Bug fixes
-- Additional LSPs / Formatters
-- Improvements to LLM performance
-- Support for new providers
-- Fixes for environment-specific quirks
+- Additional LSPs and formatters
+- LLM performance improvements
+- Environment-specific fixes
 - Missing standard behavior
 - Documentation improvements
 
-However, any UI or core product feature must go through a design review with the core team before implementation.
+UI and core product features require design review before implementation. If you are unsure whether a change fits, ask a maintainer or choose an issue labeled [`help wanted`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3Ahelp-wanted), [`good first issue`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3A%22good%20first%20issue%22), [`bug`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3Abug), or [`perf`](https://github.com/anomalyco/opencode/issues?q=is%3Aopen%20is%3Aissue%20label%3A%22perf%22).
 
-If you are unsure if a PR would be accepted, feel free to ask a maintainer or look for issues with any of the following labels:
-
-- [`help wanted`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3Ahelp-wanted)
-- [`good first issue`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3A%22good%20first%20issue%22)
-- [`bug`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3Abug)
-- [`perf`](https://github.com/anomalyco/opencode/issues?q=is%3Aopen%20is%3Aissue%20label%3A%22perf%22)
+Want to take on an issue? Leave a comment and a maintainer may assign it unless it is already being worked on.
 
 > [!NOTE]
 > PRs that ignore these guardrails will likely be closed.
 
-Want to take on an issue? Leave a comment and a maintainer may assign it to you unless it is something we are already working on.
+## Adding Providers
 
-## Adding New Providers
+New providers should rarely require OpenCode changes. Add the provider to [models.dev](https://github.com/anomalyco/models.dev) first.
 
-New providers shouldn't require many if ANY code changes, but if you want to add support for a new provider first make a PR to:
-https://github.com/anomalyco/models.dev
+## Development
 
-## Developing OpenCode
-
-- Requirements: Bun 1.3+
-- Install dependencies and start the dev server from the repo root:
-
-  ```bash
-  bun install
-  bun dev
-  ```
-
-### Running against a different directory
-
-By default, `bun dev` runs OpenCode in the `packages/opencode` directory. To run it against a different directory or repository:
+OpenCode requires Bun 1.3 or newer. From the repository root:
 
 ```bash
-bun dev <directory>
+bun install
+bun dev [directory]
 ```
 
-To run OpenCode in the root of the opencode repo itself:
+`bun dev` runs the V2 CLI and TUI. Pass a directory to open another project, or `.` to open this repository.
+
+To test a development TUI against your installed OpenCode V2 background service and live sessions:
 
 ```bash
-bun dev .
+bun run dev:live [directory]
 ```
 
-### Building a "localcode"
-
-To compile a standalone executable:
+For web development, run the backend and app in separate terminals. Other interfaces have root scripts:
 
 ```bash
-./packages/opencode/script/build.ts --single
+bun dev serve --port 4096
+bun run dev:web
+bun run dev:desktop
+bun run dev:www
 ```
 
-Then run it with:
+### Packages
+
+- `packages/schema`: shared wire and storage contracts
+- `packages/core`: domain behavior and persistence
+- `packages/protocol`: public API definitions
+- `packages/server`: HTTP server and runtime composition
+- `packages/client`: generated TypeScript clients
+- `packages/cli`: command-line entrypoint and service lifecycle
+- `packages/tui`: terminal interface
+- `packages/app`: shared web interface
+- `packages/desktop`: Electron desktop application
+- `packages/plugin`: plugin API
+
+### Verification
+
+Run typechecks, and tests where defined, from the affected package rather than the repository root:
 
 ```bash
-./packages/opencode/dist/opencode-<platform>/bin/opencode
+cd packages/core
+bun run test
+bun typecheck
 ```
 
-Replace `<platform>` with your platform (e.g., `darwin-arm64`, `linux-x64`).
+Follow package-specific instructions in nearby `AGENTS.md` files. After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`; never edit generated client files directly.
 
-- Core pieces:
-  - `packages/opencode`: OpenCode core business logic & server.
-  - `packages/opencode/src/cli/cmd/tui/`: The TUI code, written in SolidJS with [opentui](https://github.com/sst/opentui)
-  - `packages/app`: The shared web UI components, written in SolidJS
-  - `packages/desktop`: The native desktop app, built with Electron (wraps `packages/app`)
-  - `packages/plugin`: Source for `@opencode-ai/plugin`
+Follow the repository [style guide](./AGENTS.md).
 
-### Understanding bun dev vs opencode
+## Pull Requests
 
-During development, `bun dev` is the local equivalent of the built `opencode` command. Both run the same CLI interface:
+### Link Issues When Required
 
-```bash
-# Development (from project root)
-bun dev --help           # Show all available commands
-bun dev serve            # Start headless API server
-bun dev web              # Start server + open web interface
-bun dev <directory>      # Start TUI in specific directory
+Bug fixes, chores, and tests must reference an existing issue. Documentation, refactor, and feature PRs are exempt from the automated linked-issue check. When required, use `Fixes #123` or `Closes #123` in the PR description.
 
-# Production
-opencode --help          # Show all available commands
-opencode serve           # Start headless API server
-opencode web             # Start server + open web interface
-opencode <directory>     # Start TUI in specific directory
-```
+Before implementing new functionality, open a feature request describing the problem, why it belongs in OpenCode, and your proposed approach if you have one. Wait for design approval before opening the implementation PR.
 
-### Running the API Server
+Base branches on `v2`, not `dev`, and complete the provided pull request template.
 
-To start the OpenCode headless API server:
+### Keep It Focused
 
-```bash
-bun dev serve
-```
+- Keep PRs small and focused.
+- Explain the problem and why the change fixes it.
+- Check whether the functionality already exists.
+- For UI changes, include before-and-after screenshots or video.
+- For logic changes, explain what you tested and how a reviewer can verify it.
 
-This starts the headless server on port 4096 by default. You can specify a different port:
+### Keep It Brief
 
-```bash
-bun dev serve --port 8080
-```
+Long, AI-generated PR descriptions and issues may be ignored. Write a short explanation in your own words. If the change cannot be explained briefly, the PR may be too large.
 
-### Running the Web App
+### Use Conventional Titles
 
-To test UI changes during development:
-
-1. **First, start the OpenCode server** (see [Running the API Server](#running-the-api-server) section above)
-2. **Then run the web app:**
-
-```bash
-bun run --cwd packages/app dev
-```
-
-This starts a local dev server at http://localhost:5173 (or similar port shown in output). Most UI changes can be tested here, but the server must be running for full functionality.
-
-### Running the Desktop App
-
-The desktop app is an Electron application that wraps the web UI.
-
-To run the desktop app in development:
-
-```bash
-bun run --cwd packages/desktop dev
-```
-
-To create a production build and package the app:
-
-```bash
-bun run --cwd packages/desktop build
-bun run --cwd packages/desktop package
-```
-
-> [!NOTE]
-> If you make changes to the API or SDK (e.g. `packages/opencode/src/server/server.ts`), run `./script/generate.ts` to regenerate the SDK and related files.
-
-Please try to follow the [style guide](./AGENTS.md)
-
-### Setting up a Debugger
-
-Bun debugging is currently rough around the edges. We hope this guide helps you get set up and avoid some pain points.
-
-The most reliable way to debug OpenCode is to run it manually in a terminal via `bun run --inspect=<url> dev ...` and attach
-your debugger via that URL. Other methods can result in breakpoints being mapped incorrectly, at least in VSCode (YMMV).
-
-Caveats:
-
-- If you want to run the OpenCode TUI and have breakpoints triggered in the server code, you might need to run `bun dev spawn` instead of
-  the usual `bun dev`. This is because `bun dev` runs the server in a worker thread and breakpoints might not work there.
-- If `spawn` does not work for you, you can debug the server separately:
-  - Debug server: `bun run --inspect=ws://localhost:6499/ --cwd packages/opencode ./src/index.ts serve --port 4096`,
-    then attach TUI with `opencode attach http://localhost:4096`
-  - Debug TUI: `bun run --inspect=ws://localhost:6499/ --cwd packages/opencode --conditions=browser ./src/index.ts`
-
-Other tips and tricks:
-
-- You might want to use `--inspect-wait` or `--inspect-brk` instead of `--inspect`, depending on your workflow
-- Specifying `--inspect=ws://localhost:6499/` on every invocation can be tiresome, you may want to `export BUN_OPTIONS=--inspect=ws://localhost:6499/` instead
-
-#### VSCode Setup
-
-If you use VSCode, you can use our example configurations [.vscode/settings.example.json](.vscode/settings.example.json) and [.vscode/launch.example.json](.vscode/launch.example.json).
-
-Some debug methods that can be problematic:
-
-- Debug configurations with `"request": "launch"` can have breakpoints incorrectly mapped and thus unusable
-- The same problem arises when running OpenCode in the VSCode `JavaScript Debug Terminal`
-
-With that said, you may want to try these methods, as they might work for you.
-
-## Pull Request Expectations
-
-### Issue First Policy
-
-**All PRs must reference an existing issue.** Before opening a PR, open an issue describing the bug or feature. This helps maintainers triage and prevents duplicate work. PRs without a linked issue may be closed without review.
-
-- Use `Fixes #123` or `Closes #123` in your PR description to link the issue
-- For small fixes, a brief issue is fine - just enough context for maintainers to understand the problem
-
-### General Requirements
-
-- Keep pull requests small and focused
-- Explain the issue and why your change fixes it
-- Before adding new functionality, ensure it doesn't already exist elsewhere in the codebase
-
-### UI Changes
-
-If your PR includes UI changes, please include screenshots or videos showing the before and after. This helps maintainers review faster and gives you quicker feedback.
-
-### Logic Changes
-
-For non-UI changes (bug fixes, new features, refactors), explain **how you verified it works**:
-
-- What did you test?
-- How can a reviewer reproduce/confirm the fix?
-
-### No AI-Generated Walls of Text
-
-Long, AI-generated PR descriptions and issues are not acceptable and may be ignored. Respect the maintainers' time:
-
-- Write short, focused descriptions
-- Explain what changed and why in your own words
-- If you can't explain it briefly, your PR might be too large
-
-### PR Titles
-
-PR titles should follow conventional commit standards:
-
-- `feat:` new feature or functionality
-- `fix:` bug fix
-- `docs:` documentation or README changes
-- `chore:` maintenance tasks, dependency updates, etc.
-- `refactor:` code refactoring without changing behavior
-- `test:` adding or updating tests
-
-You can optionally include a scope to indicate which package is affected:
-
-- `feat(app):` feature in the app package
-- `fix(desktop):` bug fix in the desktop package
-- `chore(opencode):` maintenance in the opencode package
+Use `type(scope): summary`. Supported types are `feat`, `fix`, `docs`, `chore`, `refactor`, and `test`. The scope is optional.
 
 Examples:
 
-- `docs: update contributing guidelines`
-- `fix: resolve crash on startup`
-- `feat: add dark mode support`
-- `feat(app): add dark mode support`
-- `fix(desktop): resolve crash on startup`
-- `chore: bump dependency versions`
+- `docs: update contributing guide`
+- `fix(tui): restore scroll position`
+- `feat(app): add workspace search`
 
-### Style Preferences
+## Issues
 
-These are not strictly enforced, they are just general guidelines:
+Bug reports and feature requests must use their issue templates. Blank issues are not allowed; ask support and how-to questions in the [Discord community](https://discord.gg/opencode).
 
-- **Functions:** Keep logic within a single function unless breaking it out adds clear reuse or composition benefits.
-- **Destructuring:** Do not do unnecessary destructuring of variables.
-- **Control flow:** Avoid `else` statements.
-- **Error handling:** Prefer `.catch(...)` instead of `try`/`catch` when possible.
-- **Types:** Reach for precise types and avoid `any`.
-- **Variables:** Stick to immutable patterns and avoid `let`.
-- **Naming:** Choose concise single-word identifiers when they remain descriptive.
-- **Runtime APIs:** Use Bun helpers such as `Bun.file()` when they fit the use case.
-
-## Feature Requests
-
-For net-new functionality, start with a design conversation. Open an issue describing the problem, your proposed approach (optional), and why it belongs in OpenCode. The core team will help decide whether it should move forward; please wait for that approval instead of opening a feature PR directly.
-
-## Trust & Vouch System
-
-This project uses [vouch](https://github.com/mitchellh/vouch) to manage contributor trust. The vouch list is maintained in [`.github/VOUCHED.td`](.github/VOUCHED.td).
-
-### How it works
-
-- **Vouched users** are explicitly trusted contributors.
-- **Denounced users** are explicitly blocked. Issues and pull requests from denounced users are automatically closed. If you have been denounced, you can request to be unvouched by reaching out to a maintainer on [Discord](https://opencode.ai/discord)
-- **Everyone else** can participate normally — you don't need to be vouched to open issues or PRs.
-
-### For maintainers
-
-Collaborators with write access can manage the vouch list by commenting on any issue:
-
-- `vouch` — vouch for the issue author
-- `vouch @username` — vouch for a specific user
-- `denounce` — denounce the issue author
-- `denounce @username` — denounce a specific user
-- `denounce @username <reason>` — denounce with a reason
-- `unvouch` / `unvouch @username` — remove someone from the list
-
-Changes are committed automatically to `.github/VOUCHED.td`.
-
-### Denouncement policy
-
-Denouncement is reserved for users who repeatedly submit low-quality AI-generated contributions, spam, or otherwise act in bad faith. It is not used for disagreements or honest mistakes.
-
-## Issue Requirements
-
-All issues **must** use one of our issue templates:
-
-- **Bug report** — for reporting bugs (requires a description)
-- **Feature request** — for suggesting enhancements (requires verification checkbox and description)
-- **Question** — for asking questions (requires the question)
-
-Blank issues are not allowed. When a new issue is opened, an automated check verifies that it follows a template and meets our contributing guidelines. If an issue doesn't meet the requirements, you'll receive a comment explaining what needs to be fixed and have **2 hours** to edit the issue. After that, it will be automatically closed.
-
-Issues may be flagged for:
-
-- Not using a template
-- Required fields left empty or filled with placeholder text
-- AI-generated walls of text
-- Missing meaningful content
-
-If you believe your issue was incorrectly flagged, let a maintainer know.
+Automated checks flag missing templates, placeholder text, AI-generated walls of text, and missing meaningful content. You have two hours to correct a flagged issue before it closes automatically. Ask a maintainer if an issue was flagged incorrectly.

docs/design/service-lifecycle.md

@@ -1,685 +0,0 @@
-# Service Lifecycle: Election, Restart, and Reconnect
-
-Status: in progress
-
-Incident: [#36688](https://github.com/anomalyco/opencode/issues/36688)
-
-## Summary
-
-The managed V2 service keeps its current update policy: the background updater
-may install a new package, but only a freshly launched TUI activates that update
-after finding an older running service. Existing TUIs never replace a service;
-they only reconnect.
-
-The restart path changes in three places:
-
-1. A process-held OS lock, not the HTTP port or registration file, elects
-   exactly one server owner for its lifetime.
-2. The elected process binds and registers a minimal lifecycle surface before
-   it initializes the application, so clients can distinguish a slow winner
-   from an absent server.
-3. TUIs rediscover and reconnect indefinitely. Transport loss is never a
-   terminal error by itself.
-
-Several clients may spawn small contenders during a restart. This is safe and
-intentional: one contender acquires the lock and initializes, while every loser
-exits before expensive server boot. The design does not require clients to
-agree on a single initiator.
-
-This proposal does not introduce a supervisor process, warm candidate server,
-protocol negotiation, idle background restart, or general execution-recovery
-framework.
-
-## Architecture at a Glance
-
-```text
-                       ╭───────────────────╮
-                       │ CLI ServiceConfig │
-                       ╰─────────┬─────────╯
-                                 │
-                                 ▼
-                     ╭──────────────────────╮
-                     │ CLI ServerConnection │
-                     ╰───────────┬──────────╯
-              ╭──────────────────╰───────────────────╮
-              ▼                                      ▼
-╭──────────────────────────╮            ╭─────────────────────────╮
-│ Client Service lifecycle │            │ CLI runPromiseWith seam │
-╰─────────────┬────────────╯            ╰─────────────┬───────────╯
-              ╰─────╮                                 │
-                    ▼                                 ▼
-     ╭────────────────────────────╮            ╭─────────────╮
-     │ Background service process │            │ TUI / Solid │
-     ╰──────────────┬─────────────╯            ╰──────┬──────╯
-                    │                                 │
-                    ╰────────────◀────────────────────╯
-                     ╭───────────────────────╮
-                     │ Server HTTP transport │
-                     ╰───────────┬───────────╯
-                                 │
-                                 ▼
-                       ╭──────────────────╮
-                       │ Core application │
-                       ╰──────────────────╯
-```
-
-| Owner                                            | Responsibility                                                                                      |
-| ------------------------------------------------ | --------------------------------------------------------------------------------------------------- |
-| `packages/client/src/effect/service.ts`          | Effect-native discovery, start, and stop lifecycle operations                                       |
-| `packages/cli/src/services/service-config.ts`    | CLI registration path, installed version, and daemon command                                        |
-| `packages/cli/src/services/server-connection.ts` | Resolve an endpoint and, only for the shared service, grouped reconnect and restart Effects         |
-| `packages/cli/src/server-process.ts`             | Daemon election, registration, and server process boot                                              |
-| `packages/server/src/process.ts`                 | HTTP lifecycle shell and application transport                                                      |
-| `packages/core`                                  | Application behavior behind the transport                                                           |
-| CLI default handler                              | Convert lifecycle Effects with the outer `FileSystem` context and pass grouped Promise capabilities |
-| `packages/tui` Solid client context              | Own event-stream reconnect, endpoint replacement, status, and user-triggered restart UI             |
-
-## Implementation Status
-
-| Area                      | State                                                                 |
-| ------------------------- | --------------------------------------------------------------------- |
-| Lifetime ownership        | Implemented on this branch with a scoped OS lock                      |
-| Contender behavior        | Implemented; losers exit before the server module is imported         |
-| Registration repair       | Implemented; the owner reasserts deleted or corrupt discovery         |
-| Channel isolation         | Implemented with no-clobber migration for legacy preview discovery    |
-| Client startup waiting    | Implemented; slow winners are not killed and waiting is indefinite    |
-| Lifecycle shell           | Implemented; the owner binds and registers before application boot    |
-| Failed-state latching     | Implemented; deterministic boot failure stays bound and actionable    |
-| Recovery diagnostics      | Implemented; the TUI shows status instead of transport internals      |
-| Cross-platform validation | macOS runtime verified; Linux and Windows run in the unit-test matrix |
-
-## Context
-
-The V2 CLI runs a shared managed service that owns Sessions, location graphs,
-plugins, permissions, and tool execution. The service updater can replace the
-installed package while the current process continues running the old image.
-A later TUI launch then detects the version mismatch and replaces the service.
-
-Incident #36688 showed four failures in that replacement path:
-
-- Multiple TUIs spawned heavyweight server contenders.
-- A winner remained unobservable while it cold-booted, so another wave treated
-  it as absent and displaced it.
-- A fresh TUI exhausted its reconnect budget and crashed with an unhandled
-  transport defect.
-- A losing contender remained alive and consumed about 1 GB of RSS.
-
-The `origin/v2` baseline serializes service startup with `EffectFlock`. A
-contender acquires a three-second heartbeat lease, checks whether another
-service became discoverable, and only the winner crosses the application-boot
-boundary. This already prevents simultaneous heavy boots and makes startup
-losers exit.
-
-The lease is released immediately after registration, however, so it is not
-lifetime ownership. Registration then reverts to last-writer-wins authority: a
-deleted or corrupt registration can admit a second boot, a displaced server
-terminates itself through its 10-second registration self-check, and a stalled
-lease holder can be displaced after the three-second service staleness timeout.
-
-`Flock` and `EffectFlock` live in `packages/core/src/util` and are also used for
-config writes, MCP auth, npm installs, and repository caching. Despite the
-name, the primitive is an atomic-mkdir lease with heartbeat and staleness
-takeover, not an OS-held lock. It remains appropriate for bounded critical
-sections, including today's startup fence, but is not lifetime service
-ownership.
-
-The current implementation also mixes three different concepts:
-
-- **Ownership:** which process is allowed to be the managed server.
-- **Discovery:** where clients can reach that process.
-- **Lifecycle:** whether that process is starting, ready, stopping, or failed.
-
-This design gives each concept one authority.
-
-```definitions
-[
-  {
-    "term": "Owner",
-    "definition": "The one process holding the process-held OS service lock."
-  },
-  {
-    "term": "Contender",
-    "definition": "A small serve process attempting to acquire the service lock. It must not initialize the application before winning."
-  },
-  {
-    "term": "Registration",
-    "definition": "An atomic discovery record containing the elected owner's identity and endpoint. Registration never grants ownership."
-  },
-  {
-    "term": "Lifecycle shell",
-    "definition": "The minimal HTTP surface bound by the elected process before application initialization. It serves health and retryable startup responses."
-  },
-  {
-    "term": "Application",
-    "definition": "The full server routes and global or location-scoped modules used for normal OpenCode work."
-  }
-]
-```
-
-## Goals
-
-- At most one process initializes and serves the managed application.
-- Losing contenders exit before database, route, plugin, MCP, or location boot.
-- A slow winner becomes observable before expensive initialization.
-- Existing and freshly launched TUIs survive retryable service unavailability.
-- Reconnect follows service state instead of displaying retry counts or raw
-  transport failures.
-- Version-mismatch replacement remains triggered by a fresh TUI launch.
-- A stale or malformed registration cannot create a second owner.
-- An unresponsive owner is never killed automatically by an arbitrary TUI.
-- Every spawned contender has a bounded path to ownership or exit.
-
-## Non-goals
-
-- Restarting automatically when a background update finds an idle window.
-- Running old and candidate application servers concurrently.
-- Adding a permanent steward, proxy, or supervisor process.
-- Zero-downtime worker handoff or automatic rollback.
-- Application protocol negotiation or automatic TUI self-restart.
-- General hard-crash recovery for active Sessions.
-- Defining recovery semantics for provider attempts, tools, shells, sub-agents,
-  permissions, questions, or background jobs.
-- Automatically killing a frozen owner.
-- Bounding concurrent location cold boots after clients reconnect.
-- Multi-machine or clustered service placement.
-
-## Invariants
-
-1. **The service lock is ownership.** Exactly one process may hold the OS lock
-   for one installation channel and service profile.
-2. **Ownership precedes boot.** A contender performs no expensive application
-   initialization before it acquires the lock.
-3. **Ownership lasts for the process lifetime.** The owner holds an open lock
-   handle until the managed server exits. The OS releases it on process death
-   without a cleanup callback.
-4. **The port is transport, not election.** The owner may select a dynamic port
-   after acquiring the lock.
-5. **Registration is discovery, not election.** Deleting, corrupting, or
-   replacing registration does not invalidate a live owner's lock.
-6. **Only a fresh launch enforces package version.** Existing TUIs reconnect to
-   the current owner without initiating version replacement.
-7. **Transport loss is retryable.** It never terminates a TUI without a separate
-   diagnosed, non-retryable cause.
-8. **Clients do not kill an unresponsive owner automatically.** Destructive
-   recovery requires the explicit `service restart` command.
-9. **Lifecycle does not promise execution semantics.** Graceful replacement
-   invokes Session suspension and resumption hooks, but tool-level continuity
-   belongs to a separate design.
-
-## System Model
-
-```text
-╭───────────────────────╮                              ╭──────────────────────────────╮
-│ Fresh or existing TUI │                              │ Process-held OS service lock │
-╰───────────┬───────────╯                              ╰───────────────┬──────────────╯
-            ╰─────┬ normal requests  observe ───────────────────────╮  │
-                  │ discover               │                        ├──╯ authorizes one owner
-                  ▼                        │                        ▼
-        ╭───────────────────╮              │               ╭─────────────────╮
-        │ Registration file │              │               │ Lifecycle shell │
-        ╰───────────────────╯              │               ╰────────┬────────╯
-                                           │                        │
-                                           ├────────────────────────╯
-                                           ▼
-                               ╭──────────────────────╮
-                               │ OpenCode application │
-                               ╰──────────────────────╯
-```
-
-The lifecycle shell and application run in the same process. The distinction is
-initialization order and responsibility, not process topology.
-
-## Service Status
-
-The server reports one small status value:
-
-```typescript
-type ServiceStatus =
-  | {
-      type: "starting"
-    }
-  | {
-      type: "ready"
-    }
-  | {
-      type: "stopping"
-      targetVersion?: string
-    }
-  | {
-      type: "failed"
-      message: string
-      action: string
-    }
-```
-
-The client adds only the discovery states needed by callers:
-
-```typescript
-type Status = { type: "missing" } | { type: "unreachable" } | { type: "unresponsive" } | ServiceStatus
-```
-
-The health response retains the existing fields for old clients and adds the
-status discriminant:
-
-```typescript
-type ServiceHealth = {
-  healthy: true
-  version: string
-  pid: number
-  instanceID: string
-  status: ServiceStatus
-}
-```
-
-`healthy: true` means the registered lifecycle shell is responding and its
-identity matches registration. New clients use `status.type === "ready"` as
-the application-readiness signal.
-
-During `starting` or `stopping`, application requests are not held in memory.
-They receive an immediate retryable response:
-
-```http
-HTTP/1.1 503 Service Unavailable
-Retry-After: 1
-Content-Type: application/json
-
-```
-
-`stopping` uses `service_stopping`. A failed application boot uses
-`service_failed` and includes a safe diagnostic message.
-
-A failed owner remains bound and keeps holding the service lock. Exiting on
-failure would let every waiting client's `ensureRunning` loop elect a new
-contender that repeats the same heavy failing boot, so staying bound turns a
-deterministic boot failure into one observable `failed` state instead of a
-client-driven respawn loop. Recovery still works: a fresh launch observes the
-failed instance through the stop path, and explicit `service restart` replaces
-it.
-
-## Registration Contract
-
-Registration contains only discovery identity:
-
-```typescript
-type ServiceRegistration = {
-  schema: 1
-  instanceID: string
-  version: string
-  url: string
-  pid: number
-}
-```
-
-Authentication continues to use the existing private service credential
-storage. The registration schema does not change that policy.
-
-The owner writes registration only after the lifecycle shell has bound:
-
-1. Bind the lifecycle shell.
-2. Write a temporary registration file with mode `0600`.
-3. Atomically rename it over the old registration.
-4. Serve lifecycle health as `starting`.
-
-On shutdown, the owner removes registration only if the current file still has
-its `instanceID`. An old finalizer can never remove a successor's registration.
-
-While running, the owner periodically asserts its registration. Because the
-lock guarantees exactly one live owner, any registration that does not name the
-owner is stale or corrupt, and the owner rewrites it. A deleted or clobbered
-registration therefore heals within one assertion interval instead of leaving
-clients waiting on absent discovery. This inverts today's self-check loop,
-which terminates the displaced process instead of repairing discovery.
-
-Legacy registration shapes are decoded by a compatibility adapter. The new
-domain type does not make fields optional to represent old formats.
-
-## Election
-
-This design promotes today's startup fence into lifetime ownership.
-Last-writer-wins registration is replaced by a process-held OS lock that is
-acquired before any expensive boot work and held for the entire service
-lifetime.
-
-A heartbeat-and-staleness lease, including the existing `Flock` utility, is not
-sufficient for service ownership: the service configures a three-second stale
-timeout, after which its lock can be broken and recreated. An event-loop stall,
-a suspended machine, or a debugger pause can therefore make a live owner appear
-stale and allow a contender to displace it. Service ownership requires a
-process-held OS lock: `flock` on Unix and an exclusively bound named pipe on
-Windows. It cannot be broken because a heartbeat exceeded a timeout. Process
-death releases the lock through the OS.
-
-Neither Bun nor Node exposes `flock` directly, the existing `Flock` utility is
-an mkdir-plus-heartbeat lease rather than an OS-held lock, and the common
-lockfile packages are staleness-based leases as well. The platform layer uses
-`bun:ffi` to call `flock` on POSIX and Node's named-pipe server support on
-Windows, where Bun FFI is not available on every shipped architecture. It lives
-alongside the existing utility in `packages/core/src/util`. This primitive is
-the foundation of the design, so the delivery sequence spikes it first.
-
-```text
-Contender           Lock            Lifecycle              Application
-    │                 │                 │                       │
-    ├─ try acquire ───▶                 │                       │
-    │                 │                 │                       │
- ╭─ alt: lock held ────────────────────────────────────────────────╮
- │  │                 │                 │                       │  │
- │  ◀─ busy ──────────┤                 │                       │  │
- │  │                 │                 │                       │  │
- │  ├─────────╮       │                 │                       │  │
- │  │ exit    │       │                 │                       │  │
- │  ◀─────────╯       │                 │                       │  │
- │  │                 │                 │                       │  │
- ├─ else: lock acquired ───────────────────────────────────────────┤
- │  │                 │                 │                       │  │
- │  ◀─ owner ─────────┤                 │                       │  │
- │  │                 │                 │                       │  │
- │  ├─ bind, register, starting ────────▶                       │  │
- │  │                 │                 │                       │  │
- │  ├─ initialize ──────────────────────────────────────────────▶  │
- │  │                 │                 │                       │  │
- │╭─ alt: boot succeeds ──────────────────────────────────────────╮│
- ││ │                 │                 │                       │ ││
- ││ │                 │                 ◀─ ready ───────────────┤ ││
- ││ │                 │                 │                       │ ││
- │├─ else: boot fails ────────────────────────────────────────────┤│
- ││ │                 │                 │                       │ ││
- ││ │                 │                 ◀─ failed, stay bound ──┤ ││
- ││ │                 │                 │                       │ ││
- │╰───────────────────────────────────────────────────────────────╯│
- │  │                 │                 │                       │  │
- ╰─────────────────────────────────────────────────────────────────╯
-    │                 │                 │                       │
-```
-
-Lock acquisition by a contender is nonblocking or tightly bounded. A loser
-must exit before constructing application routes or importing startup-heavy
-modules.
-
-Several clients may spawn contenders concurrently. The design guarantees one
-heavy winner, not one process spawn. If the winner crashes during startup, the
-OS releases the lock and a later client retry starts another election.
-
-The lock is scoped by installation channel and service profile. Local, preview,
-and stable installations cannot displace one another.
-
-## Update Activation
-
-Background update behavior remains unchanged:
-
-1. The running service checks for an update.
-2. The updater installs the package in the background.
-3. The running process continues using its existing process image.
-4. No idle check or automatic restart occurs.
-
-A fresh TUI launch activates the installed update:
-
-1. Read registration and authenticate the responding service.
-2. If its package version matches the fresh client, attach normally.
-3. If the version differs, request graceful stop of that exact registered
-   instance using the existing authenticated stop path.
-4. Re-check instance identity before every signal or escalation in that path.
-5. Wait for the old process to exit and release the service lock.
-6. Call `ensureRunning` until a compatible service becomes ready.
-
-Concurrent fresh launchers may all observe the same old instance. Stopping that
-exact instance must be idempotent. Once registration names a different instance,
-a stale launcher stops signaling and returns to discovery.
-
-No durable restart-transition record is introduced. The initiating fresh TUI
-already knows the source and target versions and can display its update
-preflight. Existing TUIs may display `Updating...` if they observed `stopping`;
-otherwise `Waiting for background service...` is the honest fallback.
-
-## Fresh Launch Versus Reconnect
-
-Fresh launch and reconnect deliberately have different version policies:
-
-```typescript
-type ManagedConnection =
-  | {
-      type: "launch"
-      requiredVersion: string
-    }
-  | {
-      type: "reconnect"
-    }
-```
-
-- `launch` requires the installed package version and may activate replacement.
-- `reconnect` accepts the current owner and never activates replacement.
-
-This preserves today's permissive reconnect behavior. Explicit application
-protocol negotiation and automatic TUI re-exec remain follow-ups.
-
-## Client Reconnect
-
-Fresh and existing TUIs use the same status loop after startup:
-
-1. Read registration on every attempt. Do not retry a stale URL indefinitely.
-2. If registration is absent, call `ensureRunning` and continue waiting.
-3. If registration is unreachable, call `ensureRunning`. A live owner prevents
-   contenders from acquiring the lock; a dead owner does not.
-4. If status is `starting` or `stopping`, wait.
-5. If status is `failed`, show its actionable message.
-6. If status is `ready`, rebuild HTTP and event-stream clients for the new
-   endpoint and perform authoritative state reconciliation.
-
-Retry cadence is internal policy. Retry counts are telemetry, not user-facing
-state. The TUI waits until the service is ready or the user exits.
-
-Transport failures are handled at the TUI run boundary. A raw client transport
-error or Effect defect must not escape to the terminal. Hard exit is reserved
-for diagnosed causes such as invalid local configuration, failed authentication,
-or a foreign process occupying an explicitly configured port.
-
-The UI derives text from status:
-
-| Status                   | User-facing state                   |
-| ------------------------ | ----------------------------------- |
-| No registration          | `Starting background service...`    |
-| Registration unreachable | `Waiting for background service...` |
-| `starting`               | `Starting OpenCode vX...`           |
-| `stopping`               | `Updating to vX...`                 |
-| `failed`                 | Actionable failure message          |
-| `ready`                  | Normal TUI                          |
-
-## Graceful Session Continuity
-
-Version-mismatch replacement uses the existing graceful Session suspension and
-resumption hooks:
-
-1. The old server snapshots active Session IDs during graceful teardown.
-2. The successor schedules those Sessions for continuation.
-3. The runner reloads durable Session history before continuing.
-
-This lifecycle design does not define what an interrupted physical provider
-attempt or tool invocation means. It does not promise that external side effects
-did not occur, replay the exact interrupted tool, preserve an in-memory form, or
-recover process-local background work.
-
-Those concerns require a separate execution-continuity design covering tools,
-shells, sub-agents, permissions, questions, provider attempts, and hard-crash
-recovery.
-
-## Unresponsive Owner
-
-An unreachable registration does not prove that the owner is dead. A contender
-attempts the service lock:
-
-- If the lock is free, the contender starts a replacement.
-- If the lock is held, the contender exits and the client keeps waiting.
-
-After a bounded diagnostic threshold, the client may show:
-
-```text
-The background service owns the service lock but is not responding.
-Run `opencode service restart` to recover it.
-```
-
-Only explicit `service restart` may perform destructive recovery. It verifies
-the complete registration and process instance before signaling, waits for
-graceful exit, re-checks identity before escalation, and refuses to kill a
-process it cannot positively identify.
-
-Automatic frozen-owner recovery is deferred.
-
-## Failure Walkthroughs
-
-### Update with open TUIs
-
-1. The old service installs vNext but keeps running.
-2. A fresh vNext TUI finds the healthy vOld service and requests graceful stop.
-3. The old service reports `stopping`, suspends active Sessions, and exits.
-4. Open TUIs enter their indefinite status loops.
-5. One or more clients spawn contenders.
-6. One contender acquires the service lock. Losers exit before heavy boot.
-7. The winner binds and registers the lifecycle shell as `starting`.
-8. Clients stop spawning and wait on the observable winner.
-9. The winner initializes the application and reports `ready`.
-10. TUIs rebuild clients, reconcile state, and resume.
-
-### Server crashes while ready
-
-1. The endpoint becomes unreachable and registration may remain stale.
-2. Clients call `ensureRunning`.
-3. Process death has released the service lock.
-4. One contender wins, replaces registration, and starts normally.
-5. Detailed active-execution recovery is outside this design.
-
-### Winner crashes during startup
-
-1. Clients observed `starting` and remain alive.
-2. Process death releases the service lock.
-3. A later reconnect attempt starts another election.
-4. One new contender wins; all other contenders exit.
-
-### Registration is deleted while the owner is healthy
-
-1. Clients may call `ensureRunning` because discovery is absent.
-2. Every contender fails to acquire the owner's lock and exits.
-3. No second application initializes.
-4. The owner's next registration assertion republishes discovery.
-
-### Owner is alive but unresponsive
-
-1. Health fails, but the process still holds the service lock.
-2. Contenders fail lock acquisition and exit.
-3. Clients wait and eventually show explicit recovery guidance.
-4. No TUI kills the owner automatically.
-
-## TDD Verification
-
-Implementation should proceed test-first with real subprocesses and real locks.
-Mocks cannot establish process death, lock release, loser cleanup, or port
-behavior.
-
-### Election tests
-
-| Scenario                                              | Required result                                         |
-| ----------------------------------------------------- | ------------------------------------------------------- |
-| Ten contenders start simultaneously                   | Exactly one crosses the application-boot boundary       |
-| Winner pauses after lock acquisition                  | No loser initializes or remains alive                   |
-| Winner event loop pauses beyond the old stale timeout | Ownership is not displaced                              |
-| Winner crashes before bind                            | Lock releases; a later attempt wins                     |
-| Winner crashes after bind but before registration     | Lock releases; a later attempt replaces stale discovery |
-| Registration is deleted while owner runs              | No second owner initializes                             |
-| Registration is malformed                             | Lock still prevents a second owner                      |
-| Registration names a dead PID                         | New contender can acquire the released lock             |
-| Two installation channels start                       | Each elects an independent owner                        |
-| Explicit configured port is foreign-owned             | Fail diagnostically; do not kill the foreign process    |
-
-The fixture records a marker immediately before application initialization. The
-tests assert that only one process writes that marker and that every loser exits
-within a bounded interval. The harness should also assert that a loser's peak
-RSS stays an order of magnitude below an application boot, since import weight
-was the observed incident cost.
-
-### Lifecycle tests
-
-| Scenario                                        | Required result                                                  |
-| ----------------------------------------------- | ---------------------------------------------------------------- |
-| Winner owns lock but application boot is paused | Health reports `starting`                                        |
-| Application request arrives during startup      | Immediate retryable `503`                                        |
-| Application becomes ready                       | Status changes once from `starting` to `ready`                   |
-| Graceful replacement begins                     | Status reports `stopping` before disconnect                      |
-| Application initialization fails                | Actionable `failed` status; owner stays bound and holds the lock |
-| Registration is deleted while owner runs        | Owner republishes it within one assertion interval               |
-| Owner exits                                     | Registration is removed only if it still names that owner        |
-
-### Update tests
-
-| Scenario                               | Required result                                          |
-| -------------------------------------- | -------------------------------------------------------- |
-| Background update installs vNext       | Running vOld service does not restart                    |
-| Fresh vNext launch finds vOld          | Exact old instance stops; vNext eventually becomes ready |
-| Two fresh vNext launches race          | One heavy successor; both clients attach                 |
-| Existing vOld TUI reconnects to vNext  | It never requests replacement                            |
-| Stale launcher observes a new instance | It does not signal the new instance                      |
-
-### Reconnect tests
-
-| Scenario                                            | Required result                                    |
-| --------------------------------------------------- | -------------------------------------------------- |
-| Endpoint disappears and changes port                | TUI rediscovers and rebuilds clients               |
-| Service remains unavailable beyond old retry budget | TUI remains alive                                  |
-| Event stream reconnects                             | Client performs authoritative state reconciliation |
-| Transport returns an unexpected defect              | TUI formats it; no raw stack escapes               |
-| Owner remains unresponsive                          | TUI waits and shows explicit restart guidance      |
-
-## Delivery Sequence
-
-1. **Spike the lock primitive.** Prove a nonblocking, process-held OS lock
-   under Bun on macOS, Linux, and Windows (`bun:ffi` to `flock` on POSIX and a
-   named pipe on Windows), including release on hard kill and behavior across
-   containers and network filesystems used in CI.
-2. **Expand the subprocess test harness.** Begin from the baseline
-   two-contender test and cover ten contenders, lock release on crash, a paused
-   winner, deleted or corrupt registration, and bounded loser exit before
-   changing ownership.
-3. **Contain client failure.** Make transport loss nonterminal, rediscover on
-   every cycle, and format unexpected failures at the TUI boundary.
-4. **Promote the startup fence to process-held ownership.** Preserve the
-   existing pre-boot acquisition seam, replace its lease with the OS lock, hold
-   it until process exit, and invert the registration self-check from
-   self-termination to reassertion.
-5. **Bind the lifecycle shell first.** Publish registration and `starting`,
-   return retryable `503` for application requests, then initialize the app.
-   The health contract change is public API: regenerate clients from
-   `packages/client` with `bun run generate`.
-6. **Codify launch versus reconnect.** Fresh launch enforces installed version;
-   reconnect never activates replacement.
-7. **Integrate graceful replacement.** Preserve current background-install and
-   fresh-launch activation behavior while invoking Session continuity hooks.
-8. **Harden explicit recovery.** Verify exact process identity during explicit
-   `service restart`; never automatically kill an unresponsive owner.
-9. **Run the full multi-process suite.** Include repeated restart cycles and
-   assert that no contender or child process remains afterward.
-
-## Acceptance Criteria
-
-- Ten concurrent restart observers produce one application initialization.
-- No losing contender survives or builds a location graph.
-- A 30-second application boot remains continuously observable as `starting`.
-- A TUI remains alive through a service outage longer than the previous retry
-  budget.
-- A service endpoint change does not require restarting an existing TUI.
-- Background installation alone does not restart the service.
-- A fresh mismatched TUI eventually attaches to the installed service version.
-- Existing reconnecting TUIs never replace the current owner.
-- Registration corruption cannot produce two owners.
-- A deleted registration heals without restarting the owner or any client.
-- An unresponsive owner is not killed without an explicit recovery command.
-- Raw transport defects never escape to the terminal.
-
-## Follow-ups
-
-- Idle background update activation with an admission fence.
-- Application protocol compatibility and automatic local TUI re-exec.
-- Durable execution recovery for provider attempts and tools.
-- Shell, sub-agent, permission, question, and background-job continuity.
-- Automatic recovery for a positively identified frozen owner.
-- Cold-boot concurrency limits and interaction-prioritized location loading.
-- A steward or socket-handoff architecture if zero-downtime replacement becomes
-  a real requirement.
-  a real requirement.

docs/design/v1-v2-database-migration.md

@@ -1,118 +0,0 @@
-# V1 to V2 Database Migration
-
-## Approach
-
-- Use the `dev` branch database schema and migration registry as the V1 baseline.
-- Remove migrations that exist only on the V2 branch.
-- Generate one canonical migration from the `dev` schema to the final V2 schema.
-- Add explicit data operations to that migration where generated DDL is insufficient.
-- Test the migration against a populated database at the exact `dev` schema.
-
-## Preserve
-
-The canonical V1 data remains in its existing tables. In particular, preserve `session`, `message`, and `part` rows.
-
-Preserve `workspace` rows and existing `session.workspace_id` values unchanged. The migration must not clear or rebuild
-workspace relationships.
-
-Keep the `todo` table and its data unchanged. V2 does not currently migrate todos into another representation, and the
-generated migration must not drop the table.
-
-## Truncate
-
-Truncate these pre-launch V2 tables before applying schema changes:
-
-- `event`
-- `event_sequence`
-- `session_message`
-
-These rows are not canonical V1 data. Truncating `event` before adding the required `event.created` column means the
-column needs neither a backfill nor a default. After truncation, rebuild `session_message` from canonical V1 `message`
-and `part` rows rather than retaining its pre-launch V2 contents.
-
-## Message Backfill
-
-Backfill canonical V1 history from `message` and `part` into `session_message`. This is the main data transformation in
-the migration. Preserving the V1 tables alone keeps the data safe but does not make existing history visible through the
-V2 session APIs, which read `session_message`.
-
-Reuse each V1 `message.id` as the corresponding `session_message.id`. Stable IDs keep the migration deterministic and
-avoid rewriting other persisted state that may refer to a message.
-
-Within each session, order V1 messages by `time_created` and then `id`, matching the existing V1 message index. Assign
-contiguous `session_message.seq` values starting at `0`.
-
-Map ordinary V1 messages one-to-one by role. Each ordinary V1 user message becomes one V2 `user` row, and each ordinary
-V1 assistant message becomes one V2 `assistant` row. Fold the source message's ordered V1 parts into that row's V2
-payload.
-
-Handle semantic marker parts before applying the ordinary mapping. In particular, a V1 user message containing a
-`compaction` part and its paired assistant summary represent one compaction operation, not two ordinary messages. Special
-part mappings must be decided explicitly before implementing the backfill.
-
-V1 synthetic content is represented by user text parts with `synthetic: true`, not by a separate message role. A V1 user
-message whose visible text parts are all synthetic should become a V2 `synthetic` message. If a V1 user message mixes
-ordinary and synthetic content, preserve the ordinary content in the V2 `user` row and emit the synthetic content as an
-adjacent V2 `synthetic` row. Ignore text parts marked `ignored`, matching V1 model-history behavior.
-
-Use the V1 compaction user message ID as the ID of the collapsed V2 compaction message. This matches V2's use of the
-admitted compaction input ID and preserves references to the initiating message.
-
-For a completed compaction, create one V2 `compaction` row with `status: "completed"`. Set `reason` from the V1
-compaction part's `auto` flag, join the paired summary assistant's nonempty text parts with blank lines for `summary`, and
-serialize the retained V1 tail beginning at `tail_start_id` for `recent`. Use an empty `recent` value when no tail was
-retained, and use the compaction user message creation time. Do not emit the paired summary assistant as a separate V2
-assistant row.
-
-After rebuilding `session_message`, seed `event_sequence` with one row per migrated session. Set its watermark to that
-session's maximum backfilled `session_message.seq`. This prevents new V2 events from reusing sequence numbers or sorting
-before migrated history. The `event` table remains empty.
-
-## Drop
-
-Drop these pre-launch V2 tables without preserving or transforming their rows:
-
-- `session_input`
-- `session_context_epoch`
-
-Do not transfer `session_input` rows into `session_pending`.
-
-## Create Empty
-
-Let the generated migration create these tables empty:
-
-- `instruction_blob`
-- `instruction_entry`
-- `instruction_state`
-- `session_pending`
-- `kv`
-
-V1 has no canonical data to backfill into these tables. V2 initializes their state as it runs.
-
-## Fork Storage
-
-V1 has no fork-boundary state to backfill. New V2 forks use a required message boundary and persist it in
-`session.fork_boundary`. The durable fork event contains no parent sequence. Its resolved boundary is one of:
-
-- `before`: copy messages before the identified message.
-- `through`: copy messages through the identified message.
-
-Forking an empty session is not supported. `session.fork_seq` and `session.fork_message_id` are not part of the final V2
-schema.
-
-New nullable session columns, including `fork_session_id`, `fork_boundary`, and `time_suspended`, require no explicit
-backfill. Existing rows naturally receive `NULL` when the generated migration adds the columns.
-
-## Verification
-
-The canonical migration test should seed representative V1 sessions, messages, parts, todos, projects, accounts,
-credentials, permissions, shares, and workspaces. After migration, it should verify:
-
-- Preserved rows and encoded values remain unchanged.
-- Todo rows remain available in the unchanged `todo` table.
-- `event` is empty, and stale pre-launch rows are absent from the rebuilt projections.
-- Backfilled `session_message` rows represent the canonical V1 `message` and `part` history.
-- Each migrated session's `event_sequence` watermark matches its maximum backfilled message sequence.
-- Dropped tables no longer exist.
-- New tables exist and are empty.
-- The final schema has no ungenerated changes.

infra/console.ts

@@ -288,8 +288,12 @@ new sst.cloudflare.x.SolidStart("Console", {
     server: {
       placement: { region: "aws:us-east-2" },
       transform: {
-        worker: {
-          tailConsumers: [{ service: logProcessor.nodes.worker.scriptName }],
+        worker: (args) => {
+          args.compatibilityFlags = $resolve(args.compatibilityFlags).apply((flags) => [
+            ...(flags ?? []),
+            "global_fetch_strictly_public",
+          ])
+          args.tailConsumers = [{ service: logProcessor.nodes.worker.scriptName }]
         },
       },
     },

install

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 set -euo pipefail
-APP=opencode
+APP=opencode2
 
 MUTED='\033[0;2m'
 RED='\033[0;31m'
@@ -15,14 +15,14 @@ Usage: install.sh [options]
 
 Options:
     -h, --help              Display this help message
-    -v, --version <version> Install a specific version (e.g., 1.0.180)
+    -v, --version <version> Install a specific version (e.g., 0.0.0-next-17236)
     -b, --binary <path>     Install from a local binary instead of downloading
         --no-modify-path    Don't modify shell config files (.zshrc, .bashrc, etc.)
 
 Examples:
-    curl -fsSL https://opencode.ai/install | bash
-    curl -fsSL https://opencode.ai/install | bash -s -- --version 1.0.180
-    ./install --binary /path/to/opencode
+    curl -fsSL https://raw.githubusercontent.com/anomalyco/opencode/v2/install | bash
+    curl -fsSL https://raw.githubusercontent.com/anomalyco/opencode/v2/install | bash -s -- --version 0.0.0-next-17236
+    ./install --binary /path/to/opencode2
 EOF
 }
 
@@ -109,11 +109,6 @@ else
         ;;
     esac
 
-    archive_ext=".zip"
-    if [ "$os" = "linux" ]; then
-      archive_ext=".tar.gz"
-    fi
-
     is_musl=false
     if [ "$os" = "linux" ]; then
       if [ -f /etc/alpine-release ]; then
@@ -165,42 +160,42 @@ else
       target="$target-musl"
     fi
 
-    filename="$APP-$target$archive_ext"
-
-
-    if [ "$os" = "linux" ]; then
-        if ! command -v tar >/dev/null 2>&1; then
-             echo -e "${RED}Error: 'tar' is required but not installed.${NC}"
-             exit 1
-        fi
-    else
-        if ! command -v unzip >/dev/null 2>&1; then
-            echo -e "${RED}Error: 'unzip' is required but not installed.${NC}"
-            exit 1
-        fi
+    if ! command -v tar >/dev/null 2>&1; then
+        echo -e "${RED}Error: 'tar' is required but not installed.${NC}"
+        exit 1
     fi
 
     if [ -z "$requested_version" ]; then
-        url="https://github.com/anomalyco/opencode/releases/latest/download/$filename"
-        specific_version=$(curl -s https://api.github.com/repos/anomalyco/opencode/releases/latest | sed -n 's/.*"tag_name": *"v\([^"]*\)".*/\1/p')
+        metadata=$(curl -fsSL https://registry.npmjs.org/@opencode-ai%2fcli/next || true)
+        specific_version=$(echo "$metadata" | sed -n 's/.*"version":"\([^"]*\)".*/\1/p')
 
-        if [[ $? -ne 0 || -z "$specific_version" ]]; then
+        if [ -z "$specific_version" ]; then
             echo -e "${RED}Failed to fetch version information${NC}"
             exit 1
         fi
     else
         # Strip leading 'v' if present
         requested_version="${requested_version#v}"
-        url="https://github.com/anomalyco/opencode/releases/download/v${requested_version}/$filename"
         specific_version=$requested_version
+    fi
 
-        # Verify the release exists before downloading
-        http_status=$(curl -sI -o /dev/null -w "%{http_code}" "https://github.com/anomalyco/opencode/releases/tag/v${requested_version}")
-        if [ "$http_status" = "404" ]; then
-            echo -e "${RED}Error: Release v${requested_version} not found${NC}"
-            echo -e "${MUTED}Available releases: https://github.com/anomalyco/opencode/releases${NC}"
-            exit 1
-        fi
+    package_name="@opencode-ai/cli-$target"
+    http_status=$(curl -s -o /dev/null -w "%{http_code}" "https://registry.npmjs.org/@opencode-ai%2fcli-$target/$specific_version" || true)
+    if [ "$http_status" = "404" ]; then
+        echo -e "${RED}Error: Version ${specific_version} is not available for $target${NC}"
+        echo -e "${MUTED}Available versions: https://www.npmjs.com/package/$package_name?activeTab=versions${NC}"
+        exit 1
+    fi
+    if [ "$http_status" != "200" ]; then
+        echo -e "${RED}Failed to fetch package information${NC}"
+        exit 1
+    fi
+
+    filename="cli-$target-$specific_version.tgz"
+    url="https://registry.npmjs.org/$package_name/-/$filename"
+    binary_name="$APP"
+    if [ "$os" = "windows" ]; then
+        binary_name="$APP.exe"
     fi
 fi
 
@@ -219,11 +214,13 @@ print_message() {
 }
 
 check_version() {
-    if command -v opencode >/dev/null 2>&1; then
-        opencode_path=$(which opencode)
+    if command -v "$APP" >/dev/null 2>&1; then
+        opencode_path=$(which "$APP")
 
         ## Check the installed version
-        installed_version=$(opencode --version 2>/dev/null || echo "")
+        installed_version=$("$APP" --version 2>/dev/null || echo "")
+        installed_version="${installed_version##* }"
+        installed_version="${installed_version#v}"
 
         if [[ "$installed_version" != "$specific_version" ]]; then
             print_message info "${MUTED}Installed version: ${NC}$installed_version."
@@ -287,7 +284,7 @@ download_with_progress() {
     trap "trap - RETURN; rm -f \"$tracefile\"; printf '\033[?25h' >&4; exec 4>&-" RETURN
 
     (
-        curl --trace-ascii "$tracefile" -s -L -o "$output" "$url"
+        curl --trace-ascii "$tracefile" -fsL -o "$output" "$url"
     ) &
     local curl_pid=$!
 
@@ -325,30 +322,25 @@ download_with_progress() {
 }
 
 download_and_install() {
-    print_message info "\n${MUTED}Installing ${NC}opencode ${MUTED}version: ${NC}$specific_version"
+    print_message info "\n${MUTED}Installing ${NC}$APP ${MUTED}version: ${NC}$specific_version"
     local tmp_dir="${TMPDIR:-/tmp}/opencode_install_$$"
     mkdir -p "$tmp_dir"
 
     if [[ "$os" == "windows" ]] || ! [ -t 2 ] || ! download_with_progress "$url" "$tmp_dir/$filename"; then
         # Fallback to standard curl on Windows, non-TTY environments, or if custom progress fails
-        curl -# -L -o "$tmp_dir/$filename" "$url"
+        curl -f -# -L -o "$tmp_dir/$filename" "$url"
     fi
 
-    if [ "$os" = "linux" ]; then
-        tar -xzf "$tmp_dir/$filename" -C "$tmp_dir"
-    else
-        unzip -q "$tmp_dir/$filename" -d "$tmp_dir"
-    fi
-
-    mv "$tmp_dir/opencode" "$INSTALL_DIR"
-    chmod 755 "${INSTALL_DIR}/opencode"
+    tar -xzf "$tmp_dir/$filename" -C "$tmp_dir"
+    mv "$tmp_dir/package/bin/$binary_name" "$INSTALL_DIR"
+    chmod 755 "${INSTALL_DIR}/$binary_name"
     rm -rf "$tmp_dir"
 }
 
 install_from_binary() {
-    print_message info "\n${MUTED}Installing ${NC}opencode ${MUTED}from: ${NC}$binary_path"
-    cp "$binary_path" "${INSTALL_DIR}/opencode"
-    chmod 755 "${INSTALL_DIR}/opencode"
+    print_message info "\n${MUTED}Installing ${NC}$APP ${MUTED}from: ${NC}$binary_path"
+    cp "$binary_path" "${INSTALL_DIR}/$APP"
+    chmod 755 "${INSTALL_DIR}/$APP"
 }
 
 if [ -n "$binary_path" ]; then
@@ -453,8 +445,8 @@ echo -e ""
 echo -e "${MUTED}OpenCode includes free models, to start:${NC}"
 echo -e ""
 echo -e "cd <project>  ${MUTED}# Open directory${NC}"
-echo -e "opencode      ${MUTED}# Run command${NC}"
+echo -e "opencode2     ${MUTED}# Run command${NC}"
 echo -e ""
-echo -e "${MUTED}For more information visit ${NC}https://opencode.ai/docs"
+echo -e "${MUTED}For more information visit ${NC}https://opencode.ai/v2/docs"
 echo -e ""
 echo -e ""

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-RFek0QoEEjsgbqmTE/SxQAmPtYyzs0IPR2ugFn5Okrs=",
-    "aarch64-linux": "sha256-BmAxapY1YrAFn7mVq3/6A9+6Au5UIvSqBboHMkyJH3I=",
-    "aarch64-darwin": "sha256-Sx3bGWQqLlgoa/RudJxanjSzhFRNklckT2ffnO2I5F4=",
-    "x86_64-darwin": "sha256-CMOhiisHNowg06qadvgg4K+60zrynglwiT0qKYQ4NiA="
+    "x86_64-linux": "sha256-uduwrM143NDSc+tXsi4lVVfoMll2a3BDHRUjuO7GB68=",
+    "aarch64-linux": "sha256-6DUda78XdXY6DP86lIUkweSjys3iG4Y4mo1PiaNuXbg=",
+    "aarch64-darwin": "sha256-AkJwfLULLZVwwz+XU1QcFUZoIS7oVPCn+n/MXEaxrqE=",
+    "x86_64-darwin": "sha256-hAxKGdiITTxQ2uujQt6prNjo3NxGAMMeo+9HlMWK6GU="
   }
 }

package.json

@@ -46,9 +46,9 @@
       "@octokit/rest": "22.0.0",
       "@hono/standard-validator": "0.2.0",
       "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.4.5",
-      "@opentui/keymap": "0.4.5",
-      "@opentui/solid": "0.4.5",
+      "@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",
@@ -78,7 +78,7 @@
       "fuzzysort": "3.1.0",
       "get-east-asian-width": "1.6.0",
       "luxon": "3.6.1",
-      "marked": "17.0.6",
+      "marked": "18.0.7",
       "marked-shiki": "1.2.1",
       "remend": "1.3.0",
       "@playwright/test": "1.59.1",
@@ -100,6 +100,7 @@
       "@sentry/solid": "10.36.0",
       "@sentry/vite-plugin": "4.6.0",
       "solid-js": "1.9.10",
+      "solid-sonner": "0.3.1",
       "vite-plugin-solid": "2.11.10",
       "@lydell/node-pty": "1.2.0-beta.12"
     }
@@ -119,7 +120,8 @@
     "prettier": "3.6.2",
     "semver": "^7.6.0",
     "sst": "catalog:",
-    "turbo": "2.10.2"
+    "turbo": "2.10.2",
+    "vitest": "4.1.10"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "3.933.0",
@@ -157,6 +159,8 @@
     "effect": "catalog:"
   },
   "patchedDependencies": {
+    "@ai-sdk/openai-compatible@2.0.41": "patches/@ai-sdk%2Fopenai-compatible@2.0.41.patch",
+    "@dnd-kit/dom@0.5.0": "patches/@dnd-kit%2Fdom@0.5.0.patch",
     "@npmcli/agent@4.0.2": "patches/@npmcli%2Fagent@4.0.2.patch",
     "@silvia-odwyer/photon-node@0.3.4": "patches/@silvia-odwyer%2Fphoton-node@0.3.4.patch",
     "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
@@ -168,6 +172,7 @@
     "@pierre/trees@1.0.0-beta.4": "patches/@pierre%2Ftrees@1.0.0-beta.4.patch",
     "@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"
+    "@tanstack/virtual-core@3.17.3": "patches/@tanstack%2Fvirtual-core@3.17.3.patch",
+    "@ff-labs/fff-bun@0.10.1": "patches/@ff-labs%2Ffff-bun@0.10.1.patch"
   }
 }

packages/ai/AGENTS.md

@@ -23,14 +23,9 @@ Per-type constructors live on the type, not as top-level re-exports. Use `Messag
 
 This package is an Effect Schema-first LLM core. The Schema classes in `src/schema/` are the canonical runtime data model. Convenience functions in `src/llm.ts` are thin constructors that return those same Schema class instances; they should improve callsites without creating a second model.
 
-Primary in-repo integration point:
+Session integration lives in `packages/core/src/session`: `runner/llm.ts` owns orchestration, `model-request.ts` lowers Session state into `LLMRequest`, and `model-transport.ts` selects transport behavior.
 
-- `packages/opencode/src/session/llm.ts` is the session-owned orchestration layer that decides whether a request uses AI SDK or this package's native route runtime.
-- `packages/opencode/src/session/llm/native-request.ts` is the lowering adapter from opencode's session/AI SDK-shaped data into this package's `LLMRequest` model.
-- `packages/opencode/src/session/llm/native-runtime.ts` is the execution adapter that calls raw `LLMClient.stream(request)` and bridges one provider turn of opencode tool calls through this package's typed dispatcher.
-- `packages/opencode/src/session/llm/ai-sdk.ts` keeps the default AI SDK path compatible by converting AI SDK stream parts into this package's shared `LLMEvent`s.
-
-Keep this package independent of session concerns. Session auth, permissions, plugins, telemetry headers, and runtime selection belong in `packages/opencode/src/session/llm.ts` and its local adapters.
+Keep this package independent of Session concerns. Session auth, permissions, plugins, telemetry headers, and runtime selection belong in Core.
 
 ### Request Flow
 
@@ -80,7 +75,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 +101,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 +119,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 +148,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`.
 
@@ -368,11 +367,12 @@ Other provider exports listed above remain direct facades until they explicitly
 
 ## Provider options & HTTP overlays
 
-Three escape hatches in order of stability:
+Request options in order of stability:
 
 1. **`generation`** — portable knobs (`maxTokens`, `temperature`, `topP`, `topK`, penalties, seed, stop).
-2. **`providerOptions: { <provider>: {...} }`** — typed-at-the-facade provider-specific knobs (OpenAI `promptCacheKey`, Anthropic `thinking`, Gemini `thinkingConfig`, OpenRouter routing).
-3. **`http: { body, headers, query }`** — last-resort serializable overlays merged into the final HTTP request. Reach for this only when a stable typed path doesn't yet exist.
+2. **`promptCacheKey`** — stable cache affinity lowered by every protocol that supports it.
+3. **`providerOptions: { <provider>: {...} }`** — typed-at-the-facade provider-specific knobs (OpenAI `store`, Anthropic `thinking`, Gemini `thinkingConfig`, OpenRouter routing).
+4. **`http: { body, headers, query }`** — last-resort serializable overlays merged into the final HTTP request. Reach for this only when a stable typed path doesn't yet exist.
 
 Route/provider defaults are overridden by request-level values for each axis.
 

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"
 
 /**
@@ -33,9 +33,10 @@ const model = OpenAI.configure({
 //
 //   - `generation`: common controls such as max tokens, temperature, topP/topK,
 //     penalties, seed, and stop sequences.
+//   - `promptCacheKey`: stable cache affinity for protocols that support it.
 //   - `providerOptions`: namespaced provider-native behavior. For example,
-//     OpenAI cache keys and store behavior, Anthropic thinking, Gemini thinking
-//     config, or OpenRouter routing/reasoning.
+//     OpenAI store behavior, Anthropic thinking, Gemini thinking config, or
+//     OpenRouter routing/reasoning.
 //   - `http`: last-resort serializable overlays for final request body, headers,
 //     and query params. Prefer typed `providerOptions` when a field is stable.
 //
@@ -45,9 +46,7 @@ const request = LLM.request({
   system: "You are concise and practical.",
   prompt: "Tell me a joke",
   generation: { maxTokens: 80, temperature: 0.7 },
-  providerOptions: {
-    openai: { promptCacheKey: "tutorial-joke" },
-  },
+  promptCacheKey: "tutorial-joke",
 })
 
 // 3. `generate` sends the request and collects the event stream into one
@@ -214,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
@@ -223,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/script/recording-cost-report.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises"
 import * as path from "node:path"
 
 const RECORDINGS_DIR = path.resolve(import.meta.dir, "..", "test", "fixtures", "recordings")
-const MODELS_DEV_URL = "https://models.dev/api.json"
+const MODELS_DEV_URL = "https://models.opencode.ai/api.json"
 
 type JsonRecord = Record<string, unknown>
 

packages/ai/src/cache-policy.ts

@@ -10,8 +10,8 @@
 //
 // Manual `cache: CacheHint` placements on individual parts are preserved and
 // count against the four-breakpoint budget; auto only fills remaining slots.
-import { CacheHint, type CachePolicy, type CachePolicyObject } from "./schema/options"
-import { LLMRequest, Message, ToolDefinition, type ContentPart } from "./schema/messages"
+import { CacheHint, type CachePolicy, type CachePolicyObject } from "./schema/options.js"
+import { LLMRequest, Message, ToolDefinition, type ContentPart } from "./schema/messages.js"
 
 const AUTO: CachePolicyObject = {
   tools: true,
@@ -133,7 +133,8 @@ const countHints = (request: LLMRequest) =>
 
 export const applyCachePolicy = (request: LLMRequest): LLMRequest => {
   if (!RESPECTS_INLINE_HINTS.has(request.model.route.id)) return request
-  if (request.model.route.id === "openrouter" && (request.cache === undefined || request.cache === "auto")) return request
+  if (request.model.route.id === "openrouter" && (request.cache === undefined || request.cache === "auto"))
+    return request
   const policy = resolve(request.cache)
   if (!policy.tools && !policy.system && !policy.messages) return request
 

packages/ai/src/image-client.ts

@@ -1,7 +1,7 @@
 import { Context, Effect, Layer } from "effect"
-import { RequestExecutor } from "./route/executor"
-import type { ImageOptions, ImageRequest, ImageRequestFor, ImageResponse } from "./image"
-import type { AIError } from "./schema"
+import { RequestExecutor } from "./route/executor.js"
+import type { ImageOptions, ImageRequest, ImageRequestFor, ImageResponse } from "./image.js"
+import type { AIError } from "./schema/index.js"
 
 export type Execute = RequestExecutor.Interface["execute"]
 

packages/ai/src/image.ts

@@ -1,6 +1,14 @@
 import { Effect, Schema } from "effect"
-import { HttpOptions, InvalidRequestReason, AIError, ModelID, ProviderID, ProviderMetadata, Usage } from "./schema"
-import { ImageClient, Service, type Execute as ImageExecute } from "./image-client"
+import {
+  HttpOptions,
+  InvalidRequestReason,
+  AIError,
+  ModelID,
+  ProviderID,
+  ProviderMetadata,
+  Usage,
+} from "./schema/index.js"
+import { ImageClient, Service, type Execute as ImageExecute } from "./image-client.js"
 
 export interface ImageRoute<Options extends ImageOptions = ImageOptions> {
   readonly id: string

packages/ai/src/index.ts

@@ -1,22 +1,22 @@
-export { LLMClient } from "./route/client"
-export { ImageClient } from "./image-client"
-export { Auth } from "./route/auth"
-export { Provider } from "./provider"
-export { ProviderPackage } from "./provider-package"
-export { isContextOverflow, isContextOverflowFailure } from "./provider-error"
+export { LLMClient } from "./route/client.js"
+export { ImageClient } from "./image-client.js"
+export { Auth } from "./route/auth.js"
+export { Provider } from "./provider.js"
+export { ProviderPackage } from "./provider-package.js"
+export { isContextOverflow, isContextOverflowFailure } from "./provider-error.js"
 export type {
   RouteLanguageModelInput,
   RouteRoutedLanguageModelInput,
   Interface as LLMClientShape,
   Service as LLMClientService,
-} from "./route/client"
-export * from "./schema"
-export { GeneratedImage, ImageInput, ImageInputSchema, ImageModel, ImageRequest, ImageResponse } from "./image"
-export type { ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute } from "./image"
-export { Image } from "./image"
-export { Tool, ToolFailure, toDefinitions } from "./tool"
-export { ToolRuntime } from "./tool-runtime"
-export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime"
+} from "./route/client.js"
+export * from "./schema/index.js"
+export { GeneratedImage, ImageInput, ImageInputSchema, ImageModel, ImageRequest, ImageResponse } from "./image.js"
+export type { ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute } from "./image.js"
+export { Image } from "./image.js"
+export { Tool, ToolFailure, toDefinitions } from "./tool.js"
+export { ToolRuntime } from "./tool-runtime.js"
+export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime.js"
 export type {
   AnyExecutableTool,
   AnyTool,
@@ -29,11 +29,14 @@ export type {
   Tools,
   ToolSchema,
   ToolToModelOutput,
-} from "./tool"
-export * as LLM from "./llm"
+} from "./tool.js"
+export * as LLM from "./llm.js"
 export type {
   Definition as ProviderDefinition,
   LanguageModelFactory as ProviderLanguageModelFactory,
   LanguageModelOptions as ProviderLanguageModelOptions,
-} from "./provider"
-export type { Definition as ProviderPackageDefinition, Settings as ProviderPackageSettings } from "./provider-package"
+} from "./provider.js"
+export type {
+  Definition as ProviderPackageDefinition,
+  Settings as ProviderPackageSettings,
+} from "./provider-package.js"

packages/ai/src/llm.ts

@@ -1,5 +1,5 @@
 import { Effect, JsonSchema, Schema } from "effect"
-import { LLMClient, Service } from "./route/client"
+import { LLMClient, Service } from "./route/client.js"
 import {
   GenerationOptions,
   HttpOptions,
@@ -15,8 +15,8 @@ import {
   ToolDefinition,
   type ContentPart,
   type LanguageModelProviderOptions,
-} from "./schema"
-import { make as makeTool, toDefinitions, type ToolSchema } from "./tool"
+} from "./schema/index.js"
+import { make as makeTool, toDefinitions, type ToolSchema } from "./tool.js"
 
 /** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */
 export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<

packages/ai/src/protocols.ts

@@ -1 +1 @@
-export * from "./protocols/index"
+export * from "./protocols/index.js"

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

@@ -1,10 +1,10 @@
 import { Effect, Schema } from "effect"
 import { Tool } from "@opencode-ai/schema/tool"
-import { Route } from "../route/client"
-import { Auth } from "../route/auth"
-import { Endpoint } from "../route/endpoint"
-import { Framing } from "../route/framing"
-import { Protocol } from "../route/protocol"
+import { Route } from "../route/client.js"
+import { Auth } from "../route/auth.js"
+import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
+import { Protocol } from "../route/protocol.js"
 import {
   AIError,
   LLMEvent,
@@ -21,13 +21,13 @@ import {
   type ToolCallPart,
   type ToolDefinition,
   type ToolResultPart,
-} from "../schema"
-import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared"
-import { classifyProviderFailure } from "../provider-error"
-import * as Cache from "./utils/cache"
-import { Lifecycle } from "./utils/lifecycle"
-import { ToolSchemaProjection } from "./utils/tool-schema"
-import { ToolStream } from "./utils/tool-stream"
+} from "../schema/index.js"
+import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
+import { classifyProviderFailure } from "../provider-error.js"
+import * as Cache from "./utils/cache.js"
+import { Lifecycle } from "./utils/lifecycle.js"
+import { ToolSchemaProjection } from "./utils/tool-schema.js"
+import { ToolStream } from "./utils/tool-stream.js"
 
 const ADAPTER = "anthropic-messages"
 const MEDIA_MIMES = new Set<string>([...ProviderShared.IMAGE_MIMES, ...ProviderShared.PDF_MIMES])
@@ -422,14 +422,12 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part: Me
 
 // Tool results may carry structured text, images, and documents. Keep media as provider-native
 // content instead of JSON-stringifying base64 into a prompt string.
-const lowerToolResultContentItem = Effect.fn("AnthropicMessages.lowerToolResultContentItem")(function* (
-  item: Tool.Content,
-) {
+const lowerToolResultContentItem = Effect.fnUntraced(function* (item: Tool.Content) {
   if (item.type === "text") return { type: "text" as const, text: item.text } satisfies AnthropicTextBlock
   return yield* lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name })
 })
 
-const lowerToolResultContent = Effect.fn("AnthropicMessages.lowerToolResultContent")(function* (part: ToolResultPart) {
+const lowerToolResultContent = Effect.fnUntraced(function* (part: ToolResultPart) {
   // Text / json / error results stay as a string for backward compatibility
   // with existing cassettes and provider expectations.
   if (part.result.type !== "content") return ProviderShared.toolResultText(part)
@@ -575,7 +573,10 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
         cache_control: cacheControl(breakpoints, part.cache),
       })
     }
-    messages.push({ role: "user", content })
+    const previous = messages.at(-1)
+    if (previous?.role === "user" && previous.content.every((block) => block.type === "tool_result"))
+      messages[messages.length - 1] = { role: "user", content: [...previous.content, ...content] }
+    else messages.push({ role: "user", content })
   }
 
   return messages
@@ -1031,4 +1032,4 @@ export const route = Route.make({
   headers: () => ({ "anthropic-version": "2023-06-01" }),
 })
 
-export * as AnthropicMessages from "./anthropic-messages"
+export * as AnthropicMessages from "./anthropic-messages.js"

packages/ai/src/protocols/bedrock-converse.ts

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect"
-import { Route } from "../route/client"
-import { Endpoint } from "../route/endpoint"
-import { Protocol } from "../route/protocol"
+import { Route } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { Protocol } from "../route/protocol.js"
 import {
   AIError,
   LLMEvent,
@@ -17,20 +17,20 @@ import {
   type ToolCallPart,
   type ToolDefinition,
   type ToolResultPart,
-} from "../schema"
-import { BedrockEventStream } from "./bedrock-event-stream"
-import { classifyProviderFailure } from "../provider-error"
-import { JsonObject, optionalArray, ProviderShared } from "./shared"
-import { BedrockAuth } from "./utils/bedrock-auth"
-import { BedrockCache } from "./utils/bedrock-cache"
-import { BedrockMedia } from "./utils/bedrock-media"
-import { Lifecycle } from "./utils/lifecycle"
-import { ToolSchemaProjection } from "./utils/tool-schema"
-import { ToolStream } from "./utils/tool-stream"
+} from "../schema/index.js"
+import { BedrockEventStream } from "./bedrock-event-stream.js"
+import { classifyProviderFailure } from "../provider-error.js"
+import { JsonObject, optionalArray, ProviderShared } from "./shared.js"
+import { BedrockAuth } from "./utils/bedrock-auth.js"
+import { BedrockCache } from "./utils/bedrock-cache.js"
+import { BedrockMedia } from "./utils/bedrock-media.js"
+import { Lifecycle } from "./utils/lifecycle.js"
+import { ToolSchemaProjection } from "./utils/tool-schema.js"
+import { ToolStream } from "./utils/tool-stream.js"
 
 const ADAPTER = "bedrock-converse"
 
-export type { Credentials as BedrockCredentials } from "./utils/bedrock-auth"
+export type { Credentials as BedrockCredentials } from "./utils/bedrock-auth.js"
 
 // =============================================================================
 // Request Body Schema
@@ -348,7 +348,10 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
           continue
         }
       }
-      messages.push({ role: "user", content })
+      const previous = messages.at(-1)
+      if (previous?.role === "user")
+        messages[messages.length - 1] = { role: "user", content: [...previous.content, ...content] }
+      else messages.push({ role: "user", content })
       continue
     }
 
@@ -392,7 +395,10 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
       const cachePoint = BedrockCache.block(breakpoints, part.cache)
       if (cachePoint) content.push(cachePoint)
     }
-    messages.push({ role: "user", content })
+    const previous = messages.at(-1)
+    if (previous?.role === "user")
+      messages[messages.length - 1] = { role: "user", content: [...previous.content, ...content] }
+    else messages.push({ role: "user", content })
   }
 
   return messages
@@ -731,4 +737,4 @@ export const route = Route.make({
 
 export const sigV4Auth = BedrockAuth.sigV4
 
-export * as BedrockConverse from "./bedrock-converse"
+export * as BedrockConverse from "./bedrock-converse.js"

packages/ai/src/protocols/bedrock-event-stream.ts

@@ -1,8 +1,8 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec"
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8"
 import { Effect, Stream } from "effect"
-import { Framing } from "../route/framing"
-import { ProviderShared } from "./shared"
+import { Framing } from "../route/framing.js"
+import { ProviderShared } from "./shared.js"
 
 // Bedrock streams responses using the AWS event stream binary protocol — each
 // frame is `[length:4][headers-length:4][prelude-crc:4][headers][payload][crc:4]`.
@@ -98,4 +98,4 @@ export const framing = (route: string): Framing.Definition<object> => ({
   frame: (bytes) => bytes.pipe(Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
 })
 
-export * as BedrockEventStream from "./bedrock-event-stream"
+export * as BedrockEventStream from "./bedrock-event-stream.js"

packages/ai/src/protocols/gemini.ts

@@ -1,10 +1,10 @@
 import { Effect, Schema } from "effect"
 import { Tool } from "@opencode-ai/schema/tool"
-import { Route } from "../route/client"
-import { Auth } from "../route/auth"
-import { Endpoint } from "../route/endpoint"
-import { Framing } from "../route/framing"
-import { Protocol } from "../route/protocol"
+import { Route } from "../route/client.js"
+import { Auth } from "../route/auth.js"
+import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
+import { Protocol } from "../route/protocol.js"
 import {
   LLMEvent,
   Usage,
@@ -17,16 +17,28 @@ import {
   type TextPart,
   type ToolCallPart,
   type ToolDefinition,
-} from "../schema"
-import { JsonObject, optionalArray, ProviderShared } from "./shared"
-import { GeminiToolSchema } from "./utils/gemini-tool-schema"
-import { Lifecycle } from "./utils/lifecycle"
-import { ToolSchemaProjection } from "./utils/tool-schema"
+} from "../schema/index.js"
+import { JsonObject, optionalArray, ProviderShared } from "./shared.js"
+import { GeminiToolSchema } from "./utils/gemini-tool-schema.js"
+import { Lifecycle } from "./utils/lifecycle.js"
+import { ToolSchemaProjection } from "./utils/tool-schema.js"
 
 const ADAPTER = "gemini"
 const MEDIA_MIMES = new Set<string>(ProviderShared.MEDIA_MIMES)
+// Google documents this sentinel for replaying Gemini 3 function calls after their original signature was lost.
+const SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator"
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
 
+// Gemini 3 rejects replayed function calls without a thought signature. Google's SDKs avoid that in normal chats by
+// retaining complete model responses, but OpenCode reconstructs durable history and may encounter an unsigned call
+// from an older or external session. Model IDs are open-ended, so unknown Gemini aliases inherit current behavior.
+const requiresThoughtSignatureFallback = (modelID: string) => {
+  if (!/(^|\/)gemini-/i.test(modelID)) return false
+  if (/(^|\/)gemini-(?:1|2)(?:[.-]|$)/i.test(modelID)) return false
+  if (/(^|\/)gemini-pro(?:-vision)?$/i.test(modelID)) return false
+  return !/(^|\/)gemini-robotics-er-1\.5(?:[.-]|$)/i.test(modelID)
+}
+
 export interface OptionsInput {
   readonly [key: string]: unknown
   readonly cachedContent?: string
@@ -145,6 +157,9 @@ const GeminiGenerationConfig = Schema.Struct({
   temperature: Schema.optional(Schema.Number),
   topP: Schema.optional(Schema.Number),
   topK: Schema.optional(Schema.Number),
+  frequencyPenalty: Schema.optional(Schema.Number),
+  presencePenalty: Schema.optional(Schema.Number),
+  seed: Schema.optional(Schema.Number),
   stopSequences: optionalArray(Schema.String),
   thinkingConfig: Schema.optional(GeminiThinkingConfig),
 })
@@ -202,11 +217,13 @@ interface ParserState {
 //    keys on non-object scalars. Mirrors OpenCode's historical Gemini rules.
 //
 // 2. Project — lossy mapping from JSON Schema to Gemini's schema dialect:
-//    drop empty objects, derive `nullable: true` from `type: [..., "null"]`,
-//    coerce `const` to `[const]` enum, recurse properties/items, propagate
+//    drop empty root parameter schemas while preserving nested empty objects,
+//    expand type arrays into `anyOf`, derive `nullable: true` from null members,
+//    coerce `const` to `[const]` enum, recurse properties/items, and propagate
 //    only an allowlisted set of keys (description, required, format, type,
-//    properties, items, allOf, anyOf, oneOf, minLength). Anything outside the
-//    allowlist (e.g. `additionalProperties`, `$ref`) is silently dropped.
+//    nullable, enum, properties, items, allOf, anyOf, oneOf, minLength).
+//    Anything outside the allowlist (e.g. `additionalProperties`, `$ref`) is
+//    silently dropped.
 //
 // Sanitize runs first, then project. The implementation lives in
 // `utils/gemini-tool-schema` so this protocol keeps the same shape as the other
@@ -282,6 +299,8 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
 
     if (message.role === "assistant") {
       const parts: Array<Schema.Schema.Type<typeof GeminiContentPart>> = []
+      // Parallel Gemini 3 calls may carry one signature on the first call; unsigned sibling calls are valid.
+      let hasSignedToolCall = false
       for (const part of message.content) {
         if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
           return yield* ProviderShared.unsupportedContent("Gemini", "assistant", ["text", "reasoning", "tool-call"])
@@ -294,7 +313,17 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
           continue
         }
         if (part.type === "tool-call") {
-          parts.push(lowerToolCall(part))
+          const lowered = lowerToolCall(part)
+          const signature = lowered.thoughtSignature
+          parts.push({
+            ...lowered,
+            thoughtSignature:
+              signature ??
+              (requiresThoughtSignatureFallback(request.model.id) && !hasSignedToolCall
+                ? SKIP_THOUGHT_SIGNATURE_VALIDATOR
+                : undefined),
+          })
+          if (signature !== undefined) hasSignedToolCall = true
           continue
         }
       }
@@ -388,6 +417,9 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
     temperature: generation?.temperature,
     topP: generation?.topP,
     topK: generation?.topK,
+    frequencyPenalty: generation?.frequencyPenalty,
+    presencePenalty: generation?.presencePenalty,
+    seed: generation?.seed,
     stopSequences: generation?.stop,
     thinkingConfig: options.thinkingConfig,
   }
@@ -444,6 +476,7 @@ const mapUsage = (usage: GeminiUsage | undefined) => {
 }
 
 const mapFinishReason = (finishReason: string | undefined, hasToolCalls: boolean): FinishReason => {
+  if (finishReason === undefined) return hasToolCalls ? "tool-calls" : "unknown"
   if (finishReason === "STOP") return hasToolCalls ? "tool-calls" : "stop"
   if (finishReason === "MAX_TOKENS") return "length"
   if (
@@ -610,4 +643,4 @@ export const route = Route.make({
   framing: Framing.sse,
 })
 
-export * as Gemini from "./gemini"
+export * as Gemini from "./gemini.js"

packages/ai/src/protocols/google-images.ts

@@ -7,8 +7,8 @@ import {
   type ImageInput,
   type ImageRequestFor,
   type ImageRoute,
-} from "../image"
-import { Auth, type Definition as AuthDefinition } from "../route/auth"
+} from "../image.js"
+import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
 import {
   InvalidProviderOutputReason,
   AIError,
@@ -17,9 +17,9 @@ import {
   mergeJsonRecords,
   type HttpOptions,
   type ProviderMetadata,
-} from "../schema"
-import { ProviderShared } from "./shared"
-import { ImageInputs } from "./utils/image-input"
+} from "../schema/index.js"
+import { ProviderShared } from "./shared.js"
+import { ImageInputs } from "./utils/image-input.js"
 
 const ADAPTER = "google-images"
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"

packages/ai/src/protocols/index.ts

@@ -1,9 +1,10 @@
-export * as AnthropicMessages from "./anthropic-messages"
-export * as BedrockConverse from "./bedrock-converse"
-export * as Gemini from "./gemini"
-export * as OpenAIChat from "./openai-chat"
-export * as OpenAIImages from "./openai-images"
-export * as OpenAICompatibleChat from "./openai-compatible-chat"
-export * as OpenAICompatibleResponses from "./openai-compatible-responses"
-export * as OpenAIResponses from "./openai-responses"
-export * as OpenResponses from "./open-responses"
+export * as AnthropicMessages from "./anthropic-messages.js"
+export * as BedrockConverse from "./bedrock-converse.js"
+export * as Gemini from "./gemini.js"
+export * as OpenAIChat from "./openai-chat.js"
+export * as OpenAIImages from "./openai-images.js"
+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

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect"
 import type { Content } from "@opencode-ai/schema/tool"
-import { HttpTransport } from "../route/transport"
-import { Protocol } from "../route/protocol"
+import { HttpTransport } from "../route/transport/index.js"
+import { Protocol } from "../route/protocol.js"
 import {
   AIError,
   LLMEvent,
@@ -16,13 +16,13 @@ import {
   type ToolCallPart,
   type ToolDefinition,
   type ToolResultPart,
-} from "../schema"
-import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared"
-import { classifyProviderFailure } from "../provider-error"
-import { OpenResponsesOptions } from "./utils/open-responses-options"
-import { Lifecycle } from "./utils/lifecycle"
-import { ToolSchemaProjection } from "./utils/tool-schema"
-import { ToolStream } from "./utils/tool-stream"
+} from "../schema/index.js"
+import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
+import { classifyProviderFailure } from "../provider-error.js"
+import { OpenResponsesOptions } from "./utils/open-responses-options.js"
+import { Lifecycle } from "./utils/lifecycle.js"
+import { ToolSchemaProjection } from "./utils/tool-schema.js"
+import { ToolStream } from "./utils/tool-stream.js"
 
 const ADAPTER = "open-responses"
 const NAME = "Open Responses"
@@ -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)],
 )
@@ -358,7 +393,7 @@ const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
   return { type: "input_image" as const, image_url: media.dataUrl }
 })
 
-const lowerUserContent = Effect.fn("OpenResponses.lowerUserContent")(function* (
+const lowerUserContent = Effect.fnUntraced(function* (
   part: LLMRequest["messages"][number]["content"][number],
   request: LLMRequest,
   extension: Extension,
@@ -370,7 +405,7 @@ const lowerUserContent = Effect.fn("OpenResponses.lowerUserContent")(function* (
 
 // Tool results may carry structured text, images, and files. Keep media as provider-native
 // content instead of JSON-stringifying base64 into a prompt string.
-const lowerToolResultContentItem = Effect.fn("OpenResponses.lowerToolResultContentItem")(function* (
+const lowerToolResultContentItem = Effect.fnUntraced(function* (
   item: Content,
   request: LLMRequest,
   extension: Extension,
@@ -383,7 +418,7 @@ const lowerToolResultContentItem = Effect.fn("OpenResponses.lowerToolResultConte
   )
 })
 
-const lowerToolResultOutput = Effect.fn("OpenResponses.lowerToolResultOutput")(function* (
+const lowerToolResultOutput = Effect.fnUntraced(function* (
   part: ToolResultPart,
   request: LLMRequest,
   extension: Extension,
@@ -539,7 +574,7 @@ const lowerOptions = (request: LLMRequest) => {
   return {
     ...(options.instructions ? { instructions: options.instructions } : {}),
     ...(options.store !== undefined ? { store: options.store } : {}),
-    ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),
+    ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
     ...(options.include ? { include: options.include } : {}),
     ...(options.reasoningEffort || options.reasoningSummary
       ? { reasoning: { effort: options.reasoningEffort, summary: options.reasoningSummary } }
@@ -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])
 }
 
@@ -1061,4 +1108,4 @@ export const protocol = Protocol.make({
 
 export const httpTransport = HttpTransport.sseJson.with<OpenResponsesBody>()
 
-export * as OpenResponses from "./open-responses"
+export * as OpenResponses from "./open-responses.js"

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

@@ -1,10 +1,10 @@
 import { Effect, Schema } from "effect"
 import { Tool } from "@opencode-ai/schema/tool"
-import { Route } from "../route/client"
-import { Auth } from "../route/auth"
-import { Endpoint } from "../route/endpoint"
-import { HttpTransport } from "../route/transport"
-import { Protocol } from "../route/protocol"
+import { Route } from "../route/client.js"
+import { Auth } from "../route/auth.js"
+import { Endpoint } from "../route/endpoint.js"
+import { HttpTransport } from "../route/transport/index.js"
+import { Protocol } from "../route/protocol.js"
 import {
   AIError,
   LLMEvent,
@@ -19,13 +19,13 @@ import {
   type TextPart,
   type ToolCallPart,
   type ToolDefinition,
-} from "../schema"
-import { classifyProviderFailure } from "../provider-error"
-import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared"
-import { OpenAIOptions } from "./utils/openai-options"
-import { Lifecycle } from "./utils/lifecycle"
-import { ToolSchemaProjection } from "./utils/tool-schema"
-import { ToolStream } from "./utils/tool-stream"
+} from "../schema/index.js"
+import { classifyProviderFailure } from "../provider-error.js"
+import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
+import { OpenAIOptions } from "./utils/openai-options.js"
+import { Lifecycle } from "./utils/lifecycle.js"
+import { ToolSchemaProjection } from "./utils/tool-schema.js"
+import { ToolStream } from "./utils/tool-stream.js"
 
 const ADAPTER = "openai-chat"
 const IMAGE_MIMES = new Set<string>(ProviderShared.IMAGE_MIMES)
@@ -67,6 +67,12 @@ const OpenAIChatAssistantToolCall = Schema.Struct({
 })
 type OpenAIChatAssistantToolCall = Schema.Schema.Type<typeof OpenAIChatAssistantToolCall>
 
+// Intentionally omit Gemini's provider-specific `extra_content.google.thought_signature`
+// extension until direct Google OpenAI-compatible routing is supported here:
+// https://github.com/vercel/ai/issues/11590
+// https://github.com/vercel/ai/pull/11745
+// https://ai.google.dev/gemini-api/docs/thought-signatures#openai
+
 const OpenAIChatUserContent = Schema.Union([
   Schema.Struct({
     type: Schema.Literal("text"),
@@ -126,6 +132,7 @@ export const bodyFields = {
   stream: Schema.Literal(true),
   stream_options: Schema.optional(Schema.Struct({ include_usage: Schema.Boolean })),
   store: Schema.optional(Schema.Boolean),
+  prompt_cache_key: Schema.optional(Schema.String),
   reasoning_effort: Schema.optional(OpenAIOptions.OpenAIReasoningEffort),
   max_completion_tokens: Schema.optional(Schema.Number),
   max_tokens: Schema.optional(Schema.Number),
@@ -145,22 +152,33 @@ export type OpenAIChatBody = Schema.Schema.Type<typeof OpenAIChatBody>
 // The event schema is one decoded SSE `data:` payload. `Framing.sse` splits the
 // byte stream into strings, then `Protocol.jsonEvent` decodes each string into
 // this provider-native event shape.
-const OpenAIChatUsage = Schema.Struct({
-  prompt_tokens: Schema.optional(Schema.Number),
-  completion_tokens: Schema.optional(Schema.Number),
-  total_tokens: Schema.optional(Schema.Number),
-  prompt_tokens_details: optionalNull(
-    Schema.Struct({
-      cached_tokens: Schema.optional(Schema.Number),
-      cache_write_tokens: Schema.optional(Schema.Number),
-    }),
-  ),
-  completion_tokens_details: optionalNull(
-    Schema.Struct({
-      reasoning_tokens: Schema.optional(Schema.Number),
-    }),
-  ),
-})
+const OpenAIChatUsage = Schema.StructWithRest(
+  Schema.Struct({
+    prompt_tokens: optionalNull(Schema.Number),
+    completion_tokens: optionalNull(Schema.Number),
+    total_tokens: optionalNull(Schema.Number),
+    prompt_tokens_details: optionalNull(
+      Schema.StructWithRest(
+        Schema.Struct({
+          cached_tokens: optionalNull(Schema.Number),
+          cache_write_tokens: optionalNull(Schema.Number),
+        }),
+        [Schema.Record(Schema.String, Schema.Unknown)],
+      ),
+    ),
+    completion_tokens_details: optionalNull(
+      Schema.StructWithRest(
+        Schema.Struct({
+          reasoning_tokens: optionalNull(Schema.Number),
+          accepted_prediction_tokens: optionalNull(Schema.Number),
+          rejected_prediction_tokens: optionalNull(Schema.Number),
+        }),
+        [Schema.Record(Schema.String, Schema.Unknown)],
+      ),
+    ),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
 
 const OpenAIChatToolCallDeltaFunction = Schema.Struct({
   name: optionalNull(Schema.String),
@@ -168,7 +186,7 @@ const OpenAIChatToolCallDeltaFunction = Schema.Struct({
 })
 
 const OpenAIChatToolCallDelta = Schema.Struct({
-  index: Schema.Number,
+  index: optionalNull(Schema.Number),
   id: optionalNull(Schema.String),
   function: optionalNull(OpenAIChatToolCallDeltaFunction),
 })
@@ -222,6 +240,8 @@ export interface ParserState {
   readonly reasoningDetails: Array<unknown>
   readonly reasoningDetailsObserved: boolean
   readonly reasoningEmitted: boolean
+  readonly latestToolIndex?: number
+  readonly nextToolIndex: number
 }
 
 // =============================================================================
@@ -351,12 +371,13 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
     return text
   })()
   const cached = message.content.findLast((part) => "cache" in part && part.cache !== undefined)
+  const cacheControl = options.cacheControl?.(cached && "cache" in cached ? cached.cache : undefined)
   const result = {
     role: "assistant" as const,
-    content: content.length === 0 ? null : ProviderShared.joinText(content),
-    tool_calls: toolCalls.length === 0 ? undefined : toolCalls,
-    reasoning_details: details,
-    cache_control: options.cacheControl?.(cached && "cache" in cached ? cached.cache : undefined),
+    content: content.length > 0 ? content.map((part) => part.text).join("") : toolCalls.length > 0 ? null : "",
+    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+    ...(details !== undefined ? { reasoning_details: details } : {}),
+    ...(cacheControl !== undefined ? { cache_control: cacheControl } : {}),
   }
   if (field === undefined || reasoningText === undefined) return result
   return { ...result, [field]: reasoningText }
@@ -490,6 +511,7 @@ const lowerOptions = (request: LLMRequest) => {
   const options = OpenAIOptions.resolve(request)
   return {
     ...(options.store !== undefined ? { store: options.store } : {}),
+    ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
     ...(options.reasoningEffort ? { reasoning_effort: options.reasoningEffort } : {}),
   }
 }
@@ -559,22 +581,34 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 // satisfied on both sides.
 const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
   if (!usage) return undefined
-  const cached = usage.prompt_tokens_details?.cached_tokens
-  const cacheWrite = usage.prompt_tokens_details?.cache_write_tokens
-  const reasoning = usage.completion_tokens_details?.reasoning_tokens
-  const nonCached = ProviderShared.subtractTokens(usage.prompt_tokens, ProviderShared.sumTokens(cached, cacheWrite))
+  const input = usage.prompt_tokens ?? undefined
+  const output = usage.completion_tokens ?? undefined
+  const cached = usage.prompt_tokens_details?.cached_tokens ?? undefined
+  const cacheWrite = usage.prompt_tokens_details?.cache_write_tokens ?? undefined
+  const reasoning = usage.completion_tokens_details?.reasoning_tokens ?? undefined
+  const nonCached = ProviderShared.subtractTokens(input, ProviderShared.sumTokens(cached, cacheWrite))
   return new Usage({
-    inputTokens: usage.prompt_tokens,
-    outputTokens: usage.completion_tokens,
+    inputTokens: input,
+    outputTokens: output,
     nonCachedInputTokens: nonCached,
     cacheReadInputTokens: cached,
     cacheWriteInputTokens: cacheWrite,
     reasoningTokens: reasoning,
-    totalTokens: ProviderShared.totalTokens(usage.prompt_tokens, usage.completion_tokens, usage.total_tokens),
+    totalTokens: ProviderShared.totalTokens(input, output, usage.total_tokens ?? undefined),
     providerMetadata: { openai: usage },
   })
 }
 
+const toolIndexByID = (
+  tools: ParserState["tools"],
+  pendingTools: ParserState["pendingTools"],
+  id: string | undefined,
+) => {
+  if (!id) return undefined
+  const entry = Object.entries({ ...pendingTools, ...tools }).find(([, tool]) => tool?.id === id)
+  return entry ? Number(entry[0]) : undefined
+}
+
 const reasoningDelta = (
   delta: Schema.Schema.Type<typeof OpenAIChatDelta> | null | undefined,
   configuredField?: string,
@@ -657,25 +691,39 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     const events: LLMEvent[] = []
     const usage = mapUsage(event.usage) ?? state.usage
     const choice = event.choices?.[0]
-    const finishReason = choice?.finish_reason
-      ? { normalized: mapFinishReason(choice.finish_reason), raw: choice.native_finish_reason ?? choice.finish_reason }
-      : state.finishReason
+    const rawFinishReason = choice?.finish_reason
+    const finishReason =
+      rawFinishReason !== undefined && rawFinishReason !== null
+        ? { normalized: mapFinishReason(rawFinishReason), raw: choice?.native_finish_reason ?? rawFinishReason }
+        : state.finishReason
     const delta = choice?.delta
     const toolDeltas = delta?.tool_calls ?? []
     let tools = state.tools
     let pendingTools = state.pendingTools
+    let latestToolIndex = state.latestToolIndex
+    let nextToolIndex = state.nextToolIndex
 
     let lifecycle = state.lifecycle
 
     const reasoning = reasoningDelta(delta, state.reasoningField)
-    const reasoningField = state.reasoningField ?? (!state.lifecycle.text.has("text-0") ? reasoning?.field : undefined)
+    const hasLateContent =
+      Boolean(delta?.content) ||
+      reasoning !== undefined ||
+      (Array.isArray(delta?.reasoning_details) && delta.reasoning_details.length > 0) ||
+      toolDeltas.some((tool) => Boolean(tool.id) || Boolean(tool.function?.name) || Boolean(tool.function?.arguments))
+    if (state.finishReason !== undefined) {
+      if (hasLateContent)
+        return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat received content after the finish reason")
+      return [{ ...state, usage }, events] as const
+    }
+
+    const reasoningField = state.reasoningField ?? reasoning?.field
     const detailDelta = Array.isArray(delta?.reasoning_details) ? delta.reasoning_details : undefined
     if (detailDelta !== undefined) appendReasoningDetails(state.reasoningDetails, detailDelta)
     const reasoningDetailsObserved = state.reasoningDetailsObserved || detailDelta !== undefined
     const deltaMetadata = reasoningMetadata(reasoningField)
     const text = detailDelta?.length ? (detailText(detailDelta) ?? reasoning?.text) : reasoning?.text
-    if (!state.lifecycle.text.has("text-0") && text !== undefined)
-      lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", text, deltaMetadata)
+    if (text !== undefined) lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", text, deltaMetadata)
     else if (
       reasoningDetailsObserved &&
       !lifecycle.reasoning.has("reasoning-0") &&
@@ -694,24 +742,36 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
       lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
     }
 
-    for (const tool of toolDeltas) {
-      const current = tools[tool.index]
-      const pending = pendingTools[tool.index]
+    // Compatible providers may omit indexes. Prefer durable identity, then use
+    // batch position for parallel deltas or the latest call for sparse chunks.
+    for (const [position, tool] of toolDeltas.entries()) {
+      const matched = toolIndexByID(tools, pendingTools, tool.id || undefined)
+      const fallback = toolDeltas.length > 1 ? position : (latestToolIndex ?? position)
+      const fallbackTool = tools[fallback] ?? pendingTools[fallback]
+      const index =
+        tool.index ?? matched ?? (tool.id && fallbackTool?.id && fallbackTool.id !== tool.id ? nextToolIndex : fallback)
+      const current = tools[index]
+      const pending = pendingTools[index]
       const id = current?.id ?? pending?.id ?? (tool.id || undefined)
       const name = current?.name ?? pending?.name ?? (tool.function?.name || undefined)
       const text = `${pending?.input ?? ""}${tool.function?.arguments ?? ""}`
+      latestToolIndex = index
+      nextToolIndex = Math.max(nextToolIndex, index + 1)
       if (!current && (!id || !name)) {
-        pendingTools = { ...pendingTools, [tool.index]: { id: id || undefined, name: name || undefined, input: text } }
+        pendingTools = {
+          ...pendingTools,
+          [index]: { id: id || undefined, name: name || undefined, input: text },
+        }
         continue
       }
       if (pending) {
         pendingTools = { ...pendingTools }
-        delete pendingTools[tool.index]
+        delete pendingTools[index]
       }
       const result = ToolStream.appendOrStart(
         ADAPTER,
         tools,
-        tool.index,
+        index,
         { id: id || undefined, name: name || undefined, text },
         "OpenAI Chat tool call delta is missing id or name",
       )
@@ -743,6 +803,8 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
         reasoningDetails: state.reasoningDetails,
         reasoningDetailsObserved,
         reasoningEmitted,
+        latestToolIndex,
+        nextToolIndex,
       },
       events,
     ] as const
@@ -750,14 +812,18 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
 
 const finishEvents = (state: ParserState): ReadonlyArray<LLMEvent> => {
   const events: LLMEvent[] = []
-  const hasToolCalls = state.toolCallEvents.length > 0
+  const toolCallEvents =
+    state.finishReason === undefined && Object.keys(state.tools).length > 0
+      ? Effect.runSync(ToolStream.finishAll(ADAPTER, state.tools)).events
+      : state.toolCallEvents
+  const hasToolCalls = toolCallEvents.length > 0
   const reason = state.finishReason
     ? {
         ...state.finishReason,
         normalized:
           state.finishReason.normalized === "stop" && hasToolCalls ? "tool-calls" : state.finishReason.normalized,
       }
-    : undefined
+    : { normalized: hasToolCalls ? ("tool-calls" as const) : ("unknown" as const) }
   const metadata = reasoningMetadata(
     state.reasoningField,
     state.reasoningDetailsObserved ? state.reasoningDetails : undefined,
@@ -767,9 +833,9 @@ const finishEvents = (state: ParserState): ReadonlyArray<LLMEvent> => {
       ? Lifecycle.reasoningStart(state.lifecycle, events, "reasoning-0", reasoningMetadata(state.reasoningField))
       : state.lifecycle
   const ended = Lifecycle.reasoningEnd(started, events, "reasoning-0", metadata)
-  const lifecycle = state.toolCallEvents.length ? Lifecycle.stepStart(ended, events) : ended
-  events.push(...state.toolCallEvents)
-  if (reason) Lifecycle.finish(lifecycle, events, { reason, usage: state.usage })
+  const lifecycle = toolCallEvents.length ? Lifecycle.stepStart(ended, events) : ended
+  events.push(...toolCallEvents)
+  Lifecycle.finish(lifecycle, events, { reason, usage: state.usage })
   return events
 }
 
@@ -799,6 +865,7 @@ export const protocol = Protocol.make({
       reasoningDetails: [],
       reasoningDetailsObserved: false,
       reasoningEmitted: false,
+      nextToolIndex: 0,
     }),
     step,
     onHalt: finishEvents,
@@ -817,4 +884,4 @@ export const route = Route.make({
   transport: httpTransport,
 })
 
-export * as OpenAIChat from "./openai-chat"
+export * as OpenAIChat from "./openai-chat.js"

packages/ai/src/protocols/openai-compatible-chat.ts

@@ -1,7 +1,7 @@
-import { Route, type RouteRoutedLanguageModelInput } from "../route/client"
-import { Endpoint } from "../route/endpoint"
-import { Framing } from "../route/framing"
-import * as OpenAIChat from "./openai-chat"
+import { Route, type RouteRoutedLanguageModelInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
+import * as OpenAIChat from "./openai-chat.js"
 
 const ADAPTER = "openai-compatible-chat"
 
@@ -22,4 +22,4 @@ export const route = Route.make({
   framing: Framing.sse,
 })
 
-export * as OpenAICompatibleChat from "./openai-compatible-chat"
+export * as OpenAICompatibleChat from "./openai-compatible-chat.js"

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

@@ -1,6 +1,6 @@
-import { Route, type RouteRoutedLanguageModelInput } from "../route/client"
-import { Endpoint } from "../route/endpoint"
-import { OpenResponses } from "./open-responses"
+import { Route, type RouteRoutedLanguageModelInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { OpenResponses } from "./open-responses.js"
 
 const ADAPTER = "openai-compatible-responses"
 
@@ -19,4 +19,4 @@ export const route = Route.make({
   transport: OpenResponses.httpTransport,
 })
 
-export * as OpenAICompatibleResponses from "./openai-compatible-responses"
+export * as OpenAICompatibleResponses from "./openai-compatible-responses.js"

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

@@ -7,8 +7,8 @@ import {
   type ImageInput,
   type ImageRequestFor,
   type ImageRoute,
-} from "../image"
-import { Auth, type Definition as AuthDefinition } from "../route/auth"
+} from "../image.js"
+import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
 import {
   InvalidProviderOutputReason,
   AIError,
@@ -16,10 +16,10 @@ import {
   mergeHttpOptions,
   mergeJsonRecords,
   type HttpOptions,
-} from "../schema"
-import { ProviderShared } from "./shared"
-import { ImageInputs } from "./utils/image-input"
-import { OpenAIImage } from "./utils/openai-image"
+} from "../schema/index.js"
+import { ProviderShared } from "./shared.js"
+import { ImageInputs } from "./utils/image-input.js"
+import { OpenAIImage } from "./utils/openai-image.js"
 
 const ADAPTER = "openai-images"
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"

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 { Route } from "../route/client"
-import { Auth } from "../route/auth"
-import { Endpoint } from "../route/endpoint"
-import { Protocol } from "../route/protocol"
-import { HttpTransport, WebSocketTransport } from "../route/transport"
-import { LLMEvent, LLMRequest, type JsonSchema, type ToolDefinition } from "../schema"
-import { OpenResponses } from "./open-responses"
-import { optionalArray, ProviderShared } from "./shared"
-import { Lifecycle } from "./utils/lifecycle"
-import { OpenAIImage } from "./utils/openai-image"
-import { ToolSchemaProjection } from "./utils/tool-schema"
+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 } 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,37 +259,8 @@ export const route = Route.make({
   protocol,
   endpoint,
   auth,
-  transport: httpTransport,
+  transport,
   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,
-  defaults: { providerOptions: { openai: { store: false } } },
-})
-
-export * as OpenAIResponses from "./openai-responses"
+export * as OpenAIResponses from "./openai-responses.js"

packages/ai/src/protocols/shared.ts

@@ -12,8 +12,8 @@ import {
   type MediaPart,
   type TextPart,
   type ToolResultPart,
-} from "../schema"
-import { isRecord } from "../utils/record"
+} from "../schema/index.js"
+import { isRecord } from "../utils/record.js"
 export { isRecord }
 
 export const Json = Schema.fromJsonString(Schema.Unknown)
@@ -324,4 +324,4 @@ export const jsonPost = (input: { readonly url: string; readonly body: string; r
     HttpClientRequest.bodyText(input.body, "application/json"),
   )
 
-export * as ProviderShared from "./shared"
+export * as ProviderShared from "./shared.js"

packages/ai/src/protocols/utils/bedrock-auth.ts

@@ -1,8 +1,8 @@
 import { AwsV4Signer } from "aws4fetch"
 import { Effect } from "effect"
 import { Headers } from "effect/unstable/http"
-import { Auth, type AuthInput } from "../../route/auth"
-import { ProviderShared } from "../shared"
+import { Auth, type AuthInput } from "../../route/auth.js"
+import { ProviderShared } from "../shared.js"
 
 /**
  * AWS credentials for SigV4 signing. Bedrock also supports Bearer API key auth,
@@ -74,4 +74,4 @@ export const sigV4 = (
 /** Bedrock route auth defaults to SigV4 and expects credentials from route configuration. */
 export const auth = sigV4(undefined)
 
-export * as BedrockAuth from "./bedrock-auth"
+export * as BedrockAuth from "./bedrock-auth.js"

packages/ai/src/protocols/utils/bedrock-cache.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect"
-import type { CacheHint } from "../../schema"
-import { newBreakpoints, ttlBucket, type Breakpoints } from "./cache"
+import type { CacheHint } from "../../schema/index.js"
+import { newBreakpoints, ttlBucket, type Breakpoints } from "./cache.js"
 
 // Bedrock cache markers are positional: emit a `cachePoint` block immediately
 // after the content the caller wants treated as a cacheable prefix. Bedrock
@@ -18,7 +18,7 @@ export type CachePointBlock = Schema.Schema.Type<typeof CachePointBlock>
 // budget is respected across `system`, `messages`, and `tools`.
 export const BEDROCK_BREAKPOINT_CAP = 4
 
-export type { Breakpoints } from "./cache"
+export type { Breakpoints } from "./cache.js"
 export const breakpoints = () => newBreakpoints(BEDROCK_BREAKPOINT_CAP)
 
 const DEFAULT_5M: CachePointBlock = { cachePoint: { type: "default" } }
@@ -34,4 +34,4 @@ export const block = (breakpoints: Breakpoints, cache: CacheHint | undefined): C
   return ttlBucket(cache.ttlSeconds) === "1h" ? DEFAULT_1H : DEFAULT_5M
 }
 
-export * as BedrockCache from "./bedrock-cache"
+export * as BedrockCache from "./bedrock-cache.js"

packages/ai/src/protocols/utils/bedrock-media.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect"
-import type { MediaPart } from "../../schema"
-import { ProviderShared } from "../shared"
+import type { MediaPart } from "../../schema/index.js"
+import { ProviderShared } from "../shared.js"
 
 // Bedrock Converse accepts image `format` as the file extension and
 // `source.bytes` as base64 in the JSON wire format.
@@ -89,4 +89,4 @@ export const lower = Effect.fn("BedrockMedia.lower")(function* (part: MediaPart)
   return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.mediaType}`)
 })
 
-export * as BedrockMedia from "./bedrock-media"
+export * as BedrockMedia from "./bedrock-media.js"

packages/ai/src/protocols/utils/gemini-tool-schema.ts

@@ -1,4 +1,4 @@
-import { isRecord } from "../../utils/record"
+import { isRecord } from "../../utils/record.js"
 
 // Gemini accepts a JSON Schema-like dialect for tool parameters, but rejects a
 // handful of common JSON Schema shapes. Keep this projection isolated so the
@@ -61,39 +61,59 @@ const emptyObjectSchema = (schema: Record<string, unknown>) =>
   (!isRecord(schema.properties) || Object.keys(schema.properties).length === 0) &&
   !schema.additionalProperties
 
-const projectNode = (schema: unknown): Record<string, unknown> | undefined => {
+const projectNode = (schema: unknown, nested = false): Record<string, unknown> | undefined => {
   if (!isRecord(schema)) return undefined
-  if (emptyObjectSchema(schema)) return undefined
-  return Object.fromEntries(
+  if (!nested && emptyObjectSchema(schema)) return undefined
+  const types = Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null") : undefined
+  const anyOf = Array.isArray(schema.anyOf) ? schema.anyOf : undefined
+  const hasNullAnyOf = anyOf?.some((item) => isRecord(item) && item.type === "null") ?? false
+  const anyOfTypes = hasNullAnyOf ? anyOf?.filter((item) => !isRecord(item) || item.type !== "null") : anyOf
+  const flattenedAnyOf = hasNullAnyOf && anyOfTypes?.length === 1 ? projectNode(anyOfTypes[0], true) : undefined
+  const result = Object.fromEntries(
     [
       ["description", schema.description],
       ["required", schema.required],
       ["format", schema.format],
-      ["type", Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null")[0] : schema.type],
-      ["nullable", Array.isArray(schema.type) && schema.type.includes("null") ? true : undefined],
+      ["type", types ? (types.length === 0 ? "null" : undefined) : schema.type],
+      [
+        "nullable",
+        (Array.isArray(schema.type) && schema.type.includes("null") && types && types.length > 0) || hasNullAnyOf
+          ? true
+          : undefined,
+      ],
       ["enum", schema.const !== undefined ? [schema.const] : schema.enum],
       [
         "properties",
         isRecord(schema.properties)
-          ? Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, projectNode(value)]))
+          ? Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, projectNode(value, true)]))
           : undefined,
       ],
       [
         "items",
         Array.isArray(schema.items)
-          ? schema.items.map(projectNode)
+          ? schema.items.map((item) => projectNode(item, true))
           : schema.items === undefined
             ? undefined
-            : projectNode(schema.items),
+            : projectNode(schema.items, true),
       ],
-      ["allOf", Array.isArray(schema.allOf) ? schema.allOf.map(projectNode) : undefined],
-      ["anyOf", Array.isArray(schema.anyOf) ? schema.anyOf.map(projectNode) : undefined],
-      ["oneOf", Array.isArray(schema.oneOf) ? schema.oneOf.map(projectNode) : undefined],
+      ["allOf", Array.isArray(schema.allOf) ? schema.allOf.map((item) => projectNode(item, true)) : undefined],
+      [
+        "anyOf",
+        anyOfTypes
+          ? hasNullAnyOf && anyOfTypes.length === 1
+            ? undefined
+            : anyOfTypes.map((item) => projectNode(item, true))
+          : types && types.length > 0
+            ? types.map((type) => ({ type }))
+            : undefined,
+      ],
+      ["oneOf", Array.isArray(schema.oneOf) ? schema.oneOf.map((item) => projectNode(item, true)) : undefined],
       ["minLength", schema.minLength],
     ].filter((entry) => entry[1] !== undefined),
   )
+  return flattenedAnyOf ? { ...result, ...flattenedAnyOf } : result
 }
 
 export const convert = (schema: unknown) => projectNode(sanitizeNode(schema))
 
-export * as GeminiToolSchema from "./gemini-tool-schema"
+export * as GeminiToolSchema from "./gemini-tool-schema.js"

packages/ai/src/protocols/utils/image-input.ts

@@ -1,6 +1,6 @@
 import { Effect, Encoding } from "effect"
-import type { ImageInput } from "../../image"
-import { InvalidRequestReason, AIError } from "../../schema"
+import type { ImageInput } from "../../image.js"
+import { InvalidRequestReason, AIError } from "../../schema/index.js"
 
 const invalid = (module: string, message: string) =>
   new AIError({

packages/ai/src/protocols/utils/lifecycle.ts

@@ -1,4 +1,4 @@
-import { LLMEvent, type FinishReasonDetails, type ProviderMetadata, type Usage } from "../../schema"
+import { LLMEvent, type FinishReasonDetails, type ProviderMetadata, type Usage } from "../../schema/index.js"
 
 export interface State {
   readonly stepStarted: boolean
@@ -102,4 +102,4 @@ export const finish = (
   return { ...stepped, stepStarted: false }
 }
 
-export * as Lifecycle from "./lifecycle"
+export * as Lifecycle from "./lifecycle.js"

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

@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { TextVerbosity, type LLMRequest } from "../../schema"
+import { TextVerbosity, type LLMRequest } from "../../schema/index.js"
 
 export const ResponseIncludables = [
   "file_search_call.results",
@@ -33,7 +33,6 @@ export const ServiceTierSchema = Schema.Literals(ServiceTiers)
 export interface Resolved {
   readonly instructions?: string
   readonly store?: boolean
-  readonly promptCacheKey?: string
   readonly reasoningEffort?: string
   readonly reasoningSummary?: "auto" | "concise" | "detailed"
   readonly include?: ReadonlyArray<ResponseIncludable>
@@ -50,7 +49,6 @@ export const resolve = (request: LLMRequest): Resolved => {
   return {
     instructions: typeof input?.instructions === "string" ? input.instructions : undefined,
     store: typeof input?.store === "boolean" ? input.store : undefined,
-    promptCacheKey: typeof input?.promptCacheKey === "string" ? input.promptCacheKey : undefined,
     reasoningEffort: typeof input?.reasoningEffort === "string" ? input.reasoningEffort : undefined,
     reasoningSummary:
       reasoningSummary === "auto" || reasoningSummary === "concise" || reasoningSummary === "detailed"
@@ -62,4 +60,4 @@ export const resolve = (request: LLMRequest): Resolved => {
   }
 }
 
-export * as OpenResponsesOptions from "./open-responses-options"
+export * as OpenResponsesOptions from "./open-responses-options.js"

packages/ai/src/protocols/utils/openai-options.ts

@@ -1,5 +1,5 @@
-import { ReasoningEfforts } from "../../schema"
-import { OpenResponsesOptions } from "./open-responses-options"
+import { ReasoningEfforts } from "../../schema/index.js"
+import { OpenResponsesOptions } from "./open-responses-options.js"
 
 export const OpenAIReasoningEfforts = ReasoningEfforts
 export type OpenAIReasoningEffort = string
@@ -20,4 +20,4 @@ export const isReasoningEffort = (effort: unknown): effort is OpenAIReasoningEff
 
 export const resolve = OpenResponsesOptions.resolve
 
-export * as OpenAIOptions from "./openai-options"
+export * as OpenAIOptions from "./openai-options.js"

packages/ai/src/protocols/utils/tool-schema.ts

@@ -1,6 +1,6 @@
-import type { JsonSchema, LanguageModelToolSchemaCompatibility } from "../../schema"
-import { isRecord } from "../../utils/record"
-import { GeminiToolSchema } from "./gemini-tool-schema"
+import type { JsonSchema, LanguageModelToolSchemaCompatibility } from "../../schema/index.js"
+import { isRecord } from "../../utils/record.js"
+import { GeminiToolSchema } from "./gemini-tool-schema.js"
 
 const removeNullSchemas = (value: unknown): unknown => {
   if (Array.isArray(value)) return value.map(removeNullSchemas)

packages/ai/src/protocols/utils/tool-stream.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect"
-import { AIError, LLMEvent, type ProviderMetadata, type ToolCall, type ToolInputError } from "../../schema"
-import { eventError, parseToolInput, type ToolAccumulator } from "../shared"
+import { AIError, LLMEvent, type ProviderMetadata, type ToolCall, type ToolInputError } from "../../schema/index.js"
+import { eventError, parseToolInput, type ToolAccumulator } from "../shared.js"
 
 type StreamKey = string | number
 
@@ -223,4 +223,4 @@ export const finishAll = <K extends StreamKey>(route: string, tools: State<K>) =
     }
   })
 
-export * as ToolStream from "./tool-stream"
+export * as ToolStream from "./tool-stream.js"

packages/ai/src/protocols/xai-images.ts

@@ -1,7 +1,7 @@
 import { Effect, Encoding, Schema } from "effect"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
-import { GeneratedImage, ImageModel, ImageResponse, type ImageRequestFor, type ImageRoute } from "../image"
-import { Auth, type Definition as AuthDefinition } from "../route/auth"
+import { GeneratedImage, ImageModel, ImageResponse, type ImageRequestFor, type ImageRoute } from "../image.js"
+import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
 import {
   InvalidProviderOutputReason,
   AIError,
@@ -9,9 +9,9 @@ import {
   mergeHttpOptions,
   mergeJsonRecords,
   type HttpOptions,
-} from "../schema"
-import { ProviderShared, optionalNull } from "./shared"
-import { ImageInputs } from "./utils/image-input"
+} from "../schema/index.js"
+import { ProviderShared, optionalNull } from "./shared.js"
+import { ImageInputs } from "./utils/image-input.js"
 
 const ADAPTER = "xai-images"
 export const DEFAULT_BASE_URL = "https://api.x.ai/v1"

packages/ai/src/protocols/zai-images.ts

@@ -1,10 +1,16 @@
 import { Effect, Schema } from "effect"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
-import { GeneratedImage, ImageModel, ImageResponse, type ImageRequestFor, type ImageRoute } from "../image"
-import { Auth, type Definition as AuthDefinition } from "../route/auth"
-import { InvalidProviderOutputReason, AIError, mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema"
-import { ProviderShared } from "./shared"
-import { ImageInputs } from "./utils/image-input"
+import { GeneratedImage, ImageModel, ImageResponse, type ImageRequestFor, type ImageRoute } from "../image.js"
+import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
+import {
+  InvalidProviderOutputReason,
+  AIError,
+  mergeHttpOptions,
+  mergeJsonRecords,
+  type HttpOptions,
+} from "../schema/index.js"
+import { ProviderShared } from "./shared.js"
+import { ImageInputs } from "./utils/image-input.js"
 
 const ADAPTER = "zai-images"
 export const DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4"

packages/ai/src/provider-error.ts

@@ -12,7 +12,7 @@ import {
   type HttpContext,
   type HttpRateLimitDetails,
   type ProviderMetadata,
-} from "./schema"
+} from "./schema/index.js"
 
 const patterns = [
   /prompt is too long/i,
@@ -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/provider-package.ts

@@ -1,4 +1,4 @@
-import type { LanguageModel, ProviderOptions } from "./schema"
+import type { LanguageModel, ProviderOptions } from "./schema/index.js"
 
 export interface Settings extends Readonly<Record<string, unknown>> {
   readonly baseURL?: string
@@ -18,4 +18,4 @@ export interface Definition<
   readonly model: (modelID: string, settings: ProviderSettings) => LanguageModel<Options>
 }
 
-export * as ProviderPackage from "./provider-package"
+export * as ProviderPackage from "./provider-package.js"

packages/ai/src/provider.ts

@@ -1,4 +1,4 @@
-import type { LanguageModel, ModelID, ProviderID } from "./schema"
+import type { LanguageModel, ModelID, ProviderID } from "./schema/index.js"
 
 export type LanguageModelOptions = Pick<LanguageModel.Input, "defaults" | "compatibility">
 
@@ -33,4 +33,4 @@ export const make = <DefinitionType extends DefinitionShape>(
   definition: NoExtraFields<DefinitionType, DefinitionShape>,
 ) => definition
 
-export * as Provider from "./provider"
+export * as Provider from "./provider.js"

packages/ai/src/providers.ts

@@ -1 +1 @@
-export * from "./providers/index"
+export * from "./providers/index.js"

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

@@ -1,11 +1,11 @@
-import { Auth } from "../route/auth"
-import type { Route as RouteDef, RouteDefaultsInput } from "../route/client"
-import type { ProviderPackage } from "../provider-package"
-import { OpenAIChat } from "../protocols/openai-chat"
-import { OpenAIResponses } from "../protocols/openai-responses"
-import { BedrockAuth, type Credentials } from "../protocols/utils/bedrock-auth"
-import { ProviderID, type ModelID } from "../schema"
-import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options"
+import { Auth } from "../route/auth.js"
+import type { Route as RouteDef, RouteDefaultsInput } from "../route/client.js"
+import type { ProviderPackage } from "../provider-package.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
+import { OpenAIResponses } from "../protocols/openai-responses.js"
+import { BedrockAuth, type Credentials } from "../protocols/utils/bedrock-auth.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("amazon-bedrock")
 

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

@@ -1,9 +1,9 @@
-import type { RouteDefaultsInput } from "../route/client"
-import { Auth } from "../route/auth"
-import type { ProviderPackage } from "../provider-package"
-import { ProviderID, type ModelID } from "../schema"
-import * as BedrockConverse from "../protocols/bedrock-converse"
-import type { BedrockCredentials } from "../protocols/bedrock-converse"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { Auth } from "../route/auth.js"
+import type { ProviderPackage } from "../provider-package.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import * as BedrockConverse from "../protocols/bedrock-converse.js"
+import type { BedrockCredentials } from "../protocols/bedrock-converse.js"
 
 export const id = ProviderID.make("amazon-bedrock")
 

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

@@ -1,2 +1,2 @@
-export { chatModel as model } from "../amazon-bedrock-mantle"
-export type { Settings } from "../amazon-bedrock-mantle"
+export { chatModel as model } from "../amazon-bedrock-mantle.js"
+export type { Settings } from "../amazon-bedrock-mantle.js"

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

@@ -1,2 +1,2 @@
-export { chatModel as model } from "../../amazon-bedrock-mantle"
-export type { Settings } from "../../amazon-bedrock-mantle"
+export { chatModel as model } from "../../amazon-bedrock-mantle.js"
+export type { Settings } from "../../amazon-bedrock-mantle.js"

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

@@ -1,2 +1,2 @@
-export { responsesModel as model } from "../../amazon-bedrock-mantle"
-export type { Settings } from "../../amazon-bedrock-mantle"
+export { responsesModel as model } from "../../amazon-bedrock-mantle.js"
+export type { Settings } from "../../amazon-bedrock-mantle.js"

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

@@ -1,9 +1,9 @@
-import type { ProviderPackage } from "../provider-package"
-import { AnthropicMessages } from "../protocols/anthropic-messages"
-import { Auth } from "../route/auth"
-import type { ProviderAuthOption } from "../route/auth-options"
-import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID } from "../schema"
+import type { ProviderPackage } from "../provider-package.js"
+import { AnthropicMessages } from "../protocols/anthropic-messages.js"
+import { Auth } from "../route/auth.js"
+import type { ProviderAuthOption } from "../route/auth-options.js"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
 export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
@@ -74,4 +74,4 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
   }).model(modelID)
 }
 
-export * as AnthropicCompatible from "./anthropic-compatible"
+export * as AnthropicCompatible from "./anthropic-compatible.js"

packages/ai/src/providers/anthropic.ts

@@ -1,10 +1,10 @@
-import type { RouteDefaultsInput } from "../route/client"
-import { Auth } from "../route/auth"
-import type { ProviderAuthOption } from "../route/auth-options"
-import type { ProviderPackage } from "../provider-package"
-import { ProviderID, type ModelID } from "../schema"
-import { AnthropicMessages } from "../protocols/anthropic-messages"
-import { AnthropicCompatible } from "./anthropic-compatible"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { Auth } from "../route/auth.js"
+import type { ProviderAuthOption } from "../route/auth-options.js"
+import type { ProviderPackage } from "../provider-package.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import { AnthropicMessages } from "../protocols/anthropic-messages.js"
+import { AnthropicCompatible } from "./anthropic-compatible.js"
 
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
 export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput

packages/ai/src/providers/azure.ts

@@ -1,11 +1,12 @@
-import { Auth } from "../route/auth"
-import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options"
-import type { Route as RouteDef, RouteDefaultsInput } from "../route/client"
-import type { ProviderPackage } from "../provider-package"
-import { ProviderID, type ModelID } from "../schema"
-import * as OpenAIChat from "../protocols/openai-chat"
-import * as OpenAIResponses from "../protocols/openai-responses"
-import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options"
+import { Auth } from "../route/auth.js"
+import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
+import type { Route as RouteDef, RouteDefaultsInput } from "../route/client.js"
+import type { ProviderPackage } from "../provider-package.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import * as OpenAIChat from "../protocols/openai-chat.js"
+import * as OpenAIResponses from "../protocols/openai-responses.js"
+import { ProviderShared } from "../protocols/shared.js"
+import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("azure")
 const routeAuth = Auth.remove("authorization")
@@ -19,7 +20,7 @@ export type LanguageModelOptions = AzureURL &
   ProviderAuthOption<"optional"> & {
     readonly apiVersion?: string
     readonly queryParams?: Record<string, string>
-    readonly useCompletionUrls?: boolean
+    readonly useDeploymentBasedUrls?: boolean
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 export type Config = LanguageModelOptions
@@ -29,27 +30,22 @@ export type Settings = ProviderPackage.Settings &
     readonly apiKey?: string
     readonly apiVersion?: string
     readonly queryParams?: Readonly<Record<string, string>>
+    readonly useDeploymentBasedUrls?: boolean
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
-const resourceBaseURL = (resourceName: string) => `https://${resourceName.trim()}.openai.azure.com/openai/v1`
+const resourceBaseURL = (resourceName: string) => `https://${resourceName.trim()}.openai.azure.com/openai`
 
 const responsesRoute = OpenAIResponses.route.with({
   id: "azure-openai-responses",
   provider: id,
   auth: routeAuth,
-  endpoint: {
-    query: { "api-version": "v1" },
-  },
 })
 
 const chatRoute = OpenAIChat.route.with({
   id: "azure-openai-chat",
   provider: id,
   auth: routeAuth,
-  endpoint: {
-    query: { "api-version": "v1" },
-  },
 })
 
 export const routes = [responsesRoute, chatRoute]
@@ -59,7 +55,7 @@ const defaults = (input: Config) => {
     apiKey: _,
     apiVersion: _apiVersion,
     resourceName: _resourceName,
-    useCompletionUrls: _useCompletionUrls,
+    useDeploymentBasedUrls: _useDeploymentBasedUrls,
     baseURL: _baseURL,
     queryParams: _queryParams,
     ...rest
@@ -80,37 +76,39 @@ const auth = (input: Config) => {
   )
 }
 
-const configuredRoute = <Body, Prepared>(route: RouteDef<Body, Prepared>, input: Config) =>
+const configuredRoute = <Body, Prepared>(route: RouteDef<Body, Prepared>, input: Config, modelID: string | ModelID) =>
   route.with({
     auth: auth(input),
-    endpoint: {
-      // AtLeastOne guarantees at least one is set; baseURL wins if both are.
-      baseURL: input.baseURL ?? resourceBaseURL(input.resourceName!),
-      query: {
-        ...(input.apiVersion ? { "api-version": input.apiVersion } : {}),
-        ...input.queryParams,
-      },
-    },
+    endpoint: endpoint(input, modelID),
   })
 
+function endpoint(input: Config, modelID: string | ModelID) {
+  const baseURL = ProviderShared.trimBaseUrl(input.baseURL ?? resourceBaseURL(input.resourceName!))
+  const query = { "api-version": input.apiVersion ?? "v1", ...input.queryParams }
+
+  if (input.useDeploymentBasedUrls) return { baseURL: `${baseURL}/deployments/${modelID}`, query }
+  if (input.baseURL !== undefined && !new URL(input.baseURL).hostname.endsWith(".openai.azure.com")) {
+    return { baseURL, query: input.queryParams }
+  }
+  return { baseURL: `${baseURL}/v1`, query }
+}
+
 export const configure = (input: Config) => {
-  const configuredResponsesRoute = configuredRoute(responsesRoute, input)
-  const configuredChatRoute = configuredRoute(chatRoute, input)
   const modelDefaults = defaults(input)
 
   const responses = (modelID: string | ModelID) =>
-    configuredResponsesRoute
+    configuredRoute(responsesRoute, input, modelID)
       .with(withOpenAIOptions(modelID, modelDefaults))
       .model<OpenAIProviderOptionsInput>({ id: modelID })
 
   const chat = (modelID: string | ModelID) =>
-    configuredChatRoute
+    configuredRoute(chatRoute, input, modelID)
       .with(withOpenAIOptions(modelID, modelDefaults))
       .model<OpenAIProviderOptionsInput>({ id: modelID })
 
   return {
     id,
-    model: (modelID: string | ModelID) => (input.useCompletionUrls === true ? chat(modelID) : responses(modelID)),
+    model: responses,
     responses,
     chat,
     configure,
@@ -131,6 +129,7 @@ const config = (settings: Settings): Config => {
     limits: settings.limits,
     providerOptions: settings.providerOptions,
     queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
+    useDeploymentBasedUrls: settings.useDeploymentBasedUrls,
   }
   if (settings.baseURL !== undefined) return { ...common, baseURL: settings.baseURL }
   if (settings.resourceName !== undefined) return { ...common, resourceName: settings.resourceName }

packages/ai/src/providers/azure/chat.ts

@@ -1,2 +1,2 @@
-export { chatModel as model } from "../azure"
-export type { Settings } from "../azure"
+export { chatModel as model } from "../azure.js"
+export type { Settings } from "../azure.js"

packages/ai/src/providers/azure/responses.ts

@@ -1,2 +1,2 @@
-export { responsesModel as model } from "../azure"
-export type { Settings } from "../azure"
+export { responsesModel as model } from "../azure.js"
+export type { Settings } from "../azure.js"

packages/ai/src/providers/cloudflare.ts

@@ -1,10 +1,10 @@
 import type { Config, Redacted } from "effect"
-import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
-import { Auth } from "../route/auth"
-import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options"
-import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID } from "../schema"
-import type { OpenAIProviderOptionsInput } from "./openai-options"
+import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
+import { Auth } from "../route/auth.js"
+import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const aiGatewayID = ProviderID.make("cloudflare-ai-gateway")
 export const workersAIID = ProviderID.make("cloudflare-workers-ai")

packages/ai/src/providers/github-copilot.ts

@@ -1,71 +0,0 @@
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID } from "../schema"
-import * as OpenAIChat from "../protocols/openai-chat"
-import * as OpenAIResponses from "../protocols/openai-responses"
-import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options"
-
-export const id = ProviderID.make("github-copilot")
-
-// GitHub Copilot has no canonical public URL — callers (opencode, etc.) must
-// supply `baseURL` explicitly.
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL: string
-    readonly endpoint?: "chat" | "responses"
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export const shouldUseResponsesApi = (modelID: string | ModelID, endpoint?: LanguageModelOptions["endpoint"]) => {
-  if (endpoint) return endpoint === "responses"
-  const model = String(modelID)
-  const match = /^gpt-(\d+)/.exec(model)
-  if (!match) return false
-  return Number(match[1]) >= 5 && !model.startsWith("gpt-5-mini")
-}
-
-export const routes = [OpenAIResponses.route, OpenAIChat.route]
-
-const chatRoute = OpenAIChat.route.with({ provider: id })
-const responsesRoute = OpenAIResponses.route.with({ provider: id })
-
-const defaults = (options: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL: _baseURL, endpoint: _endpoint, ...rest } = options
-  return rest
-}
-
-const configuredResponsesRoute = (options: LanguageModelOptions) =>
-  responsesRoute.with({
-    endpoint: { baseURL: options.baseURL },
-    auth: AuthOptions.bearer(options, []),
-  })
-
-const configuredChatRoute = (options: LanguageModelOptions) =>
-  chatRoute.with({
-    endpoint: { baseURL: options.baseURL },
-    auth: AuthOptions.bearer(options, []),
-  })
-
-export const configure = (options: LanguageModelOptions) => {
-  const responsesRoute = configuredResponsesRoute(options)
-  const chatRoute = configuredChatRoute(options)
-  const responses = (modelID: string | ModelID) =>
-    responsesRoute
-      .with(withOpenAIOptions(modelID, defaults(options)))
-      .model<OpenAIProviderOptionsInput>({ id: modelID })
-  const chat = (modelID: string | ModelID) =>
-    chatRoute.with(withOpenAIOptions(modelID, defaults(options))).model<OpenAIProviderOptionsInput>({ id: modelID })
-  return {
-    id,
-    model: (modelID: string | ModelID) =>
-      shouldUseResponsesApi(modelID, options.endpoint) ? responses(modelID) : chat(modelID),
-    responses,
-    chat,
-    configure,
-  }
-}
-
-export const provider = {
-  id,
-  configure,
-}

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

@@ -1,9 +1,9 @@
-import type { ProviderPackage } from "../provider-package"
-import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat"
-import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID } from "../schema"
-import { GoogleVertexShared } from "./google-vertex-shared"
-import type { OpenAIProviderOptionsInput } from "./openai-options"
+import type { ProviderPackage } from "../provider-package.js"
+import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import { GoogleVertexShared } from "./google-vertex-shared.js"
+import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("google-vertex")
 

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

@@ -1,13 +1,13 @@
 import { Effect, Schema, Struct } from "effect"
-import type { ProviderPackage } from "../provider-package"
-import { AnthropicMessages } from "../protocols/anthropic-messages"
-import { Auth } from "../route/auth"
-import { Route, type RouteDefaultsInput } from "../route/client"
-import { Endpoint } from "../route/endpoint"
-import { Framing } from "../route/framing"
-import { Protocol } from "../route/protocol"
-import { ProviderID, type ModelID } from "../schema"
-import { GoogleVertexShared } from "./google-vertex-shared"
+import type { ProviderPackage } from "../provider-package.js"
+import { AnthropicMessages } from "../protocols/anthropic-messages.js"
+import { Auth } from "../route/auth.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
+import { Protocol } from "../route/protocol.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import { GoogleVertexShared } from "./google-vertex-shared.js"
 
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
 export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
@@ -15,8 +15,7 @@ export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput
 
 const VERSION = "vertex-2023-10-16" as const
 
-// models.dev uses this provider id even though the API contract is Anthropic Messages.
-export const id = ProviderID.make("google-vertex-anthropic")
+export const id = ProviderID.make("google-vertex")
 
 export type Config = RouteDefaultsInput &
   GoogleVertexShared.OAuthOptions & {

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

@@ -1,9 +1,9 @@
-import type { ProviderPackage } from "../provider-package"
-import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses"
-import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID } from "../schema"
-import { GoogleVertexShared } from "./google-vertex-shared"
-import type { OpenResponsesProviderOptionsInput } from "./open-responses-options"
+import type { ProviderPackage } from "../provider-package.js"
+import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses.js"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import { GoogleVertexShared } from "./google-vertex-shared.js"
+import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
 
 export const id = ProviderID.make("google-vertex")
 

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

@@ -1,6 +1,6 @@
 import type { AnyAuthClient } from "google-auth-library"
 import { Effect, Redacted } from "effect"
-import { Auth, MissingCredentialError } from "../route/auth"
+import { Auth, MissingCredentialError } from "../route/auth.js"
 
 const SCOPE = "https://www.googleapis.com/auth/cloud-platform"
 
@@ -74,4 +74,4 @@ export const oauth = (input: OAuthOptions, project?: string) => {
   return adc(project)
 }
 
-export * as GoogleVertexShared from "./google-vertex-shared"
+export * as GoogleVertexShared from "./google-vertex-shared.js"

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

@@ -1,11 +1,11 @@
-import type { ProviderPackage } from "../provider-package"
-import { Gemini } from "../protocols/gemini"
-import { Auth } from "../route/auth"
-import { Route, type RouteDefaultsInput } from "../route/client"
-import { Endpoint } from "../route/endpoint"
-import { Framing } from "../route/framing"
-import { ProviderID, type ModelID } from "../schema"
-import { GoogleVertexShared } from "./google-vertex-shared"
+import type { ProviderPackage } from "../provider-package.js"
+import { Gemini } from "../protocols/gemini.js"
+import { Auth } from "../route/auth.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import { GoogleVertexShared } from "./google-vertex-shared.js"
 
 export type GeminiOptionsInput = Gemini.OptionsInput
 export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput

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

@@ -1,2 +1,2 @@
-export { model } from "../google-vertex-chat"
-export type { Settings } from "../google-vertex-chat"
+export { model } from "../google-vertex-chat.js"
+export type { Settings } from "../google-vertex-chat.js"

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

@@ -1,2 +1,2 @@
-export { model } from "../google-vertex"
-export type { Settings } from "../google-vertex"
+export { model } from "../google-vertex.js"
+export type { Settings } from "../google-vertex.js"

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

@@ -1,2 +1,2 @@
-export { model } from "../google-vertex-messages"
-export type { Settings } from "../google-vertex-messages"
+export { model } from "../google-vertex-messages.js"
+export type { Settings } from "../google-vertex-messages.js"

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

@@ -1,2 +1,2 @@
-export { model } from "../google-vertex-responses"
-export type { Settings } from "../google-vertex-responses"
+export { model } from "../google-vertex-responses.js"
+export type { Settings } from "../google-vertex-responses.js"

packages/ai/src/providers/google.ts

@@ -1,12 +1,12 @@
-import type { RouteDefaultsInput } from "../route/client"
-import { Auth } from "../route/auth"
-import type { ProviderAuthOption } from "../route/auth-options"
-import type { ProviderPackage } from "../provider-package"
-import { HttpOptions, ProviderID, mergeHttpOptions, type ModelID } from "../schema"
-import { Gemini } from "../protocols/gemini"
-import { GoogleImages } from "../protocols/google-images"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { Auth } from "../route/auth.js"
+import type { ProviderAuthOption } from "../route/auth-options.js"
+import type { ProviderPackage } from "../provider-package.js"
+import { HttpOptions, ProviderID, mergeHttpOptions, type ModelID } from "../schema/index.js"
+import { Gemini } from "../protocols/gemini.js"
+import { GoogleImages } from "../protocols/google-images.js"
 
-export type { GoogleImageOptions } from "../protocols/google-images"
+export type { GoogleImageOptions } from "../protocols/google-images.js"
 export type GeminiOptionsInput = Gemini.OptionsInput
 export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput
 

packages/ai/src/providers/index.ts

@@ -1,19 +1,18 @@
-export * as Anthropic from "./anthropic"
-export * as AnthropicCompatible from "./anthropic-compatible"
-export * as AmazonBedrock from "./amazon-bedrock"
-export * as AmazonBedrockMantle from "./amazon-bedrock-mantle"
-export * as Azure from "./azure"
-export * as Cloudflare from "./cloudflare"
-export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare"
-export * as GitHubCopilot from "./github-copilot"
-export * as Google from "./google"
-export * as GoogleVertex from "./google-vertex"
-export * as GoogleVertexChat from "./google-vertex-chat"
-export * as GoogleVertexMessages from "./google-vertex-messages"
-export * as GoogleVertexResponses from "./google-vertex-responses"
-export * as OpenAI from "./openai"
-export * as OpenAICompatible from "./openai-compatible"
-export * as OpenAICompatibleResponses from "./openai-compatible-responses"
-export * as OpenRouter from "./openrouter"
-export * as XAI from "./xai"
-export * as ZAI from "./zai"
+export * as Anthropic from "./anthropic.js"
+export * as AnthropicCompatible from "./anthropic-compatible.js"
+export * as AmazonBedrock from "./amazon-bedrock.js"
+export * as AmazonBedrockMantle from "./amazon-bedrock-mantle.js"
+export * as Azure from "./azure.js"
+export * as Cloudflare from "./cloudflare.js"
+export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare.js"
+export * as Google from "./google.js"
+export * as GoogleVertex from "./google-vertex.js"
+export * as GoogleVertexChat from "./google-vertex-chat.js"
+export * as GoogleVertexMessages from "./google-vertex-messages.js"
+export * as GoogleVertexResponses from "./google-vertex-responses.js"
+export * as OpenAI from "./openai.js"
+export * as OpenAICompatible from "./openai-compatible.js"
+export * as OpenAICompatibleResponses from "./openai-compatible-responses.js"
+export * as OpenRouter from "./openrouter.js"
+export * as XAI from "./xai.js"
+export * as ZAI from "./zai.js"

packages/ai/src/providers/open-responses-options.ts

@@ -1,11 +1,10 @@
-import type { ResponseIncludable, ServiceTier } from "../protocols/utils/open-responses-options"
-import type { ProviderOptions, ReasoningEffort, TextVerbosity } from "../schema"
+import type { ResponseIncludable, ServiceTier } from "../protocols/utils/open-responses-options.js"
+import type { ProviderOptions, ReasoningEffort, TextVerbosity } from "../schema/index.js"
 
 export interface OpenResponsesOptionsInput {
   readonly [key: string]: unknown
   readonly instructions?: string
   readonly store?: boolean
-  readonly promptCacheKey?: string
   readonly reasoningEffort?: ReasoningEffort
   readonly reasoningSummary?: "auto" | "concise" | "detailed"
   readonly include?: ReadonlyArray<ResponseIncludable>
@@ -17,4 +16,4 @@ export type OpenResponsesProviderOptionsInput = ProviderOptions & {
   readonly openresponses?: OpenResponsesOptionsInput
 }
 
-export * as OpenResponsesProviderOptions from "./open-responses-options"
+export * as OpenResponsesProviderOptions from "./open-responses-options.js"

packages/ai/src/providers/openai-compatible-responses.ts

@@ -1,11 +1,11 @@
-import type { ProviderPackage } from "../provider-package"
-import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID } from "../schema"
-import type { OpenResponsesProviderOptionsInput } from "./open-responses-options"
+import type { ProviderPackage } from "../provider-package.js"
+import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses.js"
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
 
-export type { OpenResponsesOptionsInput, OpenResponsesProviderOptionsInput } from "./open-responses-options"
+export type { OpenResponsesOptionsInput, OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
 
 export const id = ProviderID.make("openai-compatible")
 

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

@@ -1,10 +1,10 @@
-import { ProviderID, type ModelID } from "../schema"
-import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
-import type { RouteDefaultsInput } from "../route/client"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import type { ProviderPackage } from "../provider-package"
-import { profiles, type OpenAICompatibleProfile } from "./openai-compatible-profile"
-import type { OpenAIProviderOptionsInput } from "./openai-options"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import type { ProviderPackage } from "../provider-package.js"
+import { profiles, type OpenAICompatibleProfile } from "./openai-compatible-profile.js"
+import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("openai-compatible")
 

packages/ai/src/providers/openai-compatible/responses.ts

@@ -1 +1 @@
-export * from "../openai-compatible-responses"
+export * from "../openai-compatible-responses.js"

packages/ai/src/providers/openai-options.ts

@@ -1,8 +1,8 @@
-import type { ProviderOptions } from "../schema"
-import { mergeProviderOptions } from "../schema"
-import type { OpenResponsesOptionsInput } from "./open-responses-options"
+import type { ProviderOptions } from "../schema/index.js"
+import { mergeProviderOptions } from "../schema/index.js"
+import type { OpenResponsesOptionsInput } from "./open-responses-options.js"
 
-export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options"
+export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options.js"
 
 export type OpenAIOptionsInput = OpenResponsesOptionsInput
 
@@ -17,7 +17,6 @@ const openAIProviderOptions = (options: OpenAIOptionsInput | undefined): Provide
   const openai = Object.fromEntries(
     definedEntries({
       store: options?.store,
-      promptCacheKey: options?.promptCacheKey,
       reasoningEffort: options?.reasoningEffort,
       reasoningSummary: options?.reasoningSummary,
       include: options?.include,
@@ -68,4 +67,4 @@ export const withOpenAIOptions = <Options extends { readonly providerOptions?: O
   }
 }
 
-export * as OpenAIProviderOptions from "./openai-options"
+export * as OpenAIProviderOptions from "./openai-options.js"