refactor(ai): restore inline compaction beta handling

.changeset/directory-page-heading.md

@@ -1,5 +1,5 @@
 ---
-"@opencode/core": patch
+"@opencode-ai/core": patch
 ---
 
 Correct directory page headings when the read offset is zero.

.github/workflows/deploy-files.yml

@@ -1,34 +0,0 @@
-name: deploy-files
-
-on:
-  push:
-    branches:
-      - dev
-      - v2
-  workflow_dispatch:
-
-concurrency:
-  group: deploy-files-${{ github.ref_name }}
-  cancel-in-progress: false
-
-permissions:
-  contents: read
-
-jobs:
-  deploy:
-    if: github.repository == 'anomalyco/opencode' && (github.ref_name == 'dev' || github.ref_name == 'v2')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-
-      - uses: ./.github/actions/setup-bun
-
-      - name: Typecheck
-        working-directory: services/files
-        run: bun typecheck
-
-      - name: Deploy
-        working-directory: services/files
-        run: bun run deploy --env ${{ github.ref_name == 'v2' && 'production' || 'dev' }}
-        env:
-          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

.github/workflows/deploy-www.yml

@@ -24,13 +24,13 @@ jobs:
       - uses: ./.github/actions/setup-bun
 
       - name: Build
-        working-directory: services/www
+        working-directory: packages/www
         run: bun run build
         env:
           CLOUDFLARE_ENV: ${{ github.ref_name == 'v2' && 'production' || 'dev' }}
 
       - name: Deploy
-        working-directory: services/www
+        working-directory: packages/www
         run: bun run deploy
         env:
           CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

.github/workflows/nix-hashes.yml

@@ -11,7 +11,6 @@ on:
       - "bun.lock"
       - "package.json"
       - "packages/*/package.json"
-      - "services/*/package.json"
       - "flake.lock"
       - "nix/node_modules.nix"
       - "nix/scripts/**"

.github/workflows/publish.yml

@@ -47,8 +47,8 @@ jobs:
       - uses: ./.github/actions/setup-bun
 
       - name: Deploy update service
-        if: github.ref_name == 'v2'
-        working-directory: services/updates
+        if: github.ref_name == 'v2' || github.ref_name == 'beta'
+        working-directory: packages/updates
         run: bun run deploy
         env:
           CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
@@ -91,7 +91,7 @@ jobs:
 
       - uses: ./.github/actions/setup-bun
         with:
-          bun-version: 1.4.2
+          bun-version: 1.4.0
 
       - name: Setup git committer
         id: committer
@@ -113,7 +113,7 @@ jobs:
         id: build
         run: ./packages/cli/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
         env:
-          BUN_COMPILE_RELEASE: bun-v1.4.2
+          BUN_COMPILE_RELEASE: bun-v1.4.0
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
           GH_REPO: ${{ needs.version.outputs.repo }}
@@ -417,6 +417,7 @@ jobs:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        if: github.ref_name == 'beta'
         with:
           name: opencode-preview-cli
           path: packages/cli/dist
@@ -479,7 +480,7 @@ jobs:
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
           OPENCODE_CLI_TARGET: ${{ matrix.settings.target }}
-          OPENCODE_CLI_DIST: ${{ github.workspace }}/packages/cli/dist
+          OPENCODE_CLI_DIST: ${{ (github.ref_name == 'beta' && format('{0}/packages/cli/dist', github.workspace)) || '' }}
 
       - name: Build
         run: bun run build
@@ -670,6 +671,19 @@ jobs:
           git config --global user.name "opencode"
           ssh-keyscan -H aur.archlinux.org >> ~/.ssh/known_hosts || true
 
+      - name: Upload desktop release assets
+        if: needs.version.outputs.release
+        env:
+          GH_TOKEN: ${{ steps.committer.outputs.token }}
+        run: |
+          shopt -s nullglob
+          files=(/tmp/desktop/*.{exe,blockmap,dmg,zip,AppImage,deb,rpm} /tmp/desktop/*.app.tar.gz)
+          if (( ${#files[@]} == 0 )); then
+            echo "No desktop release assets found"
+            exit 1
+          fi
+          gh release upload "v${{ needs.version.outputs.version }}" "${files[@]}" --clobber --repo "${{ needs.version.outputs.repo }}"
+
       - run: ./script/publish.ts
         env:
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
@@ -681,6 +695,3 @@ jobs:
           LATEST_YML_DIR: /tmp/latest-yml
           TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
           TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-          OPENCODE_DESKTOP_DIST: /tmp/desktop
-          CLOUDFLARE_ACCOUNT_ID: 15d29c8639fd3733b1b5486a2acfd968
-          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

.github/workflows/test.yml

@@ -49,7 +49,7 @@ jobs:
             echo "app=true" >> "$GITHUB_OUTPUT"
             exit 0
           fi
-          bun x turbo@2.10.2 ls --affected --filter=@opencode/app --output=json > affected.json
+          bun x turbo@2.10.2 ls --affected --filter=@opencode-ai/app --output=json > affected.json
           bun -e 'const result = await Bun.file("affected.json").json(); console.log(`app=${result.packages.count > 0}`)' >> "$GITHUB_OUTPUT"
 
   unit:
@@ -132,10 +132,10 @@ jobs:
         timeout-minutes: 15
         run: |
           if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            bun turbo verify:package --filter=@opencode/sdk
+            bun turbo verify:package --filter=@opencode-ai/sdk
             exit 0
           fi
-          bun turbo verify:package --affected --filter=@opencode/sdk
+          bun turbo verify:package --affected --filter=@opencode-ai/sdk
         env:
           TURBO_SCM_BASE: ${{ github.event_name == 'pull_request' && format('{0}^1', github.sha) || github.event.before }}
           TURBO_SCM_HEAD: ${{ github.sha }}
@@ -173,7 +173,7 @@ jobs:
 
       - name: Check generated documentation
         if: runner.os == 'Linux'
-        working-directory: services/www
+        working-directory: packages/www
         run: bun run check:generated
 
   e2e:

.opencode/tool/github-pr-search.ts

@@ -1,5 +1,5 @@
 /// <reference path="../env.d.ts" />
-import { tool } from "@opencode/plugin"
+import { tool } from "@opencode-ai/plugin"
 async function githubFetch(endpoint: string, options: RequestInit = {}) {
   const response = await fetch(`https://api.github.com${endpoint}`, {
     ...options,

.opencode/tool/github-triage.ts

@@ -1,5 +1,5 @@
 /// <reference path="../env.d.ts" />
-import { tool } from "@opencode/plugin"
+import { tool } from "@opencode-ai/plugin"
 
 const TEAM = {
   tui: ["kommander", "simonklee"],

AGENTS.md

@@ -3,7 +3,7 @@
 - Current implementation changes belong in `packages/core`, `packages/cli`, `packages/server`, `packages/protocol`, `packages/schema`, and related generated client surfaces when required.
 - This repository does not use Changesets. Do not add `.changeset` files; follow the existing release workflow instead.
 - The default branch in this repo is `v2`.
-- Default new branches and worktrees to `v2`, or `origin/v2` when the local `v2` ref is unavailable, and default pull requests to target `v2`. Use another base or target branch when the requester explicitly instructs it.
+- 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
@@ -84,9 +84,9 @@ const { a, b } = obj
 ### Imports
 
 - Never alias imports. Do not use `import { foo as bar } from "..."` or renamed imports like `resolve as pathResolve`.
-- Never use type-position `import("...")` references such as `Schema.declare<import("@opencode/plugin/effect/plugin").Plugin["effect"]>`. Only when two imports genuinely collide on a name and no other option exists, an aliased type import (`import type { Plugin as PluginDefinition } from "..."`) is permitted as a last resort — still strongly preferred not to.
+- Never use type-position `import("...")` references such as `Schema.declare<import("@opencode-ai/plugin/effect/plugin").Plugin["effect"]>`. Only when two imports genuinely collide on a name and no other option exists, an aliased type import (`import type { Plugin as PluginDefinition } from "..."`) is permitted as a last resort — still strongly preferred not to.
 - Never use star imports. Do not use `import * as Foo from "..."` or `import type * as Foo from "..."`.
-- If a namespace-style value is needed, import the module's own exported namespace by name, for example `import { Project } from "@opencode/core/project"`, then reference `Project.ID`.
+- If a namespace-style value is needed, import the module's own exported namespace by name, for example `import { Project } from "@opencode-ai/core/project"`, then reference `Project.ID`.
 - Prefer dynamic imports for heavy modules that are only needed in selected code paths, especially in startup-sensitive entrypoints. Destructure dynamic import bindings near the top of the narrowest scope that needs them so they read like normal imports. Avoid inline chains such as `await import("./module").then((mod) => mod.value())` or `(await import("./module")).value()`. Keep branch-specific imports inside the branch that needs them to preserve lazy loading.
 
 ### Variables
@@ -183,7 +183,7 @@ const table = sqliteTable("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. 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. At safe step boundaries, steered compaction takes priority up to the first steered move control; other steers retain enqueue order. 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.
+- 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 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.

bunfig.toml

@@ -2,7 +2,7 @@
 exact = true
 # Only install newly resolved package versions published at least 3 days ago.
 minimumReleaseAge = 259200
-minimumReleaseAgeExcludes = ["@ai-sdk/amazon-bedrock", "@ai-sdk/anthropic", "@brendonovich/vite-plugin-opencode", "@opencode/sdk", "@opencode-ai/pty", "@opencode-ai/pty-darwin-arm64", "@opencode-ai/pty-darwin-x64", "@opencode-ai/pty-linux-arm64-gnu", "@opencode-ai/pty-linux-arm64-musl", "@opencode-ai/pty-linux-x64-gnu", "@opencode-ai/pty-linux-x64-musl", "@opentui/core", "@opentui/core-darwin-arm64", "@opentui/core-darwin-x64", "@opentui/core-linux-arm64", "@opentui/core-linux-arm64-musl", "@opentui/core-linux-x64", "@opentui/core-linux-x64-musl", "@opentui/core-win32-arm64", "@opentui/core-win32-x64", "@opentui/keymap", "@opentui/solid", "opentui-spinner", "gitlab-ai-provider", "opencode-gitlab-auth", "@ff-labs/fff-node", "@ff-labs/fff-bun", "@ff-labs/fff-bin-darwin-arm64", "@ff-labs/fff-bin-darwin-x64", "@ff-labs/fff-bin-linux-arm64-gnu", "@ff-labs/fff-bin-linux-arm64-musl", "@ff-labs/fff-bin-linux-x64-gnu", "@ff-labs/fff-bin-linux-x64-musl", "@ff-labs/fff-bin-win32-arm64", "@ff-labs/fff-bin-win32-x64", "@pierre/diffs", "@pierre/theming", "app-builder-lib", "dmg-builder", "electron", "electron-builder", "electron-publish", "blume", "mermaid"]
+minimumReleaseAgeExcludes = ["@ai-sdk/amazon-bedrock", "@ai-sdk/anthropic", "@brendonovich/vite-plugin-opencode", "@opencode-ai/sdk", "@opencode-ai/pty", "@opencode-ai/pty-darwin-arm64", "@opencode-ai/pty-darwin-x64", "@opencode-ai/pty-linux-arm64-gnu", "@opencode-ai/pty-linux-arm64-musl", "@opencode-ai/pty-linux-x64-gnu", "@opencode-ai/pty-linux-x64-musl", "@opentui/core", "@opentui/core-darwin-arm64", "@opentui/core-darwin-x64", "@opentui/core-linux-arm64", "@opentui/core-linux-arm64-musl", "@opentui/core-linux-x64", "@opentui/core-linux-x64-musl", "@opentui/core-win32-arm64", "@opentui/core-win32-x64", "@opentui/keymap", "@opentui/solid", "opentui-spinner", "gitlab-ai-provider", "opencode-gitlab-auth", "@ff-labs/fff-node", "@ff-labs/fff-bun", "@ff-labs/fff-bin-darwin-arm64", "@ff-labs/fff-bin-darwin-x64", "@ff-labs/fff-bin-linux-arm64-gnu", "@ff-labs/fff-bin-linux-arm64-musl", "@ff-labs/fff-bin-linux-x64-gnu", "@ff-labs/fff-bin-linux-x64-musl", "@ff-labs/fff-bin-win32-arm64", "@ff-labs/fff-bin-win32-x64", "@pierre/diffs", "@pierre/theming", "app-builder-lib", "dmg-builder", "electron", "electron-builder", "electron-publish", "blume", "mermaid"]
 
 [test]
 root = "./do-not-run-tests-from-root"

infra/console.ts

@@ -235,7 +235,6 @@ const bucketNew = new sst.cloudflare.Bucket("ZenDataNew")
 const DISCORD_INCIDENT_WEBHOOK_URL = new sst.Secret("DISCORD_INCIDENT_WEBHOOK_URL")
 const AWS_SES_ACCESS_KEY_ID = new sst.Secret("AWS_SES_ACCESS_KEY_ID")
 const AWS_SES_SECRET_ACCESS_KEY = new sst.Secret("AWS_SES_SECRET_ACCESS_KEY")
-const ENTERPRISE_SALES_INBOX_EMAIL = new sst.Secret("ENTERPRISE_SALES_INBOX_EMAIL")
 
 const SALESFORCE_CLIENT_ID = new sst.Secret("SALESFORCE_CLIENT_ID")
 const SALESFORCE_CLIENT_SECRET = new sst.Secret("SALESFORCE_CLIENT_SECRET")
@@ -264,7 +263,6 @@ new sst.cloudflare.x.SolidStart("Console", {
     EMAILOCTOPUS_API_KEY,
     AWS_SES_ACCESS_KEY_ID,
     AWS_SES_SECRET_ACCESS_KEY,
-    ENTERPRISE_SALES_INBOX_EMAIL,
     SALESFORCE_CLIENT_ID,
     SALESFORCE_CLIENT_SECRET,
     SALESFORCE_INSTANCE_URL,

infra/webapp.ts

@@ -6,7 +6,6 @@ export function createWebApp(domain: string) {
       $app.stage === "beta"
         ? {
             OPENCODE_CHANNEL: "beta",
-            VITE_OPENCODE_SERVER_MODE: "none",
             VITE_SENTRY_ENVIRONMENT: "beta",
           }
         : undefined,

install

@@ -165,30 +165,22 @@ else
         exit 1
     fi
 
-    package_scope="@opencode"
     if [ -z "$requested_version" ]; then
-        metadata=$(curl -fsSL https://opencode.ai/update/api/beta/cli/npm || true)
+        metadata=$(curl -fsSL https://registry.npmjs.org/@opencode-ai%2fcli/beta || true)
         specific_version=$(echo "$metadata" | sed -n 's/.*"version":"\([^"]*\)".*/\1/p')
-        package=$(echo "$metadata" | sed -n 's/.*"package":"\([^"]*\)".*/\1/p')
 
-        if [ -z "$specific_version" ] || [ -z "$package" ]; then
+        if [ -z "$specific_version" ]; then
             echo -e "${RED}Failed to fetch version information${NC}"
             exit 1
         fi
-        package_scope="${package%/cli}"
     else
         # Strip leading 'v' if present
         requested_version="${requested_version#v}"
         specific_version=$requested_version
     fi
 
-    package_name="$package_scope/cli-$target"
-    http_status=$(curl -s -o /dev/null -w "%{http_code}" "https://registry.npmjs.org/$package_scope%2fcli-$target/$specific_version" || true)
-    # Older clients install the minimum release before they can migrate package names.
-    if [ "$http_status" = "404" ] && [ -n "$requested_version" ]; then
-        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)
-    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}"

nix/desktop.nix

@@ -87,11 +87,6 @@ stdenv.mkDerivation (finalAttrs: {
 
     cd packages/desktop
 
-    export OPENCODE_CLI_DIST="$TMPDIR/desktop-cli"
-    cli_package=$(bun -e 'import { getCurrentCli } from "./scripts/utils.ts"; console.log(getCurrentCli().package.replace("@opencode/", ""))')
-    mkdir -p "$OPENCODE_CLI_DIST/$cli_package/bin"
-    cp ${lib.getExe opencode} "$OPENCODE_CLI_DIST/$cli_package/bin/opencode2"
-
     bun run build
     npx electron-builder --dir \
       --config electron-builder.config.ts \

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-/5VErB3NjnKi0/LHqqJgcDadD9woNLMZZYxUjriRvJI=",
-    "aarch64-linux": "sha256-CTXqFEvQIiKDe0OmtdkdY8KLQtQOxdsJNCom/Clzc1c=",
-    "aarch64-darwin": "sha256-vF2+/jgWhF1Smef9U3nSpTS3RI5ZcriV0mjg1q9s8YM=",
-    "x86_64-darwin": "sha256-suCQ+yDT048D3EbjFAzplyZedYZYAihseLkqg6c+wHc="
+    "x86_64-linux": "sha256-fG6VYtNC0pce4VM9po7vVucPuJul42yuuijTjNSr7rk=",
+    "aarch64-linux": "sha256-3TznrmNqdt25cOxia6vcdi/5qKaeyLPIsNXGYBSJNrs=",
+    "aarch64-darwin": "sha256-8Kmagb5tfECSWZNsIJgrRP1d3X5tuEoWLEWkV3UENZo=",
+    "x86_64-darwin": "sha256-mIV+mDwIGD02BNYZVi37sY4ls1T01N6z76eBtH0sKiA="
   }
 }

nix/node_modules.nix

@@ -27,12 +27,11 @@ stdenvNoCC.mkDerivation {
     fileset = lib.fileset.intersection (lib.fileset.fromSource (lib.sources.cleanSource ../.)) (
       lib.fileset.unions [
         ../packages
-        ../services
         ../bun.lock
         ../package.json
         ../patches
         ../install # required by desktop build (cli.rs include_str!)
-        ../.github/TEAM_MEMBERS # required by @opencode/script
+        ../.github/TEAM_MEMBERS # required by @opencode-ai/script
       ]
     );
   };

package.json

@@ -5,17 +5,15 @@
   "version": "0.0.0",
   "private": true,
   "type": "module",
-  "packageManager": "bun@1.4.2",
+  "packageManager": "bun@1.3.14",
   "scripts": {
-    "dev": "bun run --cwd packages/cli src/index.ts",
-    "dev:live": "sh -c 'OPENCODE_TUI_CHANNEL=dev OPENCODE_PASSWORD=\"$(opencode2 service get password)\" exec bun run dev \"$@\" --server \"$(opencode2 service status)\"' --",
-    "dev:vite": "bun run --cwd packages/cli --conditions=browser dev/vite.ts",
-    "dev:vite:live": "sh -c 'OPENCODE_TUI_CHANNEL=dev OPENCODE_PASSWORD=\"$(opencode2 service get password)\" exec bun run dev:vite \"$@\" --server \"$(opencode2 service status)\"' --",
+    "dev": "bun run --cwd packages/cli --conditions=browser src/index.ts",
+    "dev:live": "OPENCODE_TUI_CHANNEL=dev OPENCODE_PASSWORD=\"$(opencode2 service get password)\" bun run dev --server \"$(opencode2 service status)\"",
     "dev:desktop": "bun --cwd packages/desktop dev",
     "dev:web": "bun --cwd packages/app dev",
     "dev:console": "ulimit -n 10240 2>/dev/null; bun run --cwd packages/console/app dev",
     "dev:stats": "bun sst shell --stage=production -- bun run --cwd packages/stats/app dev",
-    "dev:www": "bun run --cwd services/www dev",
+    "dev:www": "bun run --cwd packages/www dev",
     "dev:storybook": "bun --cwd packages/storybook storybook",
     "bench:devex": "bun run --cwd packages/app test:bench:devex",
     "lint": "oxlint",
@@ -29,6 +27,7 @@
     "upgrade-opentui": "bun run script/upgrade-opentui.ts",
     "postinstall": "bun run --cwd packages/core fix-node-pty",
     "prepare": "husky",
+    "reserve-packages": "bun script/reserve-package-names.ts",
     "random": "echo 'Random script'",
     "sso": "aws sso login --sso-session=opencode --no-browser",
     "test": "echo 'do not run tests from root' && exit 1"
@@ -36,7 +35,6 @@
   "workspaces": {
     "packages": [
       "packages/*",
-      "services/*",
       "packages/console/*",
       "packages/stats/*"
     ],
@@ -46,14 +44,14 @@
       "@effect/platform-node-shared": "4.0.0-rc.112",
       "@effect/sql-sqlite-bun": "4.0.0-rc.112",
       "@npmcli/arborist": "9.4.0",
-      "@types/bun": "1.4.0",
+      "@types/bun": "1.3.13",
       "@types/cross-spawn": "6.0.6",
       "@octokit/rest": "22.0.0",
       "@hono/standard-validator": "0.2.0",
       "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.10",
-      "@opentui/keymap": "0.5.10",
-      "@opentui/solid": "0.5.10",
+      "@opentui/core": "0.5.9",
+      "@opentui/keymap": "0.5.9",
+      "@opentui/solid": "0.5.9",
       "@tanstack/solid-virtual": "3.13.37",
       "@shikijs/stream": "4.4.3",
       "@standard-schema/spec": "1.1.0",
@@ -95,6 +93,7 @@
       "@typescript/native-preview": "7.0.0-dev.20251207.1",
       "zod": "4.1.8",
       "remeda": "2.26.0",
+      "resolve.exports": "2.0.3",
       "sst": "4.13.1",
       "shiki": "4.4.3",
       "solid-list": "0.3.0",
@@ -131,8 +130,8 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "3.933.0",
-    "@opencode/plugin": "workspace:*",
-    "@opencode/script": "workspace:*",
+    "@opencode-ai/plugin": "workspace:*",
+    "@opencode-ai/script": "workspace:*",
     "heap-snapshot-toolkit": "1.1.3",
     "typescript": "catalog:"
   },
@@ -149,6 +148,10 @@
     "esbuild",
     "node-pty",
     "protobufjs",
+    "tree-sitter",
+    "tree-sitter-bash",
+    "tree-sitter-powershell",
+    "web-tree-sitter",
     "electron"
   ],
   "overrides": {
@@ -158,7 +161,6 @@
     "@effect/platform-node-shared": "catalog:",
     "@types/bun": "catalog:",
     "@types/node": "catalog:",
-    "bun-types": "1.4.2",
     "effect": "catalog:",
     "solid-js": "catalog:"
   },
@@ -176,8 +178,6 @@
     "@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",
     "@tanstack/virtual-core@3.17.8": "patches/@tanstack%2Fvirtual-core@3.17.8.patch",
-    "@ff-labs/fff-bun@0.10.5": "patches/@ff-labs%2Ffff-bun@0.10.5.patch",
-    "ghostty-web@github:anomalyco/ghostty-web#83c0a07": "patches/ghostty-web@0.3.0.patch",
-    "vite@8.2.2": "patches/vite@8.2.2.patch"
+    "@ff-labs/fff-bun@0.10.5": "patches/@ff-labs%2Ffff-bun@0.10.5.patch"
   }
 }

packages/ai/AGENTS.md

@@ -13,7 +13,6 @@
 Per-type constructors live on the type, not as top-level re-exports. Use `Message.system(...)`, `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `LanguageModel.make(...)`, `ToolDefinition.make(...)`, `ToolCallPart.make(...)`, `ToolResultPart.make(...)`, `ToolChoice.make(...)`, `ToolChoice.named(...)`, `SystemPart.make(...)`, and `GenerationOptions.make(...)` directly. The top-level `LLM` namespace is reserved for request-shaped call APIs: `LLM.request`, `LLM.generate`, `LLM.stream`, and `LLM.generateObject`. Use `LLMRequest.update(...)` when deriving canonical request data; do not add a duplicate `LLM.updateRequest(...)` path. Two ways to construct the same thing is one too many.
 
 - Keep provider-defined string enums forward-compatible. Expose known values for autocomplete while accepting future values with `Known | (string & {})`; use `Schema.String` at runtime unless rejecting unknown values is required for correctness.
-- Order reasoning-effort values from lowest to highest: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. Provider-specific subsets follow the same relative order in types, schemas, option lists, and tests.
 
 ## Tests
 
@@ -82,7 +81,7 @@ export const route = Route.make({
 
 Route defaults are request-shaping defaults such as `headers`, `limits`, `generation`, `providerOptions`, and `http`. Endpoint host/query belongs on the route endpoint. Selected `LanguageModel` values carry only model id, provider id, and the configured route value. Model capability/catalog metadata lives outside this package; protocol support is enforced by request lowering and typed `AIError`s.
 
-The four-axis decomposition is the reason DeepSeek, TogetherAI, Cerebras, Baseten, Fireworks, and DeepInfra all reuse `OpenAIChat.protocol` verbatim — each provider owns a small `Route.make(...)` composition instead of a protocol clone. Bug fixes in one protocol propagate to every consumer of that protocol in a single commit.
+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 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.
 
@@ -116,16 +115,15 @@ Keep provider facades small and explicit:
 - Prefer `apiKey` as provider-specific sugar and `auth` as the explicit override; keep them mutually exclusive in provider option types with `ProviderAuthOption`.
 - Resolve `apiKey` → `Auth` with `AuthOptions.bearer(options, "<PROVIDER>_API_KEY")` (it honors an explicit `auth` override and falls back to `Auth.config(envVar)` so missing keys surface a typed `Authentication` error rather than a runtime crash).
 - Use separate top-level facades for products with different required setup, such as `CloudflareAIGateway` and `CloudflareWorkersAI`.
-- Give every named provider its own file and top-level export. Keep its endpoint, auth defaults, and route setup in that file. Compose shared protocols directly; do not nest named provider presets under generic compatible facades or keep their endpoints in a shared provider profile registry.
 
 `Provider.make(...)` remains available for simple static provider definitions, but new built-in providers should prefer plain configured facades unless a helper removes real duplication without adding runtime behavior.
 
 ### Provider Package Entrypoints
 
-Catalog-selected native providers use package-like export paths from `@opencode/ai`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model(modelID, settings)`, where settings are serializable provider configuration plus common `headers`, `body`, and `limits` overlays.
+Catalog-selected native providers use package-like export paths from `@opencode-ai/ai`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model(modelID, settings)`, where settings are serializable provider configuration plus common `headers`, `body`, and `limits` overlays.
 
 ```ts
-import { model } from "@opencode/ai/providers/openai/responses"
+import { model } from "@opencode-ai/ai/providers/openai/responses"
 
 const selected = model("gpt-5", {
   apiKey,

packages/ai/README.md

@@ -1,12 +1,12 @@
-# @opencode/ai
+# @opencode-ai/ai
 
-Schema-first language model and image-generation APIs built with Effect.
+Schema-first AI primitives for opencode. Provider quirks live in adapters, not in calling code.
 
 ```ts
 import { Effect, Layer } from "effect"
-import { LLM, LLMClient } from "@opencode/ai"
-import { RequestExecutor } from "@opencode/ai/route"
-import { OpenAI } from "@opencode/ai/providers"
+import { LLM, LLMClient } from "@opencode-ai/ai"
+import { RequestExecutor } from "@opencode-ai/ai/route"
+import { OpenAI } from "@opencode-ai/ai/providers"
 
 const model = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).responses("gpt-4o-mini")
 
@@ -29,251 +29,13 @@ await Effect.runPromise(program.pipe(Effect.provide(llmLayer)))
 
 Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
 
-## Z.AI
-
-`ZAI` uses the standard API. Chat Completions is the default language-model API;
-the existing `.image(...)` selector provides image generation.
-
-```ts
-import { LLM } from "@opencode/ai"
-import { ZAI, ZAICodingPlan } from "@opencode/ai/providers"
-
-const zai = ZAI.configure({ apiKey: process.env.ZAI_API_KEY })
-const request = LLM.request({
-  model: zai.model("glm-5.3"), // also zai.chat("glm-5.3")
-  prompt: "Explain this design.",
-  providerOptions: {
-    reasoningEffort: "high",
-    thinking: { type: "enabled", clear_thinking: false },
-  },
-})
-
-const coding = ZAICodingPlan.configure({ apiKey: process.env.ZAI_API_KEY })
-const messages = LLM.request({
-  model: coding.messages("glm-5.3"),
-  prompt: "Explain this design.",
-  providerOptions: { effort: "high" },
-})
-```
-
-The products have distinct provider identities and endpoints:
-
-| Provider                            | Selector                    | Default base URL                      |
-| ----------------------------------- | --------------------------- | ------------------------------------- |
-| `ZAI` (`zai`)                       | `.model`, `.chat`, `.image` | `https://api.z.ai/api/paas/v4`        |
-| `ZAICodingPlan` (`zai-coding-plan`) | `.model`, `.chat`           | `https://api.z.ai/api/coding/paas/v4` |
-| `ZAICodingPlan`                     | `.messages`                 | `https://api.z.ai/api/anthropic/v1`   |
-| `ZAICodingPlan`                     | `.responses`                | `https://api.z.ai/api/v1`             |
-
-Both read `ZAI_API_KEY` when `apiKey` is omitted and support an explicit `auth` override.
-Coding Plan requires an active subscription. `baseURL` overrides the selected API's
-complete base, including its version prefix. Language-model routes use HTTP/SSE.
-
-Options retain the selected API's native semantics:
-
-- Chat `reasoningEffort` lowers to `reasoning_effort`; Responses lowers it to `reasoning.effort`.
-  Messages `effort` lowers to `output_config.effort`. Omission preserves provider defaults.
-- Chat `thinking` passes `type` and `clear_thinking` through unchanged. Set
-  `clear_thinking: false` and replay complete `response.message` values to preserve reasoning
-  across user messages and tool loops. The standard API defaults to clearing historical thinking;
-  Coding Plan documents preservation by default.
-- Messages accepts `thinking: { type: "enabled" | "adaptive" | "disabled" }` without requiring
-  an Anthropic token budget. Coding Plan documents a disabled toggle as low-effort thinking
-  for GLM-5.3, with explicit effort taking precedence.
-- Chat also offers `toolStream`, `doSample`, `responseFormat`, `requestID`, and `userID`.
-  Tool-argument streaming is enabled when tools are present on GLM-4.6/4.7/5.x;
-  `toolStream: false` explicitly disables it. Older model families omit the opt-in.
-- Effort and thinking values remain forward-compatible strings. Their meaning is model-specific:
-  GLM-5.3 accepts `low`, `high`, and `max` effort and rejects disabled thinking with HTTP 400;
-  the direct GLM-5.2 recordings returned reasoning even with `none` and `minimal` effort,
-  whereas explicit `thinking.type: "disabled"` disabled it on GLM-5.2 and GLM-4.7.
-
-Standard API recordings cover GLM-5.3 efforts and a full preserved-reasoning tool loop with
-a subsequent user follow-up, GLM-5.2 efforts, older-model thinking toggles, GLM-4.5 tool calls,
-GLM-5.3-Flash image input, and JSON output. Coding Plan has unit coverage for routing,
-request options, and reasoning replay; successful live recordings are pending.
-
-Package entrypoints are `@opencode/ai/providers/zai`, `zai/chat`, `zai-coding-plan`,
-`zai-coding-plan/chat`, `zai-coding-plan/messages`, and `zai-coding-plan/responses`.
-
-## Moonshot
-
-Moonshot defaults to Chat Completions, with Messages and Responses selectors for Kimi K3:
-
-```ts
-import { LLM } from "@opencode/ai"
-import { Moonshot } from "@opencode/ai/providers"
-
-const moonshot = Moonshot.configure({ apiKey: process.env.MOONSHOT_API_KEY })
-
-const request = LLM.request({
-  model: moonshot.model("kimi-k3"), // also moonshot.chat("kimi-k3")
-  prompt: "Explain the tradeoffs in this design.",
-  providerOptions: { reasoningEffort: "high" },
-})
-
-const messages = LLM.request({
-  model: moonshot.messages("kimi-k3"),
-  prompt: "Explain the tradeoffs in this design.",
-  providerOptions: { effort: "high" },
-})
-
-const responses = LLM.request({
-  model: moonshot.responses("kimi-k3"),
-  prompt: "Explain the tradeoffs in this design.",
-  providerOptions: { reasoningEffort: "high" },
-})
-```
-
-When `apiKey` is omitted, authentication reads `MOONSHOT_API_KEY`, then `MOONSHOTAI_API_KEY`.
-Chat and Responses use `https://api.moonshot.ai/v1`; Messages uses
-`https://api.moonshot.ai/anthropic/v1`. `baseURL` overrides the selected API's complete base,
-including the version prefix, for regional endpoints or gateways. Each endpoint requires its own valid credentials.
-All three routes use HTTP/SSE.
-
-Reasoning options stay native to the selected API and model:
-
-| Model/API                   | Provider options                                                                        |
-| --------------------------- | --------------------------------------------------------------------------------------- |
-| K3 Chat / Responses         | `reasoningEffort: "low" \| "high" \| "max"`; default is `max`                           |
-| K3 Messages                 | `effort: "low" \| "high" \| "max"`; default is `max`                                    |
-| K2.6 Chat                   | `thinking: { type: "enabled" \| "disabled", keep?: "all" \| null }`; default is enabled |
-| K2.7 Code / high-speed Chat | Omit `thinking` to use always-on, preserved reasoning                                   |
-
-Omitting options preserves the model's defaults. K3 uses effort rather than the K2.x `thinking`
-parameter. Known effort values have autocomplete while future strings remain accepted.
-For K2.6, `thinking.keep: "all"` enables preservation of reasoning across user messages.
-K3 and both K2.7 Code variants always preserve reasoning. Continue with the returned
-`response.message` and matching tool results so reasoning content and any Messages signatures are retained.
-Leave sampling options such as `temperature` unset to use these models' fixed defaults.
-
-The recorded suite covers all three K3 APIs, default and explicit efforts, K2.6 thinking modes,
-both K2.7 Code variants, generated tool loops with a subsequent user follow-up, required/disabled
-tool choice, image-byte input, and native structured output through `http.body` overlays.
-K3 Chat and Messages accept required and disabled tool choice. Responses supports automatic tool
-choice only; explicit `required` and `none` produce a provider `InvalidRequest` error, also covered by recordings.
-The provider targets the Moonshot Open Platform; Kimi Code is a separate product and endpoint.
-
-Package entrypoints are `@opencode/ai/providers/moonshot`, `moonshot/chat`, `moonshot/messages`,
-and `moonshot/responses`; each exports `model(modelID, settings)`.
-
-## MiniMax
-
-MiniMax defaults to its Messages API and reads `MINIMAX_API_KEY` when `apiKey` is omitted:
-
-```ts
-import { Effect, Layer } from "effect"
-import { LLM, LLMClient } from "@opencode/ai"
-import { MiniMax } from "@opencode/ai/providers"
-import { RequestExecutor } from "@opencode/ai/route"
-
-const minimax = MiniMax.configure({ apiKey: process.env.MINIMAX_API_KEY })
-const request = LLM.request({
-  model: minimax.model("MiniMax-M3"), // also minimax.messages("MiniMax-M3")
-  prompt: "What is 173 multiplied by 219?",
-  providerOptions: { thinking: { type: "adaptive" } },
-  generation: { maxTokens: 1536 },
-})
-
-const layer = LLMClient.layer.pipe(Layer.provide(RequestExecutor.fetchLayer))
-const response = await Effect.runPromise(LLMClient.generate(request).pipe(Effect.provide(layer)))
-console.log(response.text)
-```
-
-Select `minimax.chat("MiniMax-M3")` or `minimax.responses("MiniMax-M3")` for MiniMax's native Chat Completions
-and Responses APIs. The matching package entrypoints are `@opencode/ai/providers/minimax/messages`,
-`@opencode/ai/providers/minimax/chat`, and `@opencode/ai/providers/minimax/responses`.
-
-- **Messages:** M3 thinking defaults off. Set `thinking: { type: "adaptive" }` to enable it or
-  `thinking: { type: "disabled" }` to disable it.
-- **Chat:** M3 thinking defaults on and uses the same `thinking` control. The provider enables `reasoning_split`
-  by default so reasoning is separate from answer text; `reasoningSplit: false` selects native `<think>`-tagged text.
-- **Responses:** M3 reasoning defaults off. `reasoningEffort: "none"` disables it; `"minimal"`, `"low"`,
-  `"medium"`, and `"high"` enable reasoning without changing its depth.
-
-M2.x models always think, even when a disabling option is supplied. For tool continuations, retain the complete
-`response.message` in history before adding `Message.tool(...)` results; this preserves reasoning and any signatures.
-
-The default API bases are `https://api.minimax.io/anthropic/v1` for Messages and `https://api.minimax.io/v1` for
-Chat and Responses. `configure({ baseURL })` replaces the selected API's base, including its version prefix.
-
-## Meta
-
-Use Meta's direct [Model API](https://dev.meta.ai/docs/overview) with `META_API_KEY`:
-
-```ts
-import { Meta } from "@opencode/ai/providers"
-
-const meta = Meta.configure() // or Meta.configure({ apiKey })
-const request = LLM.request({
-  model: meta.responses("muse-spark-1.3"), // meta.model(...) also selects Responses
-  prompt: "What is 173 multiplied by 219? Reply with the integer.",
-  providerOptions: { reasoningEffort: "low" },
-  generation: { maxTokens: 1024 },
-})
-```
-
-`meta.chat("muse-spark-1.3")` selects Chat Completions; `meta.messages("muse-spark-1.3")` selects
-the Anthropic-compatible Messages API. All use `https://api.meta.ai/v1`. The package entrypoints
-`@opencode/ai/providers/meta/responses`, `meta/chat`, and `meta/messages` expose `model(modelID, settings)`.
-
-[Muse Spark](https://dev.meta.ai/docs/models) supports `minimal`, `low`, `medium`, `high`, and
-`xhigh` reasoning effort; standard-tier 1.3 also supports `max`. Omitting effort uses the model's
-default. Muse Spark always reasons and rejects `none`. The output-token budget includes private reasoning.
-
-Responses defaults to `store: false` and `include: ["reasoning.encrypted_content"]`. Preserve
-`response.message` along with matching `Message.tool(...)` results in subsequent requests to replay
-reasoning through tool loops. Optional `reasoningSummary: "auto"` requests a readable summary.
-For server-managed history, override `store: true, include: []` and send the response ID through
-`http: { body: { previous_response_id: responseID } }` with only the new input.
-Chat Completions redacts private reasoning and cannot carry it between calls.
-Responses and Chat support only `toolChoice: "auto"` (the default). Messages also accepts `"none"`;
-its documented forced `"any"` choice currently returns HTTP 400. Messages defaults to adaptive thinking
-with `display: "omitted"`, preserving encrypted `redacted_thinking` in `response.message`. Use
-`providerOptions: { effort: "low" }` for depth or `thinking: { type: "enabled", budgetTokens: 1024 }`
-for budget compatibility (with `generation.maxTokens > 1024`).
-
-Add `tools: [Meta.webSearch()]` to a Spark Responses or Messages request for hosted web search.
-Responses exposes hosted results and URL citations in text-part `providerMetadata.meta.annotations`.
-To include search result lists, set `include: ["reasoning.encrypted_content", "web_search_call.results"]`.
-Messages exposes hosted search calls; the recorded Messages API stream does not supply structured
-citations or separate result blocks. Retain `response.message` for either API's continuation.
-
-Use `Image.generate` for one-off generation or editing:
-
-```ts
-import { Image, ImageInput } from "@opencode/ai"
-
-const generation = Image.generate({
-  model: meta.image("muse-image-1.0"),
-  prompt: "A flat black square on a white background.",
-  options: { n: 1, reasoningStrength: "low" },
-})
-
-const edit = Image.generate({
-  model: meta.image("muse-image-1.0"),
-  prompt: "Make the square purple.",
-  images: [ImageInput.bytes(imageBytes, "image/webp")],
-  options: { outputFormat: "png", reasoningStrength: "low" },
-})
-```
-
-The default image format is WEBP; `outputFormat` also accepts PNG/JPEG and `responseFormat: "url"`
-returns a signed URL. `size` is an aspect-ratio hint. For conversational images, select
-`meta.responses("muse-image-1.0")` with `tools: [Meta.imageGeneration({ reasoningStrength: "low" })]`.
-Generated images are provider-executed tool results with file content. Retain `response.message` to
-replay the signed image handle on the next request. Muse Image accepts only the `image_generation` tool.
-
-Meta Responses is explicitly HTTP/SSE-only and does not use WebSockets, even when a caller supplies
-`StreamOptions.webSocket`. The public `/v1/responses` endpoint rejects WebSocket upgrades with HTTP 405 (`Allow: POST`).
-
 ## Image generation
 
 Use `Image.generate` with an image model for direct asset generation:
 
 ```ts
-import { Image, ImageInput } from "@opencode/ai"
-import { OpenAI } from "@opencode/ai/providers"
+import { Image, ImageInput } from "@opencode-ai/ai"
+import { OpenAI } from "@opencode-ai/ai/providers"
 
 const program = Effect.gen(function* () {
   const response = yield* Image.generate({
@@ -369,7 +131,7 @@ yield *
 Google's current Gemini image models use the same direct API:
 
 ```ts
-import { Google } from "@opencode/ai/providers"
+import { Google } from "@opencode-ai/ai/providers"
 
 const googleProgram = Effect.gen(function* () {
   const response = yield* Image.generate({
@@ -445,12 +207,12 @@ The hosted result is represented as a provider-executed tool call and tool resul
 
 ## Testing
 
-Use the deterministic test client from `@opencode/ai/testing` to script provider-neutral responses and inspect
+Use the deterministic test client from `@opencode-ai/ai/testing` to script provider-neutral responses and inspect
 the requests sent by code under test:
 
 ```ts
 import { Effect } from "effect"
-import { TestLLM } from "@opencode/ai/testing"
+import { TestLLM } from "@opencode-ai/ai/testing"
 
 const programWithTestClient = Effect.gen(function* () {
   const test = yield* TestLLM.Test
@@ -479,90 +241,27 @@ Constructing `stream()` or `generate()` does not record a request, invoke a resp
 Each execution does. An exhausted queue without a fallback defects immediately rather than waiting for a
 future reply.
 
-Generation responses remain canonical event arrays or arbitrary `Stream<LLMEvent, AIError>` values. The client consumes
+Responses remain canonical event arrays or arbitrary `Stream<LLMEvent, AIError>` values. The client consumes
 supplied streams directly, preserving failure identity, finalizers, incomplete output, and post-finish tails;
 it does not repair or truncate them.
 
-For explicit compaction, script a `CompactionResponse` through `push`, `always`, or `serve`. Its `replacement` contains the next context window, including retained user messages. The client returns that result and usage directly, with the same lazy request recording and gates. Generation and compaction reject fixtures for the wrong operation instead of converting between response shapes.
-
-For `compact(request, { mechanism: "trigger" })`, script a `CompactionCheckpointResponse` instead. It carries `checkpoint`, `responseID`, and optional `usage`. Endpoint and trigger calls reject each other's fixtures; both share the same queue, gates, lazy recording, and fallback controls.
-
 The published legacy `Service`, `layer`, `clientLayer`, and module-level controls remain available as adapters
 over the same implementation, including the legacy live `requests` array. New tests should use `Test` and
 `testLayer`.
 
 ## Provider compaction
 
-Compaction is opt-in. The package supports automatic compaction in OpenAI/Azure Responses and Anthropic Messages (including Claude on Vertex), and explicit compaction calls in OpenAI/Azure/xAI Responses. Model and deployment support still depends on the provider.
+Compaction is opt-in. The package supports automatic compaction in OpenAI/Azure Responses and Anthropic Messages (including Claude on Vertex and Bedrock Messages), and explicit compaction calls in OpenAI/Azure/xAI Responses. Model and deployment support still depends on the provider.
 
 This is different from prompt caching, server-side history storage, or truncation. Compaction returns provider-owned context that must be replayed to continue the conversation.
 
-### Explicit compaction
-
-`LLMClient.compact(request)` (equivalently, `{ mechanism: "endpoint" }`) is the caller-controlled operation for OpenAI, Azure, and xAI Responses. It performs exactly one HTTP call to `/responses/compact`, using the selected route's endpoint, credentials, query, and HTTP middleware. It returns a `CompactionResponse` with `replacement: Message[]` and optional `usage`, not a normal generation response. This mechanism does not accept a WebSocket executor.
-
-Prefer this operation, where supported, when the application owns compaction policy and durable context updates.
-
-```ts
-const result = yield * LLMClient.compact(request)
-const next = LLMRequest.update(request, {
-  messages: result.replacement,
-})
-const response = yield * LLMClient.generate(next)
-```
-
-`replacement` replaces the complete input window. Do not append it to the original transcript or extract only the encrypted item: the provider may retain additional messages in its output. Retained user and assistant messages remain ordinary messages with typed text, media, or reasoning parts, in their original order. Provider-specific message IDs, status, and phase use `providerMetadata`, not a raw output array hidden in an assistant message. Unsupported returned item types fail explicitly.
-
-The selected model carries explicit-compaction capability through request construction and updates. Calls using unsupported routes fail type checking. When the model is selected dynamically, narrow the request with `LLMClient.canCompact(request)` before calling `LLMClient.compact`; a model or route switch does not inherit the old capability. Runtime validation still rejects unsupported calls from untyped consumers. Capability describes the route's API, not whether every model or custom deployment supports the operation.
-
-Generation-only body overlays such as `stream` and `store` are not sent to the compact endpoint. Supported compact controls such as service tier and prompt-cache settings preserve request defaults and HTTP-overlay precedence. Retained image and file detail settings survive serialization and replay.
-
-The input must still fit the model's context window. Explicit compaction is not an overflow-recovery operation. Anthropic does not expose this operation in this package; its in-band compaction remains available below. Compatible routes do not inherit an explicit compact endpoint simply because they use a Responses protocol.
-
-### Streamed checkpoint compaction
-
-OpenAI Responses also exposes a separate, explicitly selected mechanism:
-
-```ts
-const result =
-  yield *
-  LLMClient.compact(request, {
-    mechanism: "trigger",
-    webSocket, // Optional: without it, the request uses HTTP/SSE.
-  })
-
-result.checkpoint // Successful encrypted CompactionPart.
-result.responseID
-result.usage
-```
-
-This appends a native `compaction_trigger` control item to the full input and sends a normal Responses request, with tools and instructions retained, `stream: true`, `store: false`, and parallel tool calls enabled. It removes normal-answer text/output-format controls, forced tool choices, output-token/tool-call limits, and automatic `context_management`. Body overlays cannot replace `input` or supply `previous_response_id`/`conversation`; the complete canonical history is required for safe stateless replay. Request metadata, auth, headers, query parameters, service tier, and supported prompt-cache settings are preserved.
-
-Only a successful `response.completed` with a response ID and exactly one logical encrypted checkpoint succeeds. Repeated item events are correlated by ID/output slot, including ID-less checkpoints. Other output is ignored, not returned as assistant text or dispatched as tools. Failed, incomplete, malformed, and interrupted responses return errors rather than partial checkpoints.
-
-The result is **not a replacement window**. The caller selects retained history, combines it with `result.checkpoint`, and durably installs it before continuing. The operation does not choose a retention budget, prune messages, or modify the original request.
-
-The supplied WebSocket executor can reuse a compatible append baseline for the compaction request. On completion the protocol supplies no continuation checkpoint, clearing the old baseline so the next generation sends the newly installed window in full. Validation occurs before transport completion is acknowledged. There is no operation-level retry or fallback to `/responses/compact`; existing safe transport fallback may use SSE, with full history and no connection-local response ID.
-
-Trigger support is separate from endpoint support. Only the OpenAI Responses route advertises it; Azure, xAI, Chat, and compatible Responses routes do not inherit it. Untyped calls still fail before sending: missing route capabilities return `UnsupportedOperation`, while unknown mechanism names and invalid inputs return `InvalidRequest`. Dynamic callers must narrow for the selected mechanism:
-
-```ts
-if (LLMClient.canCompact(request, { mechanism: "trigger" })) {
-  const result = yield * LLMClient.compact(request, { mechanism: "trigger" })
-}
-```
-
-This capability describes protocol implementation, **not universal availability on OpenAI API deployments**. The host application owns subscription/deployment eligibility, OAuth, endpoint selection, and deployment-specific headers. Local protocol/socket tests do not establish live provider support.
-
-### Advanced: in-band compaction
-
-`providerOptions.contextManagement` lets the provider decide when to compact during an ordinary `generate` or `stream` call. This is an advanced option for callers that own persistence and recovery: persist the complete assistant message, including its checkpoint, before continuing. Enabling the option does not provide durable checkpoint storage, interruption recovery, or model-switch policy. Keep the prior context until a successful checkpoint has been persisted.
+### Automatic compaction
 
 Inside an `Effect.gen`, enable OpenAI compaction with typed provider options:
 
 ```ts
-import { LLM, LLMClient, LLMRequest, Message } from "@opencode/ai"
-import { OpenAI } from "@opencode/ai/providers"
+import { LLM, LLMClient, LLMRequest, Message } from "@opencode-ai/ai"
+import { OpenAI } from "@opencode-ai/ai/providers"
 
 const request = LLM.request({
   model: OpenAI.configure({ apiKey }).responses("gpt-5.3-codex"),
@@ -582,7 +281,7 @@ const next = LLMRequest.update(request, {
 A compaction part has `provider` and exactly one representation: `encrypted` for Responses, or `text` for Anthropic. Responses also preserves the optional checkpoint `id`. These fields survive message serialization without becoming visible assistant text. Sending a checkpoint to another provider or an incompatible API fails rather than silently losing context.
 
 ```ts
-import { CompactionPart, ProviderID } from "@opencode/ai"
+import { CompactionPart, ProviderID } from "@opencode-ai/ai"
 
 CompactionPart.make({ provider: ProviderID.make("openai"), id: "cmp_123", encrypted: "..." })
 CompactionPart.make({ provider: ProviderID.make("anthropic"), text: "Summary of the conversation..." })
@@ -606,13 +305,41 @@ providerOptions: {
 - The trigger is optional (provider default: 150,000 tokens), with a minimum of 50,000.
 - Custom instructions replace Anthropic's default summarization instructions.
 - The route adds `compact-2026-01-12` to existing beta headers, including when replaying a checkpoint without enabling new compactions.
-- A pause is exposed as `response.finishReason.raw === "compaction"`. It occurs only if the threshold triggers compaction: `pauseAfterCompaction` does not mean "compact now". The caller explicitly issues the next request; the package never automatically resumes.
+- A pause is exposed as `response.finishReason.raw === "compaction"`. The caller explicitly issues the next request; the package never automatically resumes.
 - Anthropic can return a compaction block with `content: null` when summarization fails. This becomes a compaction part with `text: null`, which is **not** a successful replacement for prior history. The package never prunes history automatically.
 - `Usage` totals include all reported Anthropic `usage.iterations`, including compaction. `contextTokens` separately reports the final message iteration's inclusive input size, when available. A compaction-only pause does not report a post-compaction context size. Raw iteration usage remains in `providerMetadata`.
 
-### Recording tests
+Bedrock's Converse API does not support this feature. Select the native Claude Messages route explicitly; the default `.model(...)` remains Converse:
 
-Tests cover serialized round trips, real local HTTP plus a tool loop, WebSocket recovery, provider errors, malformed blocks, and usage accounting. Live provider tests are gated by `RECORD=true` and the relevant API keys:
+```ts
+import { AmazonBedrock } from "@opencode-ai/ai/providers"
+
+const model = AmazonBedrock.configure({ region: "us-east-1", credentials }).messages("us.anthropic.claude-opus-4-6-v1")
+```
+
+The corresponding package entrypoint is `@opencode-ai/ai/providers/amazon-bedrock/messages`. It uses InvokeModelWithResponseStream, AWS event-stream framing, bearer or SigV4 auth, and `anthropic_beta` in the request body.
+
+### Explicit compaction
+
+`LLMClient.compact(request)` performs exactly one HTTP call to `/responses/compact`, using the selected route's endpoint, credentials, query, and HTTP middleware. It returns a `CompactionResponse` containing replacement `messages` and usage, not a normal generation response.
+
+```ts
+const compacted = yield * LLMClient.compact(request)
+const next = LLMRequest.update(request, {
+  messages: [...compacted.messages, Message.user("Continue")],
+})
+const response = yield * LLMClient.generate(next)
+```
+
+Replace the prior window with `compacted.messages`. Do not append it to the original transcript or extract only the encrypted item: the provider may retain additional messages in its output. Retained user and assistant messages remain ordinary messages with typed text, media, or reasoning parts, in their original order. Provider-specific message IDs, status, and phase use `providerMetadata`, not a raw output array hidden in an assistant message. Unsupported returned item types fail explicitly. Generation-only body overlays such as `stream` and `store` are not sent to the compact endpoint.
+
+The input must still fit the model's context window. Explicit compaction is not an overflow-recovery operation. xAI supports this explicit path, not the automatic OpenAI option. Unsupported routes, including Bedrock Mantle, do not inherit an explicit compact endpoint simply because they use a Responses protocol.
+
+### Ownership and verification
+
+The AI package transports options and typed conversation parts. It does not schedule compaction, persist Session checkpoints, select history, switch providers, or replace Core's existing local compaction policy. Native compaction is not enabled for OpenCode Sessions by this feature; Session integration must persist these parts before enabling it. The AI SDK bridge rejects native compaction parts rather than dropping them. Provider-executed tool APIs and persistence changes are a separate follow-up.
+
+Tests cover serialized round trips, real local HTTP plus a tool loop, AWS binary frames and signing, provider errors, malformed blocks, and usage accounting. Live provider tests are gated by `RECORD=true` and the relevant API keys:
 
 ```sh
 # Run from packages/ai. Only records the selected new cassette group.
@@ -621,7 +348,7 @@ RECORD=true RECORDED_PREFIX=xai-compaction bun test test/provider/compaction.rec
 RECORD=true RECORDED_PREFIX=anthropic-compaction bun test test/provider/compaction.recorded.test.ts
 ```
 
-Provider references: [OpenAI](https://developers.openai.com/api/docs/guides/compaction), [Azure](https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/responses#server-side-compaction), [Anthropic](https://platform.claude.com/docs/en/build-with-claude/compaction), [xAI](https://docs.x.ai/developers/advanced-api-usage/context-compaction).
+Provider references: [OpenAI](https://developers.openai.com/api/docs/guides/compaction), [Azure](https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/responses#server-side-compaction), [Anthropic](https://platform.claude.com/docs/en/build-with-claude/compaction), [Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/claude-messages-compaction.html), [xAI](https://docs.x.ai/developers/advanced-api-usage/context-compaction).
 
 ## Caching
 
@@ -629,7 +356,7 @@ Prompt caching is **on by default**. Every `LLMRequest` resolves to `cache: "aut
 
 ### Auto placement
 
-`"auto"` places up to four breakpoints — the last tool definition, the first system part, the last system part when distinct, and the final message boundary. These expose successively larger reusable prefixes for tool definitions, system instructions, and the active conversation. The rolling final-message boundary advances on every request so recent conversation prefixes remain reusable during tool loops.
+`"auto"` places up to four breakpoints — the last tool definition, the first system part, the last system part when distinct, and the final message boundary. These expose successively larger reusable prefixes for tools, the base agent, project instructions, and the active conversation. The rolling final-message boundary advances on every request so recent conversation prefixes remain reusable during tool loops.
 
 Tools precede every system and conversation block in the provider prefix, so tool definitions must remain byte-stable and deterministically ordered for downstream breakpoints to remain reusable.
 
@@ -688,7 +415,7 @@ Normalized cache usage is read back into `response.usage.cacheReadInputTokens` a
 Provider facades configure endpoint/auth/deployment details first, then expose model selectors that take only a model or deployment id. The selected model carries the executable route value used at runtime.
 
 ```ts
-import { OpenAI, CloudflareAIGateway } from "@opencode/ai/providers"
+import { OpenAI, CloudflareAIGateway } from "@opencode-ai/ai/providers"
 
 const openai = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).responses("gpt-4o-mini")
 const gateway = CloudflareAIGateway.configure({
@@ -697,42 +424,31 @@ const gateway = CloudflareAIGateway.configure({
 }).model("workers-ai/@cf/meta/llama-3.1-8b-instruct")
 ```
 
-Included LLM providers: OpenAI, Anthropic, Google (Gemini), Google Vertex, Amazon Bedrock, Azure OpenAI, Baseten, Cerebras, Cloudflare AI Gateway, Cloudflare Workers AI, DeepInfra, DeepSeek, Fireworks, Groq, Mistral, OpenRouter, TogetherAI, and xAI. Z.ai currently exposes image generation. Generic Chat Completions, Responses, and Anthropic Messages-compatible entrypoints support custom endpoints.
+Included providers: OpenAI, Anthropic, Google (Gemini), Google Vertex Gemini and Anthropic, Amazon Bedrock, Azure OpenAI, Cloudflare AI Gateway, Cloudflare Workers AI, GitHub Copilot, OpenRouter, xAI, Z.ai, plus generic OpenAI-compatible Chat and Responses entrypoints and an Anthropic Messages-compatible entrypoint.
 
-Each named provider owns its module, endpoint, authentication, and route setup. Providers with the same wire format compose the shared protocol directly:
+### Package-like entrypoints
+
+Native catalog integrations load provider behavior through package-like entrypoints. These are export paths from the same `@opencode-ai/ai` npm package, not independently published packages. Each entrypoint exports the same `model(modelID, settings)` contract, and `settings` contains serializable provider configuration plus common `headers` and `body` overlays.
 
 ```ts
-import { DeepSeek, Fireworks } from "@opencode/ai/providers"
-
-const deepseek = DeepSeek.configure({ apiKey }).model("deepseek-chat")
-const fireworks = Fireworks.configure({ apiKey }).model("accounts/fireworks/models/my-model")
-```
-
-The former `OpenAICompatible.baseten`, `.cerebras`, `.deepinfra`, `.deepseek`, `.fireworks`, `.groq`, and `.togetherai` presets are replaced by the top-level `Baseten`, `Cerebras`, `DeepInfra`, `DeepSeek`, `Fireworks`, `Groq`, and `TogetherAI` exports. Use `CloudflareAIGateway` and `CloudflareWorkersAI` directly; each has its own module. `OpenAICompatible` configures generic endpoints with an explicit `baseURL`.
-
-### Provider entrypoints
-
-Provider modules are available through dedicated exports from `@opencode/ai`. Each LLM entrypoint exports `model(modelID, settings)`, where `settings` contains provider configuration plus common `headers` and `body` overlays.
-
-```ts
-import { model } from "@opencode/ai/providers/openai/responses"
+import { model } from "@opencode-ai/ai/providers/openai/responses"
 
 const selected = model("gpt-5", {
   apiKey: process.env.OPENAI_API_KEY,
-  headers: { "x-application": "example" },
+  headers: { "x-application": "opencode" },
 })
 ```
 
-APIs have separate entrypoints:
+OpenAI Chat and OpenAI Responses are separate semantic entrypoints:
 
-- `@opencode/ai/providers/openai/chat`
-- `@opencode/ai/providers/openai/responses`
-- `@opencode/ai/providers/openai-compatible/responses`
-- `@opencode/ai/providers/anthropic-compatible`
-- `@opencode/ai/providers/google-vertex/gemini`
-- `@opencode/ai/providers/google-vertex/chat`
-- `@opencode/ai/providers/google-vertex/responses`
-- `@opencode/ai/providers/google-vertex/messages`
+- `@opencode-ai/ai/providers/openai/chat`
+- `@opencode-ai/ai/providers/openai/responses`
+- `@opencode-ai/ai/providers/openai-compatible/responses`
+- `@opencode-ai/ai/providers/anthropic-compatible`
+- `@opencode-ai/ai/providers/google-vertex/gemini`
+- `@opencode-ai/ai/providers/google-vertex/chat`
+- `@opencode-ai/ai/providers/google-vertex/responses`
+- `@opencode-ai/ai/providers/google-vertex/messages`
 
 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.
 
@@ -741,36 +457,32 @@ Vertex Gemini, Vertex Chat, Vertex Responses, and Vertex Messages are separate A
 Tuned Vertex Gemini deployments use model ids shaped like `endpoints/1234567890` and require OAuth or ADC; Vertex express-mode API keys support publisher models only.
 
 ```ts
-import { model } from "@opencode/ai/providers/google-vertex/gemini"
+import { model } from "@opencode-ai/ai/providers/google-vertex/gemini"
 
 model("gemini-3.5-flash", { project: "my-project", location: "global" })
 ```
 
 ```ts
-import { model } from "@opencode/ai/providers/google-vertex/chat"
+import { model } from "@opencode-ai/ai/providers/google-vertex/chat"
 
 model("deepseek-ai/deepseek-v3.2-maas", { project: "my-project", location: "global" })
 ```
 
 ```ts
-import { model } from "@opencode/ai/providers/google-vertex/responses"
+import { model } from "@opencode-ai/ai/providers/google-vertex/responses"
 
 model("xai/grok-4.20-reasoning", { project: "my-project", location: "global" })
 ```
 
 ```ts
-import { model } from "@opencode/ai/providers/google-vertex/messages"
+import { model } from "@opencode-ai/ai/providers/google-vertex/messages"
 
 model("claude-sonnet-4-6", { project: "my-project", location: "global" })
 ```
 
-Additional provider entrypoints include:
+Provider facades such as `OpenAI.configure(...).responses(...)` remain the direct application API. Package-like entrypoints are the self-similar loading contract used when a catalog selects behavior by export path.
 
-- `@opencode/ai/providers/baseten`
-- `@opencode/ai/providers/deepseek`
-- `@opencode/ai/providers/fireworks`
-- `@opencode/ai/providers/cloudflare-ai-gateway`
-- `@opencode/ai/providers/cloudflare-workers-ai`
+Other provider exports listed above remain direct facades until they explicitly implement the package-like contract. Exporting a provider facade does not implicitly make it a catalog-loadable provider package.
 
 ## Provider options & HTTP overlays
 
@@ -797,7 +509,7 @@ LLM.request({
 
 ## Routes
 
-Compose a route with `Route.make({ protocol, endpoint, auth, framing, ... })`. The route owns endpoint/auth/framing and the protocol owns body construction plus stream parsing. Transports receive the route's endpoint and auth when preparing requests. Unsupported request shapes fail during protocol lowering.
+Adding a new model or deployment is usually 5-15 lines using `Route.make({ protocol, endpoint, auth, framing, ... })`. The route owns endpoint/auth/framing and the protocol owns body construction plus stream parsing. Transports are reusable IO templates that receive route endpoint/auth at compile time. Capability/catalog metadata lives outside this low-level package; unsupported request shapes fail during protocol lowering. See `AGENTS.md` for the architectural detail.
 
 ## Effect
 

packages/ai/example/tutorial.ts

@@ -1,7 +1,7 @@
 import { Config, Effect, Formatter, Layer, Schema, Stream } from "effect"
-import { LLM, LLMClient, LLMRequest, Message, ProviderID, Tool, ToolRuntime } from "@opencode/ai"
-import { Route, Auth, Endpoint, Framing, Protocol, RequestExecutor } from "@opencode/ai/route"
-import { OpenAI } from "@opencode/ai/providers"
+import { LLM, LLMClient, LLMRequest, Message, ProviderID, Tool, ToolRuntime } from "@opencode-ai/ai"
+import { Route, Auth, Endpoint, Framing, Protocol, RequestExecutor } from "@opencode-ai/ai/route"
+import { OpenAI } from "@opencode-ai/ai/providers"
 
 /**
  * A runnable walkthrough of the LLM package use-site API.

packages/ai/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "version": "1.17.20",
-  "name": "@opencode/ai",
+  "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
   "scripts": {
@@ -21,17 +21,16 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "catalog:",
-    "@opencode/http-recorder": "workspace:*",
+    "@opencode-ai/http-recorder": "workspace:*",
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
     "@typescript/native-preview": "catalog:",
     "typescript": "catalog:"
   },
   "dependencies": {
-    "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "workspace:*",
+    "@opencode-ai/schema": "workspace:*",
     "aws4fetch": "1.0.20",
     "effect": "catalog:",
     "google-auth-library": "10.5.0"

packages/ai/script/publish.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { Script } from "@opencode/script"
+import { Script } from "@opencode-ai/script"
 import { $ } from "bun"
 import { fileURLToPath } from "url"
 

packages/ai/script/setup-recording-env.ts

@@ -7,8 +7,7 @@ import { AwsV4Signer } from "aws4fetch"
 import { Config, ConfigProvider, Effect, FileSystem, PlatformError, Redacted } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest, type HttpClientResponse } from "effect/unstable/http"
 import * as ProviderShared from "../src/protocols/shared"
-import { CloudflareAIGateway } from "../src/providers/cloudflare-ai-gateway.js"
-import { CloudflareWorkersAI } from "../src/providers/cloudflare-workers-ai.js"
+import * as Cloudflare from "../src/providers/cloudflare"
 
 type Provider = {
   readonly id: string
@@ -121,11 +120,11 @@ const PROVIDERS: ReadonlyArray<Provider> = [
     ],
     validate: (env) =>
       validateChat({
-        url: `${CloudflareAIGateway.baseURL({
+        url: `${Cloudflare.aiGatewayBaseURL({
           accountId: env.CLOUDFLARE_ACCOUNT_ID,
           gatewayId: env.CLOUDFLARE_GATEWAY_ID || undefined,
         })}/chat/completions`,
-        token: Redacted.make(envValue(env, CloudflareAIGateway.authEnvVars)),
+        token: Redacted.make(envValue(env, Cloudflare.aiGatewayAuthEnvVars)),
         tokenHeader: "cf-aig-authorization",
         model: "workers-ai/@cf/meta/llama-3.1-8b-instruct",
       }),
@@ -141,8 +140,8 @@ const PROVIDERS: ReadonlyArray<Provider> = [
     ],
     validate: (env) =>
       validateChat({
-        url: `${CloudflareWorkersAI.baseURL({ accountId: env.CLOUDFLARE_ACCOUNT_ID })}/chat/completions`,
-        token: Redacted.make(envValue(env, CloudflareWorkersAI.authEnvVars)),
+        url: `${Cloudflare.workersAIBaseURL({ accountId: env.CLOUDFLARE_ACCOUNT_ID })}/chat/completions`,
+        token: Redacted.make(envValue(env, Cloudflare.workersAIAuthEnvVars)),
         model: "@cf/meta/llama-3.1-8b-instruct",
       }),
   },

packages/ai/src/cache-policy.ts

@@ -11,7 +11,7 @@
 // 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.js"
-import { LLMRequest, Message, ToolDefinition, type ContentPart, type ToolEntry } from "./schema/messages.js"
+import { LLMRequest, Message, ToolDefinition, type ContentPart } from "./schema/messages.js"
 
 const AUTO: CachePolicyObject = {
   tools: true,
@@ -40,6 +40,7 @@ const RESPECTS_INLINE_HINTS = new Set([
   "anthropic-messages",
   "google-vertex-messages",
   "bedrock-converse",
+  "bedrock-messages",
   "openrouter",
 ])
 
@@ -50,24 +51,18 @@ interface Budget {
   remaining: number
 }
 
-const markLastTool = (tools: ReadonlyArray<ToolEntry>, hint: CacheHint, budget: Budget): ReadonlyArray<ToolEntry> => {
-  const target = tools.at(-1)
-  if (target === undefined) return tools
-  if (target.type === "namespace") {
-    const nested = markLastTool(target.tools, hint, budget)
-    return nested === target.tools ? tools : [...tools.slice(0, -1), { ...target, tools: nested }]
-  }
-  if (target.cache || budget.remaining === 0) return tools
+const markLastTool = (
+  tools: ReadonlyArray<ToolDefinition>,
+  hint: CacheHint,
+  budget: Budget,
+): ReadonlyArray<ToolDefinition> => {
+  if (tools.length === 0) return tools
+  const last = tools.length - 1
+  if (tools[last]!.cache || budget.remaining === 0) return tools
   budget.remaining -= 1
-  return [...tools.slice(0, -1), new ToolDefinition({ ...target, cache: hint })]
+  return tools.map((tool, i) => (i === last ? new ToolDefinition({ ...tool, cache: hint }) : tool))
 }
 
-const countToolHints = (tools: ReadonlyArray<ToolEntry>): number =>
-  tools.reduce(
-    (count, tool) => count + (tool.type === "tool" ? (tool.cache === undefined ? 0 : 1) : countToolHints(tool.tools)),
-    0,
-  )
-
 const markSystemBoundaries = (system: LLMRequest["system"], hint: CacheHint, budget: Budget): LLMRequest["system"] => {
   if (system.length === 0) return system
   let changed = false
@@ -128,7 +123,7 @@ const markMessages = (
 }
 
 const countHints = (request: LLMRequest) =>
-  countToolHints(request.tools) +
+  request.tools.reduce((count, tool) => count + (tool.cache === undefined ? 0 : 1), 0) +
   request.system.reduce((count, part) => count + (part.cache === undefined ? 0 : 1), 0) +
   request.messages.reduce(
     (count, message) =>

packages/ai/src/llm.ts

@@ -12,10 +12,9 @@ import {
   LanguageModel,
   SystemPart,
   ToolChoice,
-  ToolEntry,
+  ToolDefinition,
   type ContentPart,
   type LanguageModelProviderOptions,
-  type ToolEntryInput,
 } from "./schema/index.js"
 import { make as makeTool, toDefinitions, type ToolSchema } from "./tool.js"
 
@@ -28,7 +27,7 @@ export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageM
   readonly system?: string | SystemPart | ReadonlyArray<SystemPart>
   readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>
   readonly messages?: ReadonlyArray<Message | Message.Input>
-  readonly tools?: ReadonlyArray<ToolEntryInput>
+  readonly tools?: ReadonlyArray<ToolDefinition.Input>
   readonly toolChoice?: ToolChoice.Input
   readonly generation?: GenerationOptions.Input
   readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>
@@ -57,7 +56,7 @@ export const request = <const SelectedLanguageModel extends LanguageModel>(
     ...rest,
     system: SystemPart.content(requestSystem),
     messages: [...(messages?.map(Message.make) ?? []), ...(prompt === undefined ? [] : [Message.user(prompt)])],
-    tools: tools?.map(ToolEntry.make) ?? [],
+    tools: tools?.map(ToolDefinition.make) ?? [],
     toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined,
     generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration),
     providerOptions: requestProviderOptions,

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

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer"
 import { Effect, Option, Schema } from "effect"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import { Route } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
@@ -50,30 +50,20 @@ const SSE_EVENTS = new Set([
 ])
 export const framing = Framing.sseEvents(SSE_EVENTS)
 
-export type ThinkingBlockBinding = {
-  readonly prefix_mismatch_behavior?: "error" | "drop_block" | (string & {})
-}
-
 export type ThinkingInput =
   | {
       readonly type: "adaptive"
       readonly display?: "summarized" | "omitted"
-      readonly block_binding?: ThinkingBlockBinding
     }
   | {
       readonly type: "disabled"
     }
-  | ({
-      readonly type: "enabled"
-      readonly display?: "summarized" | "omitted"
-      readonly block_binding?: ThinkingBlockBinding
-    } & (
+  | ({ readonly type: "enabled"; readonly display?: "summarized" | "omitted" } & (
       | { readonly budgetTokens: number; readonly budget_tokens?: number }
       | { readonly budgetTokens?: number; readonly budget_tokens: number }
     ))
 
 export interface OptionsInput {
-  /** Advanced in-band compaction. The caller owns checkpoint persistence and recovery. */
   readonly contextManagement?: ContextManagement
   readonly [key: string]: unknown
   readonly thinking?: ThinkingInput
@@ -310,27 +300,20 @@ const AnthropicToolChoice = Schema.Union([
   }),
 ])
 
-const AnthropicThinkingBlockBinding = Schema.Struct({
-  prefix_mismatch_behavior: Schema.optional(Schema.String),
-})
-
 const AnthropicThinking = Schema.Union([
   Schema.Struct({
     type: Schema.tag("enabled"),
     budget_tokens: Schema.Number,
     display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
-    block_binding: Schema.optional(AnthropicThinkingBlockBinding),
   }),
   Schema.Struct({
     type: Schema.tag("adaptive"),
     display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
-    block_binding: Schema.optional(AnthropicThinkingBlockBinding),
   }),
   Schema.Struct({
     type: Schema.tag("disabled"),
   }),
 ])
-type AnthropicThinking = typeof AnthropicThinking.Type
 
 // SDK OutputConfig:2684 {effort?: "low"|"medium"|"high"|"xhigh"|"max"|null, format?: JSONOutputFormat:2399}
 const AnthropicJsonOutputFormat = Schema.Struct({
@@ -1041,9 +1024,8 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
           ...(outputConfigEffort === undefined ? {} : { effort: outputConfigEffort }),
           ...(outputConfigFormat === undefined ? {} : { format: outputConfigFormat }),
         }
-  const thinking = yield* resolveThinking(input?.thinking)
   return {
-    thinking: applyThinkingBindingDefault(request.model, thinking),
+    thinking: yield* resolveThinking(input?.thinking),
     effort: outputConfigEffort,
     output_config,
     service_tier,
@@ -1054,41 +1036,15 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
   }
 })
 
-const supportsThinkingBlockBinding = (model: LLMRequest["model"]) => {
-  const override = model.compatibility?.supportsThinkingBlockBinding
-  if (override !== undefined) return override
-  // Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
-  const version = /(?:^|[./])claude-[a-z]+-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/i.exec(model.id)?.groups
-  if (!version) return false
-  const major = Number(version.major)
-  const minor = Number(version.minor ?? 0)
-  return major > 5 || (major === 5 && minor >= 1)
-}
-
-const applyThinkingBindingDefault = (model: LLMRequest["model"], thinking: AnthropicThinking | undefined) => {
-  if (thinking?.type === "disabled") return thinking
-  if (!supportsThinkingBlockBinding(model)) return thinking
-  return {
-    ...(thinking ?? { type: "adaptive" as const }),
-    block_binding: {
-      prefix_mismatch_behavior: "drop_block",
-      ...thinking?.block_binding,
-    },
-  }
-}
-
 const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input: unknown) {
   if (!ProviderShared.isRecord(input)) return undefined
-  if (input.type === "disabled") return { type: "disabled" as const }
-  if (input.type !== "adaptive" && input.type !== "enabled") return undefined
-  const block_binding = yield* ProviderShared.validateWith(
-    Schema.decodeUnknownEffect(Schema.UndefinedOr(AnthropicThinkingBlockBinding)),
-  )(input.block_binding)
   const display =
     input.display === "summarized" || input.display === "omitted"
       ? (input.display as "summarized" | "omitted")
       : undefined
-  if (input.type === "adaptive") return { type: "adaptive" as const, display, block_binding }
+  if (input.type === "adaptive") return { type: "adaptive" as const, ...(display === undefined ? {} : { display }) }
+  if (input.type === "disabled") return { type: "disabled" as const }
+  if (input.type !== "enabled") return undefined
   const budget =
     typeof input.budgetTokens === "number"
       ? input.budgetTokens
@@ -1097,7 +1053,7 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
         : undefined
   if (budget === undefined)
     return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens")
-  return { type: "enabled" as const, budget_tokens: budget, display, block_binding }
+  return { type: "enabled" as const, budget_tokens: budget, ...(display === undefined ? {} : { display }) }
 })
 
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) {
@@ -1110,11 +1066,10 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
   // messages. Tools live highest in the cache hierarchy, so when callers
   // over-mark we keep their tool hints and shed the message-tail ones first.
   const breakpoints = Cache.newBreakpoints(ANTHROPIC_BREAKPOINT_CAP)
-  const flattened = ProviderShared.flattenToolRequest(request)
   const tools =
-    flattened.tools.length === 0
+    request.tools.length === 0
       ? undefined
-      : flattened.tools.map((tool) =>
+      : request.tools.map((tool) =>
           lowerTool(
             breakpoints,
             tool,
@@ -1132,7 +1087,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
           text: part.text,
           cache_control: cacheControl(breakpoints, part.cache),
         }))
-  const messages = yield* lowerMessages(flattened.request, breakpoints)
+  const messages = yield* lowerMessages(request, breakpoints)
   if (breakpoints.dropped > 0) {
     yield* Effect.logWarning(
       `Anthropic Messages: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${ANTHROPIC_BREAKPOINT_CAP} per request.`,
@@ -1679,21 +1634,24 @@ export const protocol = Protocol.make({
   },
 })
 
-export const transport = <
-  Body extends Pick<AnthropicMessagesBody, "messages" | "context_management" | "thinking">,
->() => {
+export const transport = <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management">>() => {
   const http = HttpTransport.httpJson<Body, string>({ framing })
   return {
     ...http,
     prepare: (input: Parameters<typeof http.prepare>[0]) => {
-      const requiredBetas = requiredBetaHeaders(input.body)
-      if (requiredBetas.length === 0) return http.prepare(input)
+      if (
+        !input.body.context_management?.edits.length &&
+        !input.body.messages.some((message) => message.content.some((block) => block.type === "compaction"))
+      )
+        return http.prepare(input)
       const headers = Headers.fromInput(input.request.http?.headers)
-      const existingBetas = (headers["anthropic-beta"] ?? "")
-        .split(",")
-        .map((item) => item.trim())
-        .filter(Boolean)
-      const betas = new Set([...existingBetas, ...requiredBetas])
+      const betas = new Set(
+        (headers["anthropic-beta"] ?? "")
+          .split(",")
+          .map((item) => item.trim())
+          .filter(Boolean),
+      )
+      betas.add("compact-2026-01-12")
       return http.prepare({
         ...input,
         request: LLMRequest.update(input.request, {
@@ -1707,20 +1665,6 @@ export const transport = <
   }
 }
 
-function requiredBetaHeaders(body: Pick<AnthropicMessagesBody, "messages" | "context_management" | "thinking">) {
-  const betas: string[] = []
-  const requestsCompaction = (body.context_management?.edits.length ?? 0) > 0
-  const replaysCompaction = body.messages.some((message) =>
-    message.content.some((block) => block.type === "compaction"),
-  )
-  if (requestsCompaction || replaysCompaction) betas.push("compact-2026-01-12")
-
-  const thinking = body.thinking
-  if (thinking && thinking.type !== "disabled" && thinking.block_binding)
-    betas.push("thinking-binding-controls-2026-08-01")
-  return betas
-}
-
 export const route = Route.make({
   id: ADAPTER,
   provider: "anthropic",

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

@@ -415,7 +415,10 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
 
 // System prompts share the cache-point convention: emit the text block, then
 // optionally a positional `cachePoint` marker.
-const lowerSystem = (breakpoints: BedrockCache.Breakpoints, system: ReadonlyArray<LLMRequest["system"][number]>) => {
+const lowerSystem = (
+  breakpoints: BedrockCache.Breakpoints,
+  system: ReadonlyArray<LLMRequest["system"][number]>,
+) => {
   const content = system
     .filter((part) => part.text.length > 0)
     .flatMap((part) => textWithCache(breakpoints, part.text, part.cache))
@@ -424,22 +427,21 @@ const lowerSystem = (breakpoints: BedrockCache.Breakpoints, system: ReadonlyArra
 
 const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request: LLMRequest) {
   const toolChoice = request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined
-  const flattened = ProviderShared.flattenToolRequest(request)
   const generation = request.generation
   // Bedrock-Claude shares Anthropic's 4-breakpoint cap. Spend the budget in
   // tools → system → messages order to favour the highest-impact prefixes.
-  const breakpoints = BedrockCache.breakpoints(request.model.id)
+  const breakpoints = BedrockCache.breakpoints()
   const toolConfig = (() => {
-    if (flattened.tools.length === 0) return undefined
+    if (request.tools.length === 0) return undefined
     return {
-      tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, flattened.tools),
+      tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, request.tools),
       // Converse has no native "none". Keep definitions stable for prompt
       // caching and omit only the unsupported choice.
       toolChoice,
     }
   })()
   const system = lowerSystem(breakpoints, request.system)
-  const messages = yield* lowerMessages(flattened.request, breakpoints)
+  const messages = yield* lowerMessages(request, breakpoints)
   if (breakpoints.dropped > 0) {
     yield* Effect.logWarning(
       `Bedrock Converse: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${BedrockCache.BEDROCK_BREAKPOINT_CAP} per request.`,
@@ -506,11 +508,11 @@ const mapUsage = (usage: BedrockUsageSchema | undefined, providerMetadataKey: st
 interface ParserState {
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<number>
+  readonly finishedTools: ReadonlySet<number>
   // Bedrock splits the finish into `messageStop` (carries `stopReason`) and
-  // `metadata` (carries usage). Hold both in state so `onHalt` can emit exactly
-  // one finish after both chunks have had a chance to arrive.
-  readonly finishReason: FinishReasonDetails | undefined
-  readonly usage: Usage | undefined
+  // `metadata` (carries usage). Hold the terminal event in state so `onHalt`
+  // can emit exactly one finish after both chunks have had a chance to arrive.
+  readonly pendingFinish: { readonly reason: FinishReasonDetails; readonly usage?: Usage } | undefined
   readonly hasToolCalls: boolean
   readonly lifecycle: Lifecycle.State
   readonly reasoningSignatures: Readonly<Record<number, string>>
@@ -617,14 +619,16 @@ const step = (state: ParserState, event: BedrockEvent) =>
     }
 
     if (event.contentBlockDelta?.delta?.toolUse) {
-      // A delta for a block that is not open, whether it already stopped or never
-      // started, has nothing to attach to and is dropped.
-      const result = ToolStream.append(
+      const index = event.contentBlockDelta.contentBlockIndex
+      if (state.finishedTools.has(index)) return [state, []] as const
+      const result = ToolStream.appendExisting(
+        ADAPTER,
         state.tools,
-        event.contentBlockDelta.contentBlockIndex,
+        index,
         event.contentBlockDelta.delta.toolUse.input,
+        "Bedrock Converse tool delta is missing its tool call",
       )
-      if (!result) return [state, []] as const
+      if (ToolStream.isError(result)) return yield* result
       const events: LLMEvent[] = []
       const lifecycle = result.events.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
       events.push(...result.events)
@@ -663,6 +667,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
             state.hasToolCalls,
           lifecycle,
           tools: result.tools,
+          finishedTools: resultEvents.length > 0 ? new Set([...state.finishedTools, index]) : state.finishedTools,
           reasoningSignatures: Object.fromEntries(
             Object.entries(state.reasoningSignatures).filter(([key]) => key !== String(index)),
           ),
@@ -687,9 +692,12 @@ const step = (state: ParserState, event: BedrockEvent) =>
       return [
         {
           ...state,
-          finishReason: {
-            normalized: mapFinishReason(event.messageStop.stopReason),
-            raw: event.messageStop.stopReason,
+          pendingFinish: {
+            reason: {
+              normalized: mapFinishReason(event.messageStop.stopReason),
+              raw: event.messageStop.stopReason,
+            },
+            usage: state.pendingFinish?.usage,
           },
         },
         [],
@@ -697,11 +705,14 @@ const step = (state: ParserState, event: BedrockEvent) =>
     }
 
     if (event.metadata) {
-      const usage = mapUsage(event.metadata.usage, state.providerMetadataKey) ?? state.usage
+      const usage = mapUsage(event.metadata.usage, state.providerMetadataKey) ?? state.pendingFinish?.usage
       return [
         {
           ...state,
-          usage,
+          pendingFinish: {
+            reason: state.pendingFinish?.reason ?? { normalized: "stop" },
+            usage,
+          },
         },
         [],
       ] as const
@@ -725,18 +736,18 @@ const step = (state: ParserState, event: BedrockEvent) =>
 const framing = BedrockEventStream.framing(ADAPTER)
 
 const onHalt = (state: ParserState): ReadonlyArray<LLMEvent> => {
-  if (!state.finishReason) return []
+  if (!state.pendingFinish) return []
   const normalized = (() => {
-    if (state.finishReason.normalized === "stop" && state.hasToolCalls) return "tool-calls"
-    return state.finishReason.normalized
+    if (state.pendingFinish.reason.normalized === "stop" && state.hasToolCalls) return "tool-calls"
+    return state.pendingFinish.reason.normalized
   })()
   const events: LLMEvent[] = []
   Lifecycle.finish(state.lifecycle, events, {
     reason: {
-      ...state.finishReason,
+      ...state.pendingFinish.reason,
       normalized,
     },
-    usage: state.usage,
+    usage: state.pendingFinish.usage,
   })
   return events
 }
@@ -759,8 +770,8 @@ export const protocol = Protocol.make({
     initial: (request) => ({
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       tools: ToolStream.empty<number>(),
-      finishReason: undefined,
-      usage: undefined,
+      finishedTools: new Set<number>(),
+      pendingFinish: undefined,
       hasToolCalls: false,
       lifecycle: Lifecycle.initial(),
       reasoningSignatures: {},

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

@@ -0,0 +1,96 @@
+import { Effect, Encoding, Schema, Struct } from "effect"
+import { Headers } from "effect/unstable/http"
+import { AIError } from "../schema/index.js"
+import { Route } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { Protocol } from "../route/protocol.js"
+import { classifyProviderFailure } from "../provider-error.js"
+import { AnthropicMessages } from "./anthropic-messages.js"
+import { BedrockEventStream } from "./bedrock-event-stream.js"
+import { BedrockAuth } from "./utils/bedrock-auth.js"
+import { JsonObject, ProviderShared } from "./shared.js"
+
+const ID = "bedrock-messages"
+const VERSION = "bedrock-2023-05-31"
+const Body = Schema.Struct({
+  ...Struct.omit(AnthropicMessages.AnthropicMessagesBody.fields, ["model", "stream"]),
+  anthropic_version: Schema.Literal(VERSION),
+  anthropic_beta: Schema.optional(Schema.Array(Schema.String)),
+})
+const Event = Schema.Struct({
+  chunk: Schema.optional(Schema.Struct({ bytes: Schema.String })),
+  exception: Schema.optional(
+    Schema.Struct({
+      type: Schema.String,
+      details: Schema.StructWithRest(
+        Schema.Struct({ message: Schema.optional(Schema.String), originalMessage: Schema.optional(Schema.String) }),
+        [JsonObject],
+      ),
+    }),
+  ),
+})
+
+export const protocol = Protocol.make({
+  id: ID,
+  body: {
+    schema: Body,
+    from: Effect.fn("BedrockMessages.fromRequest")(function* (request) {
+      const body = yield* AnthropicMessages.protocol.body.from(request)
+      const headers = Headers.fromInput(request.http?.headers)
+      const betas = new Set(
+        (headers["anthropic-beta"] ?? "")
+          .split(",")
+          .map((value) => value.trim())
+          .filter(Boolean),
+      )
+      if (
+        body.context_management?.edits.length ||
+        body.messages.some((message) => message.content.some((block) => block.type === "compaction"))
+      )
+        betas.add("compact-2026-01-12")
+      return {
+        ...Struct.omit(body, ["model", "stream"]),
+        anthropic_version: VERSION,
+        anthropic_beta: betas.size ? [...betas] : undefined,
+      } satisfies typeof Body.Type
+    }),
+  },
+  stream: {
+    event: Event,
+    initial: AnthropicMessages.protocol.stream.initial,
+    step: Effect.fn("BedrockMessages.step")(function* (state, event) {
+      if (event.exception)
+        return yield* new AIError({
+          reason: classifyProviderFailure({
+            message: event.exception.details.message ?? event.exception.details.originalMessage ?? event.exception.type,
+            rawBody: ProviderShared.encodeJson(event),
+          }),
+        })
+      if (!event.chunk) return yield* ProviderShared.eventError(ID, "Bedrock Messages event is missing its chunk")
+      const text = yield* Effect.fromResult(Encoding.decodeBase64String(event.chunk.bytes)).pipe(
+        Effect.mapError((cause) =>
+          ProviderShared.eventError(ID, "Invalid Bedrock Messages chunk encoding", undefined, cause),
+        ),
+      )
+      const decoded = yield* Schema.decodeUnknownEffect(AnthropicMessages.protocol.stream.event)(text).pipe(
+        Effect.mapError((cause) => ProviderShared.eventError(ID, "Invalid Bedrock Messages event", undefined, cause)),
+      )
+      return yield* AnthropicMessages.protocol.stream.step(state, decoded)
+    }),
+  },
+})
+
+export const route = Route.make({
+  id: ID,
+  provider: "amazon-bedrock",
+  providerMetadataKey: "anthropic",
+  protocol,
+  endpoint: Endpoint.path(
+    ({ request }) => `/model/${encodeURIComponent(request.model.id)}/invoke-with-response-stream`,
+    { baseURL: "https://bedrock-runtime.us-east-1.amazonaws.com" },
+  ),
+  auth: BedrockAuth.auth,
+  framing: BedrockEventStream.framing(ID),
+})
+
+export * as BedrockMessages from "./bedrock-messages.js"

packages/ai/src/protocols/gemini.ts

@@ -1,5 +1,5 @@
 import { Effect, Option, Schema } from "effect"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import { Route } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
@@ -465,8 +465,7 @@ function mapSafetySettings(value: unknown) {
 }
 
 const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMRequest) {
-  const flattened = ProviderShared.flattenToolRequest(request)
-  const hasTools = flattened.tools.length > 0
+  const hasTools = request.tools.length > 0
   const generation = request.generation
   const options = resolveOptions(request)
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
@@ -484,7 +483,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
 
   return {
     cachedContent: options.cachedContent,
-    contents: yield* lowerMessages(flattened.request),
+    contents: yield* lowerMessages(request),
     safetySettings: options.safetySettings,
     serviceTier: options.serviceTier,
     systemInstruction:
@@ -492,7 +491,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
     tools: hasTools
       ? [
           {
-            functionDeclarations: flattened.tools.map((tool) =>
+            functionDeclarations: request.tools.map((tool) =>
               lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
             ),
           },
@@ -610,27 +609,18 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
 }
 
 const step = (state: ParserState, event: GeminiEvent) => {
-  if (ProviderShared.isRecord(event.error)) {
+  if (ProviderShared.isRecord(event.error) && typeof event.error.message === "string") {
     const body = ProviderShared.encodeJson(event)
     return Effect.fail(
       new AIError({
         reason: classifyProviderFailure({
-          message:
-            typeof event.error.message === "string" && event.error.message.length > 0
-              ? event.error.message
-              : typeof event.error.status === "string" && event.error.status.length > 0
-                ? event.error.status
-                : "Gemini provider error",
+          message: event.error.message,
           status: typeof event.error.code === "number" ? event.error.code : undefined,
           rawBody: body,
         }),
       }),
     )
   }
-  if ("error" in event)
-    return Effect.fail(
-      ProviderShared.eventError(state.route, `Invalid ${state.route} stream event`, ProviderShared.encodeJson(event)),
-    )
   const nextState = {
     ...state,
     promptFeedback: event.promptFeedback ?? state.promptFeedback,
@@ -639,14 +629,6 @@ const step = (state: ParserState, event: GeminiEvent) => {
       : state.usage,
   }
   const candidate = event.candidates?.[0]
-  if (candidate?.finishReason && mapFinishReason(candidate.finishReason, state.hasToolCalls) === "error")
-    return Effect.fail(
-      ProviderShared.eventError(
-        state.route,
-        `Gemini stopped with ${candidate.finishReason}`,
-        ProviderShared.encodeJson(event),
-      ),
-    )
   if (!candidate?.content)
     return Effect.succeed([
       { ...nextState, finishReason: candidate?.finishReason ?? nextState.finishReason },

packages/ai/src/protocols/index.ts

@@ -1,5 +1,6 @@
 export * as AnthropicMessages from "./anthropic-messages.js"
 export * as BedrockConverse from "./bedrock-converse.js"
+export { BedrockMessages } from "./bedrock-messages.js"
 export * as Gemini from "./gemini.js"
 export * as MistralChat from "./mistral-chat.js"
 export * as OpenAIChat from "./openai-chat.js"

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

@@ -1,133 +0,0 @@
-import { Effect, Encoding, Schema } from "effect"
-import { Headers, HttpClientRequest } from "effect/unstable/http"
-import { GeneratedImage, ImageModel, ImageResponse, type ImageRequestFor, type ImageRoute } from "../image.js"
-import { Auth } from "../route/auth.js"
-import { Usage, mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema/index.js"
-import { JsonObject, ProviderShared, optionalNull } from "./shared.js"
-import { ImageInputs } from "./utils/image-input.js"
-
-type OpenString<Known extends string> = Known | (string & {})
-export type ImageOptions = {
-  readonly n?: number
-  /** Aspect ratio hint, not an exact output resolution. */
-  readonly size?: string
-  readonly outputFormat?: OpenString<"webp" | "png" | "jpeg">
-  readonly responseFormat?: OpenString<"b64_json" | "url">
-  readonly reasoningStrength?: OpenString<"low" | "high">
-  readonly toolEnablement?: {
-    readonly enable_image_search?: boolean
-    readonly enable_web_search?: boolean
-    readonly enable_shell?: boolean
-  }
-  readonly [key: string]: unknown
-}
-
-const Body = Schema.StructWithRest(
-  Schema.Struct({
-    model: Schema.String,
-    prompt: Schema.String,
-    images: Schema.optional(Schema.Array(JsonObject)),
-    n: Schema.optional(Schema.Number),
-    size: Schema.optional(Schema.String),
-    output_format: Schema.optional(Schema.String),
-    response_format: Schema.optional(Schema.String),
-    reasoning_strength: Schema.optional(Schema.String),
-    tool_enablement: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
-  }),
-  [JsonObject],
-)
-
-const Response = Schema.Struct({
-  data: Schema.Array(Schema.Struct({ b64_json: optionalNull(Schema.String), url: optionalNull(Schema.String) })),
-  output_format: Schema.optional(Schema.String),
-  usage: Schema.optional(
-    Schema.Struct({
-      input_tokens: Schema.optional(Schema.Number),
-      output_tokens: Schema.optional(Schema.Number),
-      total_tokens: Schema.optional(Schema.Number),
-    }),
-  ),
-})
-
-export const model = (input: {
-  readonly id: string
-  readonly auth: Auth.Definition
-  readonly baseURL: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions
-}) => {
-  const route: ImageRoute<ImageOptions> = {
-    id: "meta-images",
-    generate: Effect.fn("MetaImages.generate")(function* (request: ImageRequestFor<ImageOptions>, execute) {
-      const http = mergeHttpOptions(request.model.http, request.http)
-      const images = yield* Effect.forEach(request.images ?? [], (image) => {
-        if (image.type === "bytes") return Effect.succeed({ image_url: ImageInputs.dataUrl(image) })
-        if (image.type === "url") return Effect.succeed({ image_url: image.url })
-        return ImageInputs.invalid("Meta Images accepts image bytes and URLs")
-      })
-      const { outputFormat, responseFormat, reasoningStrength, toolEnablement, ...native } = request.options ?? {}
-      const payload = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(
-        mergeJsonRecords(
-          {
-            model: request.model.id,
-            prompt: request.prompt,
-            images: images.length === 0 ? undefined : images,
-            output_format: outputFormat,
-            response_format: responseFormat,
-            reasoning_strength: reasoningStrength,
-            tool_enablement: toolEnablement,
-          },
-          native,
-          http?.body,
-        ),
-      )
-      const body = ProviderShared.encodeJson(payload)
-      const url = new URL(`${input.baseURL.replace(/\/$/, "")}/images/${images.length === 0 ? "generations" : "edits"}`)
-      Object.entries(http?.query ?? {}).forEach(([key, value]) => url.searchParams.set(key, value))
-      const headers = yield* Auth.toEffect(input.auth)({
-        request,
-        method: "POST",
-        url: url.toString(),
-        body,
-        headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-      })
-      const response = yield* execute(
-        HttpClientRequest.post(url.toString()).pipe(
-          HttpClientRequest.setHeaders(headers),
-          HttpClientRequest.bodyText(body, "application/json"),
-        ),
-      )
-      const output = yield* ProviderShared.imageResponse("meta-images", "Meta Images", response)
-      const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(output.body).pipe(
-        Effect.mapError((cause) => output.invalid("Meta Images returned an invalid response", cause)),
-      )
-      const format = decoded.output_format ?? payload.output_format ?? "webp"
-      const generated = yield* Effect.forEach(decoded.data, (item, index) => {
-        if (item.b64_json)
-          return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
-            Effect.mapError((cause) => output.invalid(`Meta Images result ${index} contains invalid base64`, cause)),
-            Effect.map((data) => new GeneratedImage({ mediaType: `image/${format}`, data })),
-          )
-        if (item.url) return Effect.succeed(new GeneratedImage({ mediaType: `image/${format}`, data: item.url }))
-        return output.invalid(`Meta Images result ${index} has neither image data nor a URL`)
-      })
-      if (generated.length === 0) return yield* output.invalid("Meta Images returned no images")
-      return new ImageResponse({
-        images: generated,
-        usage:
-          decoded.usage === undefined
-            ? undefined
-            : new Usage({
-                inputTokens: decoded.usage.input_tokens,
-                outputTokens: decoded.usage.output_tokens,
-                totalTokens: decoded.usage.total_tokens,
-                providerMetadata: { meta: decoded.usage },
-              }),
-        providerMetadata: { meta: { outputFormat: format } },
-      })
-    }),
-  }
-  return ImageModel.make<ImageOptions>({ id: input.id, provider: "meta", route, http: input.http })
-}
-
-export * as MetaImages from "./meta-images.js"

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

@@ -1,52 +0,0 @@
-import { Effect, Schema } from "effect"
-import { Protocol } from "../route/protocol.js"
-import type { LLMRequest } from "../schema/index.js"
-import { AnthropicMessages } from "./anthropic-messages.js"
-import { MetaResponses } from "./meta-responses.js"
-import { JsonObject, optionalArray, ProviderShared } from "./shared.js"
-
-const WebSearch = Schema.Struct({
-  type: Schema.Literal("web_search"),
-  name: Schema.Literal("web_search"),
-  user_location: MetaResponses.WebSearch.fields.user_location,
-})
-const Body = Schema.Struct({
-  ...AnthropicMessages.AnthropicMessagesBody.fields,
-  tools: optionalArray(
-    Schema.Union([
-      Schema.Struct({ name: Schema.String, description: Schema.String, input_schema: JsonObject }),
-      WebSearch,
-    ]),
-  ),
-})
-
-const fromRequest = Effect.fn("MetaMessages.fromRequest")(function* (request: LLMRequest) {
-  const projected = ProviderShared.flattenToolRequest(request)
-  const body = yield* AnthropicMessages.protocol.body.from(projected.request)
-  return {
-    ...body,
-    tools:
-      body.tools === undefined
-        ? undefined
-        : yield* Effect.forEach(body.tools, (tool, index) =>
-            Effect.gen(function* () {
-              const native = projected.tools[index]?.native
-              if (native === undefined) return tool
-              const search = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(MetaResponses.WebSearch))(
-                native.meta,
-              )
-              if (search.search_context_size !== undefined)
-                return yield* ProviderShared.invalidRequest("Meta Messages does not support searchContextSize")
-              return { type: "web_search" as const, name: "web_search" as const, user_location: search.user_location }
-            }),
-          ),
-  }
-})
-
-export const protocol = Protocol.make({
-  id: "meta-messages",
-  body: { schema: Body, from: fromRequest },
-  stream: AnthropicMessages.protocol.stream,
-})
-
-export * as MetaMessages from "./meta-messages.js"

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

@@ -1,238 +0,0 @@
-import { Effect, Encoding, Schema } from "effect"
-import { Protocol } from "../route/protocol.js"
-import { HttpTransport } from "../route/transport/index.js"
-import { LLMEvent, LLMRequest, Message, ToolResultPart } from "../schema/index.js"
-import { OpenResponses } from "./open-responses.js"
-import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
-import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
-import { ToolSchemaProjection } from "./utils/tool-schema.js"
-import { MetaImage } from "./utils/meta-image.js"
-
-const ADAPTER = "meta-responses"
-const NAME = "Meta Responses"
-
-export const WebSearch = Schema.Struct({
-  type: Schema.Literal("web_search"),
-  search_context_size: Schema.optional(Schema.String),
-  user_location: Schema.optional(
-    Schema.Struct({
-      type: Schema.Literal("approximate"),
-      city: Schema.optional(Schema.String),
-      region: Schema.optional(Schema.String),
-      country: Schema.optional(Schema.String),
-      timezone: Schema.optional(Schema.String),
-    }),
-  ),
-})
-
-export const ImageGeneration = Schema.Struct({
-  type: Schema.Literal("image_generation"),
-  size: Schema.optional(Schema.String),
-  output_format: Schema.optional(Schema.String),
-  reasoning_strength: Schema.optional(Schema.String),
-  enable_image_search: Schema.optional(Schema.Boolean),
-  enable_web_search: Schema.optional(Schema.Boolean),
-  enable_shell: Schema.optional(Schema.Boolean),
-})
-
-const NativeTool = Schema.Union([WebSearch, ImageGeneration])
-const ImageItem = Schema.Struct({
-  type: Schema.Literal("image_generation_call"),
-  id: Schema.String,
-  status: Schema.optional(Schema.String),
-  result: optionalNull(Schema.String),
-  output_format: Schema.optional(Schema.String),
-  error: Schema.optional(Schema.Unknown),
-})
-
-const Body = Schema.Struct({
-  ...OpenResponses.coreFields,
-  input: Schema.Array(Schema.Union([OpenResponses.InputItem, ImageItem])),
-  tools: optionalArray(Schema.Union([OpenResponses.Tool, NativeTool])),
-  stream: Schema.Literal(true),
-})
-
-const MessageAnnotations = Schema.Struct({
-  content: Schema.Array(Schema.Struct({ annotations: optionalArray(JsonObject) })),
-})
-
-interface ParserState extends OpenResponses.ParserState {
-  readonly completedItems: ReadonlySet<string>
-}
-
-const adapter = {
-  id: ADAPTER,
-  name: NAME,
-  restoreHostedToolItem: (item: unknown) => (Schema.is(ImageItem)(item) ? item : undefined),
-} satisfies OpenResponses.ProviderAdapter
-
-const fromRequest = Effect.fn("MetaResponses.fromRequest")(function* (request: LLMRequest) {
-  const key = request.model.route.providerMetadataKey ?? String(request.model.provider)
-  const projected = ProviderShared.flattenToolRequest(
-    LLMRequest.update(request, {
-      messages: request.messages.map((message) =>
-        Message.make({
-          ...message,
-          content: message.content.map((part) => {
-            if (
-              part.type !== "tool-result" ||
-              !part.providerExecuted ||
-              part.name !== "image_generation" ||
-              part.result.type !== "content" ||
-              part.providerMetadata?.[key]?.itemId !== part.id
-            )
-              return part
-            // Meta's signed image ID carries edit state; replay the handle, not the image bytes as a user message.
-            return ToolResultPart.make({
-              ...part,
-              result: {
-                type: "json",
-                value: { type: "image_generation_call", id: part.id, status: "completed", result: null },
-              },
-            })
-          }),
-        }),
-      ),
-    }),
-  )
-  return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))({
-    ...(yield* OpenResponses.lowerConversation(projected.request, adapter)),
-    ...OpenResponses.lowerGeneration(request),
-    tools:
-      projected.tools.length === 0
-        ? undefined
-        : yield* Effect.forEach(projected.tools, (tool) =>
-            Effect.gen(function* () {
-              if (tool.native === undefined)
-                return yield* OpenResponses.lowerTool(
-                  NAME,
-                  tool,
-                  ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model.compatibility?.toolSchema),
-                )
-              return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(NativeTool))(tool.native.meta)
-            }),
-          ),
-    tool_choice:
-      OpenResponses.allowedToolChoice(request) ??
-      (request.toolChoice ? yield* OpenResponses.lowerToolChoice(NAME, request.toolChoice) : undefined),
-  })
-})
-
-const HOSTED_TOOLS = {
-  web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
-  image_generation_call: {
-    name: "image_generation",
-    input: () => ({}),
-    result: Effect.fn("MetaResponses.imageResult")(function* (raw: ResponsesHostedTools.Item) {
-      const item = yield* Schema.decodeUnknownEffect(ImageItem)(raw).pipe(
-        Effect.mapError((cause) =>
-          ProviderShared.eventError(
-            ADAPTER,
-            "Meta returned an invalid image item",
-            ProviderShared.encodeJson(raw),
-            cause,
-          ),
-        ),
-      )
-      if (item.error !== undefined && item.error !== null) return { type: "error" as const, value: item.error }
-      if (!item.result)
-        return yield* ProviderShared.eventError(
-          ADAPTER,
-          "Meta returned an image without data",
-          ProviderShared.encodeJson(raw),
-        )
-      const data = yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(
-        Effect.mapError((cause) =>
-          ProviderShared.eventError(
-            ADAPTER,
-            "Meta returned invalid image base64",
-            ProviderShared.encodeJson(raw),
-            cause,
-          ),
-        ),
-      )
-      const mime = MetaImage.mediaType(data, item.output_format)
-      return {
-        type: "content" as const,
-        value: [{ type: "file" as const, uri: `data:${mime};base64,${item.result}`, mime }],
-      }
-    }),
-  },
-} satisfies ResponsesHostedTools.Definitions
-
-const onEvent = Effect.fn("MetaResponses.onEvent")(function* (
-  state: OpenResponses.ParserState,
-  input: OpenResponses.Event,
-) {
-  const event = OpenResponses.normalize(state, input)
-  if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
-    return yield* ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
-  const result = yield* OpenResponses.step(state, event)
-  if (event.type !== "response.output_item.done" || event.item?.type !== "message") return result
-  const message = yield* Schema.decodeUnknownEffect(MessageAnnotations)(event.item).pipe(
-    Effect.mapError((cause) =>
-      ProviderShared.eventError(
-        ADAPTER,
-        "Meta returned invalid message annotations",
-        ProviderShared.encodeJson(event),
-        cause,
-      ),
-    ),
-  )
-  const annotations = message.content.flatMap((part) => part.annotations ?? [])
-  if (annotations.length === 0) return result
-  return [
-    result[0],
-    result[1].map((item) =>
-      LLMEvent.is.textEnd(item)
-        ? LLMEvent.textEnd({
-            ...item,
-            providerMetadata: {
-              ...item.providerMetadata,
-              [state.providerMetadataKey]: { ...item.providerMetadata?.[state.providerMetadataKey], annotations },
-            },
-          })
-        : item,
-    ),
-  ] satisfies OpenResponses.StepResult
-})
-
-const step = Effect.fn("MetaResponses.step")(function* (state: ParserState, input: OpenResponses.Event) {
-  const completedItems = new Set(state.completedItems)
-  const event = OpenResponses.normalize(state, input)
-  if (event.type === "response.output_item.done" && event.item && completedItems.has(event.item.id))
-    return [state, []] as const
-  const events: LLMEvent[] = []
-  let current: OpenResponses.ParserState = state
-  // Muse Image delivers its image and optional summary only in response.completed.
-  // Recover terminal-only items in order, without duplicating Spark's streamed items.
-  if (event.type === "response.completed") {
-    for (const [index, item] of (event.response?.output ?? []).entries()) {
-      const done = OpenResponses.normalize(current, { type: "response.output_item.done", item, output_index: index })
-      // Spark changes reasoning IDs in the terminal snapshot; output indices still identify the streamed items.
-      if (!done.item || completedItems.has(done.item.id) || completedItems.has(state.outputItems[index] ?? "")) continue
-      const result = yield* onEvent(current, done)
-      current = result[0]
-      events.push(...result[1])
-      completedItems.add(done.item.id)
-    }
-  }
-  const result = yield* onEvent(current, event)
-  if (event.type === "response.output_item.done" && event.item) completedItems.add(event.item.id)
-  return [{ ...result[0], completedItems }, [...events, ...result[1]]] as const
-})
-
-export const protocol = Protocol.make({
-  id: ADAPTER,
-  body: { schema: Body, from: fromRequest },
-  stream: {
-    event: OpenResponses.protocol.stream.event,
-    initial: (request): ParserState => ({ ...OpenResponses.initial(request, adapter), completedItems: new Set() }),
-    step,
-    terminal: OpenResponses.terminal,
-  },
-})
-
-export const httpTransport = HttpTransport.sseJson.with<Schema.Schema.Type<typeof Body>>()
-
-export * as MetaResponses from "./meta-responses.js"

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

@@ -9,8 +9,6 @@ import {
   AIError,
   InvalidProviderOutputError,
   LLMEvent,
-  ProviderInternalError,
-  UnknownProviderError,
   Usage,
   type FinishReasonDetails,
   type LLMRequest,
@@ -416,11 +414,10 @@ export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (reque
         tool: (name) => ({ type: "function" as const, function: { name } }),
       })
     : undefined
-  const flattened = ProviderShared.flattenToolRequest(request)
   return {
     model: request.model.id,
-    messages: yield* lowerMessages(flattened.request),
-    tools: flattened.tools.length > 0 ? flattened.tools.map(lowerTool) : undefined,
+    messages: yield* lowerMessages(request),
+    tools: request.tools.length > 0 ? request.tools.map(lowerTool) : undefined,
     tool_choice: toolChoice,
     stream: true as const,
     max_tokens: request.generation?.maxTokens,
@@ -702,16 +699,6 @@ const step = Effect.fn("MistralChat.step")(function* (state: ParserState, event:
     normalized: mapFinishReason(choice.finish_reason),
     raw: choice.finish_reason,
   }
-  if (finishReason.normalized === "error") {
-    const details = {
-      message: `Mistral Chat stopped with ${finishReason.raw}`,
-      body: ProviderShared.encodeJson(event),
-    }
-    return yield* new AIError({
-      reason:
-        finishReason.raw === "network_error" ? new ProviderInternalError(details) : new UnknownProviderError(details),
-    })
-  }
   const incomplete = finishReason.normalized === "length" || finishReason.normalized === "content-filter"
   if (!incomplete && Object.keys(withTools.pendingTools).length > 0)
     return yield* ProviderShared.eventError(

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

@@ -113,8 +113,8 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
           responseID = created
           return { type: "frame", frame }
         }
-        // Keepalives and provider notifications carry no response state and may precede response.created.
-        if (!event.type.startsWith("response.")) return { type: "frame", frame }
+        // Keepalives carry no response state and may arrive before response.created.
+        if (event.type === "keepalive") return { type: "frame", frame }
         if (!responseID)
           return yield* ProviderShared.eventError(
             options.id,

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

@@ -42,7 +42,6 @@ const canonical = (value: unknown): string => {
   if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`
   if (!ProviderShared.isRecord(value)) return ProviderShared.encodeJson(value)
   return `{${Object.keys(value)
-    .filter((key) => value[key] !== undefined)
     .sort()
     .map((key) => `${ProviderShared.encodeJson(key)}:${canonical(value[key])}`)
     .join(",")}}`
@@ -58,12 +57,7 @@ const comparable = (value: unknown) => {
   if (value.type === "message" && value.role === "assistant")
     return {
       role: "assistant",
-      // Annotations and logprobs describe the response, not the text replayed in model input.
-      content: Array.isArray(value.content)
-        ? value.content.map((part) =>
-            ProviderShared.isRecord(part) && part.type === "output_text" ? { type: part.type, text: part.text } : part,
-          )
-        : value.content,
+      content: value.content,
       ...(value.phase === undefined ? {} : { phase: value.phase }),
     }
   if (value.type === "function_call")
@@ -127,7 +121,7 @@ const rejected = (
 
 export const driver = (input: DriverInput): WebSocketChannelDriver => {
   const { previous_response_id: _previousResponseID, ...request } = input.request
-  let output: OpenResponses.StreamItem[] = []
+  let output: unknown[] = []
   return {
     create: (checkpoint) =>
       Effect.sync(() => {
@@ -155,12 +149,6 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
           if (rejection === "websocket_connection_limit_reached") return rejected(observation, "rotate-and-retry-full")
         }
         if (observation.type !== "completed") return observation
-        // A trigger installs a different context window. Clear the append baseline, retaining the socket.
-        if (
-          Array.isArray(request.input) &&
-          request.input.some((item) => ProviderShared.isRecord(item) && item.type === "compaction_trigger")
-        )
-          return observation
         const responseID = event.response?.id
         if (!responseID || responseID.trim().length === 0) return observation
         return {
@@ -171,14 +159,7 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
               version: VERSION,
               responseID,
               request,
-              // Completion can re-encrypt reasoning. Callers replay the item already emitted by output_item.done.
-              output: event.response?.output
-                ? event.response.output.map((item) =>
-                    item.type === "reasoning" && item.id !== undefined
-                      ? (output.find((done) => done.type === item.type && done.id === item.id) ?? item)
-                      : item,
-                  )
-                : output.slice(),
+              output: event.response?.output ? [...event.response.output] : output.slice(),
             } satisfies CheckpointValue,
           },
         }

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

@@ -1,5 +1,5 @@
 import { Effect, Option, Schema } from "effect"
-import type { Content } from "@opencode/schema/tool"
+import type { Content } from "@opencode-ai/schema/tool"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
 import {
@@ -41,10 +41,9 @@ export const OpenResponsesInputImage = Schema.Struct({
   image_url: Schema.String,
   detail: Schema.optional(Schema.String),
 })
-export const OpenResponsesInputFile = Schema.Struct({
+const OpenResponsesInputFile = Schema.Struct({
   type: Schema.tag("input_file"),
   filename: Schema.String,
-  detail: Schema.optional(Schema.String),
   file_data: Schema.optional(Schema.String),
   file_url: Schema.optional(Schema.String),
 })
@@ -189,7 +188,6 @@ export const InputItem = Schema.Union([
     id: Schema.optionalKey(Schema.String),
     call_id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     arguments: Schema.String,
   }),
   Schema.Struct({
@@ -200,14 +198,14 @@ export const InputItem = Schema.Union([
   HostedToolItem,
 ])
 type OpenResponsesInputItem = Schema.Schema.Type<typeof InputItem>
-export type HostedToolReplayItem = {
+export type ExtendedHostedToolItem = {
   readonly type: string
   readonly id: string
   readonly [key: string]: unknown
 }
 type LoweredInputItem =
   | OpenResponsesInputItem
-  | HostedToolReplayItem
+  | ExtendedHostedToolItem
   | {
       readonly type: "message"
       readonly id?: string
@@ -305,25 +303,18 @@ export const OpenResponsesUsage = Schema.Struct({
 })
 type OpenResponsesUsage = Schema.Schema.Type<typeof OpenResponsesUsage>
 
-// The spec requires `id` on every output item, but some gateways drop it from
-// later item events (Bedrock Mantle renames it to `item_id` on
-// `output_item.done` and `response.completed.output`). Decode it as optional
-// and let `normalize` recover or mint it once before the parser runs.
-// https://www.openresponses.org/specification#extending-items
 export const StreamItem = Schema.StructWithRest(
   Schema.Struct({
     type: Schema.String,
     id: Schema.optional(Schema.String),
     call_id: Schema.optional(Schema.String),
     name: Schema.optional(Schema.String),
-    namespace: Schema.optional(Schema.String),
     arguments: Schema.optional(Schema.String),
     encrypted_content: optionalNull(Schema.String),
   }),
   [Schema.Record(Schema.String, Schema.Unknown)],
 )
 export type StreamItem = Schema.Schema.Type<typeof StreamItem>
-export type OutputItem = StreamItem & { readonly id: string }
 
 // The Responses schema puts streaming error details at the top level and
 // response failures under `response.error`. WebSocket failures use an
@@ -403,9 +394,8 @@ export const Event = Schema.StructWithRest(
   [Schema.Record(Schema.String, Schema.Unknown)],
 )
 export type Event = Schema.Schema.Type<typeof Event>
-export type NormalizedEvent = Event & { readonly item?: OutputItem | null }
 
-export interface ProviderAdapter {
+export interface Extension {
   readonly id: string
   readonly name: string
   readonly lowerMedia?: (input: {
@@ -413,10 +403,10 @@ export interface ProviderAdapter {
     readonly media: ProviderShared.NormalizedMedia
     readonly request: LLMRequest
   }) => MediaInput | undefined
-  readonly restoreHostedToolItem?: (item: unknown) => HostedToolReplayItem | undefined
+  readonly lowerHostedToolItem?: (item: unknown) => ExtendedHostedToolItem | undefined
 }
 
-const BASE_ADAPTER: ProviderAdapter = { id: ADAPTER, name: NAME }
+const BASE: Extension = { id: ADAPTER, name: NAME }
 
 export interface ParserState {
   readonly provider: LLMRequest["model"]["provider"]
@@ -425,6 +415,8 @@ export interface ParserState {
   readonly name: string
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<string>
+  // Call ids stay independent of item ids, which may be omitted or reused.
+  readonly completedTools: ReadonlySet<string>
   readonly hasFunctionCall: boolean
   readonly lifecycle: Lifecycle.State
   readonly outputItems: Readonly<Record<number, string>>
@@ -435,6 +427,7 @@ export interface ParserState {
 type ReasoningSummaryStatus = "active" | "can-conclude" | "concluded"
 
 interface ReasoningStreamItem {
+  readonly open: boolean
   readonly encryptedContent: string | null | undefined
   // Keyed by the wire protocol's numeric `summary_index`. JS object keys coerce to
   // strings, but typing the map as `Record<number, ...>` documents intent
@@ -490,7 +483,6 @@ const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenRes
     ...(id === undefined ? {} : { id }),
     call_id: part.id,
     name: part.name,
-    namespace: part.namespace,
     arguments: ProviderShared.encodeJson(part.input),
   }
 }
@@ -514,15 +506,12 @@ const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenR
 const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
   part: MediaPart,
   request: LLMRequest,
-  adapter: ProviderAdapter,
+  extension: Extension,
   target: "message" | "tool-result",
 ) {
   const media = ProviderShared.normalizeMedia(part)
-  const providerMedia = adapter.lowerMedia?.({ part, media, request })
-  if (providerMedia) return providerMedia
-  const detail = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesInputImage.fields.detail))(
-    part.providerMetadata?.[metadataKey(request.model)]?.detail,
-  )
+  const extended = extension.lowerMedia?.({ part, media, request })
+  if (extended) return extended
   const url =
     typeof part.data === "string" && (part.data.startsWith("https://") || part.data.startsWith("http://"))
       ? part.data
@@ -533,31 +522,32 @@ const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
     return {
       type: "input_file" as const,
       filename: part.filename ?? (media.mime === "application/pdf" ? "document.pdf" : "file"),
-      detail,
       ...(url ? { file_url: url } : { file_data: media.dataUrl }),
     }
   }
   return {
     type: "input_image" as const,
     image_url: url ?? media.dataUrl,
-    detail,
+    detail: yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesInputImage.fields.detail))(
+      part.providerMetadata?.[request.model.route.providerMetadataKey ?? "openresponses"]?.detail,
+    ),
   }
 })
 
 const lowerUserContent = Effect.fnUntraced(function* (
   part: LLMRequest["messages"][number]["content"][number],
   request: LLMRequest,
-  adapter: ProviderAdapter,
+  extension: Extension,
 ) {
   if (part.type === "text") return { type: "input_text" as const, text: part.text }
-  if (part.type === "media") return yield* lowerMessageMedia(part, request, adapter)
-  return yield* ProviderShared.unsupportedContent(adapter.name, "user", ["text", "media"])
+  if (part.type === "media") return yield* lowerMessageMedia(part, request, extension)
+  return yield* ProviderShared.unsupportedContent(extension.name, "user", ["text", "media"])
 })
 
-const lowerMessageMedia = Effect.fnUntraced(function* (part: MediaPart, request: LLMRequest, adapter: ProviderAdapter) {
-  const lowered = yield* lowerMedia(part, request, adapter, "message")
+const lowerMessageMedia = Effect.fnUntraced(function* (part: MediaPart, request: LLMRequest, extension: Extension) {
+  const lowered = yield* lowerMedia(part, request, extension, "message")
   if (lowered.type === "input_video")
-    return yield* ProviderShared.invalidRequest(`${adapter.name} user messages do not support input_video`)
+    return yield* ProviderShared.invalidRequest(`${extension.name} user messages do not support input_video`)
   return lowered
 })
 
@@ -566,13 +556,13 @@ const lowerMessageMedia = Effect.fnUntraced(function* (part: MediaPart, request:
 const lowerToolResultContentItem = Effect.fnUntraced(function* (
   item: Content,
   request: LLMRequest,
-  adapter: ProviderAdapter,
+  extension: Extension,
 ) {
   if (item.type === "text") return { type: "input_text" as const, text: item.text }
   return yield* lowerMedia(
     { type: "media", mediaType: item.mime, data: item.uri, filename: item.name },
     request,
-    adapter,
+    extension,
     "tool-result",
   )
 })
@@ -580,35 +570,32 @@ const lowerToolResultContentItem = Effect.fnUntraced(function* (
 const lowerHostedToolResultContentItem = Effect.fnUntraced(function* (
   item: Content,
   request: LLMRequest,
-  adapter: ProviderAdapter,
+  extension: Extension,
 ) {
   if (item.type === "text") return { type: "input_text" as const, text: item.text }
   return yield* lowerMessageMedia(
     { type: "media", mediaType: item.mime, data: item.uri, filename: item.name },
     request,
-    adapter,
+    extension,
   )
 })
 
 const lowerToolResultOutput = Effect.fnUntraced(function* (
   part: ToolResultPart,
   request: LLMRequest,
-  adapter: ProviderAdapter,
+  extension: Extension,
 ) {
   // Text/json/error results are encoded as a plain string for backward
   // compatibility with existing cassettes and provider expectations.
   if (part.result.type !== "content") return ProviderShared.toolResultText(part)
   // Preserve the narrowed array element type when compiled through a consumer package.
   const content: ReadonlyArray<Content> = part.result.value
-  return yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request, adapter))
+  return yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request, extension))
 })
 
-const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
-  request: LLMRequest,
-  adapter: ProviderAdapter,
-) {
+const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (request: LLMRequest, extension: Extension) {
   const input: LoweredInputItem[] = []
-  const providerMetadataKey = metadataKey(request.model)
+  const providerMetadataKey = request.model.route.providerMetadataKey ?? "openresponses"
 
   for (const message of request.messages) {
     const metadata = yield* ProviderShared.validateWith(
@@ -617,13 +604,13 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
     if (message.role === "system") {
       input.push({
         role: "developer",
-        content: ProviderShared.joinText(yield* ProviderShared.systemUpdateText(adapter.name, message)),
+        content: ProviderShared.joinText(yield* ProviderShared.systemUpdateText(extension.name, message)),
       })
       continue
     }
 
     if (message.role === "user") {
-      const content = yield* Effect.forEach(message.content, (part) => lowerUserContent(part, request, adapter))
+      const content = yield* Effect.forEach(message.content, (part) => lowerUserContent(part, request, extension))
       if (content.length > 0)
         input.push({ role: "user", content, type: metadata?.type, id: metadata?.itemId, status: metadata?.status })
       continue
@@ -702,7 +689,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
               ? undefined
               : Schema.is(HostedToolItem)(part.result.value)
                 ? part.result.value
-                : adapter.restoreHostedToolItem?.(part.result.value)
+                : extension.lowerHostedToolItem?.(part.result.value)
           if (id !== undefined && hosted?.id === id) {
             if (!hostedToolItems.has(id)) {
               input.push(hosted)
@@ -716,11 +703,13 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
               : [{ type: "text", text: ProviderShared.toolResultText(part) }]
           input.push({
             role: "user",
-            content: yield* Effect.forEach(content, (item) => lowerHostedToolResultContentItem(item, request, adapter)),
+            content: yield* Effect.forEach(content, (item) =>
+              lowerHostedToolResultContentItem(item, request, extension),
+            ),
           })
           continue
         }
-        return yield* ProviderShared.unsupportedContent(adapter.name, "assistant", [
+        return yield* ProviderShared.unsupportedContent(extension.name, "assistant", [
           "text",
           "reasoning",
           "tool-call",
@@ -733,11 +722,11 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
 
     for (const part of message.content) {
       if (!ProviderShared.supportsContent(part, ["tool-result"]))
-        return yield* ProviderShared.unsupportedContent(adapter.name, "tool", ["tool-result"])
+        return yield* ProviderShared.unsupportedContent(extension.name, "tool", ["tool-result"])
       input.push({
         type: "function_call_output",
         call_id: part.id,
-        output: yield* lowerToolResultOutput(part, request, adapter),
+        output: yield* lowerToolResultOutput(part, request, extension),
       })
     }
   }
@@ -747,12 +736,12 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
 
 export const lowerConversation = Effect.fn("OpenResponses.lowerConversation")(function* (
   request: LLMRequest,
-  adapter: ProviderAdapter,
+  extension: Extension,
 ) {
   const instructions = ProviderShared.joinText(request.system)
   return {
     model: request.model.id,
-    input: yield* lowerMessages(request, adapter),
+    input: yield* lowerMessages(request, extension),
     ...(instructions ? { instructions } : {}),
   }
 })
@@ -806,35 +795,34 @@ export const allowedToolChoice = (request: LLMRequest) => {
   }
 }
 
-export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAdapter")(function* (
+export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWithExtension")(function* (
   request: LLMRequest,
-  adapter: ProviderAdapter,
+  extension: Extension,
 ) {
-  const projected = ProviderShared.flattenToolRequest(request)
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   return {
-    ...(yield* lowerConversation(projected.request, adapter)),
+    ...(yield* lowerConversation(request, extension)),
     ...lowerGeneration(request),
     tools:
-      projected.tools.length === 0
+      request.tools.length === 0
         ? undefined
-        : yield* Effect.forEach(projected.tools, (tool) =>
+        : yield* Effect.forEach(request.tools, (tool) =>
             lowerTool(
-              adapter.name,
+              extension.name,
               tool,
               ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
             ),
           ),
     tool_choice:
       allowedToolChoice(request) ??
-      (request.toolChoice ? yield* lowerToolChoice(adapter.name, request.toolChoice) : undefined),
+      (request.toolChoice ? yield* lowerToolChoice(extension.name, request.toolChoice) : undefined),
   }
 })
 
 const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesBody))
 
 export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (request: LLMRequest) {
-  return yield* decodeBody(yield* fromRequestWithAdapter(request, BASE_ADAPTER))
+  return yield* decodeBody(yield* fromRequestWithExtension(request, BASE))
 })
 
 // =============================================================================
@@ -874,12 +862,13 @@ const mapFinishReason = (event: Event, hasFunctionCall: boolean): FinishReason =
   return hasFunctionCall ? "tool-calls" : "unknown"
 }
 
-export const metadataKey = (model: LLMRequest["model"]) => model.route.providerMetadataKey ?? "openresponses"
-
 export const providerMetadata = (state: ParserState, metadata: Record<string, unknown>): ProviderMetadata => ({
   [state.providerMetadataKey]: metadata,
 })
 
+const isReasoningItem = (item: StreamItem): item is StreamItem & { type: "reasoning"; id: string } =>
+  item.type === "reasoning" && typeof item.id === "string"
+
 export type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
 
 const NO_EVENTS: StepResult["1"] = []
@@ -923,41 +912,12 @@ const joinReasoningText = (parts: ReadonlyArray<string | undefined>) => {
   return parts.filter((part) => part !== undefined).join("\n\n")
 }
 
-const outputItemID = (state: Pick<ParserState, "outputItems">, event: Event) =>
+export const outputItemID = (state: ParserState, event: Event) =>
   event.output_index === undefined ? event.item_id : (state.outputItems[event.output_index] ?? event.item_id)
 
-const ITEM_ID_PREFIX: Readonly<Record<string, string>> = {
-  message: "msg",
-  reasoning: "rs",
-  function_call: "fc",
-  compaction: "cmp",
-}
-
-// An item without an id adopts the id already open in its output slot,
-// otherwise it gets a locally minted one.
-const resolveItem = (
-  state: Pick<ParserState, "outputItems">,
-  item: StreamItem,
-  index: number | undefined,
-): OutputItem => ({
-  ...item,
-  id:
-    item.id ??
-    (index === undefined ? undefined : state.outputItems[index]) ??
-    `${ITEM_ID_PREFIX[item.type] ?? "item"}_${crypto.randomUUID().replaceAll("-", "")}`,
-})
-
-// Registered output slots are authoritative for `item_id` routing, and items
-// are resolved here so everything downstream can rely on `item.id`.
-export const normalize = (state: Pick<ParserState, "outputItems">, input: Event): NormalizedEvent => ({
-  ...input,
-  item_id: input.item_id === undefined ? undefined : outputItemID(state, input),
-  item: input.item ? resolveItem(state, input.item, input.output_index) : input.item,
-})
-
 const startReasoningSummaryPart = (state: ParserState, itemID: string, index: number): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!item || index === 0 || item.summaryParts[index] !== undefined) return [state, NO_EVENTS]
+  if (!item?.open || index === 0 || item.summaryParts[index] !== undefined) return [state, NO_EVENTS]
 
   const events: LLMEvent[] = []
   const lifecycle = Object.entries(item.summaryParts)
@@ -997,7 +957,7 @@ const startReasoningSummaryPart = (state: ParserState, itemID: string, index: nu
 
 export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!event.delta || !item) return [state, NO_EVENTS]
+  if (!event.delta || !item?.open) return [state, NO_EVENTS]
   const index = event.summary_index ?? 0
   if (item.summaryParts[index] === "concluded") return [state, NO_EVENTS]
   const [started, emitted] = startReasoningSummaryPart(state, itemID, index)
@@ -1022,13 +982,13 @@ export const onReasoningDelta = (state: ParserState, event: Event, itemID: strin
 // as a single delta unless that summary index already streamed one.
 export const onReasoningDone = (state: ParserState, event: Event, itemID: string): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!item || typeof event.text !== "string") return [state, NO_EVENTS]
+  if (!item?.open || typeof event.text !== "string") return [state, NO_EVENTS]
   const index = event.summary_index ?? 0
   if (item.deltaIndexes.has(index)) return [state, NO_EVENTS]
   return onReasoningDelta(state, { ...event, delta: event.text }, itemID)
 }
 
-const reasoningMetadata = (state: ParserState, item: OutputItem) =>
+const reasoningMetadata = (state: ParserState, item: StreamItem & { id: string }) =>
   providerMetadata(state, { itemId: item.id, reasoningEncryptedContent: item.encrypted_content ?? null })
 
 // Responses APIs normally stream reasoning items in this order:
@@ -1041,15 +1001,15 @@ const reasoningMetadata = (state: ParserState, item: OutputItem) =>
 // `onOutputItemAdded` seeds the per-item entry, while each later part start is
 // also an implicit boundary for the previous part. This keeps the common event
 // lifecycle ordered when a compatible provider omits or delays a part-done event.
-const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResult => {
+const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
   const item = event.item
-  if (!item) return [state, NO_EVENTS]
-  if (item.type === "message") {
+  if (item?.type === "message" && item.id !== undefined) {
+    const itemID = item.id
     const phase = messagePhase(item.phase)
     // A new message closes earlier messages, including ones that never streamed.
     const events: LLMEvent[] = []
     const lifecycle = [...state.lifecycle.text]
-      .filter((id) => id !== item.id)
+      .filter((id) => id !== itemID)
       .reduce((lifecycle, id) => {
         const openPhase = state.message?.id === id ? state.message.phase : undefined
         return Lifecycle.textEnd(
@@ -1064,14 +1024,14 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
         ...state,
         lifecycle,
         message: {
-          id: item.id,
-          phase: phase === undefined && state.message?.id === item.id ? state.message.phase : phase,
+          id: itemID,
+          phase: phase === undefined && state.message?.id === itemID ? state.message.phase : phase,
         },
       },
       events,
     ]
   }
-  if (item.type === "reasoning") {
+  if (item && isReasoningItem(item)) {
     if (state.reasoningItems[item.id] !== undefined) return [state, NO_EVENTS]
     const events: LLMEvent[] = []
     return [
@@ -1081,6 +1041,7 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
         reasoningItems: {
           ...state.reasoningItems,
           [item.id]: {
+            open: true,
             encryptedContent: item.encrypted_content,
             summaryParts: { 0: "active" },
             deltaIndexes: new Set(),
@@ -1090,32 +1051,25 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
       events,
     ]
   }
-  if (item.type !== "function_call" || !item.call_id) return [state, NO_EVENTS]
-  if (state.tools[item.id] !== undefined) return [state, NO_EVENTS]
-  const metadata = providerMetadata(state, { itemId: item.id })
+  if (item?.type !== "function_call" || !item.call_id) return [state, NO_EVENTS]
+  const id = item.id ?? item.call_id
+  if (Object.values(state.tools).some((tool) => tool?.id === item.call_id) || state.completedTools.has(item.call_id))
+    return [state, NO_EVENTS]
+  const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
   return [
     {
       ...state,
       lifecycle,
-      tools: ToolStream.start(state.tools, item.id, {
+      tools: ToolStream.start(state.tools, id, {
         id: item.call_id,
         name: item.name ?? "",
-        namespace: item.namespace,
         input: item.arguments ?? "",
         providerMetadata: metadata,
       }),
     },
-    [
-      ...events,
-      LLMEvent.toolInputStart({
-        id: item.call_id,
-        name: item.name ?? "",
-        namespace: item.namespace,
-        providerMetadata: metadata,
-      }),
-    ],
+    [...events, LLMEvent.toolInputStart({ id: item.call_id, name: item.name ?? "", providerMetadata: metadata })],
   ]
 }
 
@@ -1127,7 +1081,7 @@ const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResu
 const onReasoningSummaryPartDone = (state: ParserState, event: Event): StepResult => {
   if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
   const item = state.reasoningItems[event.item_id]
-  if (!item) return [state, NO_EVENTS]
+  if (!item?.open) return [state, NO_EVENTS]
   if (item.summaryParts[event.summary_index] !== "active") return [state, NO_EVENTS]
   return [
     {
@@ -1180,13 +1134,13 @@ const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgu
 
 const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
   state: ParserState,
-  item: NormalizedEvent["item"],
+  item: Event["item"],
 ) {
   if (!item) return [state, NO_EVENTS] satisfies StepResult
 
   if (item.type === "compaction") {
-    if (typeof item.encrypted_content !== "string")
-      return yield* ProviderShared.eventError(state.id, "Compaction output is missing its encrypted content")
+    if (!item.id || typeof item.encrypted_content !== "string")
+      return yield* ProviderShared.eventError(state.id, "Compaction output is missing its id or encrypted content")
     if (state.completedCompactions.has(item.id)) return [state, NO_EVENTS] satisfies StepResult
     const events: LLMEvent[] = []
     const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
@@ -1203,10 +1157,10 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     ] satisfies StepResult
   }
 
-  if (item.type === "message") {
-    const active = state.message?.id === item.id
+  if (item.type === "message" && item.id !== undefined) {
+    const message = state.message?.id === item.id ? state.message : undefined
     const itemPhase = messagePhase(item.phase)
-    const phase = itemPhase === undefined && active ? state.message?.phase : itemPhase
+    const phase = itemPhase === undefined ? message?.phase : itemPhase
     const parts: ReadonlyArray<unknown> = Array.isArray(item.content) ? item.content : []
     const content: string[] = []
     for (const part of parts) {
@@ -1217,12 +1171,13 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     const text = content.length > 0 ? content.join("") : undefined
     const metadata = providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) })
     const events: LLMEvent[] = []
-    const lifecycle = text ? Lifecycle.textStart(state.lifecycle, events, item.id, metadata) : state.lifecycle
+    const lifecycle =
+      message && text ? Lifecycle.textStart(state.lifecycle, events, item.id, metadata) : state.lifecycle
     return [
       {
         ...state,
         lifecycle: Lifecycle.textEnd(lifecycle, events, item.id, metadata, text),
-        message: active ? undefined : state.message,
+        message: message ? undefined : state.message,
       },
       events,
     ] satisfies StepResult
@@ -1230,35 +1185,36 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
 
   if (item.type === "function_call") {
     if (!item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
-    const metadata = providerMetadata(state, { itemId: item.id })
-    const registered = state.tools[item.id] !== undefined
-    const tools = registered
-      ? state.tools
-      : ToolStream.start(state.tools, item.id, {
-          id: item.call_id,
-          name: item.name,
-          namespace: item.namespace,
-          providerMetadata: metadata,
-        })
+    const callID = item.call_id
+    if (state.completedTools.has(callID)) return [state, NO_EVENTS] satisfies StepResult
+    const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
+    const fallback = item.id ?? callID
+    // Match the pending tool by call id so item events that disagree on
+    // whether `item.id` is present still resolve the same call.
+    const registered =
+      state.tools[fallback] !== undefined
+        ? fallback
+        : Object.keys(state.tools).find((key) => state.tools[key]?.id === callID)
+    const id = registered ?? fallback
+    const tools =
+      registered !== undefined
+        ? state.tools
+        : ToolStream.start(state.tools, id, {
+            id: callID,
+            name: item.name,
+            providerMetadata: metadata,
+          })
     const result =
       item.arguments === undefined
-        ? yield* ToolStream.finish(state.id, tools, item.id)
-        : yield* ToolStream.finishWithInput(state.id, tools, item.id, item.arguments)
+        ? yield* ToolStream.finish(state.id, tools, id)
+        : yield* ToolStream.finishWithInput(state.id, tools, id, item.arguments)
     const events: LLMEvent[] = []
     const finished = result.events ?? []
     // A done-only call never streamed a start event, so open its lifecycle here.
     const resultEvents =
-      registered || finished.length === 0
+      registered !== undefined || finished.length === 0
         ? finished
-        : [
-            LLMEvent.toolInputStart({
-              id: item.call_id,
-              name: item.name,
-              namespace: item.namespace,
-              providerMetadata: metadata,
-            }),
-            ...finished,
-          ]
+        : [LLMEvent.toolInputStart({ id: callID, name: item.name, providerMetadata: metadata }), ...finished]
     const lifecycle = resultEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
     events.push(...resultEvents)
     return [
@@ -1269,12 +1225,14 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
           resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
           state.hasFunctionCall,
         tools: result.tools,
+        completedTools: new Set([...state.completedTools, callID]),
       },
       events,
     ] satisfies StepResult
   }
 
-  if (item.type === "reasoning") {
+  if (isReasoningItem(item)) {
+    if (state.reasoningItems[item.id]?.open === false) return [state, NO_EVENTS] satisfies StepResult
     const metadata = reasoningMetadata(state, item)
     const summaryParts: ReadonlyArray<unknown> = Array.isArray(item.summary) ? item.summary : []
     const summary: Array<string | undefined> = []
@@ -1301,14 +1259,53 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
         const finalText = fragments.length === 1 ? itemText : summary[Number(index)]
         lifecycle = Lifecycle.reasoningEnd(lifecycle, events, `${item.id}:${index}`, metadata, finalText || undefined)
       }
-      const reasoningItems = { ...state.reasoningItems }
-      delete reasoningItems[item.id]
-      return [{ ...state, lifecycle, reasoningItems }, events] satisfies StepResult
+      return [
+        {
+          ...state,
+          lifecycle,
+          reasoningItems: {
+            ...state.reasoningItems,
+            [item.id]: {
+              ...reasoningItem,
+              open: false,
+              encryptedContent: item.encrypted_content ?? reasoningItem.encryptedContent,
+            },
+          },
+        },
+        events,
+      ] satisfies StepResult
     }
-    const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-    events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata: metadata }))
-    events.push(LLMEvent.reasoningEnd({ id: item.id, providerMetadata: metadata, text: itemText }))
-    return [{ ...state, lifecycle }, events] satisfies StepResult
+    if (!state.lifecycle.reasoning.has(item.id)) {
+      const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
+      events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata: metadata }))
+      events.push(
+        LLMEvent.reasoningEnd({
+          id: item.id,
+          providerMetadata: metadata,
+          text: itemText,
+        }),
+      )
+      return [
+        {
+          ...state,
+          lifecycle,
+          reasoningItems: {
+            ...state.reasoningItems,
+            [item.id]: {
+              open: false,
+              encryptedContent: item.encrypted_content,
+              summaryParts: { 0: "concluded" },
+              deltaIndexes: new Set(),
+            },
+          },
+        },
+        events,
+      ] satisfies StepResult
+    }
+    return [
+      { ...state, lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, item.id, metadata) },
+      events,
+    ] satisfies StepResult
   }
 
   return [state, NO_EVENTS] satisfies StepResult
@@ -1318,17 +1315,17 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
   let current = state
   const events: LLMEvent[] = []
   if (event.type === "response.completed") {
-    // An output item's array position is its output index.
-    for (const item of (event.response?.output ?? []).map((item, index) => resolveItem(state, item, index))) {
-      // Terminal recovery cannot insert a checkpoint before already-emitted content.
-      if (item.type === "compaction" && state.lifecycle.stepStarted && !state.completedCompactions.has(item.id))
-        return yield* ProviderShared.eventError(
-          state.id,
-          "Cannot recover a compaction checkpoint after output has been emitted",
-        )
-      const recoverable =
-        item.type === "compaction" || (item.type === "function_call" && current.tools[item.id] !== undefined)
-      if (!recoverable) continue
+    for (const item of event.response?.output ?? []) {
+      if (item.type !== "compaction" && item.type !== "function_call") continue
+      if (item.type === "compaction") {
+        // Terminal recovery cannot insert a checkpoint before already-emitted content.
+        if (state.lifecycle.stepStarted && !state.completedCompactions.has(item.id ?? ""))
+          return yield* ProviderShared.eventError(
+            state.id,
+            "Cannot recover a compaction checkpoint after output has been emitted",
+          )
+      }
+      if (item.type === "function_call" && !current.tools[item.id ?? item.call_id ?? ""]) continue
       const [next, emitted] = yield* onOutputItemDone(current, item)
       current = next
       events.push(...emitted)
@@ -1395,9 +1392,12 @@ export const providerFailure = (event: Event, fallback: string, body = ProviderS
   return new AIError({ reason })
 }
 
-// Callers must pass events through `normalize` first. The OpenAPI requires
-// string IDs but imposes no minLength; empty is not missing.
-export const step = (state: ParserState, event: NormalizedEvent) => {
+export const step = (state: ParserState, input: Event) => {
+  // The OpenAPI requires string IDs but imposes no minLength; empty is not missing.
+  const event =
+    input.item_id !== undefined && outputItemID(state, input) !== input.item_id
+      ? { ...input, item_id: outputItemID(state, input) }
+      : input
   if (event.type === "response.output_text.delta" || event.type === "response.output_text.done") {
     if (event.item_id === undefined) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
     return Effect.succeed(
@@ -1437,16 +1437,20 @@ export const step = (state: ParserState, event: NormalizedEvent) => {
       ? Effect.succeed(onReasoningSummaryPartDone(state, event))
       : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
   if (event.type === "response.output_item.added") {
+    if (event.item?.type === "message" && event.item.id === undefined)
+      return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
     if (
-      event.item?.type === "reasoning" &&
+      event.item &&
+      isReasoningItem(event.item) &&
       state.reasoningItems[event.item.id] === undefined &&
       state.lifecycle.reasoning.size > 0
     )
       return ProviderShared.eventError(state.id, `${event.type} started reasoning before the previous item ended`)
+    const id = event.item?.id ?? (event.item?.type === "function_call" ? event.item.call_id : undefined)
     return Effect.succeed(
       onOutputItemAdded(
-        event.output_index !== undefined && event.item
-          ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: event.item.id } }
+        event.output_index !== undefined && id !== undefined
+          ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: id } }
           : state,
         event,
       ),
@@ -1456,7 +1460,11 @@ export const step = (state: ParserState, event: NormalizedEvent) => {
     return event.item_id !== undefined
       ? onFunctionCallArgumentsDelta(state, event)
       : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
-  if (event.type === "response.output_item.done") return onOutputItemDone(state, event.item)
+  if (event.type === "response.output_item.done") {
+    if (event.item?.type === "message" && event.item.id === undefined)
+      return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
+    return onOutputItemDone(state, event.item)
+  }
   if (event.type === "response.completed" || event.type === "response.incomplete") return onResponseFinish(state, event)
   if (event.type === "response.failed") return providerFailure(event, `${state.name} response failed`)
   if (event.type === "error")
@@ -1481,14 +1489,15 @@ export const step = (state: ParserState, event: NormalizedEvent) => {
  * The provider-neutral Open Responses protocol. Provider-specific Responses
  * implementations compose this baseline with their own tools and event variants.
  */
-export const initial = (request: LLMRequest, adapter: ProviderAdapter = BASE_ADAPTER): ParserState => ({
+export const initial = (request: LLMRequest, extension: Extension = BASE): ParserState => ({
   provider: request.model.provider,
   completedCompactions: new Set<string>(),
-  id: adapter.id,
-  name: adapter.name,
-  providerMetadataKey: metadataKey(request.model),
+  id: extension.id,
+  name: extension.name,
+  providerMetadataKey: request.model.route.providerMetadataKey ?? "openresponses",
   hasFunctionCall: false,
   tools: ToolStream.empty<string>(),
+  completedTools: new Set<string>(),
   lifecycle: Lifecycle.initial(),
   outputItems: {},
   message: undefined,
@@ -1504,7 +1513,7 @@ export const protocol = Protocol.make({
   stream: {
     event: Protocol.jsonEvent(Event),
     initial,
-    step: (state: ParserState, event: Event) => step(state, normalize(state, event)),
+    step,
     terminal,
   },
 })

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

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import { Route } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
@@ -736,7 +736,6 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
     )
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  const flattened = ProviderShared.flattenToolRequest(request)
   const provider = String(request.model.provider)
   const baseURL = request.model.route.endpoint.baseURL
   const detectedMaxTokensField = detectMaxTokensField(provider, baseURL)
@@ -749,16 +748,16 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
   const zaiToolStream =
     request.model.compatibility?.zaiToolStream ?? detectZaiToolStream(provider, baseURL, request.model.id)
   const hasHistory = hasToolHistory(request.messages)
-  const hasActiveTools = flattened.tools.length > 0
+  const hasActiveTools = request.tools.length > 0
   return {
     model: request.model.id,
-    messages: yield* lowerMessages(flattened.request, options),
+    messages: yield* lowerMessages(request, options),
     tools:
-      flattened.tools.length === 0
+      request.tools.length === 0
         ? hasHistory
           ? []
           : undefined
-        : flattened.tools.map((tool) =>
+        : request.tools.map((tool) =>
             lowerTool(
               tool,
               ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),

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

@@ -5,7 +5,7 @@ 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 { LLMRequest, mergeJsonRecords, type JsonSchema, type ToolDefinition, type ToolEntry } from "../schema/index.js"
+import type { LLMRequest, JsonSchema, ToolDefinition } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { OpenAIImage } from "./utils/openai-image.js"
@@ -13,7 +13,6 @@ import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { OpenResponsesChannel } from "./open-responses-channel.js"
 import { ResponsesCompaction } from "./utils/responses-compaction.js"
-import { ResponsesCheckpoint } from "./utils/responses-checkpoint.js"
 
 const ADAPTER = "openai-responses"
 const NAME = "OpenAI Responses"
@@ -76,18 +75,7 @@ const OpenAIResponsesHostedToolItem = Schema.Union([
   ),
 ])
 
-const OpenAIResponsesNamespace = Schema.Struct({
-  type: Schema.tag("namespace"),
-  name: Schema.String,
-  description: Schema.String,
-  tools: Schema.Array(OpenResponses.Tool),
-})
-
-const OpenAIResponsesTools = Schema.Union([
-  OpenResponses.Tool,
-  OpenAIResponsesNamespace,
-  OpenAIResponsesImageGenerationTool,
-])
+const OpenAIResponsesTools = Schema.Union([OpenResponses.Tool, OpenAIResponsesImageGenerationTool])
 
 const OpenAIResponsesToolChoice = Schema.Union([
   OpenResponses.ToolChoice,
@@ -115,23 +103,11 @@ const OpenAIResponsesBody = Schema.Struct({
 })
 export type OpenAIResponsesBody = Schema.Schema.Type<typeof OpenAIResponsesBody>
 
-/** Request control, never conversation content. */
-export const CompactionTrigger = Schema.Struct({ type: Schema.Literal("compaction_trigger") })
-const CheckpointBody = Schema.Struct({
-  ...OpenAIResponsesBody.fields,
-  input: Schema.Array(Schema.Union([OpenResponses.InputItem, OpenAIResponsesHostedToolItem, CompactionTrigger])),
-  store: Schema.Literal(false),
-  prompt_cache_retention: optionalNull(Schema.String),
-  prompt_cache_options: optionalNull(
-    Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) }),
-  ),
-})
-
-const adapter = {
+const extension = {
   id: ADAPTER,
   name: NAME,
-  restoreHostedToolItem: (item: unknown) => (Schema.is(OpenAIResponsesHostedToolItem)(item) ? item : undefined),
-} satisfies OpenResponses.ProviderAdapter
+  lowerHostedToolItem: (item: unknown) => (Schema.is(OpenAIResponsesHostedToolItem)(item) ? item : undefined),
+} satisfies OpenResponses.Extension
 
 const nativeImageToolInput = (tool: ToolDefinition) => {
   const native = tool.native?.openai
@@ -152,33 +128,13 @@ const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool: ToolDe
   return yield* OpenResponses.lowerTool(NAME, tool, inputSchema)
 })
 
-// Native namespaces hold only function tools, so deeper levels flatten into
-// the leaf names the same way non-native protocols flatten the whole tree.
-const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (
-  tool: ToolEntry,
-  compatibility: Parameters<typeof ToolSchemaProjection.modelCompatibility>[1],
-) {
-  if (tool.type === "tool")
-    return yield* lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, compatibility))
-  // OpenAI requires a namespace description; fall back to a generic one so a
-  // missing description never blocks the request.
-  return {
-    type: "namespace" as const,
-    name: tool.name,
-    description: tool.description ?? `Tools in the ${tool.name} namespace.`,
-    tools: yield* Effect.forEach(ProviderShared.flattenTools(tool.tools), (leaf) =>
-      OpenResponses.lowerTool(NAME, leaf, ToolSchemaProjection.modelCompatibility(leaf.inputSchema, compatibility)),
-    ),
-  }
-})
-
-const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolEntry>) =>
+const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolDefinition>) =>
   ProviderShared.matchToolChoice(NAME, toolChoice, {
     auto: () => "auto" as const,
     none: () => "none" as const,
     required: () => "required" as const,
     tool: (name) =>
-      tools.some((tool) => tool.type === "tool" && tool.name === name && nativeImageTool(tool) !== undefined)
+      tools.some((tool) => tool.name === name && nativeImageTool(tool) !== undefined)
         ? ({ type: "image_generation" } as const)
         : { type: "function" as const, name },
   })
@@ -191,48 +147,21 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
   )(request.providerOptions?.contextManagement)
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   return yield* decodeBody({
-    ...(yield* OpenResponses.lowerConversation(request, adapter)),
+    ...(yield* OpenResponses.lowerConversation(request, extension)),
     ...OpenResponses.lowerGeneration(request),
     context_management: management?.map((edit) => ({ type: edit.type, compact_threshold: edit.compactThreshold })),
     tools:
       request.tools.length === 0
         ? undefined
-        : yield* Effect.forEach(request.tools, (tool) => lowerToolEntry(tool, toolSchemaCompatibility)),
+        : yield* Effect.forEach(request.tools, (tool) =>
+            lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
+          ),
     tool_choice:
       OpenResponses.allowedToolChoice(request) ??
       (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),
   })
 })
 
-const checkpointBody = {
-  schema: CheckpointBody,
-  from: Effect.fn("OpenAIResponses.checkpointBody")(function* (request: LLMRequest) {
-    const native = yield* fromRequest(LLMRequest.update(request, { toolChoice: undefined }))
-    const overlay = request.http?.body
-    // Complete history is required for stateless replay and SSE recovery. Raw input overrides bypass that contract.
-    if (
-      overlay?.input !== undefined ||
-      overlay?.previous_response_id !== undefined ||
-      overlay?.conversation !== undefined
-    )
-      return yield* ProviderShared.invalidRequest(
-        "Trigger compaction requires complete canonical history, not an input or continuation override",
-      )
-    return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(CheckpointBody))({
-      ...mergeJsonRecords(native, overlay),
-      input: [...native.input, { type: "compaction_trigger" }],
-      stream: true,
-      store: false,
-      parallel_tool_calls: true,
-      tool_choice: undefined,
-      context_management: undefined,
-      text: undefined,
-      max_output_tokens: undefined,
-      max_tool_calls: undefined,
-    })
-  }),
-}
-
 const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item: ResponsesHostedTools.Item) {
   const isError = item.error !== undefined && item.error !== null
   if (item.type === "image_generation_call" && item.result) {
@@ -272,11 +201,12 @@ const HOSTED_TOOLS = {
   },
 } as const satisfies ResponsesHostedTools.Definitions
 
-const step = (state: OpenResponses.ParserState, input: OpenResponses.Event) => {
-  const event = OpenResponses.normalize(state, input)
+const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
   if (event.type === "response.reasoning_text.delta")
     return event.item_id !== undefined
-      ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
+      ? Effect.succeed(
+          OpenResponses.onReasoningDelta(state, event, OpenResponses.outputItemID(state, event) ?? event.item_id),
+        )
       : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
   if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
     return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
@@ -291,7 +221,7 @@ export const protocol = Protocol.make({
   },
   stream: {
     event: OpenResponses.protocol.stream.event,
-    initial: (request) => OpenResponses.initial(request, adapter),
+    initial: (request) => OpenResponses.initial(request, extension),
     step,
     terminal: OpenResponses.terminal,
   },
@@ -310,7 +240,7 @@ export const transport = channelTransport({
 })
 
 export const route = Route.make({
-  compact: { endpoint: ResponsesCompaction.make(adapter), trigger: ResponsesCheckpoint.make(checkpointBody) },
+  compact: ResponsesCompaction.make(extension),
   id: ADAPTER,
   provider: "openai",
   providerMetadataKey: "openai",

packages/ai/src/protocols/shared.ts

@@ -1,22 +1,17 @@
 import { Buffer } from "node:buffer"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import { Effect, Schema, Stream } from "effect"
 import * as Sse from "effect/unstable/encoding/Sse"
 import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import {
   InvalidProviderOutputError,
   InvalidRequestError,
-  UnsupportedOperationError,
   AIError,
   HttpContext,
-  LLMRequest,
-  Message,
-  ToolDefinition,
   type ContentPart,
+  type LLMRequest,
   type MediaPart,
-  type ProviderID,
   type TextPart,
-  type ToolEntry,
   type ToolResultPart,
 } from "../schema/index.js"
 import { isRecord } from "../utils/record.js"
@@ -49,7 +44,6 @@ export const promptCacheKey = (request: LLMRequest): string | undefined => {
 export interface ToolAccumulator {
   readonly id: string
   readonly name: string
-  readonly namespace?: string
   readonly input: string
 }
 
@@ -260,61 +254,6 @@ export const invalidRequest = (message: string, cause?: unknown) =>
     reason: new InvalidRequestError({ message, cause }),
   })
 
-/**
- * Canonical constructor for operations the selected route does not implement.
- * Prefer this over `invalidRequest` when the failure is a missing route
- * capability rather than a malformed caller input, so consumers can branch on
- * `reason._tag` plus `reason.operation` instead of matching message text.
- */
-export const unsupportedOperation = (input: {
-  readonly operation: string
-  readonly message: string
-  readonly provider?: ProviderID
-  readonly route?: string
-  readonly cause?: unknown
-}) =>
-  new AIError({
-    reason: new UnsupportedOperationError({
-      operation: input.operation,
-      message: input.message,
-      provider: input.provider,
-      route: input.route,
-      cause: input.cause,
-    }),
-  })
-
-/**
- * Lower namespaces to flat definitions for protocols without a native
- * namespace construct. Leaf names join their namespace path with `_` because
- * `.` is not broadly accepted in provider tool names.
- */
-export const flattenTools = (tools: ReadonlyArray<ToolEntry>, path: ReadonlyArray<string> = []) => {
-  const flat = tools.flatMap((tool): ReadonlyArray<ToolDefinition> => {
-    if (tool.type === "namespace") return flattenTools(tool.tools, [...path, tool.name])
-    if (path.length === 0) return [tool]
-    return [new ToolDefinition({ ...tool, name: [...path, tool.name].join("_") })]
-  })
-  return [...new Map(flat.map((tool) => [tool.name, tool])).values()]
-}
-
-export const flattenToolRequest = (request: LLMRequest) => {
-  const messages = request.messages.map((message) => {
-    const content = message.content.map((part) => {
-      if ((part.type !== "tool-call" && part.type !== "tool-result") || part.namespace === undefined) return part
-      return { ...part, name: `${part.namespace}_${part.name}`, namespace: undefined }
-    })
-    return content.every((part, index) => part === message.content[index])
-      ? message
-      : new Message({ ...message, content })
-  })
-  return {
-    tools: flattenTools(request.tools),
-    request: messages.every((message, index) => message === request.messages[index])
-      ? request
-      : LLMRequest.update(request, { messages }),
-  }
-}
-
 export const imageResponse = Effect.fn("ProviderShared.imageResponse")(function* (
   route: string,
   name: string,

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

@@ -2,12 +2,13 @@ import { AwsV4Signer } from "aws4fetch"
 import { Effect } from "effect"
 import { Headers } from "effect/unstable/http"
 import { Auth, type AuthInput } from "../../route/auth.js"
-import { AIError, AuthenticationError } from "../../schema/index.js"
 import { ProviderShared } from "../shared.js"
 
 /**
  * AWS credentials for SigV4 signing. Bedrock also supports Bearer API key auth,
- * which provider facades configure as route auth instead of SigV4.
+ * which provider facades configure as route auth instead of SigV4. STS-vended
+ * credentials should be refreshed by the consumer (rebuild the model) before
+ * they expire; the route does not refresh.
  */
 export interface Credentials {
   readonly region: string
@@ -16,44 +17,6 @@ export interface Credentials {
   readonly sessionToken?: string
 }
 
-/** Static credentials or an effect resolved before every request. */
-export type CredentialSource = Credentials | Effect.Effect<Credentials, AIError>
-
-export interface DefaultChainOptions {
-  readonly region: string
-  /** Shared config profile passed to the AWS default chain. */
-  readonly profile?: string
-}
-
-/**
- * Resolve credentials through the AWS default provider chain: environment
- * variables, shared config and SSO caches, web identity tokens, process
- * credentials, and container or instance metadata. A fresh chain runs on every
- * request so credentials rotated on disk without an expiration (for example
- * shared-config keys rewritten by a corporate SSO tool) are always re-read;
- * the SDK's own memoization would otherwise pin them for the process lifetime.
- */
-export const defaultChain = (options: DefaultChainOptions): Effect.Effect<Credentials, AIError> =>
-  Effect.tryPromise({
-    try: async () => {
-      const { fromNodeProviderChain } = await import("@aws-sdk/credential-providers")
-      const identity = await fromNodeProviderChain(options.profile === undefined ? {} : { profile: options.profile })()
-      return {
-        region: options.region,
-        accessKeyId: identity.accessKeyId,
-        secretAccessKey: identity.secretAccessKey,
-        ...(identity.sessionToken === undefined ? {} : { sessionToken: identity.sessionToken }),
-      }
-    },
-    catch: (error) =>
-      new AIError({
-        reason: new AuthenticationError({
-          message: `AWS default credential chain failed: ${ProviderShared.errorText(error)}`,
-          cause: error,
-        }),
-      }),
-  })
-
 const signRequest = (input: {
   readonly url: string
   readonly body: string
@@ -85,17 +48,16 @@ const signRequest = (input: {
 
 /** Sign the exact JSON bytes with SigV4 using credentials configured on the route. */
 export const sigV4 = (
-  source: CredentialSource | undefined,
+  credentials: Credentials | undefined,
   options: { readonly service?: string; readonly name?: string } = {},
 ) =>
   Auth.custom((input: AuthInput) => {
     return Effect.gen(function* () {
-      if (!source) {
+      if (!credentials) {
         return yield* ProviderShared.invalidRequest(
           `${options.name ?? "Bedrock Converse"} requires either route bearer auth or AWS credentials configured on the route`,
         )
       }
-      const credentials = Effect.isEffect(source) ? yield* source : source
       const headersForSigning = Headers.set(input.headers, "content-type", "application/json")
       const signed = yield* signRequest({
         url: input.url,
@@ -112,35 +74,4 @@ export const sigV4 = (
 /** Bedrock route auth defaults to SigV4 and expects credentials from route configuration. */
 export const auth = sigV4(undefined)
 
-export const resolveRegion = (input: {
-  readonly region?: string
-  readonly credentials?: { readonly region: string }
-}) =>
-  input.region ?? input.credentials?.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1"
-
-export interface ResolveAuthInput {
-  readonly apiKey?: string
-  readonly credentials?: Credentials
-  readonly profile?: string
-}
-
-export interface ResolveAuthOptions {
-  readonly service?: string
-  readonly name?: string
-  /** `sigv4` ignores an ambient `AWS_BEARER_TOKEN_BEDROCK`; `bearer` is validated by the caller. */
-  readonly mode?: "bearer" | "sigv4"
-}
-
-/**
- * Bearer wins over SigV4 and explicit static credentials win over the default
- * chain, matching the AWS SDK's own precedence for `AWS_BEARER_TOKEN_BEDROCK`.
- * The region is applied to the SigV4 scope so it always matches the endpoint host.
- */
-export const resolveAuth = (input: ResolveAuthInput, region: string, options: ResolveAuthOptions = {}) => {
-  const apiKey = options.mode === "sigv4" ? undefined : (input.apiKey ?? process.env.AWS_BEARER_TOKEN_BEDROCK)
-  if (apiKey !== undefined) return Auth.bearer(apiKey)
-  if (input.credentials !== undefined) return sigV4({ ...input.credentials, region }, options)
-  return sigV4(defaultChain({ region, profile: input.profile }), options)
-}
-
 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/index.js"
-import { newBreakpoints, ttlBucket } from "./cache.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
@@ -13,46 +13,24 @@ export const CachePointBlock = Schema.Struct({
 })
 export type CachePointBlock = Schema.Schema.Type<typeof CachePointBlock>
 
-const LEGACY_CLAUDE = ["anthropic.claude-instant", "anthropic.claude-v1", "anthropic.claude-v2", "anthropic.claude-3-"]
-
-// These legacy Claude releases support explicit caching, but only for five minutes.
-const CLAUDE_5M = [
-  "anthropic.claude-3-5-sonnet-20241022-v2:0",
-  "anthropic.claude-3-5-haiku-20241022-v1:0",
-  "anthropic.claude-3-7-sonnet-20250219-v1:0",
-  "anthropic.claude-sonnet-4-20250514-v1:0",
-  "anthropic.claude-opus-4-20250514-v1:0",
-  "anthropic.claude-opus-4-1-20250805-v1:0",
-]
-
-// Callers share the four-breakpoint budget across system, messages, and tools.
+// Callers pass a shared counter through every `block()` call site so the
+// four-breakpoint budget is respected across `system`, `messages`, and `tools`.
 export const BEDROCK_BREAKPOINT_CAP = 4
 
-export const breakpoints = (modelID: string) => {
-  // Substring matching also handles regional prefixes and model-bearing ARNs.
-  const short = CLAUDE_5M.some((id) => modelID.includes(id))
-  return {
-    ...newBreakpoints(BEDROCK_BREAKPOINT_CAP),
-    // Assume modern Claude releases retain caching support; older generations need an explicit exception.
-    // Other model families use implicit caching where available.
-    supported: modelID.includes("anthropic.claude-") && (short || !LEGACY_CLAUDE.some((id) => modelID.includes(id))),
-    ttl1h: !short,
-  }
-}
-export type Breakpoints = ReturnType<typeof breakpoints>
+export type { Breakpoints } from "./cache.js"
+export const breakpoints = () => newBreakpoints(BEDROCK_BREAKPOINT_CAP)
 
 const DEFAULT_5M: CachePointBlock = { cachePoint: { type: "default" } }
 const DEFAULT_1H: CachePointBlock = { cachePoint: { type: "default", ttl: "1h" } }
 
 export const block = (breakpoints: Breakpoints, cache: CacheHint | undefined): CachePointBlock | undefined => {
-  if (!breakpoints.supported) return undefined
   if (cache?.type !== "ephemeral" && cache?.type !== "persistent") return undefined
   if (breakpoints.remaining <= 0) {
     breakpoints.dropped += 1
     return undefined
   }
   breakpoints.remaining -= 1
-  return breakpoints.ttl1h && ttlBucket(cache.ttlSeconds) === "1h" ? DEFAULT_1H : DEFAULT_5M
+  return ttlBucket(cache.ttlSeconds) === "1h" ? DEFAULT_1H : DEFAULT_5M
 }
 
 export * as BedrockCache from "./bedrock-cache.js"

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

@@ -1,11 +0,0 @@
-// Responses image items can omit output_format, including when PNG/JPEG was requested.
-export const mediaType = (data: Uint8Array, format?: string) => {
-  if (format !== undefined) return `image/${format}`
-  if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return "image/png"
-  if (data[0] === 255 && data[1] === 216 && data[2] === 255) return "image/jpeg"
-  if (new TextDecoder().decode(data.slice(0, 4)) === "RIFF" && new TextDecoder().decode(data.slice(8, 12)) === "WEBP")
-    return "image/webp"
-  return "application/octet-stream"
-}
-
-export * as MetaImage from "./meta-image.js"

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

@@ -1,122 +0,0 @@
-import { Effect, Schema, Stream } from "effect"
-import { Route, type RouteBody, type TriggerCompactOperation } from "../../route/client.js"
-import { Protocol } from "../../route/protocol.js"
-import { CompactionCheckpointResponse, HttpOptions, LLMEvent, LLMRequest } from "../../schema/index.js"
-import { OpenResponses } from "../open-responses.js"
-import { ProviderShared } from "../shared.js"
-
-interface State {
-  readonly parser: Pick<OpenResponses.ParserState, "id" | "provider" | "outputItems">
-  readonly checkpoints: Readonly<Record<string, CompactionCheckpointResponse["checkpoint"]>>
-  readonly responseID?: string
-}
-
-const onOutputItem = Effect.fn("ResponsesCheckpoint.onOutputItem")(function* (
-  state: State,
-  input: OpenResponses.Event,
-) {
-  const event = OpenResponses.normalize(state.parser, input)
-  const item = event.item
-  if (!item) return state
-  const parser =
-    event.output_index === undefined || state.parser.outputItems[event.output_index] === item.id
-      ? state.parser
-      : { ...state.parser, outputItems: { ...state.parser.outputItems, [event.output_index]: item.id } }
-  const next = parser === state.parser ? state : { ...state, parser }
-  if (event.type === "response.output_item.added" || item.type !== "compaction") return next
-  if (
-    event.output_index !== undefined &&
-    Object.entries(state.parser.outputItems).some(
-      ([index, id]) => id === item.id && Number(index) !== event.output_index,
-    )
-  )
-    return yield* ProviderShared.eventError(parser.id, "Compaction checkpoint appeared in multiple output slots")
-  if (!item.encrypted_content)
-    return yield* ProviderShared.eventError(parser.id, "Compaction output is missing its encrypted content")
-  const previous = state.checkpoints[item.id]
-  if (previous && previous.encrypted !== item.encrypted_content)
-    return yield* ProviderShared.eventError(parser.id, "Compaction output changed after completion")
-  if (previous) return next
-  return {
-    ...next,
-    checkpoints: {
-      ...state.checkpoints,
-      [item.id]: { type: "compaction", provider: parser.provider, id: item.id, encrypted: item.encrypted_content },
-    },
-  } satisfies State
-})
-
-/** Collect a trigger response before acknowledging transport completion. No generation output escapes. */
-export const make = <Body>(body: RouteBody<Body>): TriggerCompactOperation =>
-  Effect.fn("ResponsesCheckpoint.execute")(function* (request, executor, options) {
-    const source = request.model.route
-    let result: CompactionCheckpointResponse | undefined
-    // Route registries erase the frame type. The codec validates that boundary before parsing.
-    const event: Schema.Codec<OpenResponses.Event, unknown> = OpenResponses.protocol.stream.event
-    const protocol = Protocol.make({
-      id: source.protocol,
-      body,
-      stream: {
-        event,
-        initial: (request: LLMRequest): State => ({
-          parser: { id: source.id, provider: request.model.provider, outputItems: {} },
-          checkpoints: {},
-        }),
-        terminal: OpenResponses.terminal,
-        step: Effect.fn("ResponsesCheckpoint.step")(function* (state: State, event: OpenResponses.Event) {
-          if (event.response?.id && state.responseID && event.response.id !== state.responseID)
-            return yield* ProviderShared.eventError(source.id, "Compaction response ID changed during execution")
-          if (event.type === "response.created") return [{ ...state, responseID: event.response?.id }, []] as const
-          if (event.type === "error" || event.type === "response.failed")
-            return yield* OpenResponses.providerFailure(event, "Compaction request failed")
-          if (event.type === "response.incomplete")
-            return yield* ProviderShared.eventError(source.id, "Compaction response was incomplete")
-          if (event.type === "response.output_item.added" || event.type === "response.output_item.done")
-            return [yield* onOutputItem(state, event), []] as const
-          if (event.type !== "response.completed") return [state, []] as const
-          const responseID = event.response?.id
-          if (!responseID?.trim())
-            return yield* ProviderShared.eventError(source.id, "Compaction response is missing its response ID")
-          if (event.response?.status !== undefined && event.response.status !== "completed")
-            return yield* ProviderShared.eventError(source.id, "Compaction response did not complete successfully")
-          let next = state
-          for (const [index, item] of (event.response?.output ?? []).entries()) {
-            next = yield* onOutputItem(next, { type: "response.output_item.done", output_index: index, item })
-          }
-          const checkpoints = Object.values(next.checkpoints)
-          const checkpoint = checkpoints[0]
-          if (checkpoints.length !== 1 || !checkpoint)
-            return yield* ProviderShared.eventError(
-              source.id,
-              "Compaction response must contain exactly one checkpoint",
-            )
-          result = new CompactionCheckpointResponse({
-            checkpoint,
-            responseID,
-            usage: OpenResponses.mapUsage(event.response?.usage, OpenResponses.metadataKey(request.model)),
-          })
-          return [next, [LLMEvent.finish({ reason: { normalized: "stop" } })]] as const
-        }),
-      },
-    })
-    const route = Route.make({
-      id: source.id,
-      provider: source.provider,
-      providerMetadataKey: source.providerMetadataKey,
-      protocol,
-      endpoint: source.endpoint,
-      auth: source.auth,
-      transport: source.transport,
-    })
-    const native = yield* body.from(request)
-    // The body builder already applied and validated overlays. Do not let transport reapply them.
-    const preparedRequest = LLMRequest.update(request, {
-      http: request.http === undefined ? undefined : new HttpOptions({ ...request.http, body: undefined }),
-    })
-    const prepared = yield* route.prepareTransport(native, preparedRequest, options)
-    yield* route.streamPrepared(prepared, preparedRequest, { http: executor }, options).pipe(Stream.runDrain)
-    if (!result) return yield* ProviderShared.eventError(source.id, "Compaction response ended without a checkpoint")
-    return result
-  })
-
-export * as ResponsesCheckpoint from "./responses-checkpoint.js"

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

@@ -15,33 +15,19 @@ import { Endpoint } from "../../route/endpoint.js"
 import { RequestExecutor } from "../../route/executor.js"
 import { HttpTransport } from "../../route/transport/index.js"
 import { OpenResponses } from "../open-responses.js"
-import { JsonObject, optionalNull, ProviderShared } from "../shared.js"
+import { JsonObject, ProviderShared } from "../shared.js"
 
 const Body = Schema.Struct({
   model: Schema.String,
   input: Schema.Array(Schema.Unknown),
-  instructions: optionalNull(Schema.String),
-  previous_response_id: optionalNull(Schema.String),
-  service_tier: optionalNull(Schema.String),
-  prompt_cache_key: optionalNull(Schema.String),
-  prompt_cache_retention: optionalNull(Schema.String),
-  prompt_cache_options: optionalNull(
-    Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) }),
-  ),
+  instructions: Schema.optional(Schema.String),
+  previous_response_id: Schema.optional(Schema.String),
 })
 
 const Text = Schema.Union([OpenResponses.OpenResponsesInputText, OpenResponses.OpenResponsesOutputText])
 const File = Schema.Union([
-  Schema.Struct({
-    ...OpenResponses.OpenResponsesInputFile.fields,
-    file_url: Schema.String,
-    file_data: Schema.optional(Schema.Never),
-  }),
-  Schema.Struct({
-    ...OpenResponses.OpenResponsesInputFile.fields,
-    file_data: Schema.String,
-    file_url: Schema.optional(Schema.Never),
-  }),
+  Schema.Struct({ type: Schema.Literal("input_file"), filename: Schema.String, file_url: Schema.String }),
+  Schema.Struct({ type: Schema.Literal("input_file"), filename: Schema.String, file_data: Schema.String }),
 ])
 const MessageFields = {
   type: Schema.Literal("message"),
@@ -72,19 +58,12 @@ const Response = Schema.Struct({
   usage: Schema.optional(Schema.StructWithRest(OpenResponses.OpenResponsesUsage, [JsonObject])),
 })
 
-export const make = (adapter: OpenResponses.ProviderAdapter): CompactOperation =>
+export const make = (extension: OpenResponses.Extension): CompactOperation =>
   Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
     const route = request.model.route
-    const native = yield* OpenResponses.lowerConversation(request, adapter)
+    const native = yield* OpenResponses.lowerConversation(request, extension)
     const body = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(
-      mergeJsonRecords(
-        {
-          ...native,
-          service_tier: request.providerOptions?.serviceTier,
-          prompt_cache_key: ProviderShared.promptCacheKey(request),
-        },
-        request.http?.body,
-      ),
+      mergeJsonRecords(native, request.http?.body),
     )
     const url = Endpoint.render(route.endpoint, { request, body: native })
     url.pathname = `${url.pathname.replace(/\/$/, "")}/compact`
@@ -124,8 +103,8 @@ export const make = (adapter: OpenResponses.ProviderAdapter): CompactOperation =
     if (!result.output.some((item) => item.type === "compaction"))
       return yield* invalid("Compaction response did not contain a checkpoint")
     return new CompactionResponse({
-      replacement: result.output.map((item) => toMessage(item, request.model)),
-      usage: OpenResponses.mapUsage(result.usage, OpenResponses.metadataKey(request.model)),
+      messages: result.output.map((item) => toMessage(item, request.model)),
+      usage: OpenResponses.mapUsage(result.usage, route.providerMetadataKey ?? String(request.model.provider)),
     })
   })
 
@@ -135,7 +114,7 @@ function toMessage(item: (typeof Response.Type.output)[number], model: LLMReques
       CompactionPart.make({ provider: model.provider, id: item.id ?? undefined, encrypted: item.encrypted_content }),
     )
 
-  const key = OpenResponses.metadataKey(model)
+  const key = model.route.providerMetadataKey ?? String(model.provider)
   if (item.type === "reasoning") {
     const summary = item.summary.length ? item.summary : [{ text: "" }]
     return Message.assistant(
@@ -159,13 +138,12 @@ function toMessage(item: (typeof Response.Type.output)[number], model: LLMReques
           mediaType: /^data:([^;,]+)/.exec(part.image_url)?.[1] ?? "image/*",
           providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
         }
-      const data = part.file_url === undefined ? part.file_data : part.file_url
+      const data = "file_url" in part ? part.file_url : part.file_data
       return {
         type: "media",
         data,
         filename: part.filename,
         mediaType: /^data:([^;,]+)/.exec(data)?.[1] ?? "application/octet-stream",
-        providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
       }
     }),
   })

packages/ai/src/protocols/utils/responses-hosted-tools.ts

@@ -3,7 +3,8 @@ import { LLMEvent, type AIError, type ToolResultPart } from "../../schema/index.
 import { OpenResponses } from "../open-responses.js"
 import { Lifecycle } from "./lifecycle.js"
 
-export type Item = OpenResponses.OutputItem & {
+export type Item = OpenResponses.StreamItem & {
+  readonly id: string
   readonly status?: string
   readonly action?: unknown
   readonly queries?: unknown
@@ -26,8 +27,8 @@ export interface Definition {
 
 export type Definitions = Readonly<Record<string, Definition>>
 
-export const isItem = <Tools extends Definitions>(item: OpenResponses.OutputItem, tools: Tools): item is Item =>
-  item.type in tools
+export const isItem = <Tools extends Definitions>(item: OpenResponses.StreamItem, tools: Tools): item is Item =>
+  item.type in tools && typeof item.id === "string" && item.id.length > 0
 
 export const onDone: (
   state: OpenResponses.ParserState,

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

@@ -55,7 +55,6 @@ const inputStart = (tool: PendingTool) =>
   LLMEvent.toolInputStart({
     id: tool.id,
     name: tool.name,
-    namespace: tool.namespace,
     providerExecuted: tool.providerExecuted ? true : undefined,
     providerMetadata: tool.providerMetadata,
   })
@@ -64,7 +63,6 @@ const inputDelta = (tool: PendingTool, text: string) =>
   LLMEvent.toolInputDelta({
     id: tool.id,
     name: tool.name,
-    namespace: tool.namespace,
     text,
     input: Option.getOrElse(parsePartialInput(tool.input), () => ({})),
   })
@@ -87,7 +85,6 @@ const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
         LLMEvent.toolCall({
           id: tool.id,
           name: tool.name,
-          namespace: tool.namespace,
           input,
           providerExecuted: tool.providerExecuted ? true : undefined,
           providerMetadata: tool.providerMetadata,
@@ -97,12 +94,7 @@ const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
 }
 
 const finishEvents = (tool: PendingTool, event: ToolCall): ReadonlyArray<LLMEvent> => [
-  LLMEvent.toolInputEnd({
-    id: tool.id,
-    name: tool.name,
-    namespace: tool.namespace,
-    providerMetadata: tool.providerMetadata,
-  }),
+  LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
   event,
 ]
 
@@ -158,7 +150,6 @@ export const appendOrStart = <K extends StreamKey>(
   const tool = {
     id,
     name,
-    namespace: current?.namespace,
     input: `${current?.input ?? ""}${delta.text}`,
     providerExecuted: current?.providerExecuted,
     providerMetadata: current?.providerMetadata,
@@ -168,17 +159,6 @@ export const appendOrStart = <K extends StreamKey>(
   return appendTool(tools, key, tool, delta.text)
 }
 
-/**
- * Append argument text to a started tool. Returns `undefined` when no tool is
- * open under `key`, for protocols that ignore deltas without a matching block.
- */
-export const append = <K extends StreamKey>(tools: State<K>, key: K, text: string): AppendOutcome<K> | undefined => {
-  const current = tools[key]
-  if (!current) return undefined
-  if (text.length === 0) return { tools, tool: current, events: [] }
-  return appendTool(tools, key, { ...current, input: `${current.input}${text}` }, text)
-}
-
 /**
  * Append argument text to a tool that must already have been started. This keeps
  * protocols honest when their stream grammar promises a start event before any
@@ -190,7 +170,12 @@ export const appendExisting = <K extends StreamKey>(
   key: K,
   text: string,
   missingToolMessage: string,
-): AppendOutcome<K> | AIError => append(tools, key, text) ?? eventError(route, missingToolMessage)
+): AppendOutcome<K> | AIError => {
+  const current = tools[key]
+  if (!current) return eventError(route, missingToolMessage)
+  if (text.length === 0) return { tools, tool: current, events: [] }
+  return appendTool(tools, key, { ...current, input: `${current.input}${text}` }, text)
+}
 
 /**
  * Finalize one pending tool call: parse the accumulated raw JSON, remove it

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

@@ -37,22 +37,19 @@ const XAIResponsesBody = Schema.Struct({
   stream: Schema.Literal(true),
 })
 
-const adapter = {
+const extension = {
   id: ADAPTER,
   name: NAME,
-  restoreHostedToolItem: (item: unknown) => (Schema.is(XAIResponsesHostedToolItem)(item) ? item : undefined),
-} satisfies OpenResponses.ProviderAdapter
+  lowerHostedToolItem: (item: unknown) => (Schema.is(XAIResponsesHostedToolItem)(item) ? item : undefined),
+} satisfies OpenResponses.Extension
 
 const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(XAIResponsesBody))
 const fromRequest = Effect.fn("XAIResponses.fromRequest")(function* (request: LLMRequest) {
   if (request.providerOptions?.contextManagement !== undefined)
-    return yield* ProviderShared.unsupportedOperation({
-      operation: "in-band-compaction",
-      provider: request.model.provider,
-      route: request.model.route.id,
-      message: "xAI requires explicit compaction through LLMClient.compact; automatic context management is not supported",
-    })
-  return yield* decodeBody(yield* OpenResponses.fromRequestWithAdapter(request, adapter))
+    return yield* ProviderShared.invalidRequest(
+      "xAI requires explicit compaction through LLMClient.compact; automatic context management is not supported",
+    )
+  return yield* decodeBody(yield* OpenResponses.fromRequestWithExtension(request, extension))
 })
 
 const HOSTED_TOOLS = {
@@ -72,8 +69,7 @@ const HOSTED_TOOLS = {
 
 // Grok speaks the standard Responses reasoning dialect (`reasoning_summary_text.*`,
 // handled by the baseline); only its hosted tool vocabulary differs.
-const step = (state: OpenResponses.ParserState, input: OpenResponses.Event) => {
-  const event = OpenResponses.normalize(state, input)
+const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
   if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
     return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
   return OpenResponses.step(state, event)
@@ -87,12 +83,12 @@ export const protocol = Protocol.make({
   },
   stream: {
     event: OpenResponses.protocol.stream.event,
-    initial: (request) => OpenResponses.initial(request, adapter),
+    initial: (request) => OpenResponses.initial(request, extension),
     step,
     terminal: OpenResponses.terminal,
   },
 })
 
-export const compact = ResponsesCompaction.make(adapter)
+export const compact = ResponsesCompaction.make(extension)
 
 export * as XAIResponses from "./xai-responses.js"

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

@@ -1,75 +0,0 @@
-import { Effect, Schema } from "effect"
-import { Protocol } from "../route/protocol.js"
-import type { LanguageModelCompatibility, LLMRequest } from "../schema/index.js"
-import { OpenAIChat } from "./openai-chat.js"
-import { ProviderShared } from "./shared.js"
-
-export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | (string & {})
-
-export type OptionsInput = {
-  readonly reasoningEffort?: ReasoningEffort
-  readonly thinking?: {
-    readonly type?: "enabled" | "disabled" | (string & {})
-    /** False retains historical reasoning; omission preserves the endpoint's default. */
-    readonly clear_thinking?: boolean
-  }
-  readonly toolStream?: boolean
-  readonly doSample?: boolean
-  readonly responseFormat?: { readonly type: "text" | "json_object" | (string & {}) }
-  readonly requestID?: string
-  readonly userID?: string
-}
-
-const Options = Schema.Struct({
-  reasoningEffort: Schema.optional(Schema.String),
-  thinking: Schema.optional(
-    Schema.Struct({ type: Schema.optional(Schema.String), clear_thinking: Schema.optional(Schema.Boolean) }),
-  ),
-  toolStream: Schema.optional(Schema.Boolean),
-  doSample: Schema.optional(Schema.Boolean),
-  responseFormat: Schema.optional(Schema.Struct({ type: Schema.String })),
-  requestID: Schema.optional(Schema.String),
-  userID: Schema.optional(Schema.String),
-})
-
-const Body = Schema.Struct({
-  ...OpenAIChat.bodyFields,
-  thinking: Options.fields.thinking,
-  do_sample: Options.fields.doSample,
-  response_format: Options.fields.responseFormat,
-  request_id: Options.fields.requestID,
-  user_id: Options.fields.userID,
-})
-
-const fromRequest = Effect.fn("ZAIChat.fromRequest")(function* (request: LLMRequest) {
-  const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(request.providerOptions ?? {})
-  const body = yield* OpenAIChat.protocol.body.from(request)
-  return {
-    ...body,
-    thinking: options.thinking,
-    // Tool streaming was introduced in GLM-4.6; older models must not receive the opt-in.
-    tool_stream:
-      options.toolStream ??
-      (body.tools?.length && /^glm-(?:4\.[67]|5(?:[.-]|$))/i.test(request.model.id) ? true : undefined),
-    do_sample: options.doSample,
-    response_format: options.responseFormat,
-    request_id: options.requestID,
-    user_id: options.userID,
-  }
-})
-
-export const compatibility = {
-  maxTokensField: "max_tokens",
-  supportsStore: false,
-  supportsStrictMode: false,
-  reasoningField: "reasoning_content",
-  zaiToolStream: false,
-} satisfies LanguageModelCompatibility
-
-export const protocol = Protocol.make({
-  id: "zai-chat",
-  body: { schema: Body, from: fromRequest },
-  stream: OpenAIChat.protocol.stream,
-})
-
-export * as ZAIChat from "./zai-chat.js"

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

@@ -1,39 +0,0 @@
-import { Effect, Schema } from "effect"
-import { Protocol } from "../route/protocol.js"
-import { LLMRequest } from "../schema/index.js"
-import { AnthropicMessages } from "./anthropic-messages.js"
-import { ProviderShared } from "./shared.js"
-import type { ZAIChat } from "./zai-chat.js"
-
-export type OptionsInput = {
-  readonly effort?: ZAIChat.ReasoningEffort
-  readonly thinking?: { readonly type: "enabled" | "adaptive" | "disabled" | (string & {}) }
-}
-
-const Options = Schema.Struct({
-  effort: Schema.optional(Schema.String),
-  thinking: Schema.optional(Schema.Struct({ type: Schema.String })),
-})
-const Body = Schema.Struct({
-  ...AnthropicMessages.AnthropicMessagesBody.fields,
-  thinking: Options.fields.thinking,
-})
-
-const fromRequest = Effect.fn("ZAIMessages.fromRequest")(function* (request: LLMRequest) {
-  const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(request.providerOptions ?? {})
-  // Z.AI accepts enabled thinking without Anthropic's mandatory token budget.
-  const body = yield* AnthropicMessages.protocol.body.from(
-    LLMRequest.update(request, {
-      providerOptions: { ...request.providerOptions, thinking: undefined },
-    }),
-  )
-  return { ...body, thinking: options.thinking }
-})
-
-export const protocol = Protocol.make({
-  id: "zai-messages",
-  body: { schema: Body, from: fromRequest },
-  stream: AnthropicMessages.protocol.stream,
-})
-
-export * as ZAIMessages from "./zai-messages.js"

packages/ai/src/provider-package.ts

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

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

@@ -1,3 +1,4 @@
+import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
@@ -9,15 +10,9 @@ import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-opt
 export const id = ProviderID.make("amazon-bedrock")
 
 export type Config = RouteDefaultsInput & {
-  /** Bedrock API key. Falls back to `AWS_BEARER_TOKEN_BEDROCK`; bearer auth takes precedence over SigV4. */
   readonly apiKey?: string
-  /** `sigv4` ignores `apiKey` fallbacks from the environment; `bearer` requires a token. */
-  readonly auth?: "bearer" | "sigv4"
   readonly baseURL?: string
-  /** Static SigV4 credentials. When omitted the AWS default credential chain resolves them per request. */
   readonly credentials?: Credentials
-  /** Shared config profile for the default credential chain. */
-  readonly profile?: string
   readonly region?: string
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
@@ -27,7 +22,6 @@ export interface Settings extends ProviderPackage.Settings {
   readonly auth?: "bearer" | "sigv4"
   readonly baseURL?: string
   readonly credentials?: Credentials
-  readonly profile?: string
   readonly region?: string
   readonly topP?: number
   readonly providerOptions?: OpenAIProviderOptionsInput
@@ -53,35 +47,23 @@ const chatRoute = OpenAIChat.route.with({
 export const routes = [responsesRoute, chatRoute]
 
 const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Config) => {
-  const region = BedrockAuth.resolveRegion(input)
+  const region = input.region ?? input.credentials?.region ?? "us-east-1"
+  const credentials = input.credentials === undefined ? undefined : { ...input.credentials, region }
   return route.with({
     endpoint: { baseURL: input.baseURL ?? `https://bedrock-mantle.${region}.api.aws/v1` },
-    auth: BedrockAuth.resolveAuth(input, region, {
-      service: "bedrock-mantle",
-      name: "Bedrock Mantle",
-      mode: input.auth,
-    }),
+    auth:
+      input.apiKey === undefined
+        ? BedrockAuth.sigV4(credentials, { service: "bedrock-mantle", name: "Bedrock Mantle" })
+        : Auth.bearer(input.apiKey),
   })
 }
 
 const defaults = (input: Config) => {
-  const {
-    apiKey: _,
-    auth: _auth,
-    baseURL: _baseURL,
-    credentials: _credentials,
-    profile: _profile,
-    region: _region,
-    ...rest
-  } = input
+  const { apiKey: _, baseURL: _baseURL, credentials: _credentials, region: _region, ...rest } = input
   return rest
 }
 
 export const configure = (input: Config = {}) => {
-  if (input.auth === "bearer" && input.apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-    throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey")
-  if (input.auth === "sigv4" && input.apiKey !== undefined)
-    throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey")
   const configuredResponsesRoute = configuredRoute(responsesRoute, input)
   const configuredChatRoute = configuredRoute(chatRoute, input)
   const modelDefaults = defaults(input)
@@ -105,26 +87,29 @@ export const configure = (input: Config = {}) => {
 
 export const provider = configure()
 
-const fromSettings = (settings: Settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    auth: settings.auth,
+const config = (settings: Settings): Config => {
+  if (settings.auth === "bearer" && settings.apiKey === undefined)
+    throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey")
+  if (settings.auth === "sigv4" && settings.apiKey !== undefined)
+    throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey")
+  return {
+    apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
     baseURL: settings.baseURL,
     credentials: settings.credentials,
     generation: settings.topP === undefined ? undefined : { topP: settings.topP },
     headers: settings.headers === undefined ? undefined : { ...settings.headers },
     http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    profile: settings.profile,
     providerOptions: settings.providerOptions,
     region: settings.region,
-  })
+  }
+}
 
 export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
   modelID,
   settings,
-) => fromSettings(settings).chat(modelID)
+) => configure(config(settings)).chat(modelID)
 export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
   modelID,
   settings,
-) => fromSettings(settings).responses(modelID)
+) => configure(config(settings)).responses(modelID)
 export const model = responsesModel

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

@@ -1,23 +1,19 @@
-import type { RouteDefaultsInput } from "../route/client.js"
+import type { Route, 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"
-import { BedrockAuth } from "../protocols/utils/bedrock-auth.js"
+import { BedrockMessages } from "../protocols/bedrock-messages.js"
+import type { AnthropicMessages } from "../protocols/anthropic-messages.js"
 
 export const id = ProviderID.make("amazon-bedrock")
 
 export type Config = RouteDefaultsInput & {
-  /** Bedrock API key. Falls back to `AWS_BEARER_TOKEN_BEDROCK`; bearer auth takes precedence over SigV4. */
   readonly apiKey?: string
-  /** `sigv4` ignores `apiKey` fallbacks from the environment; `bearer` requires a token. */
-  readonly auth?: "bearer" | "sigv4"
   readonly headers?: Record<string, string>
-  /** Static SigV4 credentials. When omitted the AWS default credential chain resolves them per request. */
   readonly credentials?: BedrockCredentials
-  /** Shared config profile for the default credential chain. */
-  readonly profile?: string
-  /** AWS region. Falls back to `credentials.region`, `AWS_REGION`, `AWS_DEFAULT_REGION`, then `us-east-1`. */
+  /** AWS region. Defaults to `us-east-1` when neither this nor `credentials.region` is set. */
   readonly region?: string
   /** Override the computed `https://bedrock-runtime.<region>.amazonaws.com` URL. */
   readonly baseURL?: string
@@ -28,48 +24,57 @@ export interface Settings extends ProviderPackage.Settings {
   readonly auth?: "bearer" | "sigv4"
   readonly baseURL?: string
   readonly credentials?: BedrockCredentials
-  readonly profile?: string
   readonly region?: string
   readonly topP?: number
 }
-export const routes = [BedrockConverse.route]
+export const routes = [BedrockConverse.route, BedrockMessages.route]
 
 const bedrockBaseURL = (region: string) => `https://bedrock-runtime.${region}.amazonaws.com`
 
-const configuredRoute = (input: Config) => {
-  const { apiKey, auth, credentials, profile, region, baseURL, ...rest } = input
-  if (auth === "bearer" && apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-    throw new Error("Amazon Bedrock bearer auth requires apiKey")
-  if (auth === "sigv4" && apiKey !== undefined) throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey")
-  const resolvedRegion = BedrockAuth.resolveRegion(input)
-  return BedrockConverse.route.with({
+const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Config) => {
+  const { apiKey, credentials, region, baseURL, ...rest } = input
+  const resolvedRegion = region ?? credentials?.region ?? "us-east-1"
+  return route.with({
     ...rest,
     provider: id,
-    providerMetadataKey: "bedrock",
+    providerMetadataKey: route.providerMetadataKey,
     endpoint: { baseURL: baseURL ?? bedrockBaseURL(resolvedRegion) },
-    auth: BedrockAuth.resolveAuth({ apiKey, credentials, profile }, resolvedRegion, { mode: auth }),
+    auth: apiKey === undefined ? BedrockConverse.sigV4Auth(credentials) : Auth.bearer(apiKey),
   })
 }
 
 export const configure = (input: Config = {}) => {
-  const route = configuredRoute(input)
+  const route = configuredRoute(BedrockConverse.route, input)
+  const messages = configuredRoute(BedrockMessages.route, input)
   return {
     id,
     model: (modelID: string | ModelID) => route.model({ id: modelID }),
+    messages: (modelID: string | ModelID) => messages.model<AnthropicMessages.ProviderOptionsInput>({ id: modelID }),
     configure,
   }
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    auth: settings.auth,
+const config = (settings: Settings): Config => {
+  if (settings.auth === "bearer" && settings.apiKey === undefined)
+    throw new Error("Amazon Bedrock bearer auth requires apiKey")
+  if (settings.auth === "sigv4" && settings.apiKey !== undefined)
+    throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey")
+  return {
+    apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
     baseURL: settings.baseURL,
     credentials: settings.credentials,
     generation: settings.topP === undefined ? undefined : { topP: settings.topP },
     headers: settings.headers === undefined ? undefined : { ...settings.headers },
     http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    profile: settings.profile,
     region: settings.region,
-  }).model(modelID)
+  }
+}
+
+export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
+  configure(config(settings)).model(modelID)
+export const messagesModel: ProviderPackage.Definition<
+  Settings & { readonly providerOptions?: AnthropicMessages.ProviderOptionsInput },
+  AnthropicMessages.ProviderOptionsInput
+>["model"] = (modelID, settings) =>
+  configure({ ...config(settings), providerOptions: settings.providerOptions }).messages(modelID)

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

@@ -0,0 +1 @@
+export { messagesModel as model } from "../amazon-bedrock.js"

packages/ai/src/providers/azure.ts

@@ -1,7 +1,7 @@
 import { Headers } from "effect/unstable/http"
 import { Auth } from "../route/auth.js"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
-import type { Route, RouteDefaultsInput, CompactionOperations } from "../route/client.js"
+import type { 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"
@@ -39,7 +39,6 @@ export type Settings = ProviderPackage.Settings &
 const resourceBaseURL = (resourceName: string) => `https://${resourceName.trim()}.openai.azure.com/openai`
 
 const responsesRoute = OpenAIResponses.route.with({
-  compact: { endpoint: OpenAIResponses.route.compact.endpoint },
   id: "azure-openai-responses",
   provider: id,
   auth: routeAuth,
@@ -103,11 +102,7 @@ const auth = (input: Config) => {
   )
 }
 
-const configuredRoute = <Body, Prepared, Compact extends CompactionOperations | undefined>(
-  route: Route<Body, Prepared, Compact>,
-  input: Config,
-  modelID: string | ModelID,
-) =>
+const configuredRoute = <Body, Prepared>(route: RouteDef<Body, Prepared>, input: Config, modelID: string | ModelID) =>
   route.with({
     auth: auth(input),
     endpoint: endpoint(input, modelID),
@@ -166,11 +161,10 @@ const config = (settings: Settings): Config => {
   throw new Error("Azure requires resourceName or baseURL")
 }
 
-export const responsesModel: ProviderPackage.Definition<
-  Settings,
-  OpenAIProviderOptionsInput,
-  typeof responsesRoute.compact
->["model"] = (modelID, settings) => configure(config(settings)).responses(modelID)
+export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => configure(config(settings)).responses(modelID)
 export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
   modelID,
   settings,

packages/ai/src/providers/baseten.ts

@@ -1,60 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-import type { OpenAIProviderOptionsInput } from "./openai-options.js"
-
-export const id = ProviderID.make("baseten")
-const baseURL = "https://inference.baseten.co/v1"
-
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
-
-export const route = Route.make({
-  id: "baseten-chat",
-  provider: id,
-  providerMetadataKey: "baseten",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
-})
-
-export const routes = [route]
-
-export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
-  const configured = route.with({
-    ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
-    auth: AuthOptions.bearer(input, "BASETEN_API_KEY"),
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = configure()
-
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as Baseten from "./baseten.js"

packages/ai/src/providers/cerebras.ts

@@ -1,13 +1,12 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
+import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
+import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
+import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("cerebras")
-const baseURL = "https://api.cerebras.ai/v1"
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -21,22 +20,19 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-export const route = Route.make({
+export const route = OpenAICompatibleChat.route.with({
   id: "cerebras-chat",
   provider: id,
-  providerMetadataKey: "cerebras",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
+  endpoint: { baseURL: profiles.cerebras.baseURL },
 })
 
 export const routes = [route]
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
+  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
   const configured = route.with({
     ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? profiles.cerebras.baseURL },
     auth: AuthOptions.bearer(input, "CEREBRAS_API_KEY"),
   })
   return {

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

@@ -1,98 +0,0 @@
-import type { Config, Redacted } from "effect"
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { Auth } from "../route/auth.js"
-import type { AtLeastOne, ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-import type { OpenAIProviderOptionsInput } from "./openai-options.js"
-
-export const id = ProviderID.make("cloudflare-ai-gateway")
-export const authEnvVars = ["CLOUDFLARE_API_TOKEN", "CF_AIG_TOKEN"] as const
-
-type GatewayURL = AtLeastOne<{
-  readonly accountId: string
-  readonly baseURL: string
-}> & {
-  readonly gatewayId?: string
-}
-
-export type LanguageModelOptions = GatewayURL &
-  Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    /** Cloudflare AI Gateway authentication token. Sent as `cf-aig-authorization`. */
-    readonly gatewayApiKey?: string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export type Settings = ProviderPackage.Settings &
-  GatewayURL & {
-    readonly apiKey?: string
-    readonly gatewayApiKey?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export const baseURL = (input: GatewayURL) => {
-  if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied")
-  return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`
-}
-
-const auth = (input: LanguageModelOptions) => {
-  if ("auth" in input && input.auth) return input.auth
-  const gateway = Auth.optional(input.gatewayApiKey, "gatewayApiKey")
-    .orElse(Auth.config(authEnvVars[0]))
-    .orElse(Auth.config(authEnvVars[1]))
-    .pipe(Auth.bearerHeader("cf-aig-authorization"))
-  if (!("apiKey" in input) || input.apiKey === undefined) return gateway
-  if (input.gatewayApiKey === undefined) return Auth.bearer(input.apiKey)
-  return Auth.bearerHeader("cf-aig-authorization", input.gatewayApiKey).andThen(Auth.bearer(input.apiKey))
-}
-
-export const route = Route.make({
-  id: "cloudflare-ai-gateway",
-  provider: id,
-  providerMetadataKey: "cloudflare-ai-gateway",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions"),
-  framing: OpenAIChat.framing,
-})
-
-export const routes = [route]
-
-export const configure = (input: LanguageModelOptions) => {
-  const {
-    accountId: _accountId,
-    gatewayId: _gatewayId,
-    apiKey: _apiKey,
-    gatewayApiKey: _gatewayApiKey,
-    baseURL: _baseURL,
-    auth: _auth,
-    ...defaults
-  } = input
-  const configured = route.with({
-    ...defaults,
-    endpoint: { baseURL: baseURL(input) },
-    auth: auth(input),
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = { id, configure }
-
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    gatewayApiKey: settings.gatewayApiKey,
-    baseURL: baseURL(settings),
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js"

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

@@ -1,71 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-import type { OpenAIProviderOptionsInput } from "./openai-options.js"
-
-export const id = ProviderID.make("cloudflare-workers-ai")
-export const authEnvVars = ["CLOUDFLARE_API_KEY", "CLOUDFLARE_WORKERS_AI_TOKEN"] as const
-
-type WorkersAIURL = AtLeastOne<{
-  readonly accountId: string
-  readonly baseURL: string
-}>
-
-export type LanguageModelOptions = WorkersAIURL &
-  Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export type Settings = ProviderPackage.Settings &
-  WorkersAIURL & {
-    readonly apiKey?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export const baseURL = (input: WorkersAIURL) => {
-  if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied")
-  return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(input.accountId)}/ai/v1`
-}
-
-export const route = Route.make({
-  id: "cloudflare-workers-ai",
-  provider: id,
-  providerMetadataKey: "cloudflare-workers-ai",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions"),
-  framing: OpenAIChat.framing,
-})
-
-export const routes = [route]
-
-export const configure = (input: LanguageModelOptions) => {
-  const { accountId: _accountId, apiKey: _apiKey, auth: _auth, baseURL: _baseURL, ...defaults } = input
-  const configured = route.with({
-    ...defaults,
-    endpoint: { baseURL: baseURL(input) },
-    auth: AuthOptions.bearer(input, authEnvVars),
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = { id, configure }
-
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: baseURL(settings),
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js"

packages/ai/src/providers/cloudflare.ts

@@ -0,0 +1,133 @@
+import type { Config, Redacted } from "effect"
+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")
+export const aiGatewayAuthEnvVars = ["CLOUDFLARE_API_TOKEN", "CF_AIG_TOKEN"] as const
+export const workersAIAuthEnvVars = ["CLOUDFLARE_API_KEY", "CLOUDFLARE_WORKERS_AI_TOKEN"] as const
+
+type CloudflareSecret = string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>
+
+type GatewayURL = AtLeastOne<{
+  readonly accountId: string
+  readonly baseURL: string
+}> & {
+  readonly gatewayId?: string
+}
+
+export type AIGatewayOptions = GatewayURL &
+  Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    /** Cloudflare AI Gateway authentication token. Sent as `cf-aig-authorization`. */
+    readonly gatewayApiKey?: CloudflareSecret
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
+type WorkersAIURL = AtLeastOne<{
+  readonly accountId: string
+  readonly baseURL: string
+}>
+
+export type WorkersAIOptions = WorkersAIURL &
+  Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
+export const aiGatewayBaseURL = (input: GatewayURL) => {
+  if (input.baseURL) return input.baseURL
+  if (!input.accountId) throw new Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied")
+  return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`
+}
+
+const aiGatewayAuth = (input: AIGatewayOptions) => {
+  if ("auth" in input && input.auth) return input.auth
+  const gateway = Auth.optional(input.gatewayApiKey, "gatewayApiKey")
+    .orElse(Auth.config("CLOUDFLARE_API_TOKEN"))
+    .orElse(Auth.config("CF_AIG_TOKEN"))
+    .pipe(Auth.bearerHeader("cf-aig-authorization"))
+  if (!("apiKey" in input) || input.apiKey === undefined) return gateway
+  if (input.gatewayApiKey === undefined) return Auth.bearer(input.apiKey)
+  return Auth.bearerHeader("cf-aig-authorization", input.gatewayApiKey).andThen(Auth.bearer(input.apiKey))
+}
+
+export const workersAIBaseURL = (input: WorkersAIURL) => {
+  if (input.baseURL) return input.baseURL
+  if (!input.accountId) throw new Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied")
+  return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(input.accountId)}/ai/v1`
+}
+
+const workersAIAuth = (input: WorkersAIOptions) => {
+  return AuthOptions.bearer(input, workersAIAuthEnvVars)
+}
+
+export const aiGatewayRoute = OpenAICompatibleChat.route.with({
+  id: "cloudflare-ai-gateway",
+  provider: aiGatewayID,
+})
+
+export const workersAIRoute = OpenAICompatibleChat.route.with({
+  id: "cloudflare-workers-ai",
+  provider: workersAIID,
+})
+
+export const routes = [aiGatewayRoute, workersAIRoute]
+
+const aiGatewayDefaults = (options: AIGatewayOptions) => {
+  const {
+    accountId: _accountId,
+    gatewayId: _gatewayId,
+    apiKey: _apiKey,
+    gatewayApiKey: _gatewayApiKey,
+    baseURL: _baseURL,
+    auth: _auth,
+    ...rest
+  } = options
+  return rest
+}
+
+const workersAIDefaults = (options: WorkersAIOptions) => {
+  const { accountId: _accountId, apiKey: _apiKey, auth: _auth, baseURL: _baseURL, ...rest } = options
+  return rest
+}
+
+const configureAIGateway = (options: AIGatewayOptions) => {
+  const route = aiGatewayRoute.with({
+    ...aiGatewayDefaults(options),
+    endpoint: { baseURL: aiGatewayBaseURL(options) },
+    auth: aiGatewayAuth(options),
+  })
+  return {
+    id: aiGatewayID,
+    model: (modelID: string | ModelID) => route.model<OpenAIProviderOptionsInput>({ id: modelID }),
+    configure: configureAIGateway,
+  }
+}
+
+const configureWorkersAI = (options: WorkersAIOptions) => {
+  const route = workersAIRoute.with({
+    ...workersAIDefaults(options),
+    endpoint: { baseURL: workersAIBaseURL(options) },
+    auth: workersAIAuth(options),
+  })
+  return {
+    id: workersAIID,
+    model: (modelID: string | ModelID) => route.model<OpenAIProviderOptionsInput>({ id: modelID }),
+    configure: configureWorkersAI,
+  }
+}
+
+export const CloudflareAIGateway = {
+  id: aiGatewayID,
+  configure: configureAIGateway,
+}
+
+export const CloudflareWorkersAI = {
+  id: workersAIID,
+  configure: configureWorkersAI,
+}

packages/ai/src/providers/deepinfra.ts

@@ -1,13 +1,12 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
+import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
+import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
+import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("deepinfra")
-const baseURL = "https://api.deepinfra.com/v1/openai"
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -21,24 +20,21 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-export const route = Route.make({
+export const route = OpenAICompatibleChat.route.with({
   id: "deepinfra-chat",
   provider: id,
-  providerMetadataKey: "deepinfra",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
+  endpoint: { baseURL: profiles.deepinfra.baseURL },
 })
 
 export const routes = [route]
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
-  const root = endpoint?.replace(/\/+$/, "")
+  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
+  const root = baseURL?.replace(/\/+$/, "")
   const configured = route.with({
     ...defaults,
     endpoint: {
-      baseURL: root === undefined ? baseURL : root.endsWith("/openai") ? root : `${root}/openai`,
+      baseURL: root === undefined ? profiles.deepinfra.baseURL : root.endsWith("/openai") ? root : `${root}/openai`,
     },
     auth: AuthOptions.bearer(input, "DEEPINFRA_API_KEY"),
   })

packages/ai/src/providers/deepseek.ts

@@ -1,64 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-import type { OpenAIProviderOptionsInput } from "./openai-options.js"
-
-export const id = ProviderID.make("deepseek")
-const baseURL = "https://api.deepseek.com/v1"
-
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
-
-export const route = Route.make({
-  id: "deepseek-chat",
-  provider: id,
-  providerMetadataKey: "deepseek",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
-})
-
-export const routes = [route]
-
-export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
-  const configured = route.with({
-    ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
-    auth: AuthOptions.bearer(input, "DEEPSEEK_API_KEY"),
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) =>
-      configured.model<OpenAIProviderOptionsInput>({
-        id: modelID,
-        compatibility: { maxTokensField: "max_tokens", supportsStore: false },
-      }),
-    configure,
-  }
-}
-
-export const provider = configure()
-
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as DeepSeek from "./deepseek.js"

packages/ai/src/providers/fireworks.ts

@@ -1,60 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-import type { OpenAIProviderOptionsInput } from "./openai-options.js"
-
-export const id = ProviderID.make("fireworks")
-const baseURL = "https://api.fireworks.ai/inference/v1"
-
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: OpenAIProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
-
-export const route = Route.make({
-  id: "fireworks-chat",
-  provider: id,
-  providerMetadataKey: "fireworks",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
-})
-
-export const routes = [route]
-
-export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
-  const configured = route.with({
-    ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
-    auth: AuthOptions.bearer(input, "FIREWORKS_API_KEY"),
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) => configured.model<OpenAIProviderOptionsInput>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = configure()
-
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as Fireworks from "./fireworks.js"

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

@@ -1,7 +1,6 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
+import { 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"
@@ -25,13 +24,10 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-const route = Route.make({
+const route = OpenAICompatibleChat.route.with({
   id: "google-vertex-chat",
   provider: id,
   providerMetadataKey: "vertex",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions"),
-  framing: OpenAIChat.framing,
 })
 
 export const routes = [route]

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

@@ -1,7 +1,6 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenResponses } from "../protocols/open-responses.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
+import { 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"
@@ -25,14 +24,11 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenResponsesProviderOptionsInput
 }
 
-const route = Route.make({
+const route = OpenAICompatibleResponses.route.with({
   id: "google-vertex-responses",
   provider: id,
   providerMetadataKey: "vertex",
-  protocol: OpenResponses.protocol,
-  endpoint: Endpoint.path(OpenResponses.PATH),
-  transport: OpenResponses.httpTransport,
-  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
+  providerOptions: { store: false },
 })
 
 export const routes = [route]

packages/ai/src/providers/groq.ts

@@ -7,10 +7,10 @@ import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { ProviderID, type ModelID, type LLMRequest } from "../schema/index.js"
+import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("groq")
-const baseURL = "https://api.groq.com/openai/v1"
 
 export type ProviderOptions = Pick<OpenAIProviderOptionsInput, "reasoningEffort"> & {
   /** Controls visible reasoning on GPT-OSS; other models always use parsed reasoning. */
@@ -73,15 +73,15 @@ export const route = Route.make({
   provider: id,
   providerMetadataKey: "openai",
   protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  endpoint: Endpoint.path("/chat/completions", { baseURL: profiles.groq.baseURL }),
   framing: OpenAIChat.framing,
 })
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
+  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
   const configured = route.with({
     ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? profiles.groq.baseURL },
     auth: AuthOptions.bearer(input, "GROQ_API_KEY"),
   })
   return {

packages/ai/src/providers/index.ts

@@ -3,23 +3,17 @@ 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 Baseten from "./baseten.js"
 export * as Cerebras from "./cerebras.js"
-export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js"
-export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js"
+export * as Cloudflare from "./cloudflare.js"
+export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare.js"
 export * as DeepInfra from "./deepinfra.js"
-export * as DeepSeek from "./deepseek.js"
-export * as Fireworks from "./fireworks.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 Groq from "./groq.js"
-export * as Meta from "./meta.js"
-export * as MiniMax from "./minimax.js"
 export * as Mistral from "./mistral.js"
-export * as Moonshot from "./moonshot.js"
 export * as OpenAI from "./openai.js"
 export * as OpenAICompatible from "./openai-compatible.js"
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js"
@@ -27,4 +21,3 @@ export * as OpenRouter from "./openrouter.js"
 export * as TogetherAI from "./togetherai.js"
 export * as XAI from "./xai.js"
 export * as ZAI from "./zai.js"
-export * as ZAICodingPlan from "./zai-coding-plan.js"

packages/ai/src/providers/meta.ts

@@ -1,182 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { AnthropicMessages } from "../protocols/anthropic-messages.js"
-import { MetaResponses } from "../protocols/meta-responses.js"
-import { MetaMessages } from "../protocols/meta-messages.js"
-import { MetaImages } from "../protocols/meta-images.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { HttpOptions, ProviderID, ToolDefinition, type ModelID } from "../schema/index.js"
-import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
-
-export const id = ProviderID.make("meta")
-const baseURL = "https://api.meta.ai/v1"
-
-export type ProviderOptionsInput = OpenResponsesProviderOptionsInput &
-  Pick<AnthropicMessages.OptionsInput, "thinking" | "effort">
-export type MessagesOptionsInput = Pick<
-  AnthropicMessages.OptionsInput,
-  "thinking" | "effort" | "outputConfig" | "output_config" | "serviceTier" | "service_tier" | "metadata"
-> & { readonly [key: string]: unknown }
-export type ImageOptions = MetaImages.ImageOptions
-
-export interface WebSearchOptions {
-  readonly searchContextSize?: "low" | "medium" | "high" | (string & {})
-  readonly userLocation?: {
-    readonly city?: string
-    readonly region?: string
-    readonly country?: string
-    readonly timezone?: string
-  }
-}
-
-export const webSearch = (options: WebSearchOptions = {}) =>
-  ToolDefinition.make({
-    name: "web_search",
-    description: "Search the web with Meta's hosted search tool.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    native: {
-      meta: {
-        type: "web_search",
-        search_context_size: options.searchContextSize,
-        user_location:
-          options.userLocation === undefined ? undefined : { type: "approximate", ...options.userLocation },
-      },
-    },
-  })
-
-export interface ImageGenerationOptions {
-  readonly size?: string
-  readonly outputFormat?: "webp" | "png" | "jpeg" | (string & {})
-  readonly reasoningStrength?: "low" | "high" | (string & {})
-  readonly enableImageSearch?: boolean
-  readonly enableWebSearch?: boolean
-  readonly enableShell?: boolean
-}
-
-export const imageGeneration = (options: ImageGenerationOptions = {}) =>
-  ToolDefinition.make({
-    name: "image_generation",
-    description: "Generate or edit an image with Muse Image.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    native: {
-      meta: {
-        type: "image_generation",
-        size: options.size,
-        output_format: options.outputFormat,
-        reasoning_strength: options.reasoningStrength,
-        enable_image_search: options.enableImageSearch,
-        enable_web_search: options.enableWebSearch,
-        enable_shell: options.enableShell,
-      },
-    },
-  })
-
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: ProviderOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: ProviderOptionsInput
-}
-
-const responsesRoute = Route.make({
-  id: "meta-responses",
-  provider: id,
-  providerMetadataKey: "meta",
-  protocol: MetaResponses.protocol,
-  endpoint: Endpoint.path("/responses", { baseURL }),
-  // Meta Responses does not support WebSocket upgrades; always use HTTP/SSE.
-  transport: MetaResponses.httpTransport,
-  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
-})
-
-const chatRoute = Route.make({
-  id: "meta-chat",
-  provider: id,
-  providerMetadataKey: "meta",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
-})
-
-const messagesRoute = Route.make({
-  id: "meta-messages",
-  provider: id,
-  providerMetadataKey: "meta",
-  protocol: MetaMessages.protocol,
-  endpoint: Endpoint.path("/messages", { baseURL }),
-  framing: AnthropicMessages.framing,
-  defaults: { providerOptions: { thinking: { type: "adaptive", display: "omitted" } } },
-})
-
-export const routes = [responsesRoute, chatRoute, messagesRoute]
-
-export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
-  const options = {
-    ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
-    auth: AuthOptions.bearer(input, "META_API_KEY"),
-  }
-  const configuredResponses = responsesRoute.with(options)
-  const configuredChat = chatRoute.with(options)
-  const configuredMessages = messagesRoute.with(options)
-  const responses = (modelID: string | ModelID) =>
-    configuredResponses.model<OpenResponsesProviderOptionsInput>({ id: modelID })
-  const chat = (modelID: string | ModelID) =>
-    configuredChat.model<OpenResponsesProviderOptionsInput>({
-      id: modelID,
-      compatibility: { maxTokensField: "max_completion_tokens", supportsStore: false },
-    })
-  const messages = (modelID: string | ModelID) =>
-    configuredMessages.model<MessagesOptionsInput>({
-      id: modelID,
-      compatibility: { requireSignature: false },
-    })
-  const image = (modelID: string | ModelID) =>
-    MetaImages.model({
-      id: modelID,
-      baseURL: endpoint ?? baseURL,
-      auth: options.auth,
-      headers: input.headers,
-      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-    })
-  return { id, model: responses, responses, chat, messages, image, configure }
-}
-
-export const provider = configure()
-export const responses = provider.responses
-export const chat = provider.chat
-export const messages = provider.messages
-export const image = provider.image
-
-export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => fromSettings(settings).responses(modelID)
-
-export const chatModel: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => fromSettings(settings).chat(modelID)
-
-export const messagesModel: ProviderPackage.Definition<Settings, MessagesOptionsInput>["model"] = (modelID, settings) =>
-  fromSettings(settings).messages(modelID)
-
-function fromSettings(settings: Settings) {
-  return configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  })
-}
-
-export * as Meta from "./meta.js"

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

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

packages/ai/src/providers/meta/messages.ts

@@ -1,2 +0,0 @@
-export { messagesModel as model } from "../meta.js"
-export type { Settings } from "../meta.js"

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

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

packages/ai/src/providers/minimax.ts

@@ -1,144 +0,0 @@
-import { Effect, Schema } from "effect"
-import type { ProviderPackage } from "../provider-package.js"
-import { AnthropicMessages } from "../protocols/anthropic-messages.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { OpenResponses } from "../protocols/open-responses.js"
-import { ProviderShared } from "../protocols/shared.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.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 LLMRequest, type ModelID } from "../schema/index.js"
-
-export const id = ProviderID.make("minimax")
-
-export type MessagesOptionsInput = {
-  /** M3 defaults to disabled; M2.x always thinks. */
-  readonly thinking?: { readonly type: "adaptive" | "disabled" }
-  readonly metadata?: AnthropicMessages.OptionsInput["metadata"]
-}
-
-export type ChatOptionsInput = {
-  /** M3 defaults to adaptive; M2.x always thinks. */
-  readonly thinking?: { readonly type: "adaptive" | "disabled" | (string & {}) }
-  /** Separates reasoning from text. Defaults to true. */
-  readonly reasoningSplit?: boolean
-}
-
-export type ResponsesOptionsInput = {
-  /** M3 defaults to none. Other supported values enable thinking without changing its depth. */
-  readonly reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | (string & {})
-}
-
-export type ProviderOptionsInput = MessagesOptionsInput | ChatOptionsInput | ResponsesOptionsInput
-
-export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    /** Overrides the selected API's base URL, including its version prefix. */
-    readonly baseURL?: string
-    readonly providerOptions?: ProviderOptionsInput
-  }
-
-export interface Settings<Options = MessagesOptionsInput> extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: Options
-}
-
-const ChatOptions = Schema.Struct({
-  thinking: Schema.optional(Schema.Struct({ type: Schema.String })),
-  reasoningSplit: Schema.optional(Schema.Boolean),
-})
-
-const chatProtocol = Protocol.make({
-  id: "minimax-chat",
-  body: {
-    schema: Schema.Struct({
-      ...OpenAIChat.bodyFields,
-      thinking: ChatOptions.fields.thinking,
-      reasoning_split: Schema.Boolean,
-    }),
-    from: Effect.fn("MiniMax.chatFromRequest")(function* (request: LLMRequest) {
-      const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(ChatOptions))(
-        request.providerOptions ?? {},
-      )
-      return {
-        ...(yield* OpenAIChat.protocol.body.from(request)),
-        thinking: options.thinking,
-        // MiniMax otherwise embeds <think> tags in ordinary assistant text.
-        reasoning_split: options.reasoningSplit ?? true,
-      }
-    }),
-  },
-  stream: OpenAIChat.protocol.stream,
-})
-
-const messagesRoute = Route.make({
-  id: "minimax-messages",
-  provider: id,
-  providerMetadataKey: "minimax",
-  protocol: AnthropicMessages.protocol,
-  endpoint: Endpoint.path("/messages", { baseURL: "https://api.minimax.io/anthropic/v1" }),
-  framing: AnthropicMessages.framing,
-  headers: () => ({ "anthropic-version": "2023-06-01" }),
-})
-
-const chatRoute = Route.make({
-  id: "minimax-chat",
-  provider: id,
-  providerMetadataKey: "minimax",
-  protocol: chatProtocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: "https://api.minimax.io/v1" }),
-  framing: OpenAIChat.framing,
-})
-
-const responsesRoute = Route.make({
-  id: "minimax-responses",
-  provider: id,
-  providerMetadataKey: "minimax",
-  protocol: OpenResponses.protocol,
-  endpoint: Endpoint.path("/responses", { baseURL: "https://api.minimax.io/v1" }),
-  framing: Framing.sse,
-})
-
-export const routes = [messagesRoute, chatRoute, responsesRoute]
-
-export const configure = (input: Config = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL, ...rest } = input
-  const defaults = {
-    ...rest,
-    endpoint: baseURL === undefined ? undefined : { baseURL },
-    auth: AuthOptions.bearer(input, "MINIMAX_API_KEY"),
-  }
-  const messages = (modelID: string | ModelID) =>
-    messagesRoute.with(defaults).model<MessagesOptionsInput>({ id: modelID })
-  const chat = (modelID: string | ModelID) =>
-    chatRoute.with(defaults).model<ChatOptionsInput>({
-      id: modelID,
-      compatibility: { supportsStore: false, supportsStrictMode: false },
-    })
-  const responses = (modelID: string | ModelID) =>
-    responsesRoute.with(defaults).model<ResponsesOptionsInput>({ id: modelID })
-  return { id, model: messages, messages, chat, responses, configure }
-}
-
-export const provider = configure()
-
-export const model: ProviderPackage.Definition<Settings<MessagesOptionsInput>, MessagesOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export const messages = provider.messages
-export const chat = provider.chat
-export const responses = provider.responses
-
-export * as MiniMax from "./minimax.js"

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

@@ -1,13 +0,0 @@
-import type { ProviderPackage } from "../../provider-package.js"
-import { MiniMax } from "../minimax.js"
-
-export type Settings = MiniMax.Settings<MiniMax.ChatOptionsInput>
-
-export const model: ProviderPackage.Definition<Settings, MiniMax.ChatOptionsInput>["model"] = (modelID, settings) =>
-  MiniMax.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).chat(modelID)

packages/ai/src/providers/minimax/messages.ts

@@ -1 +0,0 @@
-export { model, type Settings, type MessagesOptionsInput } from "../minimax.js"

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

@@ -1,16 +0,0 @@
-import type { ProviderPackage } from "../../provider-package.js"
-import { MiniMax } from "../minimax.js"
-
-export type Settings = MiniMax.Settings<MiniMax.ResponsesOptionsInput>
-
-export const model: ProviderPackage.Definition<Settings, MiniMax.ResponsesOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
-  MiniMax.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).responses(modelID)

packages/ai/src/providers/moonshot.ts

@@ -1,145 +0,0 @@
-import { Effect, Schema } from "effect"
-import type { ProviderPackage } from "../provider-package.js"
-import { AnthropicMessages } from "../protocols/anthropic-messages.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { OpenResponses } from "../protocols/open-responses.js"
-import { ProviderShared } from "../protocols/shared.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.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 LLMRequest, type ModelID } from "../schema/index.js"
-
-export const id = ProviderID.make("moonshotai")
-
-export type ReasoningEffort = "low" | "high" | "max" | (string & {})
-
-export type ChatOptionsInput = {
-  /** K3 always reasons; omitted effort uses the model's default. */
-  readonly reasoningEffort?: ReasoningEffort
-  /** K2.6 supports disabling thinking; K2.7 Code always thinks and preserves reasoning. */
-  readonly thinking?: {
-    readonly type: "enabled" | "disabled" | (string & {})
-    readonly keep?: "all" | (string & {}) | null
-  }
-}
-
-export type MessagesOptionsInput = {
-  readonly effort?: ReasoningEffort
-  readonly metadata?: AnthropicMessages.OptionsInput["metadata"]
-}
-
-export type ResponsesOptionsInput = {
-  readonly reasoningEffort?: ReasoningEffort
-  readonly safetyIdentifier?: string
-}
-
-export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    /** Overrides the selected API's base URL, including its version prefix. */
-    readonly baseURL?: string
-    readonly providerOptions?: ChatOptionsInput | MessagesOptionsInput | ResponsesOptionsInput
-  }
-
-export interface Settings<Options = ChatOptionsInput> extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: Options
-}
-
-const ChatOptions = Schema.Struct({
-  reasoningEffort: Schema.optional(Schema.String),
-  thinking: Schema.optional(
-    Schema.Struct({ type: Schema.String, keep: Schema.optional(Schema.NullOr(Schema.String)) }),
-  ),
-})
-
-const chatProtocol = Protocol.make({
-  id: "moonshot-chat",
-  body: {
-    schema: Schema.Struct({ ...OpenAIChat.bodyFields, thinking: ChatOptions.fields.thinking }),
-    from: Effect.fn("Moonshot.chatFromRequest")(function* (request: LLMRequest) {
-      const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(ChatOptions))(
-        request.providerOptions ?? {},
-      )
-      return { ...(yield* OpenAIChat.protocol.body.from(request)), thinking: options.thinking }
-    }),
-  },
-  stream: OpenAIChat.protocol.stream,
-})
-
-const chatRoute = Route.make({
-  id: "moonshot-chat",
-  provider: id,
-  providerMetadataKey: "moonshot",
-  protocol: chatProtocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: "https://api.moonshot.ai/v1" }),
-  framing: OpenAIChat.framing,
-})
-
-const messagesRoute = Route.make({
-  id: "moonshot-messages",
-  provider: id,
-  providerMetadataKey: "moonshot",
-  protocol: AnthropicMessages.protocol,
-  endpoint: Endpoint.path("/messages", { baseURL: "https://api.moonshot.ai/anthropic/v1" }),
-  framing: AnthropicMessages.framing,
-})
-
-const responsesRoute = Route.make({
-  id: "moonshot-responses",
-  provider: id,
-  providerMetadataKey: "moonshot",
-  protocol: OpenResponses.protocol,
-  endpoint: Endpoint.path("/responses", { baseURL: "https://api.moonshot.ai/v1" }),
-  framing: Framing.sse,
-})
-
-export const routes = [chatRoute, messagesRoute, responsesRoute]
-
-export const configure = (input: Config = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL, ...rest } = input
-  const defaults = {
-    ...rest,
-    endpoint: baseURL === undefined ? undefined : { baseURL },
-    auth: AuthOptions.bearer(input, ["MOONSHOT_API_KEY", "MOONSHOTAI_API_KEY"]),
-  }
-  const chat = (modelID: string | ModelID) =>
-    chatRoute.with(defaults).model<ChatOptionsInput>({
-      id: modelID,
-      compatibility: {
-        maxTokensField: "max_tokens",
-        supportsStore: false,
-        supportsStrictMode: false,
-        toolSchema: "moonshot",
-        reasoningField: "reasoning_content",
-      },
-    })
-  const messages = (modelID: string | ModelID) =>
-    messagesRoute.with(defaults).model<MessagesOptionsInput>({
-      id: modelID,
-      compatibility: { requireSignature: false, toolSchema: "moonshot" },
-    })
-  const responses = (modelID: string | ModelID) =>
-    responsesRoute
-      .with(defaults)
-      .model<ResponsesOptionsInput>({ id: modelID, compatibility: { toolSchema: "moonshot" } })
-  return { id, model: chat, chat, messages, responses, configure }
-}
-
-export const provider = configure()
-export const chat = provider.chat
-export const messages = provider.messages
-export const responses = provider.responses
-
-export const model: ProviderPackage.Definition<Settings, ChatOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as Moonshot from "./moonshot.js"

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

@@ -1 +0,0 @@
-export { model, type Settings } from "../moonshot.js"

packages/ai/src/providers/moonshot/messages.ts

@@ -1,16 +0,0 @@
-import type { ProviderPackage } from "../../provider-package.js"
-import { Moonshot } from "../moonshot.js"
-
-export type Settings = Moonshot.Settings<Moonshot.MessagesOptionsInput>
-
-export const model: ProviderPackage.Definition<Settings, Moonshot.MessagesOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
-  Moonshot.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).messages(modelID)

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

@@ -1,16 +0,0 @@
-import type { ProviderPackage } from "../../provider-package.js"
-import { Moonshot } from "../moonshot.js"
-
-export type Settings = Moonshot.Settings<Moonshot.ResponsesOptionsInput>
-
-export const model: ProviderPackage.Definition<Settings, Moonshot.ResponsesOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
-  Moonshot.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).responses(modelID)

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

@@ -0,0 +1,20 @@
+export interface OpenAICompatibleProfile {
+  readonly provider: string
+  readonly baseURL: string
+}
+
+export const profiles = {
+  baseten: { provider: "baseten", baseURL: "https://inference.baseten.co/v1" },
+  cerebras: { provider: "cerebras", baseURL: "https://api.cerebras.ai/v1" },
+  deepinfra: { provider: "deepinfra", baseURL: "https://api.deepinfra.com/v1/openai" },
+  deepseek: { provider: "deepseek", baseURL: "https://api.deepseek.com/v1" },
+  fireworks: { provider: "fireworks", baseURL: "https://api.fireworks.ai/inference/v1" },
+  groq: { provider: "groq", baseURL: "https://api.groq.com/openai/v1" },
+  openrouter: { provider: "openrouter", baseURL: "https://openrouter.ai/api/v1" },
+  togetherai: { provider: "togetherai", baseURL: "https://api.together.xyz/v1" },
+  xai: { provider: "xai", baseURL: "https://api.x.ai/v1" },
+} as const satisfies Record<string, OpenAICompatibleProfile>
+
+export const byProvider: Record<string, OpenAICompatibleProfile> = Object.fromEntries(
+  Object.values(profiles).map((profile) => [profile.provider, profile]),
+)

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

@@ -1,8 +1,9 @@
 import { ProviderID, type ModelID } from "../schema/index.js"
-import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.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")
@@ -21,6 +22,12 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
+export type FamilyModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
 export const routes = [OpenAICompatibleChat.route]
 
 export const configure = (input: GenericModelOptions) => {
@@ -40,6 +47,22 @@ export const configure = (input: GenericModelOptions) => {
   }
 }
 
+const define = (profile: OpenAICompatibleProfile) => {
+  const configureProfile = (input: FamilyModelOptions = {}) => {
+    const facade = configure({
+      ...input,
+      baseURL: input.baseURL ?? profile.baseURL,
+      provider: profile.provider,
+    })
+    return {
+      id: ProviderID.make(profile.provider),
+      model: facade.model,
+      configure: configureProfile,
+    }
+  }
+  return configureProfile()
+}
+
 export const provider = {
   id,
   configure,
@@ -55,4 +78,10 @@ export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsIn
     providerOptions: settings.providerOptions,
   }).model(modelID)
 
-export * as OpenAICompatible from "./openai-compatible.js"
+export const baseten = define(profiles.baseten)
+export const cerebras = define(profiles.cerebras)
+export const deepinfra = define(profiles.deepinfra)
+export const deepseek = define(profiles.deepseek)
+export const fireworks = define(profiles.fireworks)
+export const groq = define(profiles.groq)
+export const togetherai = define(profiles.togetherai)

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

@@ -6,7 +6,6 @@ import type { ContextManagement } from "../protocols/openai-responses.js"
 export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options.js"
 
 export type OpenAIOptionsInput = Omit<Options, "serviceTier"> & {
-  /** Advanced in-band compaction. The caller owns checkpoint persistence and recovery. */
   readonly contextManagement?: ContextManagement
   readonly serviceTier?: OpenAIServiceTier
   readonly [key: string]: unknown

packages/ai/src/providers/openai.ts

@@ -1,5 +1,5 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import type { Route, RouteDefaultsInput, CompactionOperations } from "../route/client.js"
+import type { Route, RouteDefaultsInput } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
@@ -73,10 +73,7 @@ const defaults = (input: Config) => {
   return rest
 }
 
-const configuredRoute = <Body, Prepared, Compact extends CompactionOperations | undefined>(
-  route: Route<Body, Prepared, Compact>,
-  input: Config,
-) =>
+const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Config) =>
   route.with({
     auth: auth(input),
     endpoint: { baseURL: input.baseURL, query: input.queryParams },
@@ -132,11 +129,7 @@ const config = (settings: Settings): Config => {
   }
 }
 
-export const model: ProviderPackage.Definition<
-  Settings,
-  OpenAIProviderOptionsInput,
-  typeof OpenAIResponses.route.compact
->["model"] = (modelID, settings) => {
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
   return configure(config(settings)).responses(modelID)
 }
 

packages/ai/src/providers/openrouter.ts

@@ -5,12 +5,13 @@ import { Protocol } from "../route/protocol.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { ProviderID, type CacheHint, type ModelID } from "../schema/index.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
+import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
+import * as OpenAIChat from "../protocols/openai-chat.js"
 import { newBreakpoints, ttlBucket } from "../protocols/utils/cache.js"
 import { isRecord } from "../protocols/shared.js"
 
-export const id = ProviderID.make("openrouter")
-const baseURL = "https://openrouter.ai/api/v1"
+export const profile = OpenAICompatibleProfiles.profiles.openrouter
+export const id = ProviderID.make(profile.provider)
 const ADAPTER = "openrouter"
 
 type OpenRouterString<Known extends string> = Known | (string & {})
@@ -161,20 +162,20 @@ const bodyOptions = (input: unknown) => {
 
 export const route = Route.make({
   id: ADAPTER,
-  provider: id,
+  provider: profile.provider,
   providerMetadataKey: "openrouter",
   protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  endpoint: Endpoint.path("/chat/completions", { baseURL: profile.baseURL }),
   framing: OpenAIChat.framing,
 })
 
 export const routes = [route]
 
 const configuredRoute = (input: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL: endpoint, ...rest } = input
+  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
   return route.with({
     ...rest,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? profile.baseURL },
     auth: AuthOptions.bearer(input, "OPENROUTER_API_KEY"),
   })
 }

packages/ai/src/providers/togetherai.ts

@@ -1,13 +1,12 @@
 import type { ProviderPackage } from "../provider-package.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
+import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
+import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
+import { profiles } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("togetherai")
-const baseURL = "https://api.together.xyz/v1"
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -21,22 +20,19 @@ export interface Settings extends ProviderPackage.Settings {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-export const route = Route.make({
+export const route = OpenAICompatibleChat.route.with({
   id: "togetherai-chat",
   provider: id,
-  providerMetadataKey: "togetherai",
-  protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
+  endpoint: { baseURL: profiles.togetherai.baseURL },
 })
 
 export const routes = [route]
 
 export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
+  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
   const configured = route.with({
     ...defaults,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? profiles.togetherai.baseURL },
     auth: AuthOptions.bearer(input, ["TOGETHER_API_KEY", "TOGETHER_AI_API_KEY"]),
   })
   return {

packages/ai/src/providers/xai.ts

@@ -2,7 +2,9 @@ import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
+import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
+import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
+import * as OpenAIChat from "../protocols/openai-chat.js"
 import { OpenResponsesChannel } from "../protocols/open-responses-channel.js"
 import { XAIResponses } from "../protocols/xai-responses.js"
 import { XAIImages } from "../protocols/xai-images.js"
@@ -10,7 +12,6 @@ import type { OpenAIOptionsInput } from "./openai-options.js"
 import type { ProviderPackage } from "../provider-package.js"
 
 export const id = ProviderID.make("xai")
-const baseURL = "https://api.x.ai/v1"
 
 export type XAIProviderOptionsInput = OpenAIOptionsInput & { readonly contextManagement?: never }
 
@@ -31,12 +32,12 @@ export type { XAIImageOptions } from "../protocols/xai-images.js"
 const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000
 
 const responsesRoute = Route.make({
-  compact: { endpoint: XAIResponses.compact },
+  compact: XAIResponses.compact,
   id: "openai-responses",
   provider: id,
   providerMetadataKey: "xai",
   protocol: XAIResponses.protocol,
-  endpoint: Endpoint.path("/responses", { baseURL }),
+  endpoint: Endpoint.path("/responses", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
   transport: OpenResponsesChannel.transport({
     id: "openai-responses",
     name: "xAI Responses",
@@ -50,8 +51,8 @@ const chatRoute = Route.make({
   provider: id,
   providerMetadataKey: "xai",
   protocol: OpenAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL }),
-  framing: OpenAIChat.framing,
+  endpoint: Endpoint.path("/chat/completions", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
+  transport: OpenAICompatibleChat.route.transport,
   headers: ({ request }): Record<string, string> =>
     request.promptCacheKey ? { "x-grok-conv-id": request.promptCacheKey } : {},
 })
@@ -61,19 +62,19 @@ export const routes = [responsesRoute, chatRoute]
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "XAI_API_KEY")
 
 const configuredResponsesRoute = (input: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL: endpoint, ...rest } = input
+  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
   return responsesRoute.with({
     ...rest,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
     auth: auth(input),
   })
 }
 
 const configuredChatRoute = (input: LanguageModelOptions) => {
-  const { apiKey: _, auth: _auth, baseURL: endpoint, ...rest } = input
+  const { apiKey: _, auth: _auth, baseURL, ...rest } = input
   return chatRoute.with({
     ...rest,
-    endpoint: { baseURL: endpoint ?? baseURL },
+    endpoint: { baseURL: baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL },
     auth: auth(input),
   })
 }
@@ -87,7 +88,7 @@ export const configure = (input: LanguageModelOptions = {}) => {
     XAIImages.model({
       id: modelID,
       auth: auth(input),
-      baseURL: input.baseURL ?? baseURL,
+      baseURL: input.baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL,
       headers: input.headers,
       http: input.http === undefined ? undefined : HttpOptions.make(input.http),
     })
@@ -102,11 +103,7 @@ export const configure = (input: LanguageModelOptions = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<
-  Settings,
-  XAIProviderOptionsInput,
-  typeof responsesRoute.compact
->["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
     apiKey: settings.apiKey,
     baseURL: settings.baseURL,

packages/ai/src/providers/zai-coding-plan.ts

@@ -1,92 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { AnthropicMessages } from "../protocols/anthropic-messages.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
-import { OpenResponses } from "../protocols/open-responses.js"
-import { ZAIChat } from "../protocols/zai-chat.js"
-import { ZAIMessages } from "../protocols/zai-messages.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.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"
-
-export const id = ProviderID.make("zai-coding-plan")
-
-export type ChatOptionsInput = ZAIChat.OptionsInput
-export type MessagesOptionsInput = ZAIMessages.OptionsInput
-export type ResponsesOptionsInput = { readonly reasoningEffort?: ZAIChat.ReasoningEffort }
-
-export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    /** Overrides the selected API's complete base URL. */
-    readonly baseURL?: string
-    readonly providerOptions?: ChatOptionsInput | MessagesOptionsInput | ResponsesOptionsInput
-  }
-
-export interface Settings<Options = ChatOptionsInput> extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: Options
-}
-
-const chatRoute = Route.make({
-  id: "zai-coding-chat",
-  provider: id,
-  providerMetadataKey: "zai",
-  protocol: ZAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: "https://api.z.ai/api/coding/paas/v4" }),
-  framing: OpenAIChat.framing,
-})
-const messagesRoute = Route.make({
-  id: "zai-coding-messages",
-  provider: id,
-  providerMetadataKey: "zai",
-  protocol: ZAIMessages.protocol,
-  endpoint: Endpoint.path("/messages", { baseURL: "https://api.z.ai/api/anthropic/v1" }),
-  framing: AnthropicMessages.framing,
-  headers: () => ({ "anthropic-version": "2023-06-01" }),
-})
-const responsesRoute = Route.make({
-  id: "zai-coding-responses",
-  provider: id,
-  providerMetadataKey: "zai",
-  protocol: OpenResponses.protocol,
-  endpoint: Endpoint.path("/responses", { baseURL: "https://api.z.ai/api/v1" }),
-  framing: Framing.sse,
-})
-
-export const routes = [chatRoute, messagesRoute, responsesRoute]
-
-export const configure = (input: Config = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL, ...rest } = input
-  const defaults = {
-    ...rest,
-    endpoint: baseURL === undefined ? undefined : { baseURL },
-    auth: AuthOptions.bearer(input, "ZAI_API_KEY"),
-  }
-  const chat = (modelID: string | ModelID) =>
-    chatRoute.with(defaults).model<ChatOptionsInput>({ id: modelID, compatibility: ZAIChat.compatibility })
-  const messages = (modelID: string | ModelID) =>
-    messagesRoute
-      .with(defaults)
-      .model<MessagesOptionsInput>({ id: modelID, compatibility: { requireSignature: false } })
-  const responses = (modelID: string | ModelID) =>
-    responsesRoute.with(defaults).model<ResponsesOptionsInput>({ id: modelID })
-  return { id, model: chat, chat, messages, responses, configure }
-}
-
-export const provider = configure()
-export const chat = provider.chat
-export const messages = provider.messages
-export const responses = provider.responses
-
-export const model: ProviderPackage.Definition<Settings, ChatOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as ZAICodingPlan from "./zai-coding-plan.js"

packages/ai/src/providers/zai-coding-plan/chat.ts

@@ -1 +0,0 @@
-export { model, type Settings } from "../zai-coding-plan.js"

packages/ai/src/providers/zai-coding-plan/messages.ts

@@ -1,16 +0,0 @@
-import type { ProviderPackage } from "../../provider-package.js"
-import { ZAICodingPlan } from "../zai-coding-plan.js"
-
-export type Settings = ZAICodingPlan.Settings<ZAICodingPlan.MessagesOptionsInput>
-
-export const model: ProviderPackage.Definition<Settings, ZAICodingPlan.MessagesOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
-  ZAICodingPlan.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).messages(modelID)

packages/ai/src/providers/zai-coding-plan/responses.ts

@@ -1,16 +0,0 @@
-import type { ProviderPackage } from "../../provider-package.js"
-import { ZAICodingPlan } from "../zai-coding-plan.js"
-
-export type Settings = ZAICodingPlan.Settings<ZAICodingPlan.ResponsesOptionsInput>
-
-export const model: ProviderPackage.Definition<Settings, ZAICodingPlan.ResponsesOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
-  ZAICodingPlan.configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).responses(modelID)

packages/ai/src/providers/zai.ts

@@ -1,53 +1,20 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { ZAIChat } from "../protocols/zai-chat.js"
 import { ZAIImages } from "../protocols/zai-images.js"
-import { OpenAIChat } from "../protocols/openai-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
 import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
 
 export const id = ProviderID.make("zai")
 
-export type ChatOptionsInput = ZAIChat.OptionsInput
-
-export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: ChatOptionsInput
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
+export type Config = ProviderAuthOption<"optional"> & {
   readonly baseURL?: string
-  readonly providerOptions?: ChatOptionsInput
+  readonly headers?: Record<string, string>
+  readonly http?: HttpOptions.Input
 }
 
 export type { ZAIImageOptions } from "../protocols/zai-images.js"
 
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "ZAI_API_KEY")
 
-const chatRoute = Route.make({
-  id: "zai-chat",
-  provider: id,
-  providerMetadataKey: "zai",
-  protocol: ZAIChat.protocol,
-  endpoint: Endpoint.path("/chat/completions", { baseURL: "https://api.z.ai/api/paas/v4" }),
-  framing: OpenAIChat.framing,
-})
-
-export const routes = [chatRoute]
-
 export const configure = (input: Config = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL, ...rest } = input
-  const chat = (modelID: string | ModelID) =>
-    chatRoute
-      .with({
-        ...rest,
-        endpoint: baseURL === undefined ? undefined : { baseURL },
-        auth: auth(input),
-      })
-      .model<ChatOptionsInput>({ id: modelID, compatibility: ZAIChat.compatibility })
   const image = (modelID: string | ModelID) =>
     ZAIImages.model({
       id: modelID,
@@ -59,8 +26,6 @@ export const configure = (input: Config = {}) => {
 
   return {
     id,
-    model: chat,
-    chat,
     image,
     configure,
   }
@@ -68,15 +33,3 @@ export const configure = (input: Config = {}) => {
 
 export const provider = configure()
 export const image = provider.image
-export const chat = provider.chat
-
-export const model: ProviderPackage.Definition<Settings, ChatOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as ZAI from "./zai.js"

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

@@ -1 +0,0 @@
-export { model, type Settings } from "../zai.js"

packages/ai/src/route/client.ts

@@ -14,7 +14,6 @@ import type { ProtocolID, ProviderOptions } from "../schema/index.js"
 import {
   AIError,
   CompactionResponse,
-  CompactionCheckpointResponse,
   AIErrorReason,
   GenerationOptions,
   HttpOptions,
@@ -36,12 +35,8 @@ export interface RouteBody<Body> {
   readonly from: (request: LLMRequest) => Effect.Effect<Body, AIError>
 }
 
-export interface Route<
-  Body,
-  Prepared = unknown,
-  Compact extends CompactionOperations | undefined = CompactionOperations | undefined,
-> {
-  readonly compact: Compact
+export interface Route<Body, Prepared = unknown> {
+  readonly compact?: CompactOperation
   readonly id: string
   readonly provider?: ProviderID
   /** ProviderMetadata namespace emitted and consumed by this route. */
@@ -54,18 +49,10 @@ export interface Route<
   readonly transport: Transport<Body, Prepared, unknown>
   readonly defaults: RouteDefaults
   readonly body: RouteBody<Body>
-  readonly with: {
-    <Next extends CompactionOperations | undefined>(
-      patch: RoutePatch<Body, Prepared> & { readonly compact: Next },
-    ): Route<Body, Prepared, Next>
-    (
-      patch: Omit<RoutePatch<Body, Prepared>, "compact"> & { readonly compact?: undefined },
-    ): Route<Body, Prepared, Compact>
-    (patch: RoutePatch<Body, Prepared>): Route<Body, Prepared>
-  }
+  readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared>
   readonly model: <Options extends ProviderOptions = ProviderOptions>(
     input: RouteMappedLanguageModelInput,
-  ) => LanguageModel<Options, Compact>
+  ) => LanguageModel<Options>
   readonly prepareTransport: (
     body: Body,
     request: LLMRequest,
@@ -83,11 +70,7 @@ export interface Route<
 // Normal call sites use `OpenAIChat.route`; callers only need body types
 // when preparing a request with a protocol-specific type assertion.
 // oxlint-disable-next-line typescript-eslint/no-explicit-any
-export type AnyRoute<Compact extends CompactionOperations | undefined = CompactionOperations | undefined> = Route<
-  any,
-  any,
-  Compact
->
+export type AnyRoute = Route<any, any>
 
 export type HttpOptionsInput = HttpOptions.Input
 
@@ -110,7 +93,6 @@ export interface RouteDefaultsInput {
 }
 
 export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
-  readonly compact?: CompactionOperations
   readonly id?: string
   readonly provider?: string | ProviderID
   readonly providerMetadataKey?: string
@@ -121,15 +103,15 @@ export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
 
 type RouteMappedLanguageModelInput = RouteLanguageModelInput | RouteRoutedLanguageModelInput
 
-const makeRouteLanguageModel = <Options extends ProviderOptions, Compact extends CompactionOperations | undefined>(
-  route: AnyRoute<Compact>,
+const makeRouteLanguageModel = <Options extends ProviderOptions = ProviderOptions>(
+  route: AnyRoute,
   mapped: RouteMappedLanguageModelInput,
 ) => {
   const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
   if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
   if (!endpointBaseURL(route.endpoint))
     throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`)
-  return LanguageModel.make<Options, Compact>({
+  return LanguageModel.make<Options>({
     ...mapped,
     provider,
     route,
@@ -172,7 +154,10 @@ export const httpOptions = (input: HttpOptionsInput | undefined) => {
 }
 
 export interface Interface {
-  readonly compact: CompactMethod
+  readonly compact: (
+    request: LLMRequest,
+    options?: Pick<StreamOptions, "http">,
+  ) => Effect.Effect<CompactionResponse, AIError>
   readonly stream: StreamMethod
   readonly generate: GenerateMethod
 }
@@ -196,65 +181,6 @@ export type CompactOperation = (
   options?: Pick<StreamOptions, "http">,
 ) => Effect.Effect<CompactionResponse, AIError>
 
-export type TriggerCompactOperation = (
-  request: LLMRequest,
-  executor: RequestExecutor.Interface,
-  options: TriggerCompactOptions,
-) => Effect.Effect<CompactionCheckpointResponse, AIError>
-
-/** Protocol capabilities, not deployment/model eligibility. */
-export interface CompactionOperations {
-  readonly endpoint?: CompactOperation
-  readonly trigger?: TriggerCompactOperation
-}
-
-export interface EndpointCompactOptions extends Pick<StreamOptions, "http"> {
-  readonly mechanism?: "endpoint"
-  readonly webSocket?: never
-}
-
-export interface TriggerCompactOptions extends StreamOptions {
-  readonly mechanism: "trigger"
-}
-
-// Keep the required route shape explicit: the schema class's self type erases its model parameter in assignability.
-export type CompactionRequest = LLMRequest & {
-  readonly model: LanguageModel<ProviderOptions, { readonly endpoint: CompactOperation }>
-}
-export type CheckpointRequest = LLMRequest & {
-  readonly model: LanguageModel<ProviderOptions, { readonly trigger: TriggerCompactOperation }>
-}
-
-export interface CompactMethod<R = never> {
-  (request: CheckpointRequest, options: TriggerCompactOptions): Effect.Effect<CompactionCheckpointResponse, AIError, R>
-  (request: CompactionRequest, options?: EndpointCompactOptions): Effect.Effect<CompactionResponse, AIError, R>
-}
-
-export function canCompact(
-  request: LLMRequest,
-  options?: { readonly mechanism?: "endpoint" },
-): request is CompactionRequest
-export function canCompact(
-  request: LLMRequest,
-  options: { readonly mechanism: "trigger" },
-): request is CheckpointRequest
-export function canCompact(request: LLMRequest, options?: { readonly mechanism?: string }) {
-  if (options?.mechanism === "trigger") return request.model.route.compact?.trigger !== undefined
-  if (options?.mechanism !== undefined && options.mechanism !== "endpoint") return false
-  return request.model.route.compact?.endpoint !== undefined
-}
-
-const unsupportedCompaction = (request: LLMRequest, mechanism: string | undefined) => {
-  if (mechanism !== undefined && mechanism !== "endpoint" && mechanism !== "trigger")
-    return ProviderShared.invalidRequest(`Unknown compaction mechanism: ${mechanism}`)
-  return ProviderShared.unsupportedOperation({
-    operation: mechanism === "trigger" ? "compact.trigger" : "compact",
-    provider: request.model.provider,
-    route: request.model.route.id,
-    message: `${request.model.provider}/${request.model.route.id} does not support ${mechanism === "trigger" ? "trigger" : "explicit"} compaction`,
-  })
-}
-
 export class Service extends Context.Service<Service, Interface>()("@opencode/LLMClient") {}
 
 const resolveRequestOptions = (request: LLMRequest) => {
@@ -275,7 +201,7 @@ const resolveRequestOptions = (request: LLMRequest) => {
 }
 
 export interface MakeInput<Body, Frame, Event, State> {
-  readonly compact?: CompactionOperations
+  readonly compact?: CompactOperation
   /** Route id used in diagnostics and prepared request metadata. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
@@ -297,7 +223,7 @@ export interface MakeInput<Body, Frame, Event, State> {
 }
 
 export interface MakeTransportInput<Body, Prepared, Frame, Event, State> {
-  readonly compact?: CompactionOperations
+  readonly compact?: CompactOperation
   /** Route id used in diagnostics and prepared request metadata. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
@@ -385,10 +311,9 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
       defaults: routeInput.defaults ?? {},
       body: protocol.body,
       with: (patch: RoutePatch<Body, Prepared>) => {
-        const { compact, id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch
+        const { id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch
         return build({
           ...routeInput,
-          compact: "compact" in patch ? compact : routeInput.compact,
           id: id ?? routeInput.id,
           provider: provider ?? routeInput.provider,
           providerMetadataKey:
@@ -403,7 +328,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
         })
       },
       model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedLanguageModelInput) =>
-        makeRouteLanguageModel<Options, CompactionOperations | undefined>(route, input),
+        makeRouteLanguageModel<Options>(route, input),
       prepareTransport: (body, request, options) =>
         routeInput.transport.prepare({
           body,
@@ -500,12 +425,6 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
   return build({ ...input, defaults: mergeRouteDefaults(undefined, input.defaults ?? {}) })
 }
 
-export function make<Body, Prepared, Frame, Event, State, Compact extends CompactionOperations>(
-  input: MakeTransportInput<Body, Prepared, Frame, Event, State> & { readonly compact: Compact },
-): Route<Body, Prepared, Compact>
-export function make<Body, Frame, Event, State, Compact extends CompactionOperations>(
-  input: MakeInput<Body, Frame, Event, State> & { readonly compact: Compact },
-): Route<Body, HttpTransport.HttpPrepared<Frame>, Compact>
 export function make<Body, Prepared, Frame, Event, State>(
   input: MakeTransportInput<Body, Prepared, Frame, Event, State>,
 ): Route<Body, Prepared>
@@ -547,14 +466,10 @@ export function make<Body, Prepared, Frame, Event, State>(
 }
 
 const prepareRequest = (request: LLMRequest) => {
-  const original = resolveRequestOptions(request)
+  const original = applyCachePolicy(resolveRequestOptions(request))
   const sanitized = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }))
-  // Deduplicate per sibling level; a tool and a namespace may share a name.
-  const dedupe = (tools: LLMRequest["tools"]): LLMRequest["tools"] =>
-    [...new Map(tools.map((tool) => [`${tool.type}:${tool.name}`, tool])).values()].map((tool) =>
-      tool.type === "tool" ? tool : { ...tool, tools: dedupe(tool.tools) },
-    )
-  const resolved = applyCachePolicy(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) }))
+  const tools = [...new Map(sanitized.tools.map((tool) => [tool.name, tool])).values()]
+  const resolved = tools.length === sanitized.tools.length ? sanitized : LLMRequest.update(sanitized, { tools })
   const headers = resolved.model.route.headers?.({ request: resolved })
   return headers === undefined
     ? resolved
@@ -621,23 +536,14 @@ export function generate(request: LLMRequest, options?: StreamOptions): Effect.E
   })
 }
 
-export function compact(
-  request: CheckpointRequest,
-  options: TriggerCompactOptions,
-): Effect.Effect<CompactionCheckpointResponse, AIError, Service>
-export function compact(
-  request: CompactionRequest,
-  options?: EndpointCompactOptions,
-): Effect.Effect<CompactionResponse, AIError, Service>
-export function compact(request: LLMRequest, options?: EndpointCompactOptions | TriggerCompactOptions) {
-  return Effect.gen(function* () {
+export const compact = (
+  request: LLMRequest,
+  options?: Pick<StreamOptions, "http">,
+): Effect.Effect<CompactionResponse, AIError, Service> =>
+  Effect.gen(function* () {
     const client = yield* Service
-    if (options?.mechanism === "trigger" && canCompact(request, options)) return yield* client.compact(request, options)
-    if ((options?.mechanism === undefined || options.mechanism === "endpoint") && canCompact(request))
-      return yield* client.compact(request, options)
-    return yield* unsupportedCompaction(request, options?.mechanism)
+    return yield* client.compact(request, options)
   })
-}
 
 export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>
   Stream.unwrap(
@@ -651,27 +557,18 @@ export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer
   Effect.gen(function* () {
     const executor = yield* RequestExecutor.Service
     const stream = streamRequestWith({ http: executor })
-    function compact(
-      request: CompactionRequest,
-      options?: EndpointCompactOptions,
-    ): Effect.Effect<CompactionResponse, AIError>
-    function compact(
-      request: CheckpointRequest,
-      options: TriggerCompactOptions,
-    ): Effect.Effect<CompactionCheckpointResponse, AIError>
-    function compact(request: LLMRequest, options?: EndpointCompactOptions | TriggerCompactOptions) {
-      return Effect.suspend((): Effect.Effect<CompactionResponse | CompactionCheckpointResponse, AIError> => {
-        if (options?.mechanism === "trigger" && canCompact(request, options))
-          return request.model.route.compact.trigger(prepareRequest(request), executor, options)
-        if ((options?.mechanism === undefined || options.mechanism === "endpoint") && canCompact(request))
-          return request.model.route.compact.endpoint(prepareRequest(request), executor, options)
-        return unsupportedCompaction(request, options?.mechanism)
-      })
-    }
     return Service.of({
       stream,
       generate: generateWith(stream),
-      compact,
+      compact: (request, options) =>
+        Effect.suspend(() => {
+          const operation = request.model.route.compact
+          if (!operation)
+            return ProviderShared.invalidRequest(
+              `${request.model.provider}/${request.model.route.id} does not support explicit compaction`,
+            )
+          return operation(prepareRequest(request), executor, options)
+        }),
     })
   }),
 )
@@ -679,7 +576,6 @@ export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer
 export const Route = { make } as const
 
 export const LLMClient = {
-  canCompact,
   compact,
   Service,
   layer,

packages/ai/src/route/index.ts

@@ -9,12 +9,6 @@ export type {
   Interface as LLMClientShape,
   Service as LLMClientService,
   StreamOptions,
-  CompactMethod,
-  CompactionOperations,
-  CompactionRequest,
-  CheckpointRequest,
-  EndpointCompactOptions,
-  TriggerCompactOptions,
 } from "./client.js"
 export * from "./executor.js"
 export { Auth } from "./auth.js"

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

@@ -20,7 +20,7 @@ export interface WebSocketChannelExchange {
   readonly connect: {
     readonly url: string
     readonly headers: Headers.Headers
-    /** Provider-safe connection age after which the channel executor should reconnect before sending. */
+    /** Provider-safe connection age after which Core should rotate before sending. */
     readonly rotateAfterMs?: number
   }
   readonly fallback: () => Stream.Stream<string, AIError>

packages/ai/src/schema/errors.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import { ModelID, ProviderID, RouteID } from "./ids.js"
 
 export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"])
@@ -35,21 +35,6 @@ export class InvalidRequestError extends Schema.TaggedError<InvalidRequestError>
   },
 ) {}
 
-/**
- * A caller-requested operation the selected route does not implement, such as
- * explicit compaction on a route without a compact endpoint. Detected locally
- * before any network I/O, so unlike transport or provider-output failures it
- * never carries HTTP context from a provider round-trip.
- */
-export class UnsupportedOperationError extends Schema.TaggedError<UnsupportedOperationError>(
-  "AI.Error.UnsupportedOperation",
-)("UnsupportedOperation", {
-  ...ReasonFields,
-  operation: Schema.String,
-  provider: Schema.optional(ProviderID),
-  route: Schema.optional(RouteID),
-}) {}
-
 export class NoRouteError extends Schema.TaggedError<NoRouteError>("AI.Error.NoRoute")("NoRoute", {
   ...ReasonFields,
   route: RouteID,
@@ -122,7 +107,6 @@ export class UnknownProviderError extends Schema.TaggedError<UnknownProviderErro
 
 export const AIErrorReason = Schema.Union([
   InvalidRequestError,
-  UnsupportedOperationError,
   NoRouteError,
   AuthenticationError,
   RateLimitError,

packages/ai/src/schema/events.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { LLM } from "@opencode/schema/llm"
+import { LLM } from "@opencode-ai/schema/llm"
 import { ContentBlockID, ToolCallID } from "./ids.js"
 import {
   Message,
@@ -91,24 +91,9 @@ export class Usage extends Schema.Class<Usage>("AI.Usage")({
 
 export type UsageInput = Usage | ConstructorParameters<typeof Usage>[0]
 
-/** A replacement context window, not an assistant message to append to prior history. */
+/** A replacement context window. Replace prior history with these messages. */
 export class CompactionResponse extends Schema.Class<CompactionResponse>("LLM.CompactionResponse")({
-  replacement: Schema.Array(Message),
-  usage: Schema.optional(Usage),
-}) {}
-
-/** A checkpoint only; retained history and replacement-window construction belong to the caller. */
-export class CompactionCheckpointResponse extends Schema.Class<CompactionCheckpointResponse>(
-  "LLM.CompactionCheckpointResponse",
-)({
-  checkpoint: CompactionPart.pipe(
-    Schema.refine(
-      (part): part is CompactionPart & { readonly encrypted: string; readonly text?: never } =>
-        part.encrypted !== undefined && part.encrypted.length > 0,
-      { message: "A checkpoint response requires encrypted compaction content" },
-    ),
-  ),
-  responseID: Schema.String.check(Schema.isPattern(/\S/)),
+  messages: Schema.Array(Message),
   usage: Schema.optional(Usage),
 }) {}
 
@@ -170,7 +155,6 @@ export const ToolInputStart = Schema.Struct({
   type: Schema.tag("tool-input-start"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   providerExecuted: Schema.optional(Schema.Boolean),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ToolInputStart" })
@@ -180,7 +164,6 @@ export const ToolInputDelta = Schema.Struct({
   type: Schema.tag("tool-input-delta"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   text: Schema.String,
   /** Best-effort parse of all input fragments received through this delta. */
   input: Schema.optional(Schema.Unknown),
@@ -191,7 +174,6 @@ export const ToolInputEnd = Schema.Struct({
   type: Schema.tag("tool-input-end"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ToolInputEnd" })
 export type ToolInputEnd = Schema.Schema.Type<typeof ToolInputEnd>
@@ -201,7 +183,6 @@ export const ToolInputError = Schema.Struct({
   type: Schema.tag("tool-input-error"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   raw: Schema.String,
 }).annotate({ identifier: "LLM.Event.ToolInputError" })
 export type ToolInputError = Schema.Schema.Type<typeof ToolInputError>
@@ -210,7 +191,6 @@ export const ToolCall = Schema.Struct({
   type: Schema.tag("tool-call"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   input: Schema.Unknown,
   providerExecuted: Schema.optional(Schema.Boolean),
   providerMetadata: Schema.optional(ProviderMetadata),
@@ -221,7 +201,6 @@ export const ToolResult = Schema.Struct({
   type: Schema.tag("tool-result"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   result: ToolResultValue,
   output: Schema.optional(ToolOutput),
   providerExecuted: Schema.optional(Schema.Boolean),
@@ -233,7 +212,6 @@ export const ToolError = Schema.Struct({
   type: Schema.tag("tool-error"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   message: Schema.String,
   error: Schema.optional(Schema.Defect()),
   providerMetadata: Schema.optional(ProviderMetadata),
@@ -407,7 +385,6 @@ interface ContentAssembly {
 
 interface ToolInputAssembly {
   readonly name: string
-  readonly namespace?: string
   readonly text: string
   readonly providerMetadata?: ProviderMetadata
 }
@@ -545,17 +522,12 @@ const reduceToolInputStart = (state: ResponseState, event: ToolInputStart): Resp
   ...state,
   toolInputs: {
     ...state.toolInputs,
-    [event.id]: {
-      name: event.name,
-      namespace: event.namespace,
-      text: "",
-      providerMetadata: event.providerMetadata,
-    },
+    [event.id]: { name: event.name, text: "", providerMetadata: event.providerMetadata },
   },
 })
 
 const reduceToolInputDelta = (state: ResponseState, event: ToolInputDelta): ResponseState => {
-  const current = state.toolInputs[event.id] ?? { name: event.name, namespace: event.namespace, text: "" }
+  const current = state.toolInputs[event.id] ?? { name: event.name, text: "" }
   return {
     ...state,
     toolInputs: { ...state.toolInputs, [event.id]: { ...current, text: current.text + event.text } },
@@ -563,7 +535,7 @@ const reduceToolInputDelta = (state: ResponseState, event: ToolInputDelta): Resp
 }
 
 const reduceToolInputEnd = (state: ResponseState, event: ToolInputEnd): ResponseState => {
-  const current = state.toolInputs[event.id] ?? { name: event.name, namespace: event.namespace, text: "" }
+  const current = state.toolInputs[event.id] ?? { name: event.name, text: "" }
   return {
     ...state,
     toolInputs: {
@@ -571,7 +543,6 @@ const reduceToolInputEnd = (state: ResponseState, event: ToolInputEnd): Response
       [event.id]: {
         ...current,
         name: event.name,
-        namespace: event.namespace,
         providerMetadata: event.providerMetadata ?? current.providerMetadata,
       },
     },
@@ -582,7 +553,6 @@ const toolCallContent = (event: ToolCall): ContentPart =>
   ToolCallPart.make({
     id: event.id,
     name: event.name,
-    namespace: event.namespace,
     input: event.input,
     ...(event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted }),
     ...(event.providerMetadata === undefined ? {} : { providerMetadata: event.providerMetadata }),
@@ -592,7 +562,6 @@ const toolResultContent = (event: ToolResult): ContentPart =>
   ToolResultPart.make({
     id: event.id,
     name: event.name,
-    namespace: event.namespace,
     result: event.result,
     ...(event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted }),
     ...(event.providerMetadata === undefined ? {} : { providerMetadata: event.providerMetadata }),

packages/ai/src/schema/messages.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { Tool } from "@opencode/schema/tool"
+import { Tool } from "@opencode-ai/schema/tool"
 import {
   CacheHint,
   CachePolicy,
@@ -7,7 +7,6 @@ import {
   HttpOptions,
   JsonSchema,
   LanguageModelSchema,
-  type LanguageModel,
   ProviderOptions,
 } from "./options.js"
 import { ProviderID } from "./ids.js"
@@ -135,7 +134,6 @@ export const ToolCallPart = Object.assign(
     type: Schema.Literal("tool-call"),
     id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     input: Schema.Unknown,
     providerExecuted: Schema.optional(Schema.Boolean),
     cache: Schema.optional(CacheHint),
@@ -153,7 +151,6 @@ export const ToolResultPart = Object.assign(
     type: Schema.Literal("tool-result"),
     id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     result: ToolResultValue,
     providerExecuted: Schema.optional(Schema.Boolean),
     cache: Schema.optional(CacheHint),
@@ -170,7 +167,6 @@ export const ToolResultPart = Object.assign(
       type: "tool-result",
       id: input.id,
       name: input.name,
-      namespace: input.namespace,
       result: ToolResultValue.make(input.result, input.resultType),
       providerExecuted: input.providerExecuted,
       cache: input.cache,
@@ -269,7 +265,7 @@ export namespace Message {
     make({ role: "tool", content: ["type" in result ? result : ToolResultPart.make(result)] })
 }
 
-const toolDefinitionFields = {
+export class ToolDefinition extends Schema.Class<ToolDefinition>("LLM.ToolDefinition")({
   name: Schema.String,
   description: Schema.String,
   inputSchema: JsonSchema,
@@ -277,71 +273,15 @@ const toolDefinitionFields = {
   cache: Schema.optional(CacheHint),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
   native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}
-
-export type ToolDefinitionInput = Schema.Struct.Type<typeof toolDefinitionFields>
-
-export class ToolDefinition extends Schema.Class<ToolDefinition>("LLM.ToolDefinition")({
-  type: Schema.Literal("tool"),
-  ...toolDefinitionFields,
-}) {
-  constructor(input: ToolDefinitionInput) {
-    super({ ...input, type: "tool" })
-  }
-}
+}) {}
 
 export namespace ToolDefinition {
-  export type Input = ToolDefinition | ToolDefinitionInput
+  export type Input = ToolDefinition | ConstructorParameters<typeof ToolDefinition>[0]
 
   /** Normalize tool definition input into the canonical `ToolDefinition` class. */
   export const make = (input: Input) => (input instanceof ToolDefinition ? input : new ToolDefinition(input))
 }
 
-export type ToolNamespace = {
-  readonly type: "namespace"
-  readonly name: string
-  readonly description?: string
-  readonly tools: ReadonlyArray<ToolEntry>
-}
-
-export type ToolNamespaceInput = Omit<ToolNamespace, "type" | "tools"> & {
-  readonly tools: ReadonlyArray<ToolEntryInput>
-}
-export type ToolNamespaceEntryInput = ToolNamespaceInput & { readonly type: "namespace" }
-
-export const ToolNamespace: Schema.Codec<ToolNamespace> & {
-  readonly make: (input: ToolNamespace | ToolNamespaceInput) => ToolNamespace
-} = Object.assign(
-  Schema.Struct({
-    type: Schema.Literal("namespace"),
-    name: Schema.String,
-    description: Schema.optional(Schema.UndefinedOr(Schema.String)),
-    tools: Schema.Array(Schema.suspend((): Schema.Codec<ToolEntry> => ToolEntry)),
-  }).annotate({ identifier: "LLM.ToolNamespace" }),
-  {
-    make: (input: ToolNamespace | ToolNamespaceInput): ToolNamespace => ({
-      ...input,
-      type: "namespace",
-      tools: input.tools.map(ToolEntry.make),
-    }),
-  },
-)
-
-export type ToolEntry = ToolDefinition | ToolNamespace
-export type ToolEntryInput = ToolDefinition.Input | ToolNamespaceEntryInput
-export const ToolEntry: Schema.Codec<ToolEntry> & {
-  readonly make: (input: ToolEntryInput) => ToolEntry
-} = Object.assign(
-  Schema.Union([ToolDefinition, ToolNamespace]).pipe(
-    Schema.toTaggedUnion("type"),
-    Schema.annotate({ identifier: "LLM.ToolEntry" }),
-  ),
-  {
-    make: (input: ToolEntryInput): ToolEntry =>
-      "type" in input && input.type === "namespace" ? ToolNamespace.make(input) : ToolDefinition.make(input),
-  },
-)
-
 export class ToolChoice extends Schema.Class<ToolChoice>("LLM.ToolChoice")({
   type: Schema.Literals(["auto", "none", "required", "tool"]),
   name: Schema.optional(Schema.String),
@@ -366,12 +306,12 @@ export namespace ToolChoice {
   }
 }
 
-const requestSchema = Schema.Struct({
+export class LLMRequest extends Schema.Class<LLMRequest>("LLM.Request")({
   id: Schema.optional(Schema.String),
   model: LanguageModelSchema,
   system: Schema.Array(SystemPart),
   messages: Schema.Array(Message),
-  tools: Schema.Array(ToolEntry),
+  tools: Schema.Array(ToolDefinition),
   toolChoice: Schema.optional(ToolChoice),
   generation: Schema.optional(GenerationOptions),
   providerOptions: Schema.optional(ProviderOptions),
@@ -380,26 +320,12 @@ const requestSchema = Schema.Struct({
   // Stable cache affinity for protocols that support provider-managed prompt caching.
   promptCacheKey: Schema.optional(Schema.String),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-})
-
-export class LLMRequest<Model extends LanguageModel = LanguageModel> extends Schema.Class<LLMRequest>("LLM.Request")(
-  requestSchema.fields,
-) {
-  declare readonly model: Model
-
-  // Preserve model inference instead of inheriting the schema's erased constructor signature.
-  // oxlint-disable-next-line no-useless-constructor
-  constructor(input: LLMRequest.Input<Model>) {
-    super(input)
-  }
-}
+}) {}
 
 export namespace LLMRequest {
-  export type Input<Model extends LanguageModel = LanguageModel> = Omit<typeof requestSchema.Type, "model"> & {
-    readonly model: Model
-  }
+  export type Input = ConstructorParameters<typeof LLMRequest>[0]
 
-  export const input = <Model extends LanguageModel>(request: LLMRequest<Model>): Input<Model> => ({
+  export const input = (request: LLMRequest): Input => ({
     id: request.id,
     model: request.model,
     system: request.system,
@@ -414,16 +340,7 @@ export namespace LLMRequest {
     metadata: request.metadata,
   })
 
-  export function update<Model extends LanguageModel>(
-    request: LLMRequest,
-    patch: Partial<Input<Model>> & { readonly model: Model },
-  ): LLMRequest<Model>
-  export function update<Model extends LanguageModel>(
-    request: LLMRequest<Model>,
-    patch: Partial<Omit<Input, "model">> & { readonly model?: undefined },
-  ): LLMRequest<Model>
-  export function update(request: LLMRequest, patch: Partial<Input>): LLMRequest
-  export function update(request: LLMRequest, patch: Partial<Input>) {
+  export const update = (request: LLMRequest, patch: Partial<Input>) => {
     if (Object.keys(patch).length === 0) return request
     return new LLMRequest({
       ...input(request),

packages/ai/src/schema/options.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect"
 import { ModelID, ProviderID } from "./ids.js"
-import type { AnyRoute, CompactionOperations } from "../route/client.js"
+import type { AnyRoute } from "../route/client.js"
 import { isRecord } from "../utils/record.js"
 
 export const JsonSchema = Schema.Record(Schema.String, Schema.Unknown)
@@ -163,8 +163,6 @@ export class LanguageModelCompatibility extends Schema.Class<LanguageModelCompat
   supportsStrictMode: Schema.optional(Schema.Boolean),
   zaiToolStream: Schema.optional(Schema.Boolean),
   requireSignature: Schema.optional(Schema.Boolean),
-  /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
-  supportsThinkingBlockBinding: Schema.optional(Schema.Boolean),
 }) {}
 
 export namespace LanguageModelCompatibility {
@@ -175,18 +173,15 @@ export namespace LanguageModelCompatibility {
     input instanceof LanguageModelCompatibility ? input : new LanguageModelCompatibility(input)
 }
 
-export class LanguageModel<
-  Options extends ProviderOptions = ProviderOptions,
-  Compact extends CompactionOperations | undefined = CompactionOperations | undefined,
-> {
+export class LanguageModel<Options extends ProviderOptions = ProviderOptions> {
   declare protected readonly _ProviderOptions: Options
   readonly id: ModelID
   readonly provider: ProviderID
-  readonly route: AnyRoute<Compact>
+  readonly route: AnyRoute
   readonly defaults?: LanguageModelDefaults
   readonly compatibility?: LanguageModelCompatibility
 
-  constructor(input: LanguageModel.ConstructorInput<Compact>) {
+  constructor(input: LanguageModel.ConstructorInput) {
     this.id = input.id
     this.provider = input.provider
     this.route = input.route
@@ -194,11 +189,8 @@ export class LanguageModel<
     this.compatibility = input.compatibility
   }
 
-  static make<
-    Options extends ProviderOptions = ProviderOptions,
-    Compact extends CompactionOperations | undefined = CompactionOperations | undefined,
-  >(input: LanguageModel.Input<Compact>) {
-    return new LanguageModel<Options, Compact>({
+  static make<Options extends ProviderOptions = ProviderOptions>(input: LanguageModel.Input) {
+    return new LanguageModel<Options>({
       id: ModelID.make(input.id),
       provider: ProviderID.make(input.provider),
       route: input.route,
@@ -208,9 +200,7 @@ export class LanguageModel<
     })
   }
 
-  static input<Options extends ProviderOptions, Compact extends CompactionOperations | undefined>(
-    model: LanguageModel<Options, Compact>,
-  ): LanguageModel.ConstructorInput<Compact> {
+  static input<Options extends ProviderOptions>(model: LanguageModel<Options>): LanguageModel.ConstructorInput {
     return {
       id: model.id,
       provider: model.provider,
@@ -220,41 +210,25 @@ export class LanguageModel<
     }
   }
 
-  static update<Options extends ProviderOptions, Compact extends CompactionOperations | undefined>(
-    model: LanguageModel<Options>,
-    patch: Partial<LanguageModel.Input<Compact>> & { readonly route: AnyRoute<Compact> },
-  ): LanguageModel<Options, Compact>
-  static update<Options extends ProviderOptions, Compact extends CompactionOperations | undefined>(
-    model: LanguageModel<Options, Compact>,
-    patch: Partial<Omit<LanguageModel.Input, "route">> & { readonly route?: undefined },
-  ): LanguageModel<Options, Compact>
-  static update<Options extends ProviderOptions>(
-    model: LanguageModel<Options>,
-    patch: Partial<LanguageModel.Input>,
-  ): LanguageModel<Options>
   static update<Options extends ProviderOptions>(model: LanguageModel<Options>, patch: Partial<LanguageModel.Input>) {
     if (Object.keys(patch).length === 0) return model
     return LanguageModel.make<Options>({
       ...LanguageModel.input(model),
       ...patch,
-      route: patch.route ?? model.route,
     })
   }
 }
 
 export namespace LanguageModel {
-  export type ConstructorInput<Compact extends CompactionOperations | undefined = CompactionOperations | undefined> = {
+  export type ConstructorInput = {
     readonly id: ModelID
     readonly provider: ProviderID
-    readonly route: AnyRoute<Compact>
+    readonly route: AnyRoute
     readonly defaults?: LanguageModelDefaults
     readonly compatibility?: LanguageModelCompatibility
   }
 
-  export type Input<Compact extends CompactionOperations | undefined = CompactionOperations | undefined> = Omit<
-    ConstructorInput<Compact>,
-    "id" | "provider" | "defaults" | "compatibility"
-  > & {
+  export type Input = Omit<ConstructorInput, "id" | "provider" | "defaults" | "compatibility"> & {
     readonly id: string | ModelID
     readonly provider: string | ProviderID
     readonly defaults?: LanguageModelDefaults.Input
@@ -293,7 +267,7 @@ export const CachePolicyObject = Schema.Struct({
     Schema.Union([
       Schema.Literal("latest-user-message"),
       Schema.Literal("latest-assistant"),
-      Schema.Struct({ tail: Schema.Natural }),
+      Schema.Struct({ tail: Schema.Number }),
     ]),
   ),
   ttlSeconds: Schema.optional(Schema.Number),