refactor(ai): namespace model metadata by route ID

.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

@@ -25,7 +25,7 @@ on:
         required: false
         type: string
 
-concurrency: ${{ github.workflow }}-${{ github.ref }}-${{ (github.ref_name == 'v2' && (inputs.version || inputs.bump) && 'release') || inputs.version || inputs.bump }}
+concurrency: ${{ github.workflow }}-${{ github.ref }}-${{ inputs.version || inputs.bump }}
 
 permissions:
   id-token: write
@@ -33,7 +33,7 @@ permissions:
   packages: write
 
 env:
-  OPENCODE_CHANNEL: ${{ (github.ref_name == 'v2' && !inputs.bump && !inputs.version && 'dev') || '' }}
+  OPENCODE_CHANNEL: ${{ (github.ref_name == 'v2' && 'dev') || '' }}
 
 jobs:
   version:
@@ -48,7 +48,7 @@ jobs:
 
       - name: Deploy update service
         if: github.ref_name == 'v2'
-        working-directory: services/update
+        working-directory: packages/updates
         run: bun run deploy
         env:
           CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
@@ -168,7 +168,7 @@ jobs:
           fi
 
           found=0
-          for file in packages/cli/dist/cli-darwin-*/bin/opencode; do
+          for file in packages/cli/dist/cli-darwin-*/bin/opencode2; do
             if [ ! -f "$file" ]; then
               continue
             fi
@@ -191,7 +191,7 @@ jobs:
 
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
-          name: opencode-preview-cli-macos
+          name: opencode-preview-cli
           path: packages/cli/dist/cli-*
           if-no-files-found: error
 
@@ -199,7 +199,7 @@ jobs:
     needs: version
     runs-on: blacksmith-4vcpu-ubuntu-2404
     timeout-minutes: 30
-    if: github.repository == 'anomalyco/opencode' && !(github.ref_name == 'v2' && (inputs.bump || inputs.version))
+    if: github.repository == 'anomalyco/opencode'
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
 
@@ -221,7 +221,7 @@ jobs:
     needs:
       - version
       - build-node-app-archive
-    if: github.repository == 'anomalyco/opencode' && !(github.ref_name == 'v2' && (inputs.bump || inputs.version))
+    if: github.repository == 'anomalyco/opencode'
     strategy:
       fail-fast: false
       matrix:
@@ -276,9 +276,10 @@ jobs:
 
   sign-cli-windows:
     needs:
-      - sign-cli-macos
+      - build-cli
+      - version
     runs-on: blacksmith-4vcpu-windows-2025
-    if: github.repository == 'anomalyco/opencode' && (github.ref_name == 'v2' || github.ref_name == 'beta')
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2' && github.ref_name != 'beta'
     env:
       AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
       AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
@@ -291,8 +292,15 @@ jobs:
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
         with:
-          name: opencode-preview-cli-macos
-          path: packages/cli/dist
+          name: opencode-cli-windows
+          path: packages/opencode/dist
+
+      - name: Setup git committer
+        id: committer
+        uses: ./.github/actions/setup-git-committer
+        with:
+          opencode-app-id: ${{ vars.OPENCODE_APP_ID }}
+          opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}
 
       - name: Azure login
         uses: azure/login@a457da9ea143d694b1b9c7c869ebb04ebe844ef5 # v2.3.0
@@ -307,9 +315,9 @@ jobs:
           signing-account-name: ${{ env.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
           certificate-profile-name: ${{ env.AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE }}
           files: |
-            ${{ github.workspace }}\packages\cli\dist\cli-windows-arm64\bin\opencode.exe
-            ${{ github.workspace }}\packages\cli\dist\cli-windows-x64\bin\opencode.exe
-            ${{ github.workspace }}\packages\cli\dist\cli-windows-x64-baseline\bin\opencode.exe
+            ${{ github.workspace }}\packages\opencode\dist\opencode-windows-arm64\bin\opencode.exe
+            ${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64\bin\opencode.exe
+            ${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64-baseline\bin\opencode.exe
           exclude-environment-credential: true
           exclude-workload-identity-credential: true
           exclude-managed-identity-credential: true
@@ -325,9 +333,9 @@ jobs:
         shell: pwsh
         run: |
           $files = @(
-            "${{ github.workspace }}\packages\cli\dist\cli-windows-arm64\bin\opencode.exe",
-            "${{ github.workspace }}\packages\cli\dist\cli-windows-x64\bin\opencode.exe",
-            "${{ github.workspace }}\packages\cli\dist\cli-windows-x64-baseline\bin\opencode.exe"
+            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-arm64\bin\opencode.exe",
+            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64\bin\opencode.exe",
+            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64-baseline\bin\opencode.exe"
           )
 
           foreach ($file in $files) {
@@ -337,17 +345,40 @@ jobs:
             }
           }
 
+      - name: Repack Windows CLI archives
+        working-directory: packages/opencode/dist
+        shell: pwsh
+        run: |
+          Compress-Archive -Path "opencode-windows-arm64\bin\*" -DestinationPath "opencode-windows-arm64.zip" -Force
+          Compress-Archive -Path "opencode-windows-x64\bin\*" -DestinationPath "opencode-windows-x64.zip" -Force
+          Compress-Archive -Path "opencode-windows-x64-baseline\bin\*" -DestinationPath "opencode-windows-x64-baseline.zip" -Force
+
+      - name: Upload signed Windows CLI release assets
+        if: needs.version.outputs.release != ''
+        shell: pwsh
+        env:
+          GH_TOKEN: ${{ steps.committer.outputs.token }}
+        run: |
+          gh release upload "v${{ needs.version.outputs.version }}" `
+            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-arm64.zip" `
+            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64.zip" `
+            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64-baseline.zip" `
+            --clobber `
+            --repo "${{ needs.version.outputs.repo }}"
+
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
-          name: opencode-preview-cli
-          path: packages/cli/dist/cli-*
-          if-no-files-found: error
+          name: opencode-cli-signed-windows
+          path: |
+            packages/opencode/dist/opencode-windows-arm64
+            packages/opencode/dist/opencode-windows-x64
+            packages/opencode/dist/opencode-windows-x64-baseline
 
   build-electron:
     needs:
       - version
-      - sign-cli-windows
-    if: github.repository == 'anomalyco/opencode' && (github.ref_name != 'v2' || needs.version.outputs.release != '')
+      - sign-cli-macos
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2'
     continue-on-error: false
     env:
       AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
@@ -639,6 +670,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 }}
@@ -650,6 +694,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:

.github/workflows/typecheck.yml

@@ -1,4 +1,4 @@
-name: check
+name: typecheck
 
 on:
   push:
@@ -8,8 +8,7 @@ on:
   workflow_dispatch:
 
 jobs:
-  check:
-    name: typecheck
+  typecheck:
     runs-on: blacksmith-4vcpu-ubuntu-2404
     steps:
       - name: Checkout repository
@@ -18,5 +17,5 @@ jobs:
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
 
-      - name: Run checks
-        run: bun run check
+      - name: Run typecheck
+        run: bun typecheck

.gitignore

@@ -32,7 +32,6 @@ target
 # Local dev files
 opencode-dev
 UPCOMING_CHANGELOG.md
-RELEASE_REVIEW.md
 logs/
 *.bun-build
 tsconfig.tsbuildinfo

.husky/pre-push

@@ -17,4 +17,4 @@ if (process.versions.bun !== expectedBunVersion) {
   console.warn(`Warning: Bun version ${process.versions.bun} differs from expected ${expectedBunVersion}`);
 }
 '
-bun run check
+bun typecheck

.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"],

.oxlintrc.json

@@ -1,22 +1,45 @@
 {
   "$schema": "https://raw.githubusercontent.com/nicolo-ribaudo/oxc-project.github.io/refs/heads/json-schema/src/public/.oxlintrc.schema.json",
+  "options": {
+    "typeAware": true
+  },
   "categories": {
-    "correctness": "off",
-    "suspicious": "off",
-    "pedantic": "off",
-    "perf": "off",
-    "style": "off",
-    "restriction": "off",
-    "nursery": "off"
+    "suspicious": "warn"
   },
   "rules": {
-    "no-restricted-globals": [
-      "error",
-      {
-        "name": "Reflect",
-        "message": "Use typed property access or direct invocation. Suppress this rule only for genuine reflection."
-      }
-    ]
+    "typescript/no-base-to-string": "warn",
+    // Effect uses `function*` with Effect.gen/Effect.fnUntraced that don't always yield
+    "require-yield": "off",
+    // SolidJS uses `let ref: T | undefined` for JSX ref bindings assigned at runtime
+    "no-unassigned-vars": "off",
+    // SolidJS tracks reactive deps by reading properties inside createEffect
+    "no-unused-expressions": "off",
+    // Intentional control char matching (ANSI escapes, null byte sanitization)
+    "no-control-regex": "off",
+    // SST and plugin tools require triple-slash references
+    "triple-slash-reference": "off",
+
+    // Suspicious category: suppress noisy rules
+    // Effect's nested function* closures inherently shadow outer scope
+    "no-shadow": "off",
+    // Namespace-heavy codebase makes this too noisy
+    "unicorn/consistent-function-scoping": "off",
+    // Opinionated — .sort()/.reverse() mutation is fine in this codebase
+    "unicorn/no-array-sort": "off",
+    "unicorn/no-array-reverse": "off",
+    // Not relevant — this isn't a DOM event handler codebase
+    "unicorn/prefer-add-event-listener": "off",
+    // Bundler handles module resolution
+    "unicorn/require-module-specifiers": "off",
+    // postMessage target origin not relevant for this codebase
+    "unicorn/require-post-message-target-origin": "off",
+    // Side-effectful constructors are intentional in some places
+    "no-new": "off",
+
+    // Type-aware: catch unhandled promises
+    "typescript/no-floating-promises": "warn",
+    // Warn when spreading non-plain objects (Headers, class instances, etc.)
+    "typescript/no-misused-spread": "warn"
   },
   "ignorePatterns": ["**/node_modules", "**/dist", "**/.build", "**/.sst", "**/*.d.ts", "**/sdk.gen.ts"]
 }

AGENTS.md

@@ -8,9 +8,9 @@
 
 ## Live V2 TUI Testing
 
-- Run `bun run dev:live` from a development worktree to test its TUI against the currently elected `opencode` background server and live sessions.
+- Run `bun run dev:live` from a development worktree to test its TUI against the currently elected `opencode2` background server and live sessions.
 - Pass a directory after the script when needed, for example `bun run dev:live /path/to/project`.
-- The script discovers the server with `opencode service status`, injects its private local credential from `opencode service get password`, and uses the `dev` TUI storage channel so tabs and other client-local state match the installed client.
+- The script discovers the server with `opencode2 service status`, injects its private local credential from `opencode2 service get password`, and uses the `dev` TUI storage channel so tabs and other client-local state match the installed client.
 - Prefer `dev:live` over plain `bun run dev` for this workflow. An implicit managed-service connection may replace the live server when the worktree client version differs; explicit `--server` warns and continues without replacing it.
 
 ## V2 TUI Stories
@@ -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
@@ -170,10 +170,9 @@ const table = sqliteTable("session", {
 - Test actual implementation, do not duplicate logic into tests
 - Tests cannot run from repo root (guard: `do-not-run-tests-from-root`); run from package directories such as `packages/core`.
 
-## Checks
+## Type Checking
 
-- Run `bun run check` from the repository root as the canonical full lint and type-check verification.
-- During focused iteration, run `bun typecheck` from the affected package directory (for example, `packages/core`). Never run `tsc` directly.
+- Always run `bun typecheck` from package directories (for example, `packages/core`), never `tsc` directly.
 
 ## V2 Session Core
 

V2_HTTP_API_AUDIT.md

@@ -1,279 +0,0 @@
-# V2 HTTP API audit checklist
-
-**Source:** `packages/protocol/openapi.json`  
-**Current endpoint count:** 139
-**Last regenerated:** 2026-09-13
-
-## How to use this checklist
-
-Review endpoints in document order. For each endpoint, select one disposition and capture rationale or follow-up work in Notes. Mark **Reviewed** only after the disposition is agreed.
-
-### Review criteria
-
-- Resource and operation naming
-- HTTP method and idempotency
-- Request parameters and location scope
-- Response shape and error taxonomy
-- Authentication and authorization
-- Current production consumers
-- Stability level: public, experimental, or internal
-- Whether the generated client API is intuitive
-
-### Disposition legend
-
-- **Keep:** ship unchanged as a supported V2 API
-- **Change:** retain after a defined contract change
-- **Remove:** exclude from the official V2 API
-- **Experimental-only:** retain outside the stable API commitment
-
-## Progress
-
-- [x] Group 1: Foundation and placement (4)
-- [ ] Group 2: Configuration and capability catalogs (16)
-- [ ] Group 3: Credentials, integrations, MCP, and web search (22)
-- [ ] Group 4: Session lifecycle (12)
-- [ ] Group 5: Session execution and inputs (11)
-- [ ] Group 6: Session history and recovery (13)
-- [ ] Group 7: Inbox, permissions, and forms (19)
-- [ ] Group 8: Filesystem, worktrees, and VCS (12)
-- [ ] Group 9: PTYs, persistent terminals, and shells (24)
-- [ ] Group 10: Events, RPC, and experimental operations (6)
-
-## Resolved during audit
-
-### [x] `POST /api/plugin/await-activation`
-
-- **Decision:** Remove
-- **Notes:** Activation timing is an internal server concern. Catalog reads remain non-blocking.
-
-### [x] Location response wrappers
-
-- **Decision:** Reduce generic endpoint response locations to `{ directory }`.
-- **Notes:** Full project metadata remains available from `GET /api/location`; no consumers used it from wrapped responses.
-
-### [x] `GET /api/health` and `GET /api/server`
-
-- **Decision:** Merge and rename
-- **Replacement:** `GET /api/status` with operation ID `server.status`.
-- **Notes:** Returns `version`, `pid`, and connection `urls`; readiness is conveyed by HTTP status.
-
-### [x] `GET /api/project/current`
-
-- **Decision:** Remove
-- **Replacement:** `GET /api/location`, using `project` from the response.
-- **Notes:** The endpoint duplicated `Location.Info.project`; production callers were migrated.
-
-### [x] `POST /api/workspace` and `DELETE /api/workspace/{workspaceID}`
-
-- **Decision:** Remove
-- **Notes:** Provider-backed workspaces are not part of the V2 HTTP contract and can be introduced later. Core and the embedded SDK retain internal workspace support.
-
-## Group 1: Foundation and placement
-
-**Endpoints:** 4
-
-| Done | Method | Path | Operation ID | Decision | Notes |
-|---|---|---|---|---|---|
-| [x] 001–002 | `GET` | `/api/status` | `server.status` | Keep | Replaces the former health and server endpoints. |
-| [x] 003 | `GET` | `/api/location` | `location.get` | Keep | Workspace selectors and response fields removed until workspace support ships. |
-| [x] 004 | `GET` | `/api/project` | `project.list` | Keep | Removed unused `time.initialized`; the database column remains for migration data. |
-| [x] 005 | `PATCH` | `/api/project/{projectID}` | `project.update` | Keep | Request and response accepted as-is. |
-
-## Group 2: Configuration and capability catalogs
-
-**Endpoints:** 16
-
-| Done | Method | Path | Operation ID | Decision | Notes |
-|---|---|---|---|---|---|
-| [x] 008 | `GET` | `/api/agent` | `agent.list` | Keep | Request and response accepted as-is. |
-| [x] 009 | `GET` | `/api/agent/{agentID}` | `agent.get` | Keep | Request, response, and not-found error accepted as-is. |
-| [x] 010 | `GET` | `/api/plugin` | `plugin.list` | Keep | Request and response accepted as-is. |
-| [x] 012 | `POST` | `/api/plugin/check` | `plugin.check` | Keep | Request and response accepted as-is. |
-| [x] 013 | `POST` | `/api/plugin/update` | `plugin.update` | Keep | Request and errors accepted as-is. |
-| [x] 014 | `GET` | `/api/model` | `model.list` | Keep | Request and response accepted as-is. |
-| [x] 015 | `GET` | `/api/model/default` | `model.default` | Keep | Request and nullable response accepted as-is. |
-| [x] 016 | `GET` | `/api/provider` | `provider.list` | Keep | Request and response accepted as-is. |
-| [x] 017 | `GET` | `/api/provider/{providerID}` | `provider.get` | Keep | Request, response, and not-found error accepted as-is. |
-| [x] 018 | `GET` | `/api/command` | `command.list` | Keep | Request and response accepted as-is. |
-| [x] 019 | `GET` | `/api/skill` | `skill.list` | Keep | Renamed `location` to `path`; removed the skill-specific `slash` flag and slash-command behavior. |
-| [x] 020 | `GET` | `/api/reference` | `reference.list` | Keep | Removed duplicate `description` and `hidden` fields from nested `source`. |
-| [x] 021 | `GET` | `/api/config` | `config.get` | Keep | Compatibility entries removed; response now contains only documents and OpenCode directories. |
-| [x] 022 | `GET` | `/api/config/preferences` | `config.preferences` | Remove | Redundant special projection of global config. |
-| [x] 023 | `PATCH` | `/api/config/preferences` | `config.updatePreferences` | Remove | Redundant field-specific config mutation API. |
-| [ ] 024 | `GET` | `/api/config/shell` | `config.shells` |  |  |
-| [x] 024a | `PATCH` | `/api/experimental/config` | `experimental.config.update` | Change | Experimental global config mutation; initially accepts only `shell`. |
-
-## Group 3: Credentials, integrations, MCP, and web search
-
-**Endpoints:** 22
-
-| Done | Method | Path | Operation ID | Decision | Notes |
-|---|---|---|---|---|---|
-| [x] 025 | `GET` | `/api/integration` | `integration.list` | Keep | Full integration inventory is consumed by authentication and integration-selection clients. |
-| [x] 026 | `GET` | `/api/integration/{integrationID}` | `integration.get` | Change | Missing integration now returns typed `404` instead of optional data. |
-| [ ] 027 | `POST` | `/api/experimental/integration/wellknown` | `experimental.integration.wellknown.add` |  |  |
-| [ ] 028 | `POST` | `/api/integration/{integrationID}/connect/key` | `integration.connect.key` |  |  |
-| [ ] 029 | `POST` | `/api/integration/{integrationID}/connect/oauth` | `integration.oauth.connect` |  |  |
-| [ ] 030 | `GET` | `/api/integration/{integrationID}/connect/oauth/{attemptID}` | `integration.oauth.status` |  |  |
-| [ ] 031 | `DELETE` | `/api/integration/{integrationID}/connect/oauth/{attemptID}` | `integration.oauth.cancel` |  |  |
-| [ ] 032 | `POST` | `/api/integration/{integrationID}/connect/oauth/{attemptID}/complete` | `integration.oauth.complete` |  |  |
-| [ ] 033 | `POST` | `/api/integration/{integrationID}/connect/command` | `integration.command.connect` |  |  |
-| [ ] 034 | `GET` | `/api/integration/{integrationID}/connect/command/{attemptID}` | `integration.command.status` |  |  |
-| [ ] 035 | `DELETE` | `/api/integration/{integrationID}/connect/command/{attemptID}` | `integration.command.cancel` |  |  |
-| [x] 036 | `GET` | `/api/mcp` | `mcp.list` | Keep | MCP inventory and connection status retained. |
-| [x] 037 | `PUT` | `/api/experimental/mcp/{server}` | `experimental.mcp.add` | Experimental-only | Runtime-only MCP override; does not persist configuration. |
-| [x] 038 | `DELETE` | `/api/experimental/mcp/{server}` | `experimental.mcp.remove` | Experimental-only | Runtime removal override; missing server returns `404`. |
-| [x] 039 | `POST` | `/api/experimental/mcp/{server}/connect` | `experimental.mcp.connect` | Experimental-only | Runtime connection override retained outside the stable API. |
-| [x] 040 | `POST` | `/api/experimental/mcp/{server}/disconnect` | `experimental.mcp.disconnect` | Experimental-only | Runtime disconnection override retained outside the stable API. |
-| [ ] 041 | `GET` | `/api/mcp/resource` | `mcp.resource.catalog` |  | Deferred for later review. |
-| [x] 042 | `PATCH` | `/api/credential/{credentialID}` | `credential.update` | Change | Removed redundant location query; credentials and events are global. |
-| [x] 043 | `DELETE` | `/api/credential/{credentialID}` | `credential.remove` | Change | Removed redundant location query; credentials and events are global. |
-| [x] 044 | `POST` | `/api/credential/{credentialID}/activate` | `credential.activate` | Change | Removed redundant location query; credentials and events are global. |
-| [x] 045 | `GET` | `/api/websearch/provider` | `websearch.providers` | Keep | Provider availability remains location-scoped; singular resource path retained. |
-| [x] 046 | `POST` | `/api/websearch` | `websearch.query` | Keep | Unknown provider remains an invalid request; published time documented as Unix epoch milliseconds. |
-
-## Group 4: Session lifecycle
-
-**Endpoints:** 12
-
-| Done | Method | Path | Operation ID | Decision | Notes |
-|---|---|---|---|---|---|
-| [x] 047 | `GET` | `/api/session` | `session.list` | Keep | Existing filtering, ordering, and cursor contract retained for now. |
-| [x] 048 | `POST` | `/api/session` | `session.create` | Keep | Existing creation contract retained; model reference includes optional variant. |
-| [x] 049 | `GET` | `/api/experimental/session/stats` | `experimental.session.stats` | Experimental-only | Session analytics retained outside the stable API commitment. |
-| [x] 050 | `GET` | `/api/session/active` | `session.active` | Keep | Status record retained for future active-state expansion. |
-| [x] 051 | `GET` | `/api/session/{sessionID}` | `session.get` | Keep | Specific session read and typed `404` retained. |
-| [x] 052 | `DELETE` | `/api/session/{sessionID}` | `session.remove` | Keep | Session and child deletion with typed `404` retained. |
-| [x] 053 | `POST` | `/api/session/{sessionID}/fork` | `session.fork` | Change | Request now accepts optional branded `before` message ID; omission copies full history. |
-| [ ] 054 | `POST` | `/api/session/{sessionID}/agent` | `session.switchAgent` |  |  |
-| [ ] 055 | `POST` | `/api/session/{sessionID}/model` | `session.switchModel` |  |  |
-| [ ] 056 | `POST` | `/api/session/{sessionID}/rename` | `session.rename` |  |  |
-| [ ] 057 | `POST` | `/api/session/{sessionID}/move` | `session.move` |  |  |
-| [ ] 058 | `POST` | `/api/session/{sessionID}/background` | `session.background` |  |  |
-
-## Group 5: Session execution and inputs
-
-**Endpoints:** 11
-
-| Done | Method | Path | Operation ID | Decision | Notes |
-|---|---|---|---|---|---|
-| [ ] 059 | `POST` | `/api/session/{sessionID}/prompt` | `session.prompt` |  |  |
-| [ ] 060 | `POST` | `/api/session/{sessionID}/command` | `session.command` |  |  |
-| [ ] 061 | `POST` | `/api/session/{sessionID}/skill` | `session.skill` |  |  |
-| [ ] 062 | `POST` | `/api/session/{sessionID}/synthetic` | `session.synthetic` |  |  |
-| [ ] 063 | `POST` | `/api/session/{sessionID}/shell` | `session.shell` |  |  |
-| [ ] 064 | `POST` | `/api/session/{sessionID}/compact` | `session.compact` |  |  |
-| [ ] 065 | `POST` | `/api/session/{sessionID}/wait` | `session.wait` |  |  |
-| [ ] 066 | `POST` | `/api/session/{sessionID}/generate` | `session.generate` |  |  |
-| [ ] 067 | `POST` | `/api/session/{sessionID}/interrupt` | `session.interrupt` |  |  |
-| [ ] 068 | `PUT` | `/api/session/{sessionID}/environment` | `session.environment` |  |  |
-| [ ] 069 | `POST` | `/api/session/{sessionID}/view` | `session.view` |  |  |
-
-## Group 6: Session history and recovery
-
-**Endpoints:** 13
-
-| Done | Method | Path | Operation ID | Decision | Notes |
-|---|---|---|---|---|---|
-| [ ] 070 | `POST` | `/api/session/import` | `session.import` |  |  |
-| [ ] 071 | `GET` | `/api/session/{sessionID}/export` | `session.export` |  |  |
-| [ ] 072 | `POST` | `/api/session/{sessionID}/revert/stage` | `session.revert.stage` |  |  |
-| [ ] 073 | `POST` | `/api/session/{sessionID}/revert/clear` | `session.revert.clear` |  |  |
-| [ ] 074 | `POST` | `/api/session/{sessionID}/revert/commit` | `session.revert.commit` |  |  |
-| [ ] 075 | `GET` | `/api/session/{sessionID}/context` | `session.context` |  |  |
-| [ ] 076 | `GET` | `/api/session/{sessionID}/diff` | `session.diff` |  |  |
-| [ ] 077 | `GET` | `/api/session/{sessionID}/instructions/entries` | `session.instructions.entry.list` |  |  |
-| [ ] 078 | `PUT` | `/api/session/{sessionID}/instructions/entries/{key}` | `session.instructions.entry.put` |  |  |
-| [ ] 079 | `DELETE` | `/api/session/{sessionID}/instructions/entries/{key}` | `session.instructions.entry.remove` |  |  |
-| [ ] 080 | `GET` | `/api/experimental/session/{sessionID}/log` | `session.log` |  |  |
-| [ ] 081 | `GET` | `/api/session/{sessionID}/message/{messageID}` | `session.message` |  |  |
-| [ ] 082 | `GET` | `/api/session/{sessionID}/message` | `message.list` |  |  |
-
-## Group 7: Inbox, permissions, and forms
-
-**Endpoints:** 19
-
-| Done | Method | Path | Operation ID | Decision | Notes |
-|---|---|---|---|---|---|
-| [ ] 083 | `GET` | `/api/session/{sessionID}/inbox` | `session.inbox.list` |  |  |
-| [ ] 084 | `DELETE` | `/api/session/{sessionID}/inbox/{inboxID}` | `session.inbox.cancel` |  |  |
-| [ ] 085 | `POST` | `/api/session/{sessionID}/inbox/{inboxID}/steer` | `session.inbox.steer` |  |  |
-| [ ] 086 | `POST` | `/api/session/{sessionID}/inbox/{inboxID}/queue` | `session.inbox.queue` |  |  |
-| [ ] 087 | `GET` | `/api/form/request` | `form.request.list` |  |  |
-| [ ] 088 | `GET` | `/api/session/{sessionID}/form` | `session.form.list` |  |  |
-| [ ] 089 | `POST` | `/api/session/{sessionID}/form` | `session.form.create` |  |  |
-| [ ] 090 | `GET` | `/api/session/{sessionID}/form/{formID}` | `session.form.get` |  |  |
-| [ ] 091 | `GET` | `/api/session/{sessionID}/form/{formID}/state` | `session.form.state` |  |  |
-| [ ] 092 | `POST` | `/api/session/{sessionID}/form/{formID}/reply` | `session.form.reply` |  |  |
-| [ ] 093 | `POST` | `/api/session/{sessionID}/form/{formID}/cancel` | `session.form.cancel` |  |  |
-| [ ] 094 | `GET` | `/api/permission/request` | `permission.request.list` |  |  |
-| [ ] 095 | `GET` | `/api/permission/saved` | `permission.saved.list` |  |  |
-| [ ] 096 | `DELETE` | `/api/permission/saved/{id}` | `permission.saved.remove` |  |  |
-| [ ] 097 | `POST` | `/api/session/{sessionID}/permission` | `session.permission.create` |  |  |
-| [ ] 098 | `GET` | `/api/session/{sessionID}/permission` | `session.permission.list` |  |  |
-| [ ] 099 | `GET` | `/api/session/{sessionID}/permission/{requestID}` | `session.permission.get` |  |  |
-| [ ] 100 | `POST` | `/api/session/{sessionID}/permission/{requestID}/reply` | `session.permission.reply` |  |  |
-| [ ] 101 | `PUT` | `/api/session/{sessionID}/permission/rules` | `session.permission.rules` |  |  |
-
-## Group 8: Filesystem, worktrees, and VCS
-
-**Endpoints:** 12
-
-| Done | Method | Path | Operation ID | Decision | Notes |
-|---|---|---|---|---|---|
-| [ ] 102 | `GET` | `/api/fs/read/*` | `fs.read` |  |  |
-| [ ] 103 | `GET` | `/api/fs/list` | `fs.list` |  |  |
-| [ ] 104 | `GET` | `/api/fs/find` | `fs.find` |  |  |
-| [ ] 105 | `GET` | `/api/worktree` | `worktree.list` |  |  |
-| [ ] 106 | `POST` | `/api/worktree` | `worktree.create` |  |  |
-| [ ] 107 | `DELETE` | `/api/worktree` | `worktree.remove` |  |  |
-| [ ] 108 | `POST` | `/api/worktree/refresh` | `worktree.refresh` |  |  |
-| [ ] 109 | `GET` | `/api/vcs` | `vcs.get` |  |  |
-| [ ] 110 | `GET` | `/api/vcs/base` | `vcs.base` |  |  |
-| [ ] 111 | `GET` | `/api/vcs/status` | `vcs.status` |  |  |
-| [ ] 112 | `GET` | `/api/vcs/branches` | `vcs.branches` |  |  |
-| [ ] 113 | `GET` | `/api/vcs/diff` | `vcs.diff` |  |  |
-
-## Group 9: PTYs, persistent terminals, and shells
-
-**Endpoints:** 24
-
-| Done | Method | Path | Operation ID | Decision | Notes |
-|---|---|---|---|---|---|
-| [ ] 114 | `GET` | `/api/pty` | `pty.list` |  |  |
-| [ ] 115 | `POST` | `/api/pty` | `pty.create` |  |  |
-| [ ] 116 | `GET` | `/api/pty/{ptyID}` | `pty.get` |  |  |
-| [ ] 117 | `PUT` | `/api/pty/{ptyID}` | `pty.update` |  |  |
-| [ ] 118 | `DELETE` | `/api/pty/{ptyID}` | `pty.remove` |  |  |
-| [ ] 119 | `POST` | `/api/pty/{ptyID}/connect-token` | `pty.connect.token` |  |  |
-| [ ] 120 | `GET` | `/api/pty/{ptyID}/connect` | `pty.connect` |  |  |
-| [ ] 121 | `GET` | `/api/experimental/session/{sessionID}/terminal/read` | `server.experimental.persistentPty.read` |  |  |
-| [ ] 122 | `GET` | `/api/experimental/session/{sessionID}/terminal` | `server.experimental.persistentPty.list` |  |  |
-| [ ] 123 | `POST` | `/api/experimental/session/{sessionID}/terminal` | `server.experimental.persistentPty.create` |  |  |
-| [ ] 124 | `POST` | `/api/experimental/persistent-pty/shutdown` | `server.experimental.persistentPty.shutdown` |  |  |
-| [ ] 125 | `POST` | `/api/experimental/persistent-pty/handoff` | `server.experimental.persistentPty.handoff` |  |  |
-| [ ] 126 | `GET` | `/api/experimental/persistent-pty/{ptyID}` | `server.experimental.persistentPty.get` |  |  |
-| [ ] 127 | `PUT` | `/api/experimental/persistent-pty/{ptyID}` | `server.experimental.persistentPty.update` |  |  |
-| [ ] 128 | `DELETE` | `/api/experimental/persistent-pty/{ptyID}` | `server.experimental.persistentPty.remove` |  |  |
-| [ ] 129 | `GET` | `/api/experimental/persistent-pty/{ptyID}/snapshot` | `server.experimental.persistentPty.snapshot` |  |  |
-| [ ] 130 | `POST` | `/api/experimental/persistent-pty/{ptyID}/connect-token` | `server.experimental.persistentPty.connectToken` |  |  |
-| [ ] 131 | `GET` | `/api/experimental/persistent-pty/{ptyID}/connect` | `persistentPty.connect` |  |  |
-| [ ] 132 | `GET` | `/api/shell` | `shell.list` |  |  |
-| [ ] 133 | `POST` | `/api/shell` | `shell.create` |  |  |
-| [ ] 134 | `GET` | `/api/shell/{id}` | `shell.get` |  |  |
-| [ ] 135 | `DELETE` | `/api/shell/{id}` | `shell.remove` |  |  |
-| [ ] 136 | `PATCH` | `/api/shell/{id}/timeout` | `shell.timeout` |  |  |
-| [ ] 137 | `GET` | `/api/shell/{id}/output` | `shell.output` |  |  |
-
-## Group 10: Events, RPC, and experimental operations
-
-**Endpoints:** 6
-
-| Done | Method | Path | Operation ID | Decision | Notes |
-|---|---|---|---|---|---|
-| [ ] 138 | `POST` | `/api/generate` | `generate.text` |  |  |
-| [ ] 139 | `POST` | `/api/rpc/{rpcID}/{method}` | `rpc.call` |  |  |
-| [ ] 140 | `GET` | `/api/event` | `event.subscribe` |  |  |
-| [ ] 141 | `GET` | `/api/debug/location` | `debug.location.list` |  |  |
-| [ ] 142 | `DELETE` | `/api/debug/location` | `debug.location.evict` |  |  |
-| [ ] 143 | `GET` | `/api/experimental/migration/v1` | `experimental.migration.v1.status` |  |  |

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/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

@@ -1,7 +1,6 @@
 #!/usr/bin/env bash
 set -euo pipefail
-APP=opencode
-SOURCE_APP=opencode
+APP=opencode2
 
 MUTED='\033[0;2m'
 RED='\033[0;31m'
@@ -23,7 +22,7 @@ Options:
 Examples:
     curl -fsSL https://opencode.ai/v2/install | bash
     curl -fsSL https://opencode.ai/v2/install | bash -s -- --version 0.0.0-beta-17236
-    ./install --binary /path/to/opencode
+    ./install --binary /path/to/opencode2
 EOF
 }
 
@@ -166,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}"
@@ -202,9 +193,9 @@ else
 
     filename="cli-$target-$specific_version.tgz"
     url="https://registry.npmjs.org/$package_name/-/$filename"
-    binary_name="$SOURCE_APP"
+    binary_name="$APP"
     if [ "$os" = "windows" ]; then
-        binary_name="$SOURCE_APP.exe"
+        binary_name="$APP.exe"
     fi
 fi
 
@@ -231,7 +222,12 @@ check_version() {
         installed_version="${installed_version##* }"
         installed_version="${installed_version#v}"
 
-        print_message info "${MUTED}Installed version: ${NC}$installed_version."
+        if [[ "$installed_version" != "$specific_version" ]]; then
+            print_message info "${MUTED}Installed version: ${NC}$installed_version."
+        else
+            print_message info "${MUTED}Version ${NC}$specific_version${MUTED} already installed"
+            exit 0
+        fi
     fi
 }
 
@@ -336,46 +332,15 @@ download_and_install() {
     fi
 
     tar -xzf "$tmp_dir/$filename" -C "$tmp_dir"
-    local installed_binary="$APP"
-    if [ "$os" = "windows" ]; then
-        installed_binary="$APP.exe"
-    fi
-    mv "$tmp_dir/package/bin/$binary_name" "$INSTALL_DIR/$installed_binary"
-    chmod 755 "$INSTALL_DIR/$installed_binary"
+    mv "$tmp_dir/package/bin/$binary_name" "$INSTALL_DIR"
+    chmod 755 "${INSTALL_DIR}/$binary_name"
     rm -rf "$tmp_dir"
 }
 
 install_from_binary() {
     print_message info "\n${MUTED}Installing ${NC}$APP ${MUTED}from: ${NC}$binary_path"
-    local installed_binary="$APP"
-    case "$(uname -s)" in
-        MINGW*|MSYS*|CYGWIN*) installed_binary="$APP.exe" ;;
-    esac
-    cp "$binary_path" "$INSTALL_DIR/$installed_binary"
-    chmod 755 "$INSTALL_DIR/$installed_binary"
-}
-
-install_legacy_shim() {
-    local shim_os="${os:-}"
-    if [[ -z "$shim_os" ]]; then
-        case "$(uname -s)" in
-            MINGW*|MSYS*|CYGWIN*) shim_os="windows" ;;
-        esac
-    fi
-    rm -f "$INSTALL_DIR/opencode2" "$INSTALL_DIR/opencode2.exe" "$INSTALL_DIR/opencode2.cmd"
-    if [[ "$shim_os" == "windows" ]]; then
-        cat > "$INSTALL_DIR/opencode2.cmd" <<'EOF'
-@echo off
-"%~dp0opencode.exe" %*
-exit /b %errorlevel%
-EOF
-        return
-    fi
-    cat > "$INSTALL_DIR/opencode2" <<'EOF'
-#!/bin/sh
-exec "$(dirname "$0")/opencode" "$@"
-EOF
-    chmod 755 "$INSTALL_DIR/opencode2"
+    cp "$binary_path" "${INSTALL_DIR}/$APP"
+    chmod 755 "${INSTALL_DIR}/$APP"
 }
 
 if [ -n "$binary_path" ]; then
@@ -384,7 +349,6 @@ else
     check_version
     download_and_install
 fi
-install_legacy_shim
 
 
 add_to_path() {
@@ -481,7 +445,7 @@ echo -e ""
 echo -e "${MUTED}OpenCode includes free models, to start:${NC}"
 echo -e ""
 echo -e "cd <project>  ${MUTED}# Open directory${NC}"
-echo -e "opencode      ${MUTED}# Run command${NC}"
+echo -e "opencode2     ${MUTED}# Run command${NC}"
 echo -e ""
 echo -e "${MUTED}For more information visit ${NC}https://opencode.ai/v2/docs"
 echo -e ""

nix/desktop.nix

@@ -88,9 +88,9 @@ 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/", ""))')
+    cli_package=$(bun -e 'import { getCurrentCli } from "./scripts/utils.ts"; console.log(getCurrentCli().package.replace("@opencode-ai/", ""))')
     mkdir -p "$OPENCODE_CLI_DIST/$cli_package/bin"
-    cp ${lib.getExe opencode} "$OPENCODE_CLI_DIST/$cli_package/bin/opencode"
+    cp ${lib.getExe opencode} "$OPENCODE_CLI_DIST/$cli_package/bin/opencode2"
 
     bun run build
     npx electron-builder --dir \

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-euVUyj0CzjCA1nYbN2vKctEPzLkUlNGTK2dMNbackqM=",
-    "aarch64-linux": "sha256-qQkjqaxpjAae+rohoWI601QnrgKYghJ+ttqeiQBTwCM=",
-    "aarch64-darwin": "sha256-HYWs31TJlDZsDBNmbPARo16r7zNKy9x840uHGcUMYsk=",
-    "x86_64-darwin": "sha256-89FOrX813FENk3u8RAHCfyD7voaZWW++Z4Gpa3SkOJs="
+    "x86_64-linux": "sha256-T1JUv8gUrXavDI1HdVGqNRal4y2Bh5QavpR4DV+bJdA=",
+    "aarch64-linux": "sha256-wlbWdEUVWAafgxaZis0Q+SAas8k6hu3s0C39CnMZ2gw=",
+    "aarch64-darwin": "sha256-74rRue8KQWKzgMMb540beqMzp1DUShlPte6qklYCVTs=",
+    "x86_64-darwin": "sha256-ihr3DoLd/4Lw6WbyXzSQXMP4hrVGk/UiRkO2aoQn8vg="
   }
 }

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
       ]
     );
   };

nix/opencode.nix

@@ -8,7 +8,6 @@
   makeBinaryWrapper,
   models-dev,
   ripgrep,
-  wayland,
   installShellFiles,
   versionCheckHook,
   writableTmpDirAsHomeHook,
@@ -63,10 +62,9 @@ stdenvNoCC.mkDerivation (finalAttrs: {
   installPhase = ''
     runHook preInstall
 
-    install -Dm755 dist/cli-*/bin/opencode $out/bin/opencode
+    install -Dm755 dist/cli-*/bin/opencode2 $out/bin/opencode2
 
-    # OpenTUI dlopens Wayland for clipboard images.
-    wrapProgram $out/bin/opencode \
+    wrapProgram $out/bin/opencode2 \
       --prefix PATH : ${
         lib.makeBinPath (
           [
@@ -75,21 +73,13 @@ stdenvNoCC.mkDerivation (finalAttrs: {
           # bun runs sysctl to detect if running on rosetta2
           ++ lib.optional stdenvNoCC.hostPlatform.isDarwin sysctl
         )
-      } ${lib.optionalString stdenvNoCC.hostPlatform.isLinux ''
-        --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ wayland ]}
-      ''}
-
-    ln -s opencode $out/bin/opencode2
+      }
 
     runHook postInstall
   '';
 
   postInstall = lib.optionalString (stdenvNoCC.buildPlatform.canExecute stdenvNoCC.hostPlatform) ''
     # trick yargs into also generating zsh completions
-    installShellCompletion --cmd opencode \
-      --bash <($out/bin/opencode completion) \
-      --zsh <(SHELL=/bin/zsh $out/bin/opencode completion)
-
     installShellCompletion --cmd opencode2 \
       --bash <($out/bin/opencode2 completion) \
       --zsh <(SHELL=/bin/zsh $out/bin/opencode2 completion)
@@ -111,7 +101,7 @@ stdenvNoCC.mkDerivation (finalAttrs: {
     description = "The open source coding agent";
     homepage = "https://opencode.ai";
     license = lib.licenses.mit;
-    mainProgram = "opencode";
+    mainProgram = "opencode2";
     inherit (node_modules.meta) platforms;
   };
 })

package.json

@@ -2,20 +2,18 @@
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode",
   "description": "AI-powered development tool",
-  "version": "2.0.3",
+  "version": "0.0.0",
   "private": true,
   "type": "module",
   "packageManager": "bun@1.4.2",
   "scripts": {
     "dev": "bun run --cwd packages/cli src/index.ts",
-    "dev:live": "sh -c 'OPENCODE_TUI_CHANNEL=dev OPENCODE_PASSWORD=\"$(opencode service get password)\" exec bun run dev \"$@\" --server \"$(opencode 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=\"$(opencode service get password)\" exec bun run dev:vite \"$@\" --server \"$(opencode service status)\"' --",
+    "dev:live": "sh -c 'OPENCODE_TUI_CHANNEL=dev OPENCODE_PASSWORD=\"$(opencode2 service get password)\" exec 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",
@@ -24,7 +22,6 @@
     "test:lint-rules": "ast-grep test -c script/ast-grep/sgconfig.yml",
     "test:effect-simplification-rules": "ast-grep test -c script/ast-grep/effect-simplifications/sgconfig.yml",
     "typecheck": "bun turbo typecheck --concurrency=3",
-    "check": "bun run lint && bun run typecheck",
     "typecheck:profile": "bun script/profile-typecheck.ts",
     "typecheck:profile:packages": "bun script/profile-typecheck-packages.ts",
     "upgrade-opentui": "bun run script/upgrade-opentui.ts",
@@ -37,7 +34,6 @@
   "workspaces": {
     "packages": [
       "packages/*",
-      "services/*",
       "packages/console/*",
       "packages/stats/*"
     ],
@@ -116,7 +112,6 @@
   "devDependencies": {
     "@actions/artifact": "5.0.1",
     "@ast-grep/cli": "0.44.0",
-    "@opencode/client": "workspace:*",
     "@types/react": "19.2.17",
     "@types/react-dom": "19.2.3",
     "@tsconfig/bun": "catalog:",
@@ -133,8 +128,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:"
   },
@@ -176,10 +171,10 @@
     "pacote@21.5.0": "patches/pacote@21.5.0.patch",
     "@ai-sdk/google@3.0.73": "patches/@ai-sdk%2Fgoogle@3.0.73.patch",
     "@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",
-    "@modelcontextprotocol/client@2.0.0": "patches/@modelcontextprotocol%2Fclient@2.0.0.patch"
+    "vite@8.2.2": "patches/vite@8.2.2.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,6 +81,8 @@ 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.
 
+LLM `ProviderMetadata` is indexed by the selected `LanguageModel.route.id`. Use that same route ID when emitting usage, reasoning signatures, item IDs, and hosted-tool state and when reading them for continuation. There is no independently configurable metadata namespace. Reassigning a provider does not rename the route or its metadata; changing the route ID changes both. Provider-specific APIs with different replay formats must have distinct route IDs.
+
 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.
 
 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.
@@ -122,14 +123,13 @@ Keep provider facades small and explicit:
 
 ### 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 one flat serializable object: the connection keys the entrypoint declares (`apiKey`, `baseURL`, `region`, …), the common `headers` and `body` overlays, and the protocol's request options (`reasoningEffort`, `thinking`, …) side by side. Each entrypoint destructures its own connection keys and passes the rest to the route as `providerOptions`; there is no nested `providerOptions` at the entrypoint.
+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,
-  reasoningEffort: "high",
 })
 ```
 

packages/ai/README.md

@@ -1,12 +1,12 @@
-# @opencode/ai
+# @opencode-ai/ai
 
 Schema-first language model and image-generation APIs built with Effect.
 
 ```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,323 +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.
 
-## Alibaba Cloud Model Studio
-
-`Alibaba` provides standard Model Studio inference. Configure a region explicitly, then select
-Chat Completions (`.model` or `.chat`), Anthropic-compatible Messages (`.messages`), or OpenAI-compatible
-Responses (`.responses`). These routes use HTTP/SSE.
-
-```ts
-import { LLM } from "@opencode/ai"
-import { Alibaba } from "@opencode/ai/providers"
-
-const alibaba = Alibaba.configure({
-  region: "ap-southeast-1", // Singapore
-  apiKey: process.env.DASHSCOPE_API_KEY,
-  // workspaceID: "llm-your-workspace", // use a workspace-dedicated endpoint
-})
-
-const request = LLM.request({
-  model: alibaba.model("qwen3.8-max"),
-  prompt: "Explain this design.",
-  providerOptions: { reasoningEffort: "medium" },
-})
-```
-
-### Regions and credentials
-
-| Region              | `region`         | Shared host when `workspaceID` is omitted |
-| ------------------- | ---------------- | ----------------------------------------- |
-| Singapore           | `ap-southeast-1` | `dashscope-intl.aliyuncs.com`             |
-| China (Beijing)     | `cn-beijing`     | `dashscope.aliyuncs.com`                  |
-| China (Hong Kong)   | `cn-hongkong`    | `cn-hongkong.dashscope.aliyuncs.com`      |
-| US (Virginia)       | `us-east-1`      | `dashscope-us.aliyuncs.com`               |
-| Germany (Frankfurt) | `eu-central-1`   | Supply `workspaceID` or `baseURL`         |
-| Japan (Tokyo)       | `ap-northeast-1` | Supply `workspaceID` or `baseURL`         |
-
-With `workspaceID`, the host is `{workspaceID}.{region}.maas.aliyuncs.com`. A complete `baseURL`
-overrides regional setup, including the API prefix: `/compatible-mode/v1` for Chat/Responses,
-or `/apps/anthropic/v1` for Messages. The selector appends its operation path.
-
-Keys and model availability are region-specific. Auth resolves from explicit `auth` or `apiKey`,
-then `DASHSCOPE_API_KEY`, then `ALIBABA_API_KEY`.
-
-The access region and inference scope differ: Virginia's `-us` model IDs request US-only inference;
-some regions select scope through their workspace. Model IDs pass through unchanged.
-Alibaba's [regional guide](https://www.alibabacloud.com/help/en/model-studio/regions) and
-[base URL table](https://www.alibabacloud.com/help/en/model-studio/base-url) disagree about Virginia's
-shared host; the entry above follows the base URL table. Dedicated hosts can be copied from the console.
-
-### Native options
-
-- **Chat:** `reasoningEffort` → `reasoning_effort`, `enableThinking` → `enable_thinking`,
-  `thinkingBudget` → `thinking_budget`, and `preserveThinking` → `preserve_thinking`.
-  Replay complete `response.message` values to retain `reasoning_content` separately from answer text.
-  Qwen 3.8 defaults to preserving thinking; older models have different defaults.
-  Additional options include `toolStream`, `parallelToolCalls`, `repetitionPenalty`, `responseFormat`,
-  `enableSearch`, and native `searchOptions`. `generation.topK` lowers to `top_k`.
-  `clearThinking` is a hosted GLM control, and `thinking.type` is available for hosted MiniMax models.
-- **Messages:** `effort` → `output_config.effort`. `thinking.type` accepts enabled/disabled with an
-  optional `budgetTokens` (or native `budget_tokens`). `outputConfig.format` accepts a JSON schema.
-  Model Studio's empty thinking signatures are accepted; supplied signatures are replayed unchanged.
-- **Responses:** `reasoningEffort` → `reasoning.effort`, plus `enableThinking`, `store`,
-  `previousResponseId`, and `conversation`. Omitted `store` retains the API's default (`true`);
-  set it to `false` for client-managed history. `previousResponseId` requires a stored response.
-  Hosted tools are `Alibaba.webSearch()`, `Alibaba.webExtractor()`, and `Alibaba.codeInterpreter()`.
-  Web extraction is used together with web search. Hosted calls/results carry `providerExecuted: true`.
-
-Omitted options preserve provider defaults. Effort values pass through unchanged and accept future
-strings. Qwen 3.8 Chat rejects requests combining a thinking budget with effort.
-
-Package entrypoints are `@opencode/ai/providers/alibaba`, `alibaba/chat`, `alibaba/messages`,
-and `alibaba/responses`. Live recordings cover all three APIs in Singapore; regional URL construction
-is unit-tested for all six regions.
-
-## 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({
@@ -441,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({
@@ -517,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
@@ -633,8 +323,8 @@ This capability describes protocol implementation, **not universal availability
 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"),
@@ -654,7 +344,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..." })
@@ -760,7 +450,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({
@@ -774,7 +464,7 @@ Included LLM providers: OpenAI, Anthropic, Google (Gemini), Google Vertex, Amazo
 Each named provider owns its module, endpoint, authentication, and route setup. Providers with the same wire format compose the shared protocol directly:
 
 ```ts
-import { DeepSeek, Fireworks } from "@opencode/ai/providers"
+import { DeepSeek, Fireworks } from "@opencode-ai/ai/providers"
 
 const deepseek = DeepSeek.configure({ apiKey }).model("deepseek-chat")
 const fireworks = Fireworks.configure({ apiKey }).model("accounts/fireworks/models/my-model")
@@ -784,10 +474,10 @@ The former `OpenAICompatible.baseten`, `.cerebras`, `.deepinfra`, `.deepseek`, `
 
 ### 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.
+Provider modules are available through dedicated exports from `@opencode-ai/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,
@@ -797,14 +487,14 @@ const selected = model("gpt-5", {
 
 APIs have separate 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.
 
@@ -813,36 +503,65 @@ 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:
 
-- `@opencode/ai/providers/baseten`
-- `@opencode/ai/providers/deepseek`
-- `@opencode/ai/providers/fireworks`
-- `@opencode/ai/providers/cloudflare-ai-gateway`
-- `@opencode/ai/providers/cloudflare-workers-ai`
+- `@opencode-ai/ai/providers/baseten`
+- `@opencode-ai/ai/providers/deepseek`
+- `@opencode-ai/ai/providers/fireworks`
+- `@opencode-ai/ai/providers/cloudflare-ai-gateway`
+- `@opencode-ai/ai/providers/cloudflare-workers-ai`
+
+### Route-keyed metadata
+
+LLM messages, events, and usage retain provider-specific information under `providerMetadata[model.route.id]`. The provider ID identifies the provider; the route ID identifies its API and owns the metadata needed to replay that API's responses.
+
+```ts
+const model = GoogleVertexMessages.configure({ project, accessToken }).model("claude-sonnet-4-5")
+const response = yield * LLM.generate(LLM.request({ model, prompt: "Think through this problem." }))
+const reasoning = response.message.content.find((part) => part.type === "reasoning")
+const signature = reasoning?.providerMetadata?.[model.route.id]?.signature
+// model.route.id === "google-vertex-messages"
+```
+
+The former `providerMetadataKey` route option has been removed. Existing application-owned LLM metadata must use route keys instead of provider names, for example:
+
+| API                                                                | Metadata key                                                                                                 |
+| ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------ |
+| OpenAI Chat / Responses                                            | `openai-chat` / `openai-responses`                                                                           |
+| Azure Chat / Responses                                             | `azure-openai-chat` / `azure-openai-responses`                                                               |
+| Anthropic Messages                                                 | `anthropic-messages`                                                                                         |
+| Google Gemini                                                      | `gemini`                                                                                                     |
+| Vertex Gemini / Chat / Responses / Messages                        | `google-vertex-gemini` / `google-vertex-chat` / `google-vertex-responses` / `google-vertex-messages`         |
+| Bedrock Converse / Mantle Chat / Mantle Responses                  | `bedrock-converse` / `bedrock-mantle-chat` / `bedrock-mantle-responses`                                      |
+| Groq / Mistral                                                     | `groq-chat` / `mistral-chat`                                                                                 |
+| xAI Chat / Responses                                               | `xai-chat` / `xai-responses`                                                                                 |
+| Baseten / Cerebras / DeepInfra / DeepSeek / Fireworks / TogetherAI | `baseten-chat` / `cerebras-chat` / `deepinfra-chat` / `deepseek-chat` / `fireworks-chat` / `togetherai-chat` |
+| Generic Chat / Responses                                           | `openai-compatible-chat` / `openai-compatible-responses`                                                     |
+
+OpenRouter and Cloudflare already use matching provider and route IDs. Generic Messages uses `anthropic-messages`. Custom routes use their own `id`.
 
 ## Provider options & HTTP overlays
 

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": "2.0.3",
-  "name": "@opencode/ai",
+  "version": "1.17.20",
+  "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
   "scripts": {
@@ -21,7 +21,7 @@
   "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:",
@@ -31,7 +31,7 @@
     "@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/src/protocols/alibaba-chat.ts

@@ -1,92 +0,0 @@
-import { Effect, Schema } from "effect"
-import { Protocol } from "../route/protocol.js"
-import type { LanguageModelCompatibility } from "../schema/index.js"
-import { OpenAIChat } from "./openai-chat.js"
-import { JsonObject, ProviderShared } from "./shared.js"
-import { OpenResponsesOptions } from "./utils/open-responses-options.js"
-
-export type ReasoningEffort = OpenResponsesOptions.ReasoningEffort
-
-const Options = Schema.Struct({
-  reasoningEffort: OpenResponsesOptions.Options.fields.reasoningEffort,
-  enableThinking: Schema.optional(Schema.Boolean),
-  thinkingBudget: Schema.optional(Schema.Int),
-  preserveThinking: Schema.optional(Schema.Boolean),
-  clearThinking: Schema.optional(Schema.Boolean),
-  thinking: Schema.optional(
-    Schema.Struct({
-      type: Schema.declare<"adaptive" | "disabled" | (string & {})>(Schema.is(Schema.String)),
-    }),
-  ),
-  toolStream: Schema.optional(Schema.Boolean),
-  parallelToolCalls: OpenResponsesOptions.Options.fields.parallelToolCalls,
-  repetitionPenalty: Schema.optional(Schema.Number),
-  responseFormat: Schema.optional(
-    Schema.Struct({
-      type: Schema.declare<"text" | "json_object" | "json_schema" | (string & {})>(Schema.is(Schema.String)),
-      json_schema: Schema.optional(JsonObject),
-    }),
-  ),
-  enableSearch: Schema.optional(Schema.Boolean),
-  searchOptions: Schema.optional(
-    Schema.Struct({
-      forced_search: Schema.optional(Schema.Boolean),
-      search_strategy: Schema.optional(
-        Schema.declare<"turbo" | "max" | "agent" | "agent_max" | (string & {})>(Schema.is(Schema.String)),
-      ),
-      enable_search_extension: Schema.optional(Schema.Boolean),
-    }),
-  ),
-})
-export type OptionsInput = typeof Options.Type
-
-export const compatibility = {
-  maxTokensField: "max_completion_tokens",
-  supportsStore: false,
-  supportsStrictMode: false,
-  reasoningField: "reasoning_content",
-  zaiToolStream: false,
-} satisfies LanguageModelCompatibility
-
-export const protocol = Protocol.make({
-  id: "alibaba-chat",
-  body: {
-    schema: Schema.Struct({
-      ...OpenAIChat.bodyFields,
-      enable_thinking: Options.fields.enableThinking,
-      thinking_budget: Options.fields.thinkingBudget,
-      preserve_thinking: Options.fields.preserveThinking,
-      clear_thinking: Options.fields.clearThinking,
-      thinking: Options.fields.thinking,
-      parallel_tool_calls: Options.fields.parallelToolCalls,
-      repetition_penalty: Options.fields.repetitionPenalty,
-      top_k: Schema.optional(Schema.Int),
-      response_format: Options.fields.responseFormat,
-      enable_search: Options.fields.enableSearch,
-      search_options: Options.fields.searchOptions,
-    }),
-    from: Effect.fn("AlibabaChat.fromRequest")(function* (req) {
-      const opts = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(req.providerOptions ?? {})
-      return {
-        ...(yield* OpenAIChat.protocol.body.from(req)),
-        enable_thinking: opts.enableThinking,
-        thinking_budget: opts.thinkingBudget,
-        preserve_thinking: opts.preserveThinking,
-        clear_thinking: opts.clearThinking,
-        thinking: opts.thinking,
-        tool_stream: opts.toolStream,
-        parallel_tool_calls:
-          opts.parallelToolCalls ??
-          (req.toolChoice?.disableParallelToolUse === undefined ? undefined : !req.toolChoice.disableParallelToolUse),
-        repetition_penalty: opts.repetitionPenalty,
-        top_k: req.generation?.topK,
-        response_format: opts.responseFormat,
-        enable_search: opts.enableSearch,
-        search_options: opts.searchOptions,
-      }
-    }),
-  },
-  stream: OpenAIChat.protocol.stream,
-})
-
-export * as AlibabaChat from "./alibaba-chat.js"

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

@@ -1,48 +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 { OpenResponsesOptions } from "./utils/open-responses-options.js"
-
-const Options = Schema.Struct({
-  effort: Schema.optional(OpenResponsesOptions.ReasoningEffort),
-  thinking: Schema.optional(
-    Schema.Struct({
-      type: Schema.declare<"enabled" | "disabled" | (string & {})>(Schema.is(Schema.String)),
-      budgetTokens: Schema.optional(Schema.Int),
-      budget_tokens: Schema.optional(Schema.Int),
-    }),
-  ),
-})
-export type OptionsInput = typeof Options.Type & Pick<AnthropicMessages.OptionsInput, "outputConfig">
-export const protocol = Protocol.make({
-  id: "alibaba-messages",
-  body: {
-    schema: Schema.Struct({
-      ...AnthropicMessages.AnthropicMessagesBody.fields,
-      thinking: Schema.optional(Schema.Struct({ type: Schema.String, budget_tokens: Schema.optional(Schema.Int) })),
-    }),
-    from: Effect.fn("AlibabaMessages.fromRequest")(function* (req) {
-      const opts = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(req.providerOptions ?? {})
-      // Model Studio accepts enabled thinking without Anthropic's mandatory token budget.
-      return {
-        ...(yield* AnthropicMessages.protocol.body.from(
-          LLMRequest.update(req, {
-            providerOptions: { ...req.providerOptions, thinking: undefined },
-          }),
-        )),
-        thinking:
-          opts.thinking === undefined
-            ? undefined
-            : {
-                type: opts.thinking.type,
-                budget_tokens: opts.thinking.budgetTokens ?? opts.thinking.budget_tokens,
-              },
-      }
-    }),
-  },
-  stream: AnthropicMessages.protocol.stream,
-})
-
-export * as AlibabaMessages from "./alibaba-messages.js"

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

@@ -1,98 +0,0 @@
-import { Effect, Schema } from "effect"
-import { Protocol } from "../route/protocol.js"
-import { OpenResponses } from "./open-responses.js"
-import { JsonObject, optionalArray, ProviderShared } from "./shared.js"
-import { OpenResponsesOptions } from "./utils/open-responses-options.js"
-import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
-
-const Options = Schema.Struct({
-  reasoningEffort: OpenResponsesOptions.Options.fields.reasoningEffort,
-  enableThinking: Schema.optional(Schema.Boolean),
-  store: OpenResponsesOptions.Options.fields.store,
-  previousResponseId: Schema.optional(Schema.String),
-  conversation: Schema.optional(Schema.String),
-})
-export type OptionsInput = typeof Options.Type
-const NativeTool = Schema.Struct({ type: Schema.Literals(["web_search", "web_extractor", "code_interpreter"]) })
-const WebExtractorItem = Schema.StructWithRest(
-  Schema.Struct({
-    type: Schema.Literal("web_extractor_call"),
-    id: Schema.String,
-    urls: Schema.optional(Schema.Array(Schema.String)),
-    goal: Schema.optional(Schema.String),
-  }),
-  [JsonObject],
-)
-const Body = Schema.Struct({
-  ...OpenResponses.coreFields,
-  input: Schema.Array(Schema.Union([OpenResponses.InputItem, WebExtractorItem])),
-  tools: optionalArray(Schema.Union([OpenResponses.Tool, NativeTool])),
-  enable_thinking: Options.fields.enableThinking,
-  previous_response_id: Options.fields.previousResponseId,
-  conversation: Options.fields.conversation,
-  stream: Schema.Literal(true),
-})
-const adapter = {
-  id: "alibaba-responses",
-  name: "Alibaba Responses",
-  nativeTool: (native) => ProviderShared.validateWith(Schema.decodeUnknownEffect(NativeTool))(native.alibaba),
-  restoreHostedToolItem: (item: unknown) => (Schema.is(WebExtractorItem)(item) ? item : undefined),
-} satisfies OpenResponses.ProviderAdapter
-
-const tools = {
-  web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
-  code_interpreter_call: { name: "code_interpreter", input: (item) => ({ code: item.code }) },
-} satisfies ResponsesHostedTools.Definitions
-
-export const protocol = Protocol.make({
-  id: adapter.id,
-  body: {
-    schema: Body,
-    from: Effect.fn("AlibabaResponses.fromRequest")(function* (req) {
-      const opts = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(req.providerOptions ?? {})
-      const body = yield* OpenResponses.fromRequestWithAdapter(req, adapter)
-      const choice = body.tool_choice
-      return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))({
-        ...body,
-        enable_thinking: opts.enableThinking,
-        previous_response_id: opts.previousResponseId,
-        conversation: opts.conversation,
-        // Model Studio expresses named selection through allowed_tools.
-        tool_choice:
-          typeof choice === "object" && choice.type === "function"
-            ? { type: "allowed_tools" as const, mode: "required" as const, tools: [choice] }
-            : choice,
-      })
-    }),
-  },
-  stream: {
-    event: OpenResponses.protocol.stream.event,
-    initial: (req) => OpenResponses.initial(req, adapter),
-    step: (state, input) =>
-      Effect.gen(function* () {
-        const event = OpenResponses.normalize(state, input)
-        if (event.type !== "response.output_item.done" || !event.item) return yield* OpenResponses.step(state, event)
-        if (event.item.type === "web_extractor_call") {
-          const item = yield* Schema.decodeUnknownEffect(WebExtractorItem)(event.item).pipe(
-            Effect.mapError((cause) =>
-              ProviderShared.eventError(
-                adapter.id,
-                "Alibaba returned an invalid web extraction item",
-                ProviderShared.encodeJson(event),
-                cause,
-              ),
-            ),
-          )
-          return yield* ResponsesHostedTools.onDone(state, item, {
-            web_extractor_call: { name: "web_extractor", input: () => ({ urls: item.urls, goal: item.goal }) },
-          })
-        }
-        if (ResponsesHostedTools.isItem(event.item, tools))
-          return yield* ResponsesHostedTools.onDone(state, event.item, tools)
-        return yield* OpenResponses.step(state, event)
-      }),
-    terminal: OpenResponses.terminal,
-  },
-})
-
-export * as AlibabaResponses from "./alibaba-responses.js"

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,24 +50,15 @@ 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 }
     ))
@@ -310,27 +301,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({
@@ -471,7 +455,7 @@ type AnthropicEvent = Schema.Schema.Type<typeof AnthropicEvent>
 interface ParserState {
   readonly provider: LLMRequest["model"]["provider"]
   readonly compactions: Readonly<Record<number, string | null>>
-  readonly providerMetadataKey: string
+  readonly routeID: string
   readonly tools: ToolStream.State<number>
   readonly reasoningSignatures: Readonly<Record<number, string>>
   readonly usage?: Usage
@@ -579,14 +563,14 @@ const serverToolResultType = (name: string): AnthropicServerToolResultType | und
 
 const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult")(function* (
   part: ToolResultPart,
-  providerMetadataKey: string,
+  routeID: string,
 ) {
   const wireType = serverToolResultType(part.name)
   if (!wireType)
     return yield* invalid(`Anthropic Messages does not know how to round-trip server tool result for ${part.name}`)
   // Prefer the provider-owned replay payload; fall back to the result value for
   // histories constructed directly from provider events.
-  const payload = part.providerMetadata?.[providerMetadataKey]?.["result"] ?? part.result.value
+  const payload = part.providerMetadata?.[routeID]?.["result"] ?? part.result.value
   return {
     type: wireType,
     tool_use_id: scrubToolCallID(part.id),
@@ -873,7 +857,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
   breakpoints: Cache.Breakpoints,
 ) {
   const messages: AnthropicMessage[] = []
-  const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider)
+  const routeID = request.model.route.id
 
   for (const [index, message] of request.messages.entries()) {
     if (message.role === "system") {
@@ -927,8 +911,8 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
         if (part.type === "reasoning") {
           // A signature marks visible thinking; only signature-less parts carrying
           // redactedData round-trip as opaque redacted_thinking blocks.
-          const signature = part.encrypted ?? signatureFromMetadata(part.providerMetadata, providerMetadataKey)
-          const redactedData = redactedDataFromMetadata(part.providerMetadata, providerMetadataKey)
+          const signature = part.encrypted ?? signatureFromMetadata(part.providerMetadata, routeID)
+          const redactedData = redactedDataFromMetadata(part.providerMetadata, routeID)
           if (signature === undefined && redactedData !== undefined) {
             content.push({ type: "redacted_thinking", data: redactedData })
             continue
@@ -957,7 +941,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
           continue
         }
         if (part.type === "tool-result" && part.providerExecuted) {
-          content.push(yield* lowerServerToolResult(part, providerMetadataKey))
+          content.push(yield* lowerServerToolResult(part, routeID))
           continue
         }
         return yield* invalid(
@@ -1041,9 +1025,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 +1037,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 +1054,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) {
@@ -1191,7 +1148,7 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 // inclusive `inputTokens` the rest of the contract expects. Extended
 // thinking tokens are included in `output_tokens`; newer responses also
 // expose that subset through `output_tokens_details.thinking_tokens`.
-const mapUsage = (usage: AnthropicUsage | undefined, providerMetadataKey: string): Usage | undefined => {
+const mapUsage = (usage: AnthropicUsage | undefined, routeID: string): Usage | undefined => {
   if (!usage) return undefined
   const iterations = usage.iterations?.length ? usage.iterations : [usage]
   const last = usage.iterations?.at(-1)
@@ -1218,7 +1175,7 @@ const mapUsage = (usage: AnthropicUsage | undefined, providerMetadataKey: string
     cacheWriteInputTokens: cacheWrite,
     reasoningTokens: ProviderShared.sumTokens(...iterations.map((item) => item.output_tokens_details?.thinking_tokens)),
     totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
-    providerMetadata: { [providerMetadataKey]: usage },
+    providerMetadata: { [routeID]: usage },
   })
 }
 
@@ -1227,7 +1184,7 @@ const mapUsage = (usage: AnthropicUsage | undefined, providerMetadataKey: string
 // field prefers `right` when defined, falls back to `left`. `inputTokens` is
 // recomputed from the merged breakdown so the inclusive total stays
 // consistent with `nonCached + cacheRead + cacheWrite`.
-const mergeUsage = (left: Usage | undefined, right: Usage | undefined, providerMetadataKey: string) => {
+const mergeUsage = (left: Usage | undefined, right: Usage | undefined, routeID: string) => {
   if (!left) return right
   if (!right) return left
   const nonCachedInputTokens = right.nonCachedInputTokens ?? left.nonCachedInputTokens
@@ -1246,9 +1203,7 @@ const mergeUsage = (left: Usage | undefined, right: Usage | undefined, providerM
     reasoningTokens,
     totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
     providerMetadata: {
-      [providerMetadataKey]:
-        mergeJsonRecords(left.providerMetadata?.[providerMetadataKey], right.providerMetadata?.[providerMetadataKey]) ??
-        {},
+      [routeID]: mergeJsonRecords(left.providerMetadata?.[routeID], right.providerMetadata?.[routeID]) ?? {},
     },
   })
 }
@@ -1266,7 +1221,7 @@ const SERVER_TOOL_RESULT_NAMES: Record<AnthropicServerToolResultType, string> =
 
 const isServerToolResultType = (type: string): type is AnthropicServerToolResultType => type in SERVER_TOOL_RESULT_NAMES
 
-const serverToolResultEvent = (block: AnthropicStreamBlock, providerMetadataKey: string): LLMEvent | undefined => {
+const serverToolResultEvent = (block: AnthropicStreamBlock, routeID: string): LLMEvent | undefined => {
   if (!block.type || !isServerToolResultType(block.type)) return undefined
   const errorPayload =
     typeof block.content === "object" && block.content !== null && "type" in block.content
@@ -1280,7 +1235,7 @@ const serverToolResultEvent = (block: AnthropicStreamBlock, providerMetadataKey:
     providerExecuted: true,
     // The complete payload is irreducible provider replay state: subsequent
     // stateless requests must round-trip the typed result block verbatim.
-    providerMetadata: providerMetadata(providerMetadataKey, { blockType: block.type, result: block.content }),
+    providerMetadata: providerMetadata(routeID, { blockType: block.type, result: block.content }),
   })
 }
 
@@ -1289,8 +1244,8 @@ type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
 const NO_EVENTS: StepResult["1"] = []
 
 const onMessageStart = (state: ParserState, event: AnthropicEvent): StepResult => {
-  const usage = mapUsage(event.message?.usage, state.providerMetadataKey)
-  return [usage ? { ...state, usage: mergeUsage(state.usage, usage, state.providerMetadataKey) } : state, NO_EVENTS]
+  const usage = mapUsage(event.message?.usage, state.routeID)
+  return [usage ? { ...state, usage: mergeUsage(state.usage, usage, state.routeID) } : state, NO_EVENTS]
 }
 
 const onContentBlockStart = (
@@ -1342,9 +1297,7 @@ const onContentBlockStart = (
     const events: LLMEvent[] = []
     const id = `reasoning-${event.index ?? 0}`
     const metadata =
-      block.signature === undefined
-        ? undefined
-        : providerMetadata(state.providerMetadataKey, { signature: block.signature })
+      block.signature === undefined ? undefined : providerMetadata(state.routeID, { signature: block.signature })
     const lifecycle = Lifecycle.reasoningStart(state.lifecycle, events, id, metadata)
     return [
       {
@@ -1373,14 +1326,14 @@ const onContentBlockStart = (
           state.lifecycle,
           events,
           `reasoning-${event.index ?? 0}`,
-          providerMetadata(state.providerMetadataKey, { redactedData: block.data }),
+          providerMetadata(state.routeID, { redactedData: block.data }),
         ),
       },
       events,
     ]
   }
 
-  const result = serverToolResultEvent(block, state.providerMetadataKey)
+  const result = serverToolResultEvent(block, state.routeID)
   if (!result) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
   return [{ ...state, lifecycle: Lifecycle.stepStart(state.lifecycle, events) }, [...events, result]]
@@ -1481,7 +1434,7 @@ const onContentBlockStop = Effect.fn("AnthropicMessages.onContentBlockStop")(fun
         Lifecycle.textEnd(state.lifecycle, events, `text-${event.index}`),
         events,
         `reasoning-${event.index}`,
-        signature === undefined ? undefined : providerMetadata(state.providerMetadataKey, { signature }),
+        signature === undefined ? undefined : providerMetadata(state.routeID, { signature }),
       )
   events.push(...resultEvents)
   const reasoningSignatures = { ...state.reasoningSignatures }
@@ -1493,7 +1446,7 @@ const onMessageDelta = (
   state: ParserState,
   event: AnthropicEvent & { readonly delta?: AnthropicStreamDelta },
 ): StepResult => {
-  const usage = mergeUsage(state.usage, mapUsage(event.usage, state.providerMetadataKey), state.providerMetadataKey)
+  const usage = mergeUsage(state.usage, mapUsage(event.usage, state.routeID), state.routeID)
   const pendingFinish = (() => {
     const stopReason = event.delta?.stop_reason
     if (stopReason === null || stopReason === undefined) return state.pendingFinish
@@ -1502,7 +1455,7 @@ const onMessageDelta = (
     const finishMetadata =
       stopSequence === null || stopSequence === undefined
         ? state.pendingFinish?.providerMetadata
-        : providerMetadata(state.providerMetadataKey, { stopSequence })
+        : providerMetadata(state.routeID, { stopSequence })
     return {
       reason: {
         normalized: mapFinishReason(stopReason),
@@ -1530,12 +1483,7 @@ const onMessageStop = Effect.fn("AnthropicMessages.onMessageStop")(function* (st
   events.push(...result.events)
   const closed = Object.entries(state.reasoningSignatures).reduce(
     (current, [index, signature]) =>
-      Lifecycle.reasoningEnd(
-        current,
-        events,
-        `reasoning-${index}`,
-        providerMetadata(state.providerMetadataKey, { signature }),
-      ),
+      Lifecycle.reasoningEnd(current, events, `reasoning-${index}`, providerMetadata(state.routeID, { signature })),
     lifecycle,
   )
   const finished = Lifecycle.finish(closed, events, {
@@ -1670,7 +1618,7 @@ export const protocol = Protocol.make({
     initial: (request) => ({
       provider: request.model.provider,
       compactions: {},
-      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
+      routeID: request.model.route.id,
       tools: ToolStream.empty<number>(),
       reasoningSignatures: {},
       lifecycle: Lifecycle.initial(),
@@ -1679,21 +1627,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,27 +1658,9 @@ export const transport = <
   }
 }
 
-function requiredBetaHeaders(body: Pick<AnthropicMessagesBody, "messages" | "context_management" | "thinking">) {
-  // Always request interleaved thinking. The API accepts the header on any
-  // model and ignores it where unsupported, while manual-thinking models need
-  // it for thinking between tool calls.
-  const betas: string[] = ["interleaved-thinking-2025-05-14"]
-  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",
-  providerMetadataKey: "anthropic",
   protocol,
   endpoint: Endpoint.path((input) => (input.request.model.provider === "anthropic" ? `${PATH}?beta=true` : PATH), {
     baseURL: DEFAULT_BASE_URL,

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

@@ -25,7 +25,6 @@ import { BedrockAuth } from "./utils/bedrock-auth.js"
 import { BedrockCache } from "./utils/bedrock-cache.js"
 import { BedrockMedia } from "./utils/bedrock-media.js"
 import { Lifecycle } from "./utils/lifecycle.js"
-import { MistralToolID } from "./utils/mistral-tool-id.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { ToolStream } from "./utils/tool-stream.js"
 
@@ -107,7 +106,7 @@ type BedrockSystemBlock = Schema.Schema.Type<typeof BedrockSystemBlock>
 const BedrockToolSpec = Schema.Struct({
   toolSpec: Schema.Struct({
     name: Schema.String,
-    description: Schema.optional(Schema.String),
+    description: Schema.String,
     inputSchema: Schema.Struct({
       json: JsonObject,
     }),
@@ -223,7 +222,7 @@ type BedrockEvent = Schema.Schema.Type<typeof BedrockEvent>
 const lowerToolSpec = (tool: ToolDefinition, inputSchema: JsonSchema): BedrockToolSpec => ({
   toolSpec: {
     name: tool.name,
-    ...(tool.description.trim().length > 0 ? { description: tool.description } : {}),
+    description: tool.description,
     inputSchema: { json: inputSchema },
   },
 })
@@ -261,14 +260,14 @@ const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
 
 const providerMetadata = (key: string, metadata: Record<string, unknown>): ProviderMetadata => ({ [key]: metadata })
 
-const reasoningSignature = (part: ReasoningPart, providerMetadataKey: string) => {
-  const metadata = part.providerMetadata?.[providerMetadataKey]
+const reasoningSignature = (part: ReasoningPart, routeID: string) => {
+  const metadata = part.providerMetadata?.[routeID]
   if (part.encrypted !== undefined) return part.encrypted
   if (ProviderShared.isRecord(metadata) && typeof metadata.signature === "string") return metadata.signature
 }
 
-const reasoningRedactedData = (part: ReasoningPart, providerMetadataKey: string) => {
-  const metadata = part.providerMetadata?.[providerMetadataKey]
+const reasoningRedactedData = (part: ReasoningPart, routeID: string) => {
+  const metadata = part.providerMetadata?.[routeID]
   if (ProviderShared.isRecord(metadata) && typeof metadata.redactedData === "string") return metadata.redactedData
 }
 
@@ -280,19 +279,15 @@ const removeEmptyToolInputKeys = (input: unknown): unknown => {
   )
 }
 
-const lowerToolCall = (part: ToolCallPart, normalizeID: (id: string) => string): BedrockToolUseBlock => ({
+const lowerToolCall = (part: ToolCallPart): BedrockToolUseBlock => ({
   toolUse: {
-    toolUseId: normalizeID(part.id),
-    // Models can emit names that Converse rejects when replayed in history.
-    name: part.name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "_",
+    toolUseId: part.id,
+    name: part.name,
     input: removeEmptyToolInputKeys(part.input),
   },
 })
 
-const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent")(function* (
-  part: ToolResultPart,
-  documentNames: Set<string>,
-) {
+const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent")(function* (part: ToolResultPart) {
   if (part.result.type === "text" || part.result.type === "error")
     return [{ text: ProviderShared.toolResultText(part) }]
   if (part.result.type === "json") return [{ json: part.result.value }]
@@ -303,29 +298,22 @@ const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent
       content.push({ text: item.text })
       continue
     }
-    const media = yield* BedrockMedia.lower(
-      {
-        type: "media",
-        mediaType: item.mime,
-        data: item.uri,
-        filename: item.name,
-      },
-      documentNames,
-    )
-    content.push(...media)
+    const media = yield* BedrockMedia.lower({
+      type: "media",
+      mediaType: item.mime,
+      data: item.uri,
+      filename: item.name,
+    })
+    content.push(media)
   }
   return content
 })
 
-const lowerToolResult = Effect.fn("BedrockConverse.lowerToolResult")(function* (
-  part: ToolResultPart,
-  documentNames: Set<string>,
-  normalizeID: (id: string) => string,
-) {
+const lowerToolResult = Effect.fn("BedrockConverse.lowerToolResult")(function* (part: ToolResultPart) {
   return {
     toolResult: {
-      toolUseId: normalizeID(part.id),
-      content: yield* lowerToolResultContent(part, documentNames),
+      toolUseId: part.id,
+      content: yield* lowerToolResultContent(part),
       status: part.result.type === "error" ? "error" : "success",
     },
   } satisfies BedrockToolResultBlock
@@ -336,10 +324,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
   breakpoints: BedrockCache.Breakpoints,
 ) {
   const messages: BedrockMessage[] = []
-  const documentNames = new Set<string>()
-  // Mistral can reject replay IDs even when they satisfy Converse's broader ID syntax.
-  const normalizeID = request.model.id.includes("mistral.") ? MistralToolID.normalizer(request) : (id: string) => id
-  const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider)
+  const routeID = request.model.route.id
 
   for (const message of request.messages) {
     if (message.role === "system") {
@@ -362,7 +347,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
           continue
         }
         if (part.type === "media") {
-          content.push(...(yield* BedrockMedia.lower(part, documentNames)))
+          content.push(yield* BedrockMedia.lower(part))
           continue
         }
       }
@@ -387,8 +372,8 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
           continue
         }
         if (part.type === "reasoning") {
-          const signature = reasoningSignature(part, providerMetadataKey)
-          const redactedData = reasoningRedactedData(part, providerMetadataKey)
+          const signature = reasoningSignature(part, routeID)
+          const redactedData = reasoningRedactedData(part, routeID)
           if (signature === undefined && redactedData !== undefined) {
             content.push({ reasoningContent: { redactedContent: redactedData } })
             continue
@@ -403,7 +388,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
           continue
         }
         if (part.type === "tool-call") {
-          content.push(lowerToolCall(part, normalizeID))
+          content.push(lowerToolCall(part))
           continue
         }
       }
@@ -415,7 +400,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
     for (const part of message.content) {
       if (!ProviderShared.supportsContent(part, ["tool-result"]))
         return yield* ProviderShared.unsupportedContent("Bedrock Converse", "tool", ["tool-result"])
-      content.push(yield* lowerToolResult(part, documentNames, normalizeID))
+      content.push(yield* lowerToolResult(part))
       const cachePoint = BedrockCache.block(breakpoints, part.cache)
       if (cachePoint) content.push(cachePoint)
     }
@@ -500,7 +485,7 @@ const mapFinishReason = (reason: string): FinishReason => {
 
 // AWS reports inputTokens separately from cache reads and writes.
 // Bedrock does not break reasoning out of outputTokens for current models.
-const mapUsage = (usage: BedrockUsageSchema | undefined, providerMetadataKey: string): Usage | undefined => {
+const mapUsage = (usage: BedrockUsageSchema | undefined, routeID: string): Usage | undefined => {
   if (!usage) return undefined
   const inputTokens = ProviderShared.sumTokens(
     usage.inputTokens,
@@ -514,12 +499,12 @@ const mapUsage = (usage: BedrockUsageSchema | undefined, providerMetadataKey: st
     cacheReadInputTokens: usage.cacheReadInputTokens,
     cacheWriteInputTokens: usage.cacheWriteInputTokens,
     totalTokens: ProviderShared.totalTokens(inputTokens, usage.outputTokens, usage.totalTokens),
-    providerMetadata: { [providerMetadataKey]: usage },
+    providerMetadata: { [routeID]: usage },
   })
 }
 
 interface ParserState {
-  readonly providerMetadataKey: string
+  readonly routeID: string
   readonly tools: ToolStream.State<number>
   // Bedrock splits the finish into `messageStop` (carries `stopReason`) and
   // `metadata` (carries usage). Hold both in state so `onHalt` can emit exactly
@@ -602,8 +587,8 @@ const step = (state: ParserState, event: BedrockEvent) =>
       })()
       const redactedData = redactedChunks === undefined ? reasoning.data : encodeRedactedContent(redactedChunks)
       const metadata = (() => {
-        if (reasoning.signature) return providerMetadata(state.providerMetadataKey, { signature: reasoning.signature })
-        if (redactedData !== undefined) return providerMetadata(state.providerMetadataKey, { redactedData })
+        if (reasoning.signature) return providerMetadata(state.routeID, { signature: reasoning.signature })
+        if (redactedData !== undefined) return providerMetadata(state.routeID, { redactedData })
       })()
       const lifecycle = (() => {
         if (reasoning.text === undefined && metadata === undefined) return state.lifecycle
@@ -655,10 +640,10 @@ const step = (state: ParserState, event: BedrockEvent) =>
         if (resultEvents.length) return Lifecycle.stepStart(state.lifecycle, events)
         const metadata = (() => {
           const signature = state.reasoningSignatures[index]
-          if (signature) return providerMetadata(state.providerMetadataKey, { signature })
+          if (signature) return providerMetadata(state.routeID, { signature })
           const redactedContent = state.reasoningRedactedContent[index]
           if (redactedContent)
-            return providerMetadata(state.providerMetadataKey, {
+            return providerMetadata(state.routeID, {
               redactedData: encodeRedactedContent(redactedContent),
             })
         })()
@@ -712,7 +697,7 @@ 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.routeID) ?? state.usage
       return [
         {
           ...state,
@@ -772,7 +757,7 @@ export const protocol = Protocol.make({
   stream: {
     event: BedrockEvent,
     initial: (request) => ({
-      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
+      routeID: request.model.route.id,
       tools: ToolStream.empty<number>(),
       finishReason: undefined,
       usage: undefined,
@@ -789,7 +774,6 @@ export const protocol = Protocol.make({
 export const route = Route.make({
   id: ADAPTER,
   provider: "bedrock",
-  providerMetadataKey: "bedrock",
   protocol,
   // Bedrock's URL embeds the region in the route endpoint host and the
   // validated modelId in the path. We read the validated body so the URL

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"
@@ -232,7 +232,7 @@ type GeminiEvent = Schema.Schema.Type<typeof GeminiEvent>
 
 interface ParserState {
   readonly route: string
-  readonly providerMetadataKey: string
+  readonly routeID: string
   readonly finishReason?: string
   readonly hasToolCalls: boolean
   readonly promptFeedback?: GeminiPromptFeedback
@@ -309,7 +309,7 @@ const lowerToolCall = (part: ToolCallPart, omitIds: boolean, metadataKey: string
 
 const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMRequest) {
   const contents: GeminiContent[] = []
-  const metadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider)
+  const metadataKey = request.model.route.id
   const omitCallIds = omitsFunctionCallIds(request.model.id)
   const legacyToolMedia = routesLegacyToolMedia(request.model.id)
   let pendingMedia: GeminiInlineDataPart[] | undefined
@@ -583,7 +583,7 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
       state.reasoningId,
       state.reasoningSignature === undefined
         ? undefined
-        : providerMetadata(state.providerMetadataKey, { thoughtSignature: state.reasoningSignature }),
+        : providerMetadata(state.routeID, { thoughtSignature: state.reasoningSignature }),
     )
   if (state.textId !== undefined)
     lifecycle = Lifecycle.textEnd(
@@ -592,7 +592,7 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
       state.textId,
       state.textSignature === undefined
         ? undefined
-        : providerMetadata(state.providerMetadataKey, { thoughtSignature: state.textSignature }),
+        : providerMetadata(state.routeID, { thoughtSignature: state.textSignature }),
     )
   Lifecycle.finish(lifecycle, events, {
     reason: {
@@ -604,7 +604,7 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
     providerMetadata:
       state.promptFeedback === undefined
         ? undefined
-        : providerMetadata(state.providerMetadataKey, { promptFeedback: state.promptFeedback }),
+        : providerMetadata(state.routeID, { promptFeedback: state.promptFeedback }),
   })
   return events
 }
@@ -634,9 +634,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
   const nextState = {
     ...state,
     promptFeedback: event.promptFeedback ?? state.promptFeedback,
-    usage: event.usageMetadata
-      ? (mapUsage(event.usageMetadata, state.providerMetadataKey) ?? state.usage)
-      : state.usage,
+    usage: event.usageMetadata ? (mapUsage(event.usageMetadata, state.routeID) ?? state.usage) : state.usage,
   }
   const candidate = event.candidates?.[0]
   if (candidate?.finishReason && mapFinishReason(candidate.finishReason, state.hasToolCalls) === "error")
@@ -692,9 +690,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
             lifecycle,
             events,
             textId,
-            textSignature
-              ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature })
-              : undefined,
+            textSignature ? providerMetadata(state.routeID, { thoughtSignature: textSignature }) : undefined,
           )
           textId = undefined
           textSignature = undefined
@@ -708,7 +704,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
           events,
           reasoningId,
           part.text,
-          signature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: signature }) : undefined,
+          signature ? providerMetadata(state.routeID, { thoughtSignature: signature }) : undefined,
         )
         continue
       }
@@ -717,9 +713,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
           lifecycle,
           events,
           reasoningId,
-          reasoningSignature
-            ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
-            : undefined,
+          reasoningSignature ? providerMetadata(state.routeID, { thoughtSignature: reasoningSignature }) : undefined,
         )
         reasoningId = undefined
         reasoningSignature = undefined
@@ -733,7 +727,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
         events,
         textId,
         part.text,
-        textSignature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature }) : undefined,
+        textSignature ? providerMetadata(state.routeID, { thoughtSignature: textSignature }) : undefined,
       )
       textSignature = undefined
       continue
@@ -754,9 +748,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
           lifecycle,
           events,
           reasoningId,
-          reasoningSignature
-            ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
-            : undefined,
+          reasoningSignature ? providerMetadata(state.routeID, { thoughtSignature: reasoningSignature }) : undefined,
         )
         reasoningId = undefined
         reasoningSignature = undefined
@@ -766,7 +758,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
           lifecycle,
           events,
           textId,
-          textSignature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature }) : undefined,
+          textSignature ? providerMetadata(state.routeID, { thoughtSignature: textSignature }) : undefined,
         )
         textId = undefined
         textSignature = undefined
@@ -778,7 +770,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
           name: part.functionCall.name,
           input,
           providerMetadata: part.thoughtSignature
-            ? providerMetadata(state.providerMetadataKey, { thoughtSignature: part.thoughtSignature })
+            ? providerMetadata(state.routeID, { thoughtSignature: part.thoughtSignature })
             : undefined,
         }),
       )
@@ -821,7 +813,7 @@ export const protocol = Protocol.make({
     event: Protocol.jsonEvent(GeminiEvent),
     initial: (request) => ({
       route: `${request.model.provider}/${request.model.route.id}`,
-      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
+      routeID: request.model.route.id,
       hasToolCalls: false,
       lifecycle: Lifecycle.initial(),
       nextReasoningId: 0,
@@ -835,7 +827,6 @@ export const protocol = Protocol.make({
 export const route = Route.make({
   id: ADAPTER,
   provider: "google",
-  providerMetadataKey: "google",
   protocol,
   // Gemini's path embeds the model id and pins SSE framing at the URL level.
   endpoint: Endpoint.path(({ request }) => `/models/${request.model.id}:streamGenerateContent?alt=sse`, {

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

@@ -21,11 +21,11 @@ import {
 import { classifyProviderFailure } from "../provider-error.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { Lifecycle } from "./utils/lifecycle.js"
-import { MistralToolID } from "./utils/mistral-tool-id.js"
 import { ToolStream } from "./utils/tool-stream.js"
 
 const ADAPTER = "mistral-chat"
 const DONE = "[DONE]" as const
+const TOOL_ID = /^[A-Za-z0-9]{9}$/
 export const DEFAULT_BASE_URL = "https://api.mistral.ai/v1"
 export const PATH = "/chat/completions"
 
@@ -223,6 +223,34 @@ const MistralEvent = Schema.StructWithRest(
 type MistralEvent = Schema.Schema.Type<typeof MistralEvent>
 const MistralStreamEvent = Schema.Union([Schema.Literal(DONE), Protocol.jsonEvent(MistralEvent)])
 
+const hashID = (value: string) => {
+  const hash = (seed: number) => {
+    let result = seed
+    for (const char of value) result = Math.imul(result ^ char.charCodeAt(0), 16777619)
+    return (result >>> 0).toString(36)
+  }
+  return `${hash(2166136261).padStart(7, "0")}${hash(2246822519).padStart(7, "0")}`.slice(-9)
+}
+
+const toolIDNormalizer = (request: LLMRequest) => {
+  const ids = request.messages.flatMap((message) =>
+    message.content.flatMap((part) => (part.type === "tool-call" || part.type === "tool-result" ? [part.id] : [])),
+  )
+  const used = new Set(ids.filter((id) => TOOL_ID.test(id)))
+  const normalized = new Map<string, string>()
+  return (id: string) => {
+    if (TOOL_ID.test(id)) return id
+    const previous = normalized.get(id)
+    if (previous) return previous
+    let attempt = 0
+    let candidate = hashID(id)
+    while (used.has(candidate)) candidate = hashID(`${id}:${++attempt}`)
+    used.add(candidate)
+    normalized.set(id, candidate)
+    return candidate
+  }
+}
+
 const lowerMedia = Effect.fn("MistralChat.lowerMedia")(function* (part: MediaPart) {
   const media = ProviderShared.normalizeMedia(part)
   const url = typeof part.data === "string" && /^(?:https?:|data:)/.test(part.data) ? part.data : media.dataUrl
@@ -259,9 +287,10 @@ const lowerAssistant = Effect.fn("MistralChat.lowerAssistant")(function* (
   message: LLMRequest["messages"][number],
   normalizeID: (id: string) => string,
   prefix: boolean,
+  routeID: string,
 ) {
   const structured = message.content.some(
-    (part) => part.type === "reasoning" && isMistralThinkingContent(part.providerMetadata?.mistral?.thinking),
+    (part) => part.type === "reasoning" && isMistralThinkingContent(part.providerMetadata?.[routeID]?.thinking),
   )
   const content: Array<Schema.Schema.Type<typeof MistralTextContent> | MistralThinkingContent> = []
   const text: string[] = []
@@ -273,7 +302,7 @@ const lowerAssistant = Effect.fn("MistralChat.lowerAssistant")(function* (
       continue
     }
     if (part.type === "reasoning") {
-      const native = part.providerMetadata?.mistral?.thinking
+      const native = part.providerMetadata?.[routeID]?.thinking
       if (structured && isMistralThinkingContent(native)) content.push(native)
       else if (structured) content.push({ type: "text", text: part.text })
       else text.push(part.text)
@@ -331,7 +360,7 @@ const lowerToolResults = Effect.fn("MistralChat.lowerToolResults")(function* (
 })
 
 const lowerMessages = Effect.fn("MistralChat.lowerMessages")(function* (request: LLMRequest) {
-  const normalizeID = MistralToolID.normalizer(request)
+  const normalizeID = toolIDNormalizer(request)
   const messages: MistralMessage[] =
     request.system.length === 0 ? [] : [{ role: "system", content: ProviderShared.joinText(request.system) }]
   for (const message of request.messages) {
@@ -350,13 +379,22 @@ const lowerMessages = Effect.fn("MistralChat.lowerMessages")(function* (request:
     if (message.role === "assistant") {
       const hasToolCalls = message.content.some((part) => part.type === "tool-call")
       const hasNativeThinking = message.content.some(
-        (part) => part.type === "reasoning" && isMistralThinkingContent(part.providerMetadata?.mistral?.thinking),
+        (part) =>
+          part.type === "reasoning" &&
+          isMistralThinkingContent(part.providerMetadata?.[request.model.route.id]?.thinking),
       )
       const text = message.content
         .flatMap((part) => (part.type === "text" || part.type === "reasoning" ? [part.text] : []))
         .join("")
       if (!hasToolCalls && !hasNativeThinking && text.trim() === "") continue
-      messages.push(yield* lowerAssistant(message, normalizeID, !hasToolCalls && message === request.messages.at(-1)))
+      messages.push(
+        yield* lowerAssistant(
+          message,
+          normalizeID,
+          !hasToolCalls && message === request.messages.at(-1),
+          request.model.route.id,
+        ),
+      )
       continue
     }
     messages.push(...(yield* lowerToolResults(message, normalizeID)))
@@ -427,6 +465,7 @@ interface ActiveContent {
 }
 
 export interface ParserState {
+  readonly routeID: string
   readonly tools: ToolStream.State<ToolKey>
   readonly pendingTools: Partial<Record<ToolKey, PendingTool>>
   readonly toolIDs: ReadonlyMap<string, string>
@@ -441,7 +480,7 @@ export interface ParserState {
   readonly finishReason?: FinishReasonDetails
 }
 
-const mapUsage = (usage: MistralEvent["usage"]): Usage | undefined => {
+const mapUsage = (usage: MistralEvent["usage"], routeID: string): Usage | undefined => {
   if (!usage) return undefined
   const input = usage.prompt_tokens ?? undefined
   const reported =
@@ -457,7 +496,7 @@ const mapUsage = (usage: MistralEvent["usage"]): Usage | undefined => {
     nonCachedInputTokens: ProviderShared.subtractTokens(input, cached),
     cacheReadInputTokens: cached,
     totalTokens: ProviderShared.totalTokens(input, output, usage.total_tokens ?? undefined),
-    providerMetadata: { mistral: usage },
+    providerMetadata: { [routeID]: usage },
   })
 }
 
@@ -489,7 +528,7 @@ const thinkingUnits = (value: unknown): ReadonlyArray<MistralThinkingUnit> => {
 const thinkingText = (thinking: ReadonlyArray<MistralThinkingUnit>) =>
   thinking.flatMap((unit) => (typeof unit.text === "string" ? [unit.text] : [])).join("")
 
-const thinkingMetadata = (thinking: MistralThinkingContent) => ({ mistral: { thinking } })
+const thinkingMetadata = (thinking: MistralThinkingContent, routeID: string) => ({ [routeID]: { thinking } })
 
 const closeActive = (state: ParserState, events: LLMEvent[]) => {
   if (!state.active) return state
@@ -500,7 +539,7 @@ const closeActive = (state: ParserState, events: LLMEvent[]) => {
           state.lifecycle,
           events,
           state.active.id,
-          thinkingMetadata(state.active.thinking ?? { type: "thinking", thinking: [] }),
+          thinkingMetadata(state.active.thinking ?? { type: "thinking", thinking: [] }, state.routeID),
           thinkingText(state.active.thinking?.thinking ?? []),
         )
   return { ...state, lifecycle, active: undefined }
@@ -533,8 +572,14 @@ const appendThinking = (state: ParserState, events: LLMEvent[], part: MistralOut
     ...current,
     lifecycle:
       text.length > 0
-        ? Lifecycle.reasoningDelta(current.lifecycle, events, active.id, text, thinkingMetadata(thinking))
-        : Lifecycle.reasoningStart(current.lifecycle, events, active.id, thinkingMetadata(thinking)),
+        ? Lifecycle.reasoningDelta(
+            current.lifecycle,
+            events,
+            active.id,
+            text,
+            thinkingMetadata(thinking, state.routeID),
+          )
+        : Lifecycle.reasoningStart(current.lifecycle, events, active.id, thinkingMetadata(thinking, state.routeID)),
     active: { ...active, thinking },
     nextContent: current.active ? current.nextContent : current.nextContent + 1,
   }
@@ -554,13 +599,13 @@ const appendContent = (
 }
 
 const normalizeStreamToolID = (state: ParserState, source: string) => {
-  if (MistralToolID.valid.test(source))
+  if (TOOL_ID.test(source))
     return { id: source, state: { ...state, usedToolIDs: new Set([...state.usedToolIDs, source]) } }
   const previous = state.toolIDs.get(source)
   if (previous) return { id: previous, state }
   let attempt = 0
-  let id = MistralToolID.hash(source)
-  while (state.usedToolIDs.has(id)) id = MistralToolID.hash(`${source}:${++attempt}`)
+  let id = hashID(source)
+  while (state.usedToolIDs.has(id)) id = hashID(`${source}:${++attempt}`)
   return {
     id,
     state: {
@@ -655,7 +700,7 @@ const step = Effect.fn("MistralChat.step")(function* (state: ParserState, event:
     })
   }
   const events: LLMEvent[] = []
-  const usage = mapUsage(event.usage) ?? state.usage
+  const usage = mapUsage(event.usage, state.routeID) ?? state.usage
   if (state.finishReason) {
     if (hasLateContent(event))
       return yield* ProviderShared.eventError(
@@ -733,7 +778,8 @@ export const protocol = Protocol.make({
   body: { schema: MistralBody, from: fromRequest },
   stream: {
     event: MistralStreamEvent,
-    initial: (): ParserState => ({
+    initial: (request): ParserState => ({
+      routeID: request.model.route.id,
       tools: ToolStream.empty<ToolKey>(),
       pendingTools: {},
       toolIDs: new Map(),
@@ -755,7 +801,6 @@ export const httpTransport = HttpTransport.sseJson.with<MistralBody>().with({ fr
 export const route = Route.make({
   id: ADAPTER,
   provider: "mistral",
-  providerMetadataKey: "mistral",
   protocol,
   endpoint: Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL }),
   auth: Auth.none,

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

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

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

@@ -6,6 +6,7 @@ import { OpenResponses } from "./open-responses.js"
 
 const PROTOCOL = "open-responses.websocket.v1"
 const VERSION = 1
+const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)
 
 interface CheckpointValue {
   readonly version: typeof VERSION
@@ -14,19 +15,12 @@ interface CheckpointValue {
   readonly output: ReadonlyArray<unknown>
 }
 
-/**
- * Fields to send next to `previous_response_id` on an incremental step, or undefined to send the step in full.
- * Whether omitted fields carry over from the continued response is provider behavior the route must know.
- */
-export type Shape = (request: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>> | undefined
-
 export interface DriverInput {
   readonly id: string
   readonly name: string
   readonly request: Readonly<Record<string, unknown>>
   readonly message: string
   readonly base: WebSocketChannelDriver
-  readonly continuation?: Shape
 }
 
 const checkpointValue = (checkpoint: ChannelCheckpoint | undefined): CheckpointValue | undefined => {
@@ -133,26 +127,22 @@ const rejected = (
 
 export const driver = (input: DriverInput): WebSocketChannelDriver => {
   const { previous_response_id: _previousResponseID, ...request } = input.request
-  const shape = input.continuation ?? ((fields: Readonly<Record<string, unknown>>) => fields)
   let output: OpenResponses.StreamItem[] = []
   return {
     create: (checkpoint) =>
       Effect.sync(() => {
         output = []
         const previous = checkpointValue(checkpoint)
-        // Ask the route first: diffing the whole history is wasted when it declines the continuation.
-        const fields = previous ? shape(request) : undefined
-        const delta = previous && fields ? incremental(request, previous) : undefined
-        if (!previous || !fields || !delta)
-          return { message: ProviderShared.encodeJson(request), mode: "full" as const }
+        const delta = previous ? incremental(request, previous) : undefined
+        if (!previous || !delta) return { message: ProviderShared.encodeJson(request), mode: "full" as const }
         return {
-          message: ProviderShared.encodeJson({ ...fields, input: delta, previous_response_id: previous.responseID }),
+          message: ProviderShared.encodeJson({ ...request, input: delta, previous_response_id: previous.responseID }),
           mode: "incremental" as const,
         }
       }),
     observe: (create, frame) =>
       Effect.gen(function* () {
-        const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(
+        const event = yield* decodeEvent(frame).pipe(
           Effect.mapError((cause) =>
             ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause),
           ),
@@ -163,15 +153,6 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
           const rejection = code(event)
           if (rejection === "previous_response_not_found") return rejected(observation, "retry-full")
           if (rejection === "websocket_connection_limit_reached") return rejected(observation, "rotate-and-retry-full")
-          // Only the continuation distinguishes an incremental send from a full one, so an unclassified
-          // invalid request there is retried full; Codex reports a stale previous_response_id that way, with
-          // no code. Classified failures such as context overflow keep their runner-owned recovery.
-          if (
-            create.mode === "incremental" &&
-            observation.error.reason._tag === "InvalidRequest" &&
-            observation.error.reason.classification === undefined
-          )
-            return rejected(observation, "retry-full")
         }
         if (observation.type !== "completed") return observation
         // A trigger installs a different context window. Clear the append baseline, retaining the socket.
@@ -191,7 +172,7 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
               responseID,
               request,
               // Completion can re-encrypt reasoning. Callers replay the item already emitted by output_item.done.
-              output: event.response?.output?.length
+              output: event.response?.output
                 ? event.response.output.map((item) =>
                     item.type === "reasoning" && item.id !== undefined
                       ? (output.find((done) => done.type === item.type && done.id === item.id) ?? item)
@@ -205,4 +186,4 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
   }
 }
 
-export * as OpenResponsesContinuation from "./open-responses-continuation.js"
+export const OpenResponsesContinuation = { driver } as const

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

@@ -1,5 +1,5 @@
-import { Effect, Option, Schema, SchemaGetter } from "effect"
-import type { Content } from "@opencode/schema/tool"
+import { Effect, Option, Schema } from "effect"
+import type { Content } from "@opencode-ai/schema/tool"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
 import {
@@ -325,8 +325,9 @@ export const StreamItem = Schema.StructWithRest(
 export type StreamItem = Schema.Schema.Type<typeof StreamItem>
 export type OutputItem = StreamItem & { readonly id: string }
 
-// Responses-compatible providers put streaming error details at the top level or
-// under `error`, and response failures under `response.error`. Accept all three shapes.
+// The Responses schema puts streaming error details at the top level and
+// response failures under `response.error`. WebSocket failures use an
+// event-level `error` envelope, so accept all three shapes here.
 // https://www.openresponses.org/specification
 const OpenResponsesErrorPayload = Schema.Struct({
   type: optionalNull(Schema.String),
@@ -400,45 +401,13 @@ export const Event = Schema.StructWithRest(
     headers: Schema.optional(Schema.Unknown),
   }),
   [Schema.Record(Schema.String, Schema.Unknown)],
-).pipe(
-  Schema.decode({
-    decode: SchemaGetter.transform((event) => {
-      if (event.type !== "error" || event.error != null) return event
-      const { code, message, param, ...rest } = event
-      if (code === undefined && message === undefined && param === undefined) return event
-      // Flat errors (for example, Meta's) can also arrive through generic Responses endpoints.
-      return { ...rest, error: { code, message, param } }
-    }),
-    encode: SchemaGetter.passthrough(),
-  }),
 )
 export type Event = Schema.Schema.Type<typeof Event>
 export type NormalizedEvent = Event & { readonly item?: OutputItem | null }
 
-const decodeEventValue = Schema.decodeUnknownEffect(Event)
-const decodeFrame = Schema.decodeUnknownEffect(ProviderShared.Json)
-
-/**
- * Decodes one WebSocket frame. xAI answers a rejected `response.create` with `{ "error": { "message", "type" } }` and no
- * event type; that envelope reads as an error event so the failure classifies instead of failing decoding.
- */
-export const decodeChannelEvent = (frame: string) =>
-  decodeFrame(frame).pipe(
-    Effect.flatMap((value) =>
-      decodeEventValue(
-        ProviderShared.isRecord(value) && value.type === undefined && ProviderShared.isRecord(value.error)
-          ? { ...value, type: "error" }
-          : value,
-      ),
-    ),
-  )
-
 export interface ProviderAdapter {
   readonly id: string
   readonly name: string
-  readonly nativeTool?: (
-    native: NonNullable<ToolDefinition["native"]>,
-  ) => Effect.Effect<{ readonly type: string }, AIError>
   readonly lowerMedia?: (input: {
     readonly part: MediaPart
     readonly media: ProviderShared.NormalizedMedia
@@ -454,7 +423,7 @@ export interface ParserState {
   readonly completedCompactions: ReadonlySet<string>
   readonly id: string
   readonly name: string
-  readonly providerMetadataKey: string
+  readonly routeID: string
   readonly tools: ToolStream.State<string>
   readonly hasFunctionCall: boolean
   readonly lifecycle: Lifecycle.State
@@ -507,29 +476,29 @@ export const lowerToolChoice = (protocolName: string, toolChoice: NonNullable<LL
 
 // Server-issued item ids need a nonempty prefix and suffix, but the prefix is
 // provider-defined and does not necessarily identify the item's semantic type.
-const itemID = (providerMetadata: ProviderMetadata | undefined, providerMetadataKey: string) => {
-  const metadata = providerMetadata?.[providerMetadataKey]
+const itemID = (providerMetadata: ProviderMetadata | undefined, routeID: string) => {
+  const metadata = providerMetadata?.[routeID]
   if (!ProviderShared.isRecord(metadata) || typeof metadata.itemId !== "string") return undefined
   const separator = metadata.itemId.indexOf("_")
   return separator > 0 && separator < metadata.itemId.length - 1 ? metadata.itemId : undefined
 }
 
-const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenResponsesInputItem => {
-  const id = itemID(part.providerMetadata, providerMetadataKey)
+const lowerToolCall = (part: ToolCallPart, routeID: string): OpenResponsesInputItem => {
+  const id = itemID(part.providerMetadata, routeID)
   return {
     type: "function_call",
     ...(id === undefined ? {} : { id }),
     call_id: part.id,
     name: part.name,
     namespace: part.namespace,
-    arguments: ProviderShared.encodeJson(part.input === undefined ? {} : part.input),
+    arguments: ProviderShared.encodeJson(part.input),
   }
 }
 
-const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenResponsesReasoningInput | undefined => {
-  const metadata = part.providerMetadata?.[providerMetadataKey]
+const lowerReasoning = (part: ReasoningPart, routeID: string): OpenResponsesReasoningInput | undefined => {
+  const metadata = part.providerMetadata?.[routeID]
   if (!ProviderShared.isRecord(metadata)) return undefined
-  const id = itemID(part.providerMetadata, providerMetadataKey)
+  const id = itemID(part.providerMetadata, routeID)
   const encryptedContent =
     typeof metadata.reasoningEncryptedContent === "string" || metadata.reasoningEncryptedContent === null
       ? metadata.reasoningEncryptedContent
@@ -552,7 +521,7 @@ const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
   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,
+    part.providerMetadata?.[request.model.route.id]?.detail,
   )
   const url =
     typeof part.data === "string" && (part.data.startsWith("https://") || part.data.startsWith("http://"))
@@ -639,12 +608,12 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
   adapter: ProviderAdapter,
 ) {
   const input: LoweredInputItem[] = []
-  const providerMetadataKey = metadataKey(request.model)
+  const routeID = request.model.route.id
 
   for (const message of request.messages) {
     const metadata = yield* ProviderShared.validateWith(
       Schema.decodeUnknownEffect(Schema.UndefinedOr(MessageMetadata)),
-    )(message.providerMetadata?.[providerMetadataKey])
+    )(message.providerMetadata?.[routeID])
     if (message.role === "system") {
       input.push({
         role: "developer",
@@ -669,8 +638,8 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
         const groups = content.reduce<
           Array<{ id: string | undefined; phase: MessagePhase | null | undefined; parts: TextPart[] }>
         >((groups, part) => {
-          const partMetadata = part.providerMetadata?.[providerMetadataKey]
-          const id = itemID(part.providerMetadata, providerMetadataKey) ?? metadata?.itemId
+          const partMetadata = part.providerMetadata?.[routeID]
+          const id = itemID(part.providerMetadata, routeID) ?? metadata?.itemId
           const partPhase = messagePhase(partMetadata?.phase)
           const phase = partPhase === undefined ? metadata?.phase : partPhase
           const group = groups.at(-1)
@@ -683,8 +652,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
             type: "message" as const,
             ...(group.id === undefined ? {} : { id: group.id }),
             role: "assistant" as const,
-            // Replayed text is a finished input item, even if generation was cut short.
-            status: "completed",
+            status: metadata?.status,
             content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
             ...(group.phase === undefined ? {} : { phase: group.phase }),
           })),
@@ -707,7 +675,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
         }
         if (part.type === "reasoning") {
           flushText()
-          const reasoning = lowerReasoning(part, providerMetadataKey)
+          const reasoning = lowerReasoning(part, routeID)
           if (!reasoning) continue
           const existing = reasoning.id === undefined ? undefined : reasoningItems[reasoning.id]
           if (existing) {
@@ -723,12 +691,12 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
         if (part.type === "tool-call") {
           flushText()
           if (part.providerExecuted === true) continue
-          input.push(lowerToolCall(part, providerMetadataKey))
+          input.push(lowerToolCall(part, routeID))
           continue
         }
         if (part.type === "tool-result" && part.providerExecuted === true) {
           flushText()
-          const id = itemID(part.providerMetadata, providerMetadataKey)
+          const id = itemID(part.providerMetadata, routeID)
           const hosted =
             part.result.type !== "json"
               ? undefined
@@ -851,13 +819,11 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
       projected.tools.length === 0
         ? undefined
         : yield* Effect.forEach(projected.tools, (tool) =>
-            tool.native !== undefined && adapter.nativeTool
-              ? adapter.nativeTool(tool.native)
-              : lowerTool(
-                  adapter.name,
-                  tool,
-                  ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
-                ),
+            lowerTool(
+              adapter.name,
+              tool,
+              ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
+            ),
           ),
     tool_choice:
       allowedToolChoice(request) ??
@@ -878,7 +844,7 @@ export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (req
 // cached-read and cache-write subsets, and `output_tokens` (inclusive total)
 // with a `reasoning_tokens` subset. Pass the totals through and derive the
 // non-cached breakdown.
-export const mapUsage = (usage: OpenResponsesUsage | null | undefined, providerMetadataKey: string) => {
+export const mapUsage = (usage: OpenResponsesUsage | null | undefined, routeID: string) => {
   if (!usage) return undefined
   const cached = usage.input_tokens_details?.cached_tokens
   const cacheWrite = usage.input_tokens_details?.cache_write_tokens
@@ -892,7 +858,7 @@ export const mapUsage = (usage: OpenResponsesUsage | null | undefined, providerM
     cacheWriteInputTokens: cacheWrite,
     reasoningTokens: reasoning,
     totalTokens: ProviderShared.totalTokens(usage.input_tokens, usage.output_tokens, usage.total_tokens),
-    providerMetadata: { [providerMetadataKey]: usage },
+    providerMetadata: { [routeID]: usage },
   })
 }
 
@@ -908,10 +874,8 @@ 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,
+  [state.routeID]: metadata,
 })
 
 export type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
@@ -1383,7 +1347,7 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
       normalized: mapFinishReason(event, current.hasFunctionCall),
       raw: event.response?.incomplete_details?.reason,
     },
-    usage: mapUsage(event.response?.usage, current.providerMetadataKey),
+    usage: mapUsage(event.response?.usage, current.routeID),
     providerMetadata:
       event.response?.id || event.response?.service_tier
         ? providerMetadata(current, {
@@ -1520,7 +1484,7 @@ export const initial = (request: LLMRequest, adapter: ProviderAdapter = BASE_ADA
   completedCompactions: new Set<string>(),
   id: adapter.id,
   name: adapter.name,
-  providerMetadataKey: metadataKey(request.model),
+  routeID: request.model.route.id,
   hasFunctionCall: false,
   tools: ToolStream.empty<string>(),
   lifecycle: Lifecycle.initial(),

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"
@@ -257,7 +257,7 @@ interface PendingToolDelta {
 }
 
 export interface ParserState {
-  readonly providerMetadataKey: string
+  readonly routeID: string
   readonly tools: ToolStream.State<number>
   readonly pendingTools: Partial<Record<number, PendingToolDelta>>
   readonly toolCallEvents: ReadonlyArray<LLMEvent>
@@ -315,7 +315,7 @@ const lowerToolCall = (part: ToolCallPart, options: LoweringOptions): OpenAIChat
   type: "function",
   function: {
     name: part.name,
-    arguments: ProviderShared.encodeJson(part.input === undefined ? {} : part.input),
+    arguments: ProviderShared.encodeJson(part.input),
   },
 })
 
@@ -323,28 +323,23 @@ const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part: MediaPart
   const media = ProviderShared.normalizeMedia(part)
   if (!media.mime.startsWith("image/"))
     return yield* ProviderShared.invalidRequest(`OpenAI Chat does not support media type ${part.mediaType}`)
-  const url =
-    typeof part.data === "string" && (part.data.startsWith("https://") || part.data.startsWith("http://"))
-      ? part.data
-      : media.dataUrl
-  return { type: "image_url" as const, image_url: { url } }
+  return { type: "image_url" as const, image_url: { url: media.dataUrl } }
 })
 
 const openAICompatibleReasoningContent = (native: unknown) =>
   isRecord(native) && typeof native.reasoning_content === "string" ? native.reasoning_content : undefined
 
-const reasoningField = (part: ReasoningPart, providerMetadataKey: string) => {
-  const field = part.providerMetadata?.[providerMetadataKey]?.reasoningField
+const reasoningField = (part: ReasoningPart, routeID: string) => {
+  const field = part.providerMetadata?.[routeID]?.reasoningField
   return typeof field === "string" ? field : undefined
 }
 
-const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown, providerMetadataKey: string) => {
+const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown, routeID: string) => {
   const observed = parts.flatMap((part) => {
-    const details = part.providerMetadata?.[providerMetadataKey]?.reasoningDetails
+    const details = part.providerMetadata?.[routeID]?.reasoningDetails
     return Array.isArray(details) ? details : []
   })
-  if (parts.some((part) => Array.isArray(part.providerMetadata?.[providerMetadataKey]?.reasoningDetails)))
-    return observed
+  if (parts.some((part) => Array.isArray(part.providerMetadata?.[routeID]?.reasoningDetails))) return observed
   if (isRecord(native) && Array.isArray(native.reasoning_details)) return native.reasoning_details
 }
 
@@ -376,7 +371,7 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
   message: OpenAIChatRequestMessage,
   configuredField: string | undefined,
   requireReasoning: boolean,
-  options: LoweringOptions & { readonly providerMetadataKey: string },
+  options: LoweringOptions & { readonly routeID: string },
 ) {
   const content: TextPart[] = []
   const reasoning: ReasoningPart[] = []
@@ -398,13 +393,13 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
     }
   }
   const text = reasoning.map((part) => part.text).join("")
-  const details = reasoningDetails(reasoning, message.native?.openaiCompatible, options.providerMetadataKey)
+  const details = reasoningDetails(reasoning, message.native?.openaiCompatible, options.routeID)
   const observedField = reasoning
-    .map((part) => reasoningField(part, options.providerMetadataKey))
+    .map((part) => reasoningField(part, options.routeID))
     .find((value) => value !== undefined)
   const nativeReasoning = openAICompatibleReasoningContent(message.native?.openaiCompatible)
   const fullyStructured = reasoning.every((part) =>
-    Array.isArray(part.providerMetadata?.[options.providerMetadataKey]?.reasoningDetails),
+    Array.isArray(part.providerMetadata?.[options.routeID]?.reasoningDetails),
   )
   const field = (() => {
     if (configuredField !== undefined && (requireReasoning || reasoning.length > 0 || nativeReasoning !== undefined))
@@ -473,7 +468,7 @@ const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (
   message: OpenAIChatRequestMessage,
   reasoningField: string | undefined,
   requireReasoning: boolean,
-  options: LoweringOptions & { readonly providerMetadataKey: string },
+  options: LoweringOptions & { readonly routeID: string },
 ) {
   if (message.role === "user") return [yield* lowerUserMessage(message, options)]
   if (message.role === "assistant")
@@ -509,7 +504,7 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
   const mistral = ["mistral", "devstral", "codestral", "pixtral", "mixtral"].some((family) => modelID.includes(family))
   const lowering = {
     ...options,
-    providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
+    routeID: request.model.route.id,
     toolCallID: (id: string) => {
       if (mistral)
         return id
@@ -770,7 +765,7 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
               supportsStrictMode,
             ),
           ),
-    tool_choice: hasActiveTools && request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
+    tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
     stream: true as const,
     ...(supportsUsageInStreaming ? { stream_options: { include_usage: true } } : {}),
     ...(zaiToolStream && hasActiveTools ? { tool_stream: true } : {}),
@@ -837,7 +832,7 @@ const mapFinishReason = Effect.fn("OpenAIChat.mapFinishReason")(function* (event
 // Providers differ on cache-hit location: OpenAI uses
 // `prompt_tokens_details.cached_tokens`, DeepSeek uses
 // `prompt_cache_hit_tokens`, and Zai uses top-level `cached_tokens`.
-const mapUsage = (usage: OpenAIChatEvent["usage"], providerMetadataKey: string): Usage | undefined => {
+const mapUsage = (usage: OpenAIChatEvent["usage"], routeID: string): Usage | undefined => {
   if (!usage) return undefined
   const input = usage.prompt_tokens ?? undefined
   const output = usage.completion_tokens ?? undefined
@@ -856,7 +851,7 @@ const mapUsage = (usage: OpenAIChatEvent["usage"], providerMetadataKey: string):
     cacheWriteInputTokens: cacheWrite,
     reasoningTokens: reasoning,
     totalTokens: ProviderShared.totalTokens(input, output, usage.total_tokens ?? undefined),
-    providerMetadata: { [providerMetadataKey]: usage },
+    providerMetadata: { [routeID]: usage },
   })
 }
 
@@ -931,11 +926,11 @@ const conflictingDetailValue = (previous: unknown, current: unknown) =>
   previous !== undefined && previous !== null && current !== undefined && current !== null && previous !== current
 
 const reasoningMetadata = (
-  providerMetadataKey: string,
+  routeID: string,
   field: ParserState["reasoningField"],
   details?: ReadonlyArray<unknown>,
 ) => ({
-  [providerMetadataKey]: {
+  [routeID]: {
     ...(field ? { reasoningField: field } : {}),
     ...(details ? { reasoningDetails: details } : {}),
   },
@@ -959,8 +954,8 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     // `choice.usage` instead of the top-level `usage` field.
     const choiceUsage = (choice as unknown as { usage?: OpenAIChatEvent["usage"] })?.usage
     const usage =
-      mapUsage(event.usage, state.providerMetadataKey) ??
-      (choiceUsage ? mapUsage(choiceUsage, state.providerMetadataKey) : undefined) ??
+      mapUsage(event.usage, state.routeID) ??
+      (choiceUsage ? mapUsage(choiceUsage, state.routeID) : undefined) ??
       state.usage
     const rawFinishReason = choice?.finish_reason
     const finishReason = rawFinishReason
@@ -999,7 +994,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     const detailDelta = Array.isArray(delta?.reasoning_details) ? delta.reasoning_details : undefined
     if (detailDelta !== undefined) appendReasoningDetails(state.reasoningDetails, detailDelta)
     const reasoningDetailsObserved = state.reasoningDetailsObserved || detailDelta !== undefined
-    const deltaMetadata = reasoningMetadata(state.providerMetadataKey, reasoningField)
+    const deltaMetadata = reasoningMetadata(state.routeID, reasoningField)
     const text = detailDelta?.length ? (detailText(detailDelta) ?? reasoning?.text) : reasoning?.text
     if (text !== undefined) lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", text, deltaMetadata)
     else if (
@@ -1088,7 +1083,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
 
     return [
       {
-        providerMetadataKey: state.providerMetadataKey,
+        routeID: state.routeID,
         tools: finished?.tools ?? tools,
         pendingTools,
         toolCallEvents: finished?.events ?? state.toolCallEvents,
@@ -1132,7 +1127,7 @@ const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state: Pars
   // Snapshot details at publish time so the emitted event never observes later
   // mutation of the accumulated `reasoningDetails` array.
   const metadata = reasoningMetadata(
-    state.providerMetadataKey,
+    state.routeID,
     state.reasoningField,
     state.reasoningDetailsObserved ? [...state.reasoningDetails] : undefined,
   )
@@ -1142,7 +1137,7 @@ const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state: Pars
           state.lifecycle,
           events,
           "reasoning-0",
-          reasoningMetadata(state.providerMetadataKey, state.reasoningField),
+          reasoningMetadata(state.routeID, state.reasoningField),
         )
       : state.lifecycle
   const ended = Lifecycle.reasoningEnd(started, events, "reasoning-0", metadata)
@@ -1170,7 +1165,7 @@ export const protocol = Protocol.make({
   stream: {
     event: OpenAIChatStreamEvent,
     initial: (request) => ({
-      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
+      routeID: request.model.route.id,
       tools: ToolStream.empty<number>(),
       pendingTools: {},
       toolCallEvents: [],
@@ -1194,7 +1189,6 @@ export const httpTransport = HttpTransport.sseJson.with<OpenAIChatBody>().with({
 export const route = Route.make({
   id: ADAPTER,
   provider: "openai",
-  providerMetadataKey: "openai",
   protocol,
   endpoint: Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL }),
   auth: Auth.none,

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

@@ -15,7 +15,6 @@ export type OpenAICompatibleChatLanguageModelInput = RouteRoutedLanguageModelInp
  */
 export const route = Route.make({
   id: ADAPTER,
-  providerMetadataKey: "openai",
   protocol: OpenAIChat.protocol,
   endpoint: Endpoint.path("/chat/completions"),
   framing: OpenAIChat.framing,

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

@@ -13,7 +13,6 @@ export type OpenAICompatibleResponsesLanguageModelInput = RouteRoutedLanguageMod
  */
 export const route = Route.make({
   id: ADAPTER,
-  providerMetadataKey: "openresponses",
   protocol: OpenResponses.protocol,
   endpoint: Endpoint.path(OpenResponses.PATH),
   transport: OpenResponses.httpTransport,

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

@@ -199,10 +199,8 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
         ? undefined
         : yield* Effect.forEach(request.tools, (tool) => lowerToolEntry(tool, toolSchemaCompatibility)),
     tool_choice:
-      request.tools.length === 0
-        ? undefined
-        : (OpenResponses.allowedToolChoice(request) ??
-          (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined)),
+      OpenResponses.allowedToolChoice(request) ??
+      (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),
   })
 })
 
@@ -315,7 +313,6 @@ export const route = Route.make({
   compact: { endpoint: ResponsesCompaction.make(adapter), trigger: ResponsesCheckpoint.make(checkpointBody) },
   id: ADAPTER,
   provider: "openai",
-  providerMetadataKey: "openai",
   protocol,
   endpoint,
   auth,

packages/ai/src/protocols/shared.ts

@@ -1,5 +1,5 @@
 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"

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

@@ -57,25 +57,6 @@ const documentBlock = (name: string, format: DocumentFormat, bytes: string): Doc
   },
 })
 
-function documentName(filename: string | undefined, names: Set<string>) {
-  const base =
-    (filename ?? "")
-      .replace(/\.[^.]*$/, "")
-      .replace(/[^a-zA-Z0-9 ()[\]-]/g, " ")
-      .replace(/\s+/g, " ")
-      .trim()
-      .slice(0, 200)
-      .trim() || "document"
-  let name = base
-  // Converse requires labels to be unique across the entire request, including tool results.
-  for (let index = 2; names.has(name); index++) {
-    const suffix = ` ${index}`
-    name = `${base.slice(0, 200 - suffix.length).trimEnd()}${suffix}`
-  }
-  names.add(name)
-  return name
-}
-
 const mediaBase64 = Effect.fn("BedrockMedia.mediaBase64")(function* (part: MediaPart) {
   const media = ProviderShared.normalizeMedia(part)
   const bytes = yield* Effect.fromResult(Encoding.decodeBase64(media.base64)).pipe(
@@ -91,26 +72,19 @@ const mediaBase64 = Effect.fn("BedrockMedia.mediaBase64")(function* (part: Media
 // document block. Image MIME types not in `IMAGE_FORMATS` (e.g. `image/svg+xml`)
 // get an image-specific error so the caller knows it's a format-support issue,
 // not a kind-detection issue.
-export const lower = Effect.fn("BedrockMedia.lower")(function* (part: MediaPart, documentNames: Set<string>) {
+export const lower = Effect.fn("BedrockMedia.lower")(function* (part: MediaPart) {
   const mime = part.mediaType.toLowerCase()
   const imageFormat = IMAGE_FORMATS[mime as keyof typeof IMAGE_FORMATS]
   if (imageFormat) {
-    return [{ image: { format: imageFormat, source: { bytes: yield* mediaBase64(part) } } } satisfies ImageBlock]
+    return { image: { format: imageFormat, source: { bytes: yield* mediaBase64(part) } } } satisfies ImageBlock
   }
   if (mime.startsWith("image/"))
     return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support image media type ${part.mediaType}`)
   const documentFormat = DOCUMENT_FORMATS[mime as keyof typeof DOCUMENT_FORMATS]
   if (documentFormat) {
-    const name = documentName(part.filename, documentNames)
-    const block = documentBlock(name, documentFormat, yield* mediaBase64(part))
-    return part.filename !== undefined && part.filename !== name
-      ? [
-          {
-            text: `Attached file ${ProviderShared.encodeJson(part.filename)} has document label ${ProviderShared.encodeJson(name)}.`,
-          },
-          block,
-        ]
-      : [block]
+    if (!part.filename)
+      return yield* ProviderShared.invalidRequest("Bedrock Converse document media requires a filename")
+    return documentBlock(part.filename, documentFormat, yield* mediaBase64(part))
   }
   return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.mediaType}`)
 })

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/mistral-tool-id.ts

@@ -1,34 +0,0 @@
-import type { LLMRequest } from "../../schema/index.js"
-
-export const valid = /^[A-Za-z0-9]{9}$/
-
-export const hash = (value: string) => {
-  const hash = (seed: number) => {
-    let result = seed
-    for (const char of value) result = Math.imul(result ^ char.charCodeAt(0), 16777619)
-    return (result >>> 0).toString(36)
-  }
-  return `${hash(2166136261).padStart(7, "0")}${hash(2246822519).padStart(7, "0")}`.slice(-9)
-}
-
-export const normalizer = (request: LLMRequest) => {
-  const ids = request.messages.flatMap((message) =>
-    message.content.flatMap((part) => (part.type === "tool-call" || part.type === "tool-result" ? [part.id] : [])),
-  )
-  // Reserve valid IDs before projecting any history, including IDs encountered later.
-  const used = new Set(ids.filter((id) => valid.test(id)))
-  const normalized = new Map<string, string>()
-  return (id: string) => {
-    if (valid.test(id)) return id
-    const previous = normalized.get(id)
-    if (previous) return previous
-    let attempt = 0
-    let candidate = hash(id)
-    while (used.has(candidate)) candidate = hash(`${id}:${++attempt}`)
-    used.add(candidate)
-    normalized.set(id, candidate)
-    return candidate
-  }
-}
-
-export * as MistralToolID from "./mistral-tool-id.js"

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

@@ -93,7 +93,7 @@ export const make = <Body>(body: RouteBody<Body>): TriggerCompactOperation =>
           result = new CompactionCheckpointResponse({
             checkpoint,
             responseID,
-            usage: OpenResponses.mapUsage(event.response?.usage, OpenResponses.metadataKey(request.model)),
+            usage: OpenResponses.mapUsage(event.response?.usage, request.model.route.id),
           })
           return [next, [LLMEvent.finish({ reason: { normalized: "stop" } })]] as const
         }),
@@ -102,7 +102,6 @@ export const make = <Body>(body: RouteBody<Body>): TriggerCompactOperation =>
     const route = Route.make({
       id: source.id,
       provider: source.provider,
-      providerMetadataKey: source.providerMetadataKey,
       protocol,
       endpoint: source.endpoint,
       auth: source.auth,

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

@@ -125,7 +125,7 @@ export const make = (adapter: OpenResponses.ProviderAdapter): CompactOperation =
       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)),
+      usage: OpenResponses.mapUsage(result.usage, request.model.route.id),
     })
   })
 
@@ -135,7 +135,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.id
   if (item.type === "reasoning") {
     const summary = item.summary.length ? item.summary : [{ text: "" }]
     return Message.assistant(

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,10 +1,6 @@
 import type { LanguageModel, ProviderOptions } from "./schema/index.js"
 import type { CompactionOperations } from "./route/client.js"
 
-/**
- * Flat, serializable settings for `model(modelID, settings)`. Each entrypoint declares the connection keys it
- * reads; every other key is a request option for the route's protocol.
- */
 export interface Settings extends Readonly<Record<string, unknown>> {
   readonly baseURL?: string
   readonly headers?: Readonly<Record<string, string>>

packages/ai/src/providers/alibaba.ts

@@ -1,144 +0,0 @@
-import { Struct } from "effect"
-import type { ProviderPackage } from "../provider-package.js"
-import { AlibabaChat } from "../protocols/alibaba-chat.js"
-import { AlibabaMessages } from "../protocols/alibaba-messages.js"
-import { AlibabaResponses } from "../protocols/alibaba-responses.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 { Framing } from "../route/framing.js"
-import { ProviderConfigurationError, ProviderID, ToolDefinition, type ModelID } from "../schema/index.js"
-
-export const id = ProviderID.make("alibaba")
-
-export type Region =
-  | "ap-southeast-1"
-  | "cn-beijing"
-  | "cn-hongkong"
-  | "us-east-1"
-  | "eu-central-1"
-  | "ap-northeast-1"
-  | (string & {})
-export type ChatOptionsInput = AlibabaChat.OptionsInput
-export type MessagesOptionsInput = AlibabaMessages.OptionsInput
-export type ResponsesOptionsInput = AlibabaResponses.OptionsInput
-
-type Location = AtLeastOne<{
-  readonly region: Region
-  /** Overrides the selected API's complete base URL, including its version prefix. */
-  readonly baseURL: string
-}> & { readonly workspaceID?: string }
-
-export type Config = Location &
-  Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly providerOptions?: ChatOptionsInput | MessagesOptionsInput | ResponsesOptionsInput
-  }
-export type Settings<Options = ChatOptionsInput> = Location &
-  ProviderPackage.Settings &
-  Options & {
-    readonly apiKey?: string
-  }
-
-const hosts = new Map<string, string>([
-  ["ap-southeast-1", "dashscope-intl.aliyuncs.com"],
-  ["cn-beijing", "dashscope.aliyuncs.com"],
-  ["cn-hongkong", "cn-hongkong.dashscope.aliyuncs.com"],
-  ["us-east-1", "dashscope-us.aliyuncs.com"],
-])
-const chatRoute = Route.make({
-  id: "alibaba-chat",
-  provider: id,
-  providerMetadataKey: "alibaba",
-  protocol: AlibabaChat.protocol,
-  endpoint: Endpoint.path("/chat/completions"),
-  framing: Framing.sse,
-})
-const messagesRoute = Route.make({
-  id: "alibaba-messages",
-  provider: id,
-  providerMetadataKey: "alibaba",
-  protocol: AlibabaMessages.protocol,
-  endpoint: Endpoint.path("/messages"),
-  framing: Framing.sse,
-  headers: () => ({ "anthropic-version": "2023-06-01" }),
-})
-const responsesRoute = Route.make({
-  id: "alibaba-responses",
-  provider: id,
-  providerMetadataKey: "alibaba",
-  protocol: AlibabaResponses.protocol,
-  endpoint: Endpoint.path("/responses"),
-  framing: Framing.sse,
-})
-
-export const routes = [chatRoute, messagesRoute, responsesRoute]
-
-export const configure = (input: Config) => {
-  const { apiKey: _key, auth: _auth, region, workspaceID, baseURL, ...rest } = input
-  const host =
-    region === undefined
-      ? undefined
-      : workspaceID === undefined
-        ? hosts.get(region)
-        : `${workspaceID}.${region}.maas.aliyuncs.com`
-  if (baseURL === undefined) {
-    if (region === undefined)
-      throw new ProviderConfigurationError({ provider: id, message: "Alibaba requires region or baseURL" })
-    if (host === undefined)
-      throw new ProviderConfigurationError({
-        provider: id,
-        message: `Alibaba region ${region} requires workspaceID or baseURL`,
-      })
-  }
-  const opts = { ...rest, auth: AuthOptions.bearer(input, ["DASHSCOPE_API_KEY", "ALIBABA_API_KEY"]) }
-  const common = { ...opts, endpoint: { baseURL: baseURL ?? `https://${host}/compatible-mode/v1` } }
-  const chat = (id: string | ModelID) =>
-    chatRoute.with(common).model<ChatOptionsInput>({ id, compatibility: AlibabaChat.compatibility })
-  const messages = (id: string | ModelID) =>
-    messagesRoute
-      .with({
-        ...opts,
-        endpoint: { baseURL: baseURL ?? `https://${host}/apps/anthropic/v1` },
-      })
-      .model<MessagesOptionsInput>({ id, compatibility: { requireSignature: false } })
-  const responses = (id: string | ModelID) => responsesRoute.with(common).model<ResponsesOptionsInput>({ id })
-  return { id, model: chat, chat, messages, responses, configure }
-}
-
-export const provider = { id, configure }
-
-export const model: ProviderPackage.Definition<Settings, ChatOptionsInput>["model"] = (id, input) =>
-  fromSettings(input).chat(id)
-export const messagesModel: ProviderPackage.Definition<
-  Settings<MessagesOptionsInput>,
-  MessagesOptionsInput
->["model"] = (id, input) => fromSettings(input).messages(id)
-export const responsesModel: ProviderPackage.Definition<
-  Settings<ResponsesOptionsInput>,
-  ResponsesOptionsInput
->["model"] = (id, input) => fromSettings(input).responses(id)
-
-function fromSettings(input: Settings<Config["providerOptions"]>) {
-  const { body, ...rest } = input
-  return configure({
-    ...rest,
-    http: body === undefined ? undefined : { body },
-    providerOptions: Struct.omit(rest, ["apiKey", "baseURL", "headers", "region", "workspaceID"]),
-  })
-}
-
-export const webSearch = () => hostedTool("web_search", "Search the web with Alibaba's hosted search tool.")
-export const webExtractor = () => hostedTool("web_extractor", "Extract web page content with Alibaba's hosted tool.")
-export const codeInterpreter = () => hostedTool("code_interpreter", "Execute code with Alibaba's hosted interpreter.")
-
-function hostedTool(type: "web_search" | "web_extractor" | "code_interpreter", description: string) {
-  return ToolDefinition.make({
-    name: type,
-    description,
-    inputSchema: { type: "object", properties: {} },
-    native: { alibaba: { type } },
-  })
-}
-
-export * as Alibaba from "./alibaba.js"

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

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

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

@@ -1,3 +0,0 @@
-import type { Alibaba } from "../alibaba.js"
-export { messagesModel as model } from "../alibaba.js"
-export type Settings = Alibaba.Settings<Alibaba.MessagesOptionsInput>

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

@@ -1,3 +0,0 @@
-import type { Alibaba } from "../alibaba.js"
-export { responsesModel as model } from "../alibaba.js"
-export type Settings = Alibaba.Settings<Alibaba.ResponsesOptionsInput>

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

@@ -1,10 +1,9 @@
 import { Route, type RouteDefaultsInput } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
-import { OpenResponses } from "../protocols/open-responses.js"
+import { OpenAIResponses } from "../protocols/openai-responses.js"
 import { BedrockAuth, type Credentials } from "../protocols/utils/bedrock-auth.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("amazon-bedrock")
@@ -23,31 +22,30 @@ export type Config = RouteDefaultsInput & {
   readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
-export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly auth?: "bearer" | "sigv4"
-    readonly baseURL?: string
-    readonly credentials?: Credentials
-    readonly profile?: string
-    readonly region?: string
-    readonly topP?: number
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly auth?: "bearer" | "sigv4"
+  readonly baseURL?: string
+  readonly credentials?: Credentials
+  readonly profile?: string
+  readonly region?: string
+  readonly topP?: number
+  readonly providerOptions?: OpenAIProviderOptionsInput
+}
 
 const responsesRoute = Route.make({
   id: "bedrock-mantle-responses",
   provider: id,
-  providerMetadataKey: "mantle",
-  protocol: OpenResponses.protocol,
-  endpoint: Endpoint.path(OpenResponses.PATH),
-  transport: OpenResponses.httpTransport,
-  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
+  protocol: OpenAIResponses.protocol,
+  endpoint: OpenAIResponses.route.endpoint,
+  auth: OpenAIResponses.route.auth,
+  transport: OpenAIResponses.httpTransport,
+  defaults: OpenAIResponses.route.defaults,
 })
 
 const chatRoute = OpenAIChat.route.with({
   id: "bedrock-mantle-chat",
   provider: id,
-  providerMetadataKey: "mantle",
 })
 
 export const routes = [responsesRoute, chatRoute]
@@ -79,12 +77,9 @@ const defaults = (input: Config) => {
 
 export const configure = (input: Config = {}) => {
   if (input.auth === "bearer" && input.apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock Mantle bearer auth requires apiKey" })
+    throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey")
   if (input.auth === "sigv4" && input.apiKey !== undefined)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "Amazon Bedrock Mantle SigV4 auth does not accept apiKey",
-    })
+    throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey")
   const configuredResponsesRoute = configuredRoute(responsesRoute, input)
   const configuredChatRoute = configuredRoute(chatRoute, input)
   const modelDefaults = defaults(input)
@@ -108,29 +103,18 @@ export const configure = (input: Config = {}) => {
 
 export const provider = configure()
 
-const fromSettings = ({
-  apiKey,
-  auth,
-  baseURL,
-  body,
-  credentials,
-  headers,
-  profile,
-  region,
-  topP,
-  ...providerOptions
-}: Settings) =>
+const fromSettings = (settings: Settings) =>
   configure({
-    apiKey,
-    auth,
-    baseURL,
-    credentials,
-    generation: topP === undefined ? undefined : { topP },
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    profile,
-    providerOptions,
-    region,
+    apiKey: settings.apiKey,
+    auth: settings.auth,
+    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"] = (

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

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

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

@@ -3,7 +3,7 @@ import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
 import type { RouteDefaultsInput } from "../route/client.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
 export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
@@ -19,13 +19,13 @@ export type Config = RouteDefaultsInput &
   }
 
 export type Settings = ProviderPackage.Settings &
-  AnthropicMessages.ProviderOptionsInput &
   (
     | { readonly apiKey?: string; readonly authToken?: never }
     | { readonly apiKey?: never; readonly authToken?: string }
   ) & {
     readonly baseURL: string
     readonly provider?: string
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
   }
 
 export const routes = [AnthropicMessages.route]
@@ -36,12 +36,8 @@ const auth = (input: ProviderAuthOption<"optional">) => {
 }
 
 export const configure = (input: Config) => {
+  if (!input.baseURL) throw new Error("Anthropic-compatible providers require a baseURL")
   const provider = input.provider ?? "anthropic-compatible"
-  if (!input.baseURL)
-    throw new ProviderConfigurationError({
-      provider: ProviderID.make(provider),
-      message: "Anthropic-compatible providers require a baseURL",
-    })
   const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
   const route = AnthropicMessages.route.with({
     ...rest,
@@ -63,20 +59,17 @@ export const provider = {
 
 export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
   modelID,
-  { apiKey, authToken, baseURL, body, headers, provider, ...providerOptions },
+  settings,
 ) => {
-  if (apiKey !== undefined && authToken !== undefined)
-    throw new ProviderConfigurationError({
-      provider: ProviderID.make(provider ?? id),
-      message: "Anthropic-compatible apiKey cannot be combined with authToken",
-    })
+  if (settings.apiKey !== undefined && settings.authToken !== undefined)
+    throw new Error("Anthropic-compatible apiKey cannot be combined with authToken")
   return configure({
-    ...(authToken === undefined ? { apiKey: apiKey } : { auth: Auth.bearer(authToken) }),
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    provider,
-    providerOptions,
+    ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    provider: settings.provider,
+    providerOptions: settings.providerOptions,
   }).model(modelID)
 }
 

packages/ai/src/providers/anthropic.ts

@@ -2,7 +2,7 @@ import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { AnthropicCompatible } from "./anthropic-compatible.js"
 
@@ -21,12 +21,12 @@ export type Config = RouteDefaultsInput &
   }
 
 export type Settings = ProviderPackage.Settings &
-  AnthropicMessages.ProviderOptionsInput &
   (
     | { readonly apiKey?: string; readonly authToken?: never }
     | { readonly apiKey?: never; readonly authToken?: string }
   ) & {
     readonly baseURL?: string
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
   }
 
 const auth = (options: ProviderAuthOption<"optional">) => {
@@ -54,18 +54,15 @@ export const configure = (input: Config = {}) => {
 export const provider = configure()
 export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
   modelID,
-  { apiKey, authToken, baseURL, body, headers, ...providerOptions },
+  settings,
 ) => {
-  if (apiKey !== undefined && authToken !== undefined)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "Anthropic apiKey cannot be combined with authToken",
-    })
+  if (settings.apiKey !== undefined && settings.authToken !== undefined)
+    throw new Error("Anthropic apiKey cannot be combined with authToken")
   return configure({
-    ...(authToken === undefined ? { apiKey: apiKey } : { auth: Auth.bearer(authToken) }),
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
   }).model(modelID)
 }

packages/ai/src/providers/azure.ts

@@ -3,7 +3,7 @@ import { Auth } from "../route/auth.js"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
 import type { Route, RouteDefaultsInput, CompactionOperations } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import * as OpenAIResponses from "../protocols/openai-responses.js"
 import { ProviderShared } from "../protocols/shared.js"
@@ -28,12 +28,12 @@ export type LanguageModelOptions = AzureURL &
 export type Config = LanguageModelOptions
 
 export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput &
   AzureURL & {
     readonly apiKey?: string
     readonly apiVersion?: string
     readonly queryParams?: Readonly<Record<string, string>>
     readonly useDeploymentBasedUrls?: boolean
+    readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
 const resourceBaseURL = (resourceName: string) => `https://${resourceName.trim()}.openai.azure.com/openai`
@@ -151,29 +151,19 @@ export const provider = {
   configure,
 }
 
-const config = ({
-  apiKey,
-  apiVersion,
-  baseURL,
-  body,
-  headers,
-  queryParams,
-  resourceName,
-  useDeploymentBasedUrls,
-  ...providerOptions
-}: Settings): Config => {
+const config = (settings: Settings): Config => {
   const common = {
-    apiKey,
-    apiVersion,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
-    queryParams: queryParams === undefined ? undefined : { ...queryParams },
-    useDeploymentBasedUrls,
+    apiKey: settings.apiKey,
+    apiVersion: settings.apiVersion,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
+    useDeploymentBasedUrls: settings.useDeploymentBasedUrls,
   }
-  if (baseURL !== undefined) return { ...common, baseURL }
-  if (resourceName !== undefined) return { ...common, resourceName }
-  throw new ProviderConfigurationError({ provider: id, message: "Azure requires resourceName or baseURL" })
+  if (settings.baseURL !== undefined) return { ...common, baseURL: settings.baseURL }
+  if (settings.resourceName !== undefined) return { ...common, resourceName: settings.resourceName }
+  throw new Error("Azure requires resourceName or baseURL")
 }
 
 export const responsesModel: ProviderPackage.Definition<

packages/ai/src/providers/baseten.ts

@@ -15,16 +15,15 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
+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,
@@ -48,16 +47,13 @@ export const configure = (input: LanguageModelOptions = {}) => {
 
 export const provider = configure()
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
-    apiKey,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    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

@@ -15,16 +15,15 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: OpenAIProviderOptionsInput
+}
 
 export const route = Route.make({
   id: "cerebras-chat",
   provider: id,
-  providerMetadataKey: "cerebras",
   protocol: OpenAIChat.protocol,
   endpoint: Endpoint.path("/chat/completions", { baseURL }),
   framing: OpenAIChat.framing,
@@ -52,14 +51,11 @@ export const configure = (input: LanguageModelOptions = {}) => {
 
 export const provider = configure()
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
-    apiKey,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    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)

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

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js"
 import type { AtLeastOne, ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("cloudflare-ai-gateway")
@@ -27,19 +27,15 @@ export type LanguageModelOptions = GatewayURL &
   }
 
 export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput &
   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 ProviderConfigurationError({
-      provider: id,
-      message: "CloudflareAIGateway.configure requires accountId unless baseURL is supplied",
-    })
+  if (!input.accountId) throw new Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied")
   return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`
 }
 
@@ -57,7 +53,6 @@ const auth = (input: LanguageModelOptions) => {
 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,
@@ -89,25 +84,14 @@ export const configure = (input: LanguageModelOptions) => {
 
 export const provider = { id, configure }
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
-  const {
-    accountId: _,
-    apiKey,
-    baseURL: _url,
-    body,
-    gatewayApiKey,
-    gatewayId: _id,
-    headers,
-    ...providerOptions
-  } = settings
-  return configure({
-    apiKey,
-    gatewayApiKey,
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+  configure({
+    apiKey: settings.apiKey,
+    gatewayApiKey: settings.gatewayApiKey,
     baseURL: baseURL(settings),
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    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

@@ -3,7 +3,7 @@ import { OpenAIChat } from "../protocols/openai-chat.js"
 import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("cloudflare-workers-ai")
@@ -21,25 +21,20 @@ export type LanguageModelOptions = WorkersAIURL &
   }
 
 export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput &
   WorkersAIURL & {
     readonly apiKey?: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
 export const baseURL = (input: WorkersAIURL) => {
   if (input.baseURL) return input.baseURL
-  if (!input.accountId)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "CloudflareWorkersAI.configure requires accountId unless baseURL is supplied",
-    })
+  if (!input.accountId) throw new Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied")
   return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(input.accountId)}/ai/v1`
 }
 
 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,
@@ -63,15 +58,13 @@ export const configure = (input: LanguageModelOptions) => {
 
 export const provider = { id, configure }
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
-  const { accountId: _, apiKey, baseURL: _url, body, headers, ...providerOptions } = settings
-  return configure({
-    apiKey,
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+  configure({
+    apiKey: settings.apiKey,
     baseURL: baseURL(settings),
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    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/deepinfra.ts

@@ -15,16 +15,15 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: OpenAIProviderOptionsInput
+}
 
 export const route = Route.make({
   id: "deepinfra-chat",
   provider: id,
-  providerMetadataKey: "deepinfra",
   protocol: OpenAIChat.protocol,
   endpoint: Endpoint.path("/chat/completions", { baseURL }),
   framing: OpenAIChat.framing,
@@ -55,14 +54,11 @@ export const configure = (input: LanguageModelOptions = {}) => {
 
 export const provider = configure()
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
-    apiKey,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    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)

packages/ai/src/providers/deepseek.ts

@@ -15,16 +15,15 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
+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,
@@ -52,16 +51,13 @@ export const configure = (input: LanguageModelOptions = {}) => {
 
 export const provider = configure()
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
-    apiKey,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    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

@@ -15,16 +15,15 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
+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,
@@ -48,16 +47,13 @@ export const configure = (input: LanguageModelOptions = {}) => {
 
 export const provider = configure()
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
-    apiKey,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    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

@@ -2,7 +2,7 @@ import type { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
@@ -16,19 +16,18 @@ export type Config = RouteDefaultsInput &
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput & {
-    readonly accessToken?: string
-    readonly apiKey?: never
-    readonly baseURL?: string
-    readonly location?: string
-    readonly project?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly accessToken?: string
+  readonly apiKey?: never
+  readonly baseURL?: string
+  readonly location?: string
+  readonly project?: string
+  readonly providerOptions?: OpenAIProviderOptionsInput
+}
 
 const route = Route.make({
   id: "google-vertex-chat",
   provider: id,
-  providerMetadataKey: "vertex",
   protocol: OpenAIChat.protocol,
   endpoint: Endpoint.path("/chat/completions"),
   framing: OpenAIChat.framing,
@@ -37,8 +36,7 @@ const route = Route.make({
 export const routes = [route]
 
 const configuredRoute = (input: Config) => {
-  if ("apiKey" in input && input.apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Chat does not support API keys" })
+  if ("apiKey" in input && input.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
   const {
     accessToken: _accessToken,
     auth: _auth,
@@ -74,19 +72,15 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  { accessToken, apiKey, baseURL, body, headers, location, project, ...providerOptions },
-) => {
-  if (apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Chat does not support API keys" })
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
+  if (settings.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
   return configure({
-    accessToken,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    location,
-    project,
-    providerOptions,
+    accessToken: settings.accessToken,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    location: settings.location,
+    project: settings.project,
+    providerOptions: settings.providerOptions,
   }).model(modelID)
 }

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

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
@@ -25,19 +25,18 @@ export type Config = RouteDefaultsInput &
     readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  AnthropicMessages.ProviderOptionsInput & {
-    readonly accessToken?: string
-    readonly apiKey?: never
-    readonly baseURL?: string
-    readonly location?: string
-    readonly project?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly accessToken?: string
+  readonly apiKey?: never
+  readonly baseURL?: string
+  readonly location?: string
+  readonly project?: string
+  readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
+}
 
 const route = Route.make({
   id: "google-vertex-messages",
   provider: id,
-  providerMetadataKey: "anthropic",
   protocol: Protocol.make({
     id: AnthropicMessages.protocol.id,
     body: {
@@ -67,7 +66,7 @@ export const routes = [route]
 
 const configuredRoute = (input: Config) => {
   if ("apiKey" in input && input.apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Messages does not support API keys" })
+    throw new Error("Google Vertex Messages does not support API keys")
   const {
     accessToken: _accessToken,
     auth: _auth,
@@ -105,17 +104,16 @@ export const provider = {
 
 export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
   modelID,
-  { accessToken, apiKey, baseURL, body, headers, location, project, ...providerOptions },
+  settings,
 ) => {
-  if (apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Messages does not support API keys" })
+  if (settings.apiKey !== undefined) throw new Error("Google Vertex Messages does not support API keys")
   return configure({
-    accessToken,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    location,
-    project,
-    providerOptions,
+    accessToken: settings.accessToken,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    location: settings.location,
+    project: settings.project,
+    providerOptions: settings.providerOptions,
   }).model(modelID)
 }

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

@@ -2,7 +2,7 @@ import type { ProviderPackage } from "../provider-package.js"
 import { OpenResponses } from "../protocols/open-responses.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
 
@@ -16,19 +16,18 @@ export type Config = RouteDefaultsInput &
     readonly providerOptions?: OpenResponsesProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  OpenResponsesProviderOptionsInput & {
-    readonly accessToken?: string
-    readonly apiKey?: never
-    readonly baseURL?: string
-    readonly location?: string
-    readonly project?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly accessToken?: string
+  readonly apiKey?: never
+  readonly baseURL?: string
+  readonly location?: string
+  readonly project?: string
+  readonly providerOptions?: OpenResponsesProviderOptionsInput
+}
 
 const route = Route.make({
   id: "google-vertex-responses",
   provider: id,
-  providerMetadataKey: "vertex",
   protocol: OpenResponses.protocol,
   endpoint: Endpoint.path(OpenResponses.PATH),
   transport: OpenResponses.httpTransport,
@@ -39,7 +38,7 @@ export const routes = [route]
 
 const configuredRoute = (input: Config) => {
   if ("apiKey" in input && input.apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Responses does not support API keys" })
+    throw new Error("Google Vertex Responses does not support API keys")
   const {
     accessToken: _accessToken,
     auth: _auth,
@@ -77,17 +76,16 @@ export const provider = {
 
 export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
   modelID,
-  { accessToken, apiKey, baseURL, body, headers, location, project, ...providerOptions },
+  settings,
 ) => {
-  if (apiKey !== undefined)
-    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Responses does not support API keys" })
+  if (settings.apiKey !== undefined) throw new Error("Google Vertex Responses does not support API keys")
   return configure({
-    accessToken,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    location,
-    project,
-    providerOptions,
+    accessToken: settings.accessToken,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    location: settings.location,
+    project: settings.project,
+    providerOptions: settings.providerOptions,
   }).model(modelID)
 }

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

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

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

@@ -6,7 +6,7 @@ import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
-import { ProviderConfigurationError, ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
+import { ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 
 export interface GeminiOptionsInput extends Gemini.OptionsInput {
@@ -26,7 +26,6 @@ export type Config = RouteDefaultsInput &
   }
 
 export type Settings = ProviderPackage.Settings &
-  GeminiProviderOptionsInput &
   (
     | { readonly accessToken?: string; readonly apiKey?: never }
     | { readonly accessToken?: never; readonly apiKey?: string }
@@ -34,10 +33,11 @@ export type Settings = ProviderPackage.Settings &
     readonly baseURL?: string
     readonly location?: string
     readonly project?: string
+    readonly providerOptions?: GeminiProviderOptionsInput
   }
 
 const fromRequest = Effect.fn("GoogleVertex.fromRequest")(function* (request: LLMRequest) {
-  const { serviceTier: _, ...body } = yield* Gemini.protocol.body.from(request)
+  const body = yield* Gemini.protocol.body.from(request)
   // Vertex's native REST schema rejects `id` on FunctionCall/FunctionResponse parts with HTTP 400,
   // unlike AI Studio, so history minted there cannot be lowered verbatim.
   const contents = body.contents.map((content) => ({
@@ -68,17 +68,12 @@ const protocol = {
 const route = Route.make({
   id: "google-vertex-gemini",
   provider: id,
-  providerMetadataKey: "vertex",
   protocol,
   endpoint: Endpoint.path(({ request }) => {
     const model = String(request.model.id)
     return `/${model.startsWith("endpoints/") ? model : `models/${model}`}:streamGenerateContent?alt=sse`
   }),
   auth: Auth.none,
-  headers: ({ request }): Record<string, string> => {
-    const serviceTier = request.providerOptions?.serviceTier
-    return typeof serviceTier === "string" ? { "x-vertex-ai-llm-shared-request-type": serviceTier } : {}
-  },
   framing: Framing.sse,
 })
 
@@ -97,10 +92,7 @@ const configuredRoute = (input: Config, modelID: string | ModelID) => {
   const apiKey = GoogleVertexShared.apiKey(input)
   const endpointModel = String(modelID).startsWith("endpoints/")
   if (apiKey !== undefined && endpointModel)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "Google Vertex tuned models do not support Express Mode API keys",
-    })
+    throw new Error("Google Vertex tuned models do not support Express Mode API keys")
   const location = GoogleVertexShared.location(inputLocation, "us-central1")
   const project = GoogleVertexShared.project(inputProject)
   const endpoint =
@@ -128,22 +120,16 @@ export const provider = {
   id,
   configure,
 }
-export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"] = (
-  modelID,
-  { accessToken, apiKey, baseURL, body, headers, location, project, ...providerOptions },
-) => {
-  if (apiKey !== undefined && accessToken !== undefined)
-    throw new ProviderConfigurationError({
-      provider: id,
-      message: "Google Vertex apiKey cannot be combined with accessToken or auth",
-    })
+export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"] = (modelID, settings) => {
+  if (settings.apiKey !== undefined && settings.accessToken !== undefined)
+    throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth")
   return configure({
-    ...(apiKey === undefined ? { accessToken: accessToken } : { apiKey: apiKey }),
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    location,
-    project,
-    providerOptions,
+    ...(settings.apiKey === undefined ? { accessToken: settings.accessToken } : { apiKey: settings.apiKey }),
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    location: settings.location,
+    project: settings.project,
+    providerOptions: settings.providerOptions,
   }).model(modelID)
 }

packages/ai/src/providers/google.ts

@@ -20,11 +20,11 @@ export type Config = RouteDefaultsInput &
     readonly providerOptions?: Gemini.ProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  Gemini.ProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: Gemini.ProviderOptionsInput
+}
 
 const auth = (options: ProviderAuthOption<"optional">) => {
   if ("auth" in options && options.auth) return options.auth
@@ -57,16 +57,13 @@ export const configure = (input: Config = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (
-  modelID,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
+export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
-    apiKey,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    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 const image = provider.image

packages/ai/src/providers/groq.ts

@@ -26,11 +26,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
     readonly providerOptions?: ProviderOptions
   }
 
-export type Settings = ProviderPackage.Settings &
-  ProviderOptions & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: ProviderOptions
+}
 
 const Options = Schema.Struct({
   includeReasoning: Schema.optional(Schema.Boolean),
@@ -71,7 +71,6 @@ export const protocol = Protocol.make({
 export const route = Route.make({
   id: "groq-chat",
   provider: id,
-  providerMetadataKey: "openai",
   protocol,
   endpoint: Endpoint.path("/chat/completions", { baseURL }),
   framing: OpenAIChat.framing,
@@ -103,16 +102,13 @@ export const configure = (input: LanguageModelOptions = {}) => {
 
 export const provider = configure()
 
-export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (
-  modelID,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
+export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (modelID, settings) =>
   configure({
-    apiKey,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    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 Groq from "./groq.js"

packages/ai/src/providers/index.ts

@@ -1,4 +1,3 @@
-export * as Alibaba from "./alibaba.js"
 export * as Anthropic from "./anthropic.js"
 export * as AnthropicCompatible from "./anthropic-compatible.js"
 export * as AmazonBedrock from "./amazon-bedrock.js"
@@ -17,10 +16,7 @@ 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"
@@ -28,4 +24,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 type Settings = ProviderPackage.Settings &
-  ProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
-
-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({ apiKey, baseURL, body, headers, ...providerOptions }: Settings) {
-  return configure({
-    apiKey,
-    baseURL,
-    headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    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 type Settings<Options = MessagesOptionsInput> = ProviderPackage.Settings &
-  Options & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
-
-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,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
-  configure({
-    apiKey,
-    baseURL,
-    headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    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,16 +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,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
-  MiniMax.configure({
-    apiKey,
-    baseURL,
-    headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    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,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
-  MiniMax.configure({
-    apiKey,
-    baseURL,
-    headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
-  }).responses(modelID)

packages/ai/src/providers/mistral.ts

@@ -14,11 +14,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
     readonly providerOptions?: ProviderOptions
   }
 
-export type Settings = ProviderPackage.Settings &
-  ProviderOptions & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: ProviderOptions
+}
 
 export const route = MistralChat.route
 export const routes = [route]
@@ -39,16 +39,13 @@ export const configure = (input: LanguageModelOptions = {}) => {
 
 export const provider = configure()
 
-export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (
-  modelID,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
+export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (modelID, settings) =>
   configure({
-    apiKey,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    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 Mistral from "./mistral.js"

packages/ai/src/providers/moonshot.ts

@@ -1,148 +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 type Settings<Options = ChatOptionsInput> = ProviderPackage.Settings &
-  Options & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
-
-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,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
-  configure({
-    apiKey,
-    baseURL,
-    headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    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,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
-  Moonshot.configure({
-    apiKey,
-    baseURL,
-    headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    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,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
-  Moonshot.configure({
-    apiKey,
-    baseURL,
-    headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
-  }).responses(modelID)

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

@@ -16,12 +16,12 @@ export type Config = RouteDefaultsInput &
     readonly providerOptions?: OpenResponsesProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  OpenResponsesProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL: string
-    readonly provider?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL: string
+  readonly provider?: string
+  readonly providerOptions?: OpenResponsesProviderOptionsInput
+}
 
 export const routes = [OpenAICompatibleResponses.route]
 
@@ -48,13 +48,13 @@ export const provider = {
 
 export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
   modelID,
-  { apiKey, baseURL, body, headers, provider, ...providerOptions },
+  settings,
 ) =>
   configure({
-    apiKey,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    provider,
-    providerOptions,
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    provider: settings.provider,
+    providerOptions: settings.providerOptions,
   }).model(modelID)

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

@@ -14,12 +14,12 @@ type GenericModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL: string
-    readonly provider?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL: string
+  readonly provider?: string
+  readonly providerOptions?: OpenAIProviderOptionsInput
+}
 
 export const routes = [OpenAICompatibleChat.route]
 
@@ -45,17 +45,14 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  { apiKey, baseURL, body, headers, provider, ...providerOptions },
-) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
-    apiKey,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    provider,
-    providerOptions,
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    provider: settings.provider,
+    providerOptions: settings.providerOptions,
   }).model(modelID)
 
 export * as OpenAICompatible from "./openai-compatible.js"

packages/ai/src/providers/openai.ts

@@ -57,14 +57,14 @@ export const imageGeneration = (options: ImageGenerationOptions = {}) =>
     },
   })
 
-export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-    readonly organization?: string
-    readonly project?: string
-    readonly queryParams?: Readonly<Record<string, string>>
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly organization?: string
+  readonly project?: string
+  readonly queryParams?: Readonly<Record<string, string>>
+  readonly providerOptions?: OpenAIProviderOptionsInput
+}
 
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "OPENAI_API_KEY")
 
@@ -116,28 +116,19 @@ export const configure = (input: Config = {}) => {
 
 export const provider = configure()
 
-const config = ({
-  apiKey,
-  baseURL,
-  body,
-  headers: given,
-  organization,
-  project,
-  queryParams,
-  ...providerOptions
-}: Settings): Config => {
+const config = (settings: Settings): Config => {
   const headers = {
-    ...(organization === undefined ? {} : { "OpenAI-Organization": organization }),
-    ...(project === undefined ? {} : { "OpenAI-Project": project }),
-    ...given,
+    ...(settings.organization === undefined ? {} : { "OpenAI-Organization": settings.organization }),
+    ...(settings.project === undefined ? {} : { "OpenAI-Project": settings.project }),
+    ...settings.headers,
   }
   return {
-    apiKey,
-    baseURL,
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
     headers: Object.keys(headers).length === 0 ? undefined : headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
-    queryParams: queryParams === undefined ? undefined : { ...queryParams },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
   }
 }
 

packages/ai/src/providers/openrouter.ts

@@ -77,11 +77,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
     readonly providerOptions?: OpenRouterProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  OpenRouterProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: OpenRouterProviderOptionsInput
+}
 
 const OpenRouterBody = Schema.StructWithRest(Schema.Struct(OpenAIChat.bodyFields), [
   Schema.Record(Schema.String, Schema.Any),
@@ -162,7 +162,6 @@ const bodyOptions = (input: unknown) => {
 export const route = Route.make({
   id: ADAPTER,
   provider: id,
-  providerMetadataKey: "openrouter",
   protocol,
   endpoint: Endpoint.path("/chat/completions", { baseURL }),
   framing: OpenAIChat.framing,
@@ -191,12 +190,12 @@ export const configure = (input: LanguageModelOptions = {}) => {
 export const provider = configure()
 export const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptionsInput>["model"] = (
   modelID,
-  { apiKey, baseURL, body, headers, ...providerOptions },
+  settings,
 ) =>
   configure({
-    apiKey,
-    baseURL,
-    headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers,
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
   }).model(modelID)

packages/ai/src/providers/togetherai.ts

@@ -15,16 +15,15 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  OpenAIProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: OpenAIProviderOptionsInput
+}
 
 export const route = Route.make({
   id: "togetherai-chat",
   provider: id,
-  providerMetadataKey: "togetherai",
   protocol: OpenAIChat.protocol,
   endpoint: Endpoint.path("/chat/completions", { baseURL }),
   framing: OpenAIChat.framing,
@@ -52,14 +51,11 @@ export const configure = (input: LanguageModelOptions = {}) => {
 
 export const provider = configure()
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
-    apiKey,
-    baseURL,
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    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)

packages/ai/src/providers/xai.ts

@@ -20,11 +20,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
     readonly providerOptions?: XAIProviderOptionsInput
   }
 
-export type Settings = ProviderPackage.Settings &
-  XAIProviderOptionsInput & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: XAIProviderOptionsInput
+}
 
 export type { XAIImageOptions } from "../protocols/xai-images.js"
 
@@ -32,27 +32,21 @@ const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000
 
 const responsesRoute = Route.make({
   compact: { endpoint: XAIResponses.compact },
-  id: "openai-responses",
+  id: "xai-responses",
   provider: id,
-  providerMetadataKey: "xai",
   protocol: XAIResponses.protocol,
   endpoint: Endpoint.path("/responses", { baseURL }),
   transport: OpenResponsesChannel.transport({
-    id: "openai-responses",
+    id: "xai-responses",
     name: "xAI Responses",
     rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
-    // xAI continues a chain only from stored responses: with `store: false` (the route default) `previous_response_id`
-    // fails with "Response with id=… not found", so those steps are sent in full over the reused connection. It also
-    // rejects `instructions` next to `previous_response_id` and keeps the instructions of the response it continues.
-    continuation: ({ instructions: _instructions, ...request }) => (request.store === false ? undefined : request),
   }),
   defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 })
 
 const chatRoute = Route.make({
-  id: "openai-compatible-chat",
+  id: "xai-chat",
   provider: id,
-  providerMetadataKey: "xai",
   protocol: OpenAIChat.protocol,
   endpoint: Endpoint.path("/chat/completions", { baseURL }),
   framing: OpenAIChat.framing,
@@ -110,13 +104,13 @@ export const model: ProviderPackage.Definition<
   Settings,
   XAIProviderOptionsInput,
   typeof responsesRoute.compact
->["model"] = (modelID, { apiKey, baseURL, body, headers, ...providerOptions }) =>
+>["model"] = (modelID, settings) =>
   configure({
-    apiKey,
-    baseURL,
-    headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers,
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
   }).model(modelID)
 export const responses = provider.responses
 export const chat = provider.chat

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

@@ -1,95 +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 type Settings<Options = ChatOptionsInput> = ProviderPackage.Settings &
-  Options & {
-    readonly apiKey?: string
-    readonly baseURL?: string
-  }
-
-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,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
-  configure({
-    apiKey,
-    baseURL,
-    headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    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,
-  { apiKey, baseURL, body, headers, ...providerOptions },
-) =>
-  ZAICodingPlan.configure({
-    apiKey,
-    baseURL,
-    headers,
-    http: body === undefined ? undefined : { body: { ...body } },
-    providerOptions,
-  }).messages(modelID)