chore(tui): log stalled plugin startup

fix(tui): remove preview session tabs
fix(tools): clarify unavailable tool errors (#48620 )
2026-09-12 11:56:23 +00:00 · 2026-09-12 03:36:30 -04:00 · 2026-09-12 03:22:32 -04:00 · 2026-09-12 02:20:04 -05:00 · 2026-09-12 02:19:30 -05:00 · 2026-09-12 02:10:54 -05:00
2356 changed files with 72937 additions and 24759 deletions
@@ -1,5 +1,5 @@
 ---
-"@opencode-ai/core": patch
+"@opencode/core": patch
 ---

 Correct directory page headings when the read offset is zero.
@@ -0,0 +1,34 @@
+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 }}
@@ -24,13 +24,13 @@ jobs:
      - uses: ./.github/actions/setup-bun

      - name: Build
-        working-directory: packages/www
+        working-directory: services/www
        run: bun run build
        env:
          CLOUDFLARE_ENV: ${{ github.ref_name == 'v2' && 'production' || 'dev' }}

      - name: Deploy
-        working-directory: packages/www
+        working-directory: services/www
        run: bun run deploy
        env:
          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
@@ -11,6 +11,7 @@ on:
      - "bun.lock"
      - "package.json"
      - "packages/*/package.json"
+      - "services/*/package.json"
      - "flake.lock"
      - "nix/node_modules.nix"
      - "nix/scripts/**"
@@ -25,7 +25,7 @@ on:
        required: false
        type: string

-concurrency: ${{ github.workflow }}-${{ github.ref }}-${{ inputs.version || inputs.bump }}
+concurrency: ${{ github.workflow }}-${{ github.ref }}-${{ (github.ref_name == 'v2' && (inputs.version || inputs.bump) && 'release') || inputs.version || inputs.bump }}

 permissions:
  id-token: write
@@ -33,7 +33,7 @@ permissions:
  packages: write

 env:
-  OPENCODE_CHANNEL: ${{ (github.ref_name == 'v2' && 'dev') || '' }}
+  OPENCODE_CHANNEL: ${{ (github.ref_name == 'v2' && !inputs.bump && !inputs.version && 'dev') || '' }}

 jobs:
  version:
@@ -48,7 +48,7 @@ jobs:

      - name: Deploy update service
        if: github.ref_name == 'v2'
-        working-directory: packages/updates
+        working-directory: services/update
        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/opencode2; do
+          for file in packages/cli/dist/cli-darwin-*/bin/opencode; 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
+          name: opencode-preview-cli-macos
          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'
+    if: github.repository == 'anomalyco/opencode' && !(github.ref_name == 'v2' && (inputs.bump || inputs.version))
    steps:
      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0

@@ -221,7 +221,7 @@ jobs:
    needs:
      - version
      - build-node-app-archive
-    if: github.repository == 'anomalyco/opencode'
+    if: github.repository == 'anomalyco/opencode' && !(github.ref_name == 'v2' && (inputs.bump || inputs.version))
    strategy:
      fail-fast: false
      matrix:
@@ -276,10 +276,9 @@ jobs:

  sign-cli-windows:
    needs:
-      - build-cli
-      - version
+      - sign-cli-macos
    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 }}
@@ -292,15 +291,8 @@ jobs:

      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
        with:
-          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: opencode-preview-cli-macos
+          path: packages/cli/dist

      - name: Azure login
        uses: azure/login@a457da9ea143d694b1b9c7c869ebb04ebe844ef5 # v2.3.0
@@ -315,9 +307,9 @@ jobs:
          signing-account-name: ${{ env.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
          certificate-profile-name: ${{ env.AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE }}
          files: |
-            ${{ 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
+            ${{ 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
          exclude-environment-credential: true
          exclude-workload-identity-credential: true
          exclude-managed-identity-credential: true
@@ -333,9 +325,9 @@ jobs:
        shell: pwsh
        run: |
          $files = @(
-            "${{ 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"
+            "${{ 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"
          )

          foreach ($file in $files) {
@@ -345,40 +337,17 @@ 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-cli-signed-windows
-          path: |
-            packages/opencode/dist/opencode-windows-arm64
-            packages/opencode/dist/opencode-windows-x64
-            packages/opencode/dist/opencode-windows-x64-baseline
+          name: opencode-preview-cli
+          path: packages/cli/dist/cli-*
+          if-no-files-found: error

  build-electron:
    needs:
      - version
-      - sign-cli-macos
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'v2'
+      - sign-cli-windows
+    if: github.repository == 'anomalyco/opencode' && (github.ref_name != 'v2' || needs.version.outputs.release != '')
    continue-on-error: false
    env:
      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
@@ -670,19 +639,6 @@ 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 }}
@@ -694,3 +650,6 @@ 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 }}
@@ -49,7 +49,7 @@ jobs:
            echo "app=true" >> "$GITHUB_OUTPUT"
            exit 0
          fi
-          bun x turbo@2.10.2 ls --affected --filter=@opencode-ai/app --output=json > affected.json
+          bun x turbo@2.10.2 ls --affected --filter=@opencode/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-ai/sdk
+            bun turbo verify:package --filter=@opencode/sdk
            exit 0
          fi
-          bun turbo verify:package --affected --filter=@opencode-ai/sdk
+          bun turbo verify:package --affected --filter=@opencode/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: packages/www
+        working-directory: services/www
        run: bun run check:generated

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

 const TEAM = {
  tui: ["kommander", "simonklee"],
@@ -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 `opencode2` background server and live sessions.
+- Run `bun run dev:live` from a development worktree to test its TUI against the currently elected `opencode` 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 `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.
+- 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.
 - 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-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 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 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-ai/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/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
@@ -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-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"]
+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"]

 [test]
 root = "./do-not-run-tests-from-root"
@@ -6,6 +6,7 @@ export function createWebApp(domain: string) {
      $app.stage === "beta"
        ? {
            OPENCODE_CHANNEL: "beta",
+            VITE_OPENCODE_SERVER_MODE: "none",
            VITE_SENTRY_ENVIRONMENT: "beta",
          }
        : undefined,
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail
-APP=opencode2
+APP=opencode
+SOURCE_APP=opencode

 MUTED='\033[0;2m'
 RED='\033[0;31m'
@@ -22,7 +23,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/opencode2
+    ./install --binary /path/to/opencode
 EOF
 }

@@ -165,22 +166,30 @@ else
        exit 1
    fi

+    package_scope="@opencode"
    if [ -z "$requested_version" ]; then
-        metadata=$(curl -fsSL https://registry.npmjs.org/@opencode-ai%2fcli/beta || true)
+        metadata=$(curl -fsSL https://opencode.ai/update/api/beta/cli/npm || true)
        specific_version=$(echo "$metadata" | sed -n 's/.*"version":"\([^"]*\)".*/\1/p')
+        package=$(echo "$metadata" | sed -n 's/.*"package":"\([^"]*\)".*/\1/p')

-        if [ -z "$specific_version" ]; then
+        if [ -z "$specific_version" ] || [ -z "$package" ]; 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="@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)
+    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
    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}"
@@ -193,9 +202,9 @@ else

    filename="cli-$target-$specific_version.tgz"
    url="https://registry.npmjs.org/$package_name/-/$filename"
-    binary_name="$APP"
+    binary_name="$SOURCE_APP"
    if [ "$os" = "windows" ]; then
-        binary_name="$APP.exe"
+        binary_name="$SOURCE_APP.exe"
    fi
 fi

@@ -222,12 +231,7 @@ check_version() {
        installed_version="${installed_version##* }"
        installed_version="${installed_version#v}"

-        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
+        print_message info "${MUTED}Installed version: ${NC}$installed_version."
    fi
 }

@@ -332,15 +336,46 @@ download_and_install() {
    fi

    tar -xzf "$tmp_dir/$filename" -C "$tmp_dir"
-    mv "$tmp_dir/package/bin/$binary_name" "$INSTALL_DIR"
-    chmod 755 "${INSTALL_DIR}/$binary_name"
+    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"
    rm -rf "$tmp_dir"
 }

 install_from_binary() {
    print_message info "\n${MUTED}Installing ${NC}$APP ${MUTED}from: ${NC}$binary_path"
-    cp "$binary_path" "${INSTALL_DIR}/$APP"
-    chmod 755 "${INSTALL_DIR}/$APP"
+    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"
 }

 if [ -n "$binary_path" ]; then
@@ -349,6 +384,7 @@ else
    check_version
    download_and_install
 fi
+install_legacy_shim


 add_to_path() {
@@ -445,7 +481,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 "opencode2     ${MUTED}# Run command${NC}"
+echo -e "opencode      ${MUTED}# Run command${NC}"
 echo -e ""
 echo -e "${MUTED}For more information visit ${NC}https://opencode.ai/v2/docs"
 echo -e ""
@@ -88,7 +88,7 @@ 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-ai/", ""))')
+    cli_package=$(bun -e 'import { getCurrentCli } from "./scripts/utils.ts"; console.log(getCurrentCli().package.replace("@opencode/", ""))')
    mkdir -p "$OPENCODE_CLI_DIST/$cli_package/bin"
    cp ${lib.getExe opencode} "$OPENCODE_CLI_DIST/$cli_package/bin/opencode2"

@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-T1JUv8gUrXavDI1HdVGqNRal4y2Bh5QavpR4DV+bJdA=",
-    "aarch64-linux": "sha256-wlbWdEUVWAafgxaZis0Q+SAas8k6hu3s0C39CnMZ2gw=",
-    "aarch64-darwin": "sha256-74rRue8KQWKzgMMb540beqMzp1DUShlPte6qklYCVTs=",
-    "x86_64-darwin": "sha256-ihr3DoLd/4Lw6WbyXzSQXMP4hrVGk/UiRkO2aoQn8vg="
+    "x86_64-linux": "sha256-yzCk746pospz8EVakHRcDhYJkhGYGSt9dHOPbzO4OYo=",
+    "aarch64-linux": "sha256-MFJVLos4v2r9jazmmr3ldVCJKLrO+Qp/BpGpyM/1lf8=",
+    "aarch64-darwin": "sha256-k8r/HVSgdRSTlJ1lI7EebqbxeA3AElnaw1sDYOPEdQw=",
+    "x86_64-darwin": "sha256-ACJdJfz12xLBQvWIkbuve86znSoGJ2PLDQbgh0cT6/g="
  }
 }
@@ -27,11 +27,12 @@ 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-ai/script
+        ../.github/TEAM_MEMBERS # required by @opencode/script
      ]
    );
  };
@@ -2,18 +2,20 @@
  "$schema": "https://json.schemastore.org/package.json",
  "name": "opencode",
  "description": "AI-powered development tool",
-  "version": "0.0.0",
+  "version": "2.0.1",
  "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=\"$(opencode2 service get password)\" exec bun run dev \"$@\" --server \"$(opencode2 service status)\"' --",
+    "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: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 packages/www dev",
+    "dev:www": "bun run --cwd services/www dev",
    "dev:storybook": "bun --cwd packages/storybook storybook",
    "bench:devex": "bun run --cwd packages/app test:bench:devex",
    "lint": "oxlint",
@@ -34,6 +36,7 @@
  "workspaces": {
    "packages": [
      "packages/*",
+      "services/*",
      "packages/console/*",
      "packages/stats/*"
    ],
@@ -128,8 +131,8 @@
  },
  "dependencies": {
    "@aws-sdk/client-s3": "3.933.0",
-    "@opencode-ai/plugin": "workspace:*",
-    "@opencode-ai/script": "workspace:*",
+    "@opencode/plugin": "workspace:*",
+    "@opencode/script": "workspace:*",
    "heap-snapshot-toolkit": "1.1.3",
    "typescript": "catalog:"
  },
@@ -13,6 +13,7 @@
 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

@@ -81,8 +82,6 @@ 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.
@@ -123,13 +122,14 @@ Keep provider facades small and explicit:

 ### Provider Package Entrypoints

-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.
+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.

 ```ts
-import { model } from "@opencode-ai/ai/providers/openai/responses"
+import { model } from "@opencode/ai/providers/openai/responses"

 const selected = model("gpt-5", {
  apiKey,
+  reasoningEffort: "high",
 })
 ```

@@ -1,12 +1,12 @@
-# @opencode-ai/ai
+# @opencode/ai

 Schema-first language model and image-generation APIs built with Effect.

 ```ts
 import { Effect, Layer } from "effect"
-import { LLM, LLMClient } from "@opencode-ai/ai"
-import { RequestExecutor } from "@opencode-ai/ai/route"
-import { OpenAI } from "@opencode-ai/ai/providers"
+import { LLM, LLMClient } from "@opencode/ai"
+import { RequestExecutor } from "@opencode/ai/route"
+import { OpenAI } from "@opencode/ai/providers"

 const model = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).responses("gpt-4o-mini")

@@ -29,13 +29,323 @@ 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/ai"
-import { OpenAI } from "@opencode-ai/ai/providers"
+import { Image, ImageInput } from "@opencode/ai"
+import { OpenAI } from "@opencode/ai/providers"

 const program = Effect.gen(function* () {
  const response = yield* Image.generate({
@@ -131,7 +441,7 @@ yield *
 Google's current Gemini image models use the same direct API:

 ```ts
-import { Google } from "@opencode-ai/ai/providers"
+import { Google } from "@opencode/ai/providers"

 const googleProgram = Effect.gen(function* () {
  const response = yield* Image.generate({
@@ -207,12 +517,12 @@ The hosted result is represented as a provider-executed tool call and tool resul

 ## Testing

-Use the deterministic test client from `@opencode-ai/ai/testing` to script provider-neutral responses and inspect
+Use the deterministic test client from `@opencode/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/ai/testing"
+import { TestLLM } from "@opencode/ai/testing"

 const programWithTestClient = Effect.gen(function* () {
  const test = yield* TestLLM.Test
@@ -323,8 +633,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/ai"
-import { OpenAI } from "@opencode-ai/ai/providers"
+import { LLM, LLMClient, LLMRequest, Message } from "@opencode/ai"
+import { OpenAI } from "@opencode/ai/providers"

 const request = LLM.request({
  model: OpenAI.configure({ apiKey }).responses("gpt-5.3-codex"),
@@ -344,7 +654,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/ai"
+import { CompactionPart, ProviderID } from "@opencode/ai"

 CompactionPart.make({ provider: ProviderID.make("openai"), id: "cmp_123", encrypted: "..." })
 CompactionPart.make({ provider: ProviderID.make("anthropic"), text: "Summary of the conversation..." })
@@ -450,7 +760,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/ai/providers"
+import { OpenAI, CloudflareAIGateway } from "@opencode/ai/providers"

 const openai = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).responses("gpt-4o-mini")
 const gateway = CloudflareAIGateway.configure({
@@ -464,7 +774,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/ai/providers"
+import { DeepSeek, Fireworks } from "@opencode/ai/providers"

 const deepseek = DeepSeek.configure({ apiKey }).model("deepseek-chat")
 const fireworks = Fireworks.configure({ apiKey }).model("accounts/fireworks/models/my-model")
@@ -474,10 +784,10 @@ The former `OpenAICompatible.baseten`, `.cerebras`, `.deepinfra`, `.deepseek`, `

 ### Provider entrypoints

-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.
+Provider modules are available through dedicated exports from `@opencode/ai`. Each LLM entrypoint exports `model(modelID, settings)`, where `settings` contains provider configuration plus common `headers` and `body` overlays.

 ```ts
-import { model } from "@opencode-ai/ai/providers/openai/responses"
+import { model } from "@opencode/ai/providers/openai/responses"

 const selected = model("gpt-5", {
  apiKey: process.env.OPENAI_API_KEY,
@@ -487,14 +797,14 @@ const selected = model("gpt-5", {

 APIs have separate entrypoints:

- `@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`
+- `@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`

 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.

@@ -503,65 +813,36 @@ 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/ai/providers/google-vertex/gemini"
+import { model } from "@opencode/ai/providers/google-vertex/gemini"

 model("gemini-3.5-flash", { project: "my-project", location: "global" })
 ```

 ```ts
-import { model } from "@opencode-ai/ai/providers/google-vertex/chat"
+import { model } from "@opencode/ai/providers/google-vertex/chat"

 model("deepseek-ai/deepseek-v3.2-maas", { project: "my-project", location: "global" })
 ```

 ```ts
-import { model } from "@opencode-ai/ai/providers/google-vertex/responses"
+import { model } from "@opencode/ai/providers/google-vertex/responses"

 model("xai/grok-4.20-reasoning", { project: "my-project", location: "global" })
 ```

 ```ts
-import { model } from "@opencode-ai/ai/providers/google-vertex/messages"
+import { model } from "@opencode/ai/providers/google-vertex/messages"

 model("claude-sonnet-4-6", { project: "my-project", location: "global" })
 ```

 Additional provider entrypoints include:

- `@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`.
+- `@opencode/ai/providers/baseten`
+- `@opencode/ai/providers/deepseek`
+- `@opencode/ai/providers/fireworks`
+- `@opencode/ai/providers/cloudflare-ai-gateway`
+- `@opencode/ai/providers/cloudflare-workers-ai`

 ## Provider options & HTTP overlays

@@ -1,7 +1,7 @@
 import { Config, Effect, Formatter, Layer, Schema, Stream } from "effect"
-import { LLM, LLMClient, LLMRequest, Message, ProviderID, Tool, ToolRuntime } from "@opencode-ai/ai"
-import { Route, Auth, Endpoint, Framing, Protocol, RequestExecutor } from "@opencode-ai/ai/route"
-import { OpenAI } from "@opencode-ai/ai/providers"
+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"

 /**
 * A runnable walkthrough of the LLM package use-site API.
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.17.20",
-  "name": "@opencode-ai/ai",
+  "version": "2.0.1",
+  "name": "@opencode/ai",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -21,7 +21,7 @@
  "devDependencies": {
    "@clack/prompts": "1.0.0-alpha.1",
    "@effect/platform-node": "catalog:",
-    "@opencode-ai/http-recorder": "workspace:*",
+    "@opencode/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-ai/schema": "workspace:*",
+    "@opencode/schema": "workspace:*",
    "aws4fetch": "1.0.20",
    "effect": "catalog:",
    "google-auth-library": "10.5.0"
@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { Script } from "@opencode-ai/script"
+import { Script } from "@opencode/script"
 import { $ } from "bun"
 import { fileURLToPath } from "url"

@@ -0,0 +1,92 @@
+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"
@@ -0,0 +1,48 @@
+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"
@@ -0,0 +1,98 @@
+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"
@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer"
 import { Effect, Option, Schema } from "effect"
-import { Tool } from "@opencode-ai/schema/tool"
+import { Tool } from "@opencode/schema/tool"
 import { Route } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
@@ -50,15 +50,24 @@ 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 type: "enabled"
+      readonly display?: "summarized" | "omitted"
+      readonly block_binding?: ThinkingBlockBinding
+    } & (
      | { readonly budgetTokens: number; readonly budget_tokens?: number }
      | { readonly budgetTokens?: number; readonly budget_tokens: number }
    ))
@@ -301,20 +310,27 @@ 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({
@@ -455,7 +471,7 @@ type AnthropicEvent = Schema.Schema.Type<typeof AnthropicEvent>
 interface ParserState {
  readonly provider: LLMRequest["model"]["provider"]
  readonly compactions: Readonly<Record<number, string | null>>
-  readonly routeID: string
+  readonly providerMetadataKey: string
  readonly tools: ToolStream.State<number>
  readonly reasoningSignatures: Readonly<Record<number, string>>
  readonly usage?: Usage
@@ -563,14 +579,14 @@ const serverToolResultType = (name: string): AnthropicServerToolResultType | und

 const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult")(function* (
  part: ToolResultPart,
-  routeID: string,
+  providerMetadataKey: 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?.[routeID]?.["result"] ?? part.result.value
+  const payload = part.providerMetadata?.[providerMetadataKey]?.["result"] ?? part.result.value
  return {
    type: wireType,
    tool_use_id: scrubToolCallID(part.id),
@@ -857,7 +873,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
  breakpoints: Cache.Breakpoints,
 ) {
  const messages: AnthropicMessage[] = []
-  const routeID = request.model.route.id
+  const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider)

  for (const [index, message] of request.messages.entries()) {
    if (message.role === "system") {
@@ -911,8 +927,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, routeID)
-          const redactedData = redactedDataFromMetadata(part.providerMetadata, routeID)
+          const signature = part.encrypted ?? signatureFromMetadata(part.providerMetadata, providerMetadataKey)
+          const redactedData = redactedDataFromMetadata(part.providerMetadata, providerMetadataKey)
          if (signature === undefined && redactedData !== undefined) {
            content.push({ type: "redacted_thinking", data: redactedData })
            continue
@@ -941,7 +957,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
          continue
        }
        if (part.type === "tool-result" && part.providerExecuted) {
-          content.push(yield* lowerServerToolResult(part, routeID))
+          content.push(yield* lowerServerToolResult(part, providerMetadataKey))
          continue
        }
        return yield* invalid(
@@ -1025,8 +1041,9 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
          ...(outputConfigEffort === undefined ? {} : { effort: outputConfigEffort }),
          ...(outputConfigFormat === undefined ? {} : { format: outputConfigFormat }),
        }
+  const thinking = yield* resolveThinking(input?.thinking)
  return {
-    thinking: yield* resolveThinking(input?.thinking),
+    thinking: applyThinkingBindingDefault(request.model, thinking),
    effort: outputConfigEffort,
    output_config,
    service_tier,
@@ -1037,15 +1054,41 @@ 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 === undefined ? {} : { display }) }
-  if (input.type === "disabled") return { type: "disabled" as const }
-  if (input.type !== "enabled") return undefined
+  if (input.type === "adaptive") return { type: "adaptive" as const, display, block_binding }
  const budget =
    typeof input.budgetTokens === "number"
      ? input.budgetTokens
@@ -1054,7 +1097,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 === undefined ? {} : { display }) }
+  return { type: "enabled" as const, budget_tokens: budget, display, block_binding }
 })

 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) {
@@ -1148,7 +1191,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, routeID: string): Usage | undefined => {
+const mapUsage = (usage: AnthropicUsage | undefined, providerMetadataKey: string): Usage | undefined => {
  if (!usage) return undefined
  const iterations = usage.iterations?.length ? usage.iterations : [usage]
  const last = usage.iterations?.at(-1)
@@ -1175,7 +1218,7 @@ const mapUsage = (usage: AnthropicUsage | undefined, routeID: string): Usage | u
    cacheWriteInputTokens: cacheWrite,
    reasoningTokens: ProviderShared.sumTokens(...iterations.map((item) => item.output_tokens_details?.thinking_tokens)),
    totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
-    providerMetadata: { [routeID]: usage },
+    providerMetadata: { [providerMetadataKey]: usage },
  })
 }

@@ -1184,7 +1227,7 @@ const mapUsage = (usage: AnthropicUsage | undefined, routeID: string): Usage | u
 // 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, routeID: string) => {
+const mergeUsage = (left: Usage | undefined, right: Usage | undefined, providerMetadataKey: string) => {
  if (!left) return right
  if (!right) return left
  const nonCachedInputTokens = right.nonCachedInputTokens ?? left.nonCachedInputTokens
@@ -1203,7 +1246,9 @@ const mergeUsage = (left: Usage | undefined, right: Usage | undefined, routeID:
    reasoningTokens,
    totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
    providerMetadata: {
-      [routeID]: mergeJsonRecords(left.providerMetadata?.[routeID], right.providerMetadata?.[routeID]) ?? {},
+      [providerMetadataKey]:
+        mergeJsonRecords(left.providerMetadata?.[providerMetadataKey], right.providerMetadata?.[providerMetadataKey]) ??
+        {},
    },
  })
 }
@@ -1221,7 +1266,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, routeID: string): LLMEvent | undefined => {
+const serverToolResultEvent = (block: AnthropicStreamBlock, providerMetadataKey: string): LLMEvent | undefined => {
  if (!block.type || !isServerToolResultType(block.type)) return undefined
  const errorPayload =
    typeof block.content === "object" && block.content !== null && "type" in block.content
@@ -1235,7 +1280,7 @@ const serverToolResultEvent = (block: AnthropicStreamBlock, routeID: string): LL
    providerExecuted: true,
    // The complete payload is irreducible provider replay state: subsequent
    // stateless requests must round-trip the typed result block verbatim.
-    providerMetadata: providerMetadata(routeID, { blockType: block.type, result: block.content }),
+    providerMetadata: providerMetadata(providerMetadataKey, { blockType: block.type, result: block.content }),
  })
 }

@@ -1244,8 +1289,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.routeID)
-  return [usage ? { ...state, usage: mergeUsage(state.usage, usage, state.routeID) } : state, NO_EVENTS]
+  const usage = mapUsage(event.message?.usage, state.providerMetadataKey)
+  return [usage ? { ...state, usage: mergeUsage(state.usage, usage, state.providerMetadataKey) } : state, NO_EVENTS]
 }

 const onContentBlockStart = (
@@ -1297,7 +1342,9 @@ const onContentBlockStart = (
    const events: LLMEvent[] = []
    const id = `reasoning-${event.index ?? 0}`
    const metadata =
-      block.signature === undefined ? undefined : providerMetadata(state.routeID, { signature: block.signature })
+      block.signature === undefined
+        ? undefined
+        : providerMetadata(state.providerMetadataKey, { signature: block.signature })
    const lifecycle = Lifecycle.reasoningStart(state.lifecycle, events, id, metadata)
    return [
      {
@@ -1326,14 +1373,14 @@ const onContentBlockStart = (
          state.lifecycle,
          events,
          `reasoning-${event.index ?? 0}`,
-          providerMetadata(state.routeID, { redactedData: block.data }),
+          providerMetadata(state.providerMetadataKey, { redactedData: block.data }),
        ),
      },
      events,
    ]
  }

-  const result = serverToolResultEvent(block, state.routeID)
+  const result = serverToolResultEvent(block, state.providerMetadataKey)
  if (!result) return [state, NO_EVENTS]
  const events: LLMEvent[] = []
  return [{ ...state, lifecycle: Lifecycle.stepStart(state.lifecycle, events) }, [...events, result]]
@@ -1434,7 +1481,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.routeID, { signature }),
+        signature === undefined ? undefined : providerMetadata(state.providerMetadataKey, { signature }),
      )
  events.push(...resultEvents)
  const reasoningSignatures = { ...state.reasoningSignatures }
@@ -1446,7 +1493,7 @@ const onMessageDelta = (
  state: ParserState,
  event: AnthropicEvent & { readonly delta?: AnthropicStreamDelta },
 ): StepResult => {
-  const usage = mergeUsage(state.usage, mapUsage(event.usage, state.routeID), state.routeID)
+  const usage = mergeUsage(state.usage, mapUsage(event.usage, state.providerMetadataKey), state.providerMetadataKey)
  const pendingFinish = (() => {
    const stopReason = event.delta?.stop_reason
    if (stopReason === null || stopReason === undefined) return state.pendingFinish
@@ -1455,7 +1502,7 @@ const onMessageDelta = (
    const finishMetadata =
      stopSequence === null || stopSequence === undefined
        ? state.pendingFinish?.providerMetadata
-        : providerMetadata(state.routeID, { stopSequence })
+        : providerMetadata(state.providerMetadataKey, { stopSequence })
    return {
      reason: {
        normalized: mapFinishReason(stopReason),
@@ -1483,7 +1530,12 @@ 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.routeID, { signature })),
+      Lifecycle.reasoningEnd(
+        current,
+        events,
+        `reasoning-${index}`,
+        providerMetadata(state.providerMetadataKey, { signature }),
+      ),
    lifecycle,
  )
  const finished = Lifecycle.finish(closed, events, {
@@ -1618,7 +1670,7 @@ export const protocol = Protocol.make({
    initial: (request) => ({
      provider: request.model.provider,
      compactions: {},
-      routeID: request.model.route.id,
+      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
      tools: ToolStream.empty<number>(),
      reasoningSignatures: {},
      lifecycle: Lifecycle.initial(),
@@ -1627,24 +1679,21 @@ export const protocol = Protocol.make({
  },
 })

-export const transport = <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management">>() => {
+export const transport = <
+  Body extends Pick<AnthropicMessagesBody, "messages" | "context_management" | "thinking">,
+>() => {
  const http = HttpTransport.httpJson<Body, string>({ framing })
  return {
    ...http,
    prepare: (input: Parameters<typeof http.prepare>[0]) => {
-      if (
-        !input.body.context_management?.edits.length &&
-        !input.body.messages.some((message) => message.content.some((block) => block.type === "compaction"))
-      )
-        return http.prepare(input)
+      const requiredBetas = requiredBetaHeaders(input.body)
+      if (requiredBetas.length === 0) return http.prepare(input)
      const headers = Headers.fromInput(input.request.http?.headers)
-      const betas = new Set(
-        (headers["anthropic-beta"] ?? "")
-          .split(",")
-          .map((item) => item.trim())
-          .filter(Boolean),
-      )
-      betas.add("compact-2026-01-12")
+      const existingBetas = (headers["anthropic-beta"] ?? "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean)
+      const betas = new Set([...existingBetas, ...requiredBetas])
      return http.prepare({
        ...input,
        request: LLMRequest.update(input.request, {
@@ -1658,9 +1707,27 @@ export const transport = <Body extends Pick<AnthropicMessagesBody, "messages" |
  }
 }

+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,
@@ -106,7 +106,7 @@ type BedrockSystemBlock = Schema.Schema.Type<typeof BedrockSystemBlock>
 const BedrockToolSpec = Schema.Struct({
  toolSpec: Schema.Struct({
    name: Schema.String,
-    description: Schema.String,
+    description: Schema.optional(Schema.String),
    inputSchema: Schema.Struct({
      json: JsonObject,
    }),
@@ -222,7 +222,7 @@ type BedrockEvent = Schema.Schema.Type<typeof BedrockEvent>
 const lowerToolSpec = (tool: ToolDefinition, inputSchema: JsonSchema): BedrockToolSpec => ({
  toolSpec: {
    name: tool.name,
-    description: tool.description,
+    ...(tool.description.trim().length > 0 ? { description: tool.description } : {}),
    inputSchema: { json: inputSchema },
  },
 })
@@ -260,14 +260,14 @@ const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>

 const providerMetadata = (key: string, metadata: Record<string, unknown>): ProviderMetadata => ({ [key]: metadata })

-const reasoningSignature = (part: ReasoningPart, routeID: string) => {
-  const metadata = part.providerMetadata?.[routeID]
+const reasoningSignature = (part: ReasoningPart, providerMetadataKey: string) => {
+  const metadata = part.providerMetadata?.[providerMetadataKey]
  if (part.encrypted !== undefined) return part.encrypted
  if (ProviderShared.isRecord(metadata) && typeof metadata.signature === "string") return metadata.signature
 }

-const reasoningRedactedData = (part: ReasoningPart, routeID: string) => {
-  const metadata = part.providerMetadata?.[routeID]
+const reasoningRedactedData = (part: ReasoningPart, providerMetadataKey: string) => {
+  const metadata = part.providerMetadata?.[providerMetadataKey]
  if (ProviderShared.isRecord(metadata) && typeof metadata.redactedData === "string") return metadata.redactedData
 }

@@ -324,7 +324,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
  breakpoints: BedrockCache.Breakpoints,
 ) {
  const messages: BedrockMessage[] = []
-  const routeID = request.model.route.id
+  const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider)

  for (const message of request.messages) {
    if (message.role === "system") {
@@ -372,8 +372,8 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
          continue
        }
        if (part.type === "reasoning") {
-          const signature = reasoningSignature(part, routeID)
-          const redactedData = reasoningRedactedData(part, routeID)
+          const signature = reasoningSignature(part, providerMetadataKey)
+          const redactedData = reasoningRedactedData(part, providerMetadataKey)
          if (signature === undefined && redactedData !== undefined) {
            content.push({ reasoningContent: { redactedContent: redactedData } })
            continue
@@ -485,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, routeID: string): Usage | undefined => {
+const mapUsage = (usage: BedrockUsageSchema | undefined, providerMetadataKey: string): Usage | undefined => {
  if (!usage) return undefined
  const inputTokens = ProviderShared.sumTokens(
    usage.inputTokens,
@@ -499,12 +499,12 @@ const mapUsage = (usage: BedrockUsageSchema | undefined, routeID: string): Usage
    cacheReadInputTokens: usage.cacheReadInputTokens,
    cacheWriteInputTokens: usage.cacheWriteInputTokens,
    totalTokens: ProviderShared.totalTokens(inputTokens, usage.outputTokens, usage.totalTokens),
-    providerMetadata: { [routeID]: usage },
+    providerMetadata: { [providerMetadataKey]: usage },
  })
 }

 interface ParserState {
-  readonly routeID: string
+  readonly providerMetadataKey: 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
@@ -587,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.routeID, { signature: reasoning.signature })
-        if (redactedData !== undefined) return providerMetadata(state.routeID, { redactedData })
+        if (reasoning.signature) return providerMetadata(state.providerMetadataKey, { signature: reasoning.signature })
+        if (redactedData !== undefined) return providerMetadata(state.providerMetadataKey, { redactedData })
      })()
      const lifecycle = (() => {
        if (reasoning.text === undefined && metadata === undefined) return state.lifecycle
@@ -640,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.routeID, { signature })
+          if (signature) return providerMetadata(state.providerMetadataKey, { signature })
          const redactedContent = state.reasoningRedactedContent[index]
          if (redactedContent)
-            return providerMetadata(state.routeID, {
+            return providerMetadata(state.providerMetadataKey, {
              redactedData: encodeRedactedContent(redactedContent),
            })
        })()
@@ -697,7 +697,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
    }

    if (event.metadata) {
-      const usage = mapUsage(event.metadata.usage, state.routeID) ?? state.usage
+      const usage = mapUsage(event.metadata.usage, state.providerMetadataKey) ?? state.usage
      return [
        {
          ...state,
@@ -757,7 +757,7 @@ export const protocol = Protocol.make({
  stream: {
    event: BedrockEvent,
    initial: (request) => ({
-      routeID: request.model.route.id,
+      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
      tools: ToolStream.empty<number>(),
      finishReason: undefined,
      usage: undefined,
@@ -774,6 +774,7 @@ 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
@@ -1,5 +1,5 @@
 import { Effect, Option, Schema } from "effect"
-import { Tool } from "@opencode-ai/schema/tool"
+import { Tool } from "@opencode/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 routeID: string
+  readonly providerMetadataKey: 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.id
+  const metadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider)
  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.routeID, { thoughtSignature: state.reasoningSignature }),
+        : providerMetadata(state.providerMetadataKey, { 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.routeID, { thoughtSignature: state.textSignature }),
+        : providerMetadata(state.providerMetadataKey, { 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.routeID, { promptFeedback: state.promptFeedback }),
+        : providerMetadata(state.providerMetadataKey, { promptFeedback: state.promptFeedback }),
  })
  return events
 }
@@ -634,7 +634,9 @@ const step = (state: ParserState, event: GeminiEvent) => {
  const nextState = {
    ...state,
    promptFeedback: event.promptFeedback ?? state.promptFeedback,
-    usage: event.usageMetadata ? (mapUsage(event.usageMetadata, state.routeID) ?? state.usage) : state.usage,
+    usage: event.usageMetadata
+      ? (mapUsage(event.usageMetadata, state.providerMetadataKey) ?? state.usage)
+      : state.usage,
  }
  const candidate = event.candidates?.[0]
  if (candidate?.finishReason && mapFinishReason(candidate.finishReason, state.hasToolCalls) === "error")
@@ -690,7 +692,9 @@ const step = (state: ParserState, event: GeminiEvent) => {
            lifecycle,
            events,
            textId,
-            textSignature ? providerMetadata(state.routeID, { thoughtSignature: textSignature }) : undefined,
+            textSignature
+              ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature })
+              : undefined,
          )
          textId = undefined
          textSignature = undefined
@@ -704,7 +708,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
          events,
          reasoningId,
          part.text,
-          signature ? providerMetadata(state.routeID, { thoughtSignature: signature }) : undefined,
+          signature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: signature }) : undefined,
        )
        continue
      }
@@ -713,7 +717,9 @@ const step = (state: ParserState, event: GeminiEvent) => {
          lifecycle,
          events,
          reasoningId,
-          reasoningSignature ? providerMetadata(state.routeID, { thoughtSignature: reasoningSignature }) : undefined,
+          reasoningSignature
+            ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
+            : undefined,
        )
        reasoningId = undefined
        reasoningSignature = undefined
@@ -727,7 +733,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
        events,
        textId,
        part.text,
-        textSignature ? providerMetadata(state.routeID, { thoughtSignature: textSignature }) : undefined,
+        textSignature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature }) : undefined,
      )
      textSignature = undefined
      continue
@@ -748,7 +754,9 @@ const step = (state: ParserState, event: GeminiEvent) => {
          lifecycle,
          events,
          reasoningId,
-          reasoningSignature ? providerMetadata(state.routeID, { thoughtSignature: reasoningSignature }) : undefined,
+          reasoningSignature
+            ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
+            : undefined,
        )
        reasoningId = undefined
        reasoningSignature = undefined
@@ -758,7 +766,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
          lifecycle,
          events,
          textId,
-          textSignature ? providerMetadata(state.routeID, { thoughtSignature: textSignature }) : undefined,
+          textSignature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature }) : undefined,
        )
        textId = undefined
        textSignature = undefined
@@ -770,7 +778,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
          name: part.functionCall.name,
          input,
          providerMetadata: part.thoughtSignature
-            ? providerMetadata(state.routeID, { thoughtSignature: part.thoughtSignature })
+            ? providerMetadata(state.providerMetadataKey, { thoughtSignature: part.thoughtSignature })
            : undefined,
        }),
      )
@@ -813,7 +821,7 @@ export const protocol = Protocol.make({
    event: Protocol.jsonEvent(GeminiEvent),
    initial: (request) => ({
      route: `${request.model.provider}/${request.model.route.id}`,
-      routeID: request.model.route.id,
+      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
      hasToolCalls: false,
      lifecycle: Lifecycle.initial(),
      nextReasoningId: 0,
@@ -827,6 +835,7 @@ 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`, {
@@ -0,0 +1,133 @@
+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"
@@ -0,0 +1,52 @@
+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"
@@ -0,0 +1,238 @@
+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"
@@ -287,10 +287,9 @@ 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?.[routeID]?.thinking),
+    (part) => part.type === "reasoning" && isMistralThinkingContent(part.providerMetadata?.mistral?.thinking),
  )
  const content: Array<Schema.Schema.Type<typeof MistralTextContent> | MistralThinkingContent> = []
  const text: string[] = []
@@ -302,7 +301,7 @@ const lowerAssistant = Effect.fn("MistralChat.lowerAssistant")(function* (
      continue
    }
    if (part.type === "reasoning") {
-      const native = part.providerMetadata?.[routeID]?.thinking
+      const native = part.providerMetadata?.mistral?.thinking
      if (structured && isMistralThinkingContent(native)) content.push(native)
      else if (structured) content.push({ type: "text", text: part.text })
      else text.push(part.text)
@@ -379,22 +378,13 @@ 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?.[request.model.route.id]?.thinking),
+        (part) => part.type === "reasoning" && isMistralThinkingContent(part.providerMetadata?.mistral?.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),
-          request.model.route.id,
-        ),
-      )
+      messages.push(yield* lowerAssistant(message, normalizeID, !hasToolCalls && message === request.messages.at(-1)))
      continue
    }
    messages.push(...(yield* lowerToolResults(message, normalizeID)))
@@ -465,7 +455,6 @@ interface ActiveContent {
 }

 export interface ParserState {
-  readonly routeID: string
  readonly tools: ToolStream.State<ToolKey>
  readonly pendingTools: Partial<Record<ToolKey, PendingTool>>
  readonly toolIDs: ReadonlyMap<string, string>
@@ -480,7 +469,7 @@ export interface ParserState {
  readonly finishReason?: FinishReasonDetails
 }

-const mapUsage = (usage: MistralEvent["usage"], routeID: string): Usage | undefined => {
+const mapUsage = (usage: MistralEvent["usage"]): Usage | undefined => {
  if (!usage) return undefined
  const input = usage.prompt_tokens ?? undefined
  const reported =
@@ -496,7 +485,7 @@ const mapUsage = (usage: MistralEvent["usage"], routeID: string): Usage | undefi
    nonCachedInputTokens: ProviderShared.subtractTokens(input, cached),
    cacheReadInputTokens: cached,
    totalTokens: ProviderShared.totalTokens(input, output, usage.total_tokens ?? undefined),
-    providerMetadata: { [routeID]: usage },
+    providerMetadata: { mistral: usage },
  })
 }

@@ -528,7 +517,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, routeID: string) => ({ [routeID]: { thinking } })
+const thinkingMetadata = (thinking: MistralThinkingContent) => ({ mistral: { thinking } })

 const closeActive = (state: ParserState, events: LLMEvent[]) => {
  if (!state.active) return state
@@ -539,7 +528,7 @@ const closeActive = (state: ParserState, events: LLMEvent[]) => {
          state.lifecycle,
          events,
          state.active.id,
-          thinkingMetadata(state.active.thinking ?? { type: "thinking", thinking: [] }, state.routeID),
+          thinkingMetadata(state.active.thinking ?? { type: "thinking", thinking: [] }),
          thinkingText(state.active.thinking?.thinking ?? []),
        )
  return { ...state, lifecycle, active: undefined }
@@ -572,14 +561,8 @@ const appendThinking = (state: ParserState, events: LLMEvent[], part: MistralOut
    ...current,
    lifecycle:
      text.length > 0
-        ? Lifecycle.reasoningDelta(
-            current.lifecycle,
-            events,
-            active.id,
-            text,
-            thinkingMetadata(thinking, state.routeID),
-          )
-        : Lifecycle.reasoningStart(current.lifecycle, events, active.id, thinkingMetadata(thinking, state.routeID)),
+        ? Lifecycle.reasoningDelta(current.lifecycle, events, active.id, text, thinkingMetadata(thinking))
+        : Lifecycle.reasoningStart(current.lifecycle, events, active.id, thinkingMetadata(thinking)),
    active: { ...active, thinking },
    nextContent: current.active ? current.nextContent : current.nextContent + 1,
  }
@@ -700,7 +683,7 @@ const step = Effect.fn("MistralChat.step")(function* (state: ParserState, event:
    })
  }
  const events: LLMEvent[] = []
-  const usage = mapUsage(event.usage, state.routeID) ?? state.usage
+  const usage = mapUsage(event.usage) ?? state.usage
  if (state.finishReason) {
    if (hasLateContent(event))
      return yield* ProviderShared.eventError(
@@ -778,8 +761,7 @@ export const protocol = Protocol.make({
  body: { schema: MistralBody, from: fromRequest },
  stream: {
    event: MistralStreamEvent,
-    initial: (request): ParserState => ({
-      routeID: request.model.route.id,
+    initial: (): ParserState => ({
      tools: ToolStream.empty<ToolKey>(),
      pendingTools: {},
      toolIDs: new Map(),
@@ -801,6 +783,7 @@ 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,
@@ -18,7 +18,6 @@ const WebSocketResponseCreate = Schema.StructWithRest(Schema.Struct({ type: Sche
 ])
 const decodeMessage = ProviderShared.validateWith(Schema.decodeUnknownEffect(WebSocketResponseCreate))
 const encodeMessage = Schema.encodeSync(Schema.fromJsonString(WebSocketResponseCreate))
-const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)

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

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

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

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

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

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

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

-export const OpenResponsesContinuation = { driver } as const
+export * as OpenResponsesContinuation from "./open-responses-continuation.js"
@@ -1,5 +1,5 @@
-import { Effect, Option, Schema } from "effect"
-import type { Content } from "@opencode-ai/schema/tool"
+import { Effect, Option, Schema, SchemaGetter } from "effect"
+import type { Content } from "@opencode/schema/tool"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
 import {
@@ -325,9 +325,8 @@ export const StreamItem = Schema.StructWithRest(
 export type StreamItem = Schema.Schema.Type<typeof StreamItem>
 export type OutputItem = StreamItem & { readonly id: string }

-// The Responses schema puts streaming error details at the top level and
-// response failures under `response.error`. WebSocket failures use an
-// event-level `error` envelope, so accept all three shapes here.
+// Responses-compatible providers put streaming error details at the top level or
+// under `error`, and response failures under `response.error`. Accept all three shapes.
 // https://www.openresponses.org/specification
 const OpenResponsesErrorPayload = Schema.Struct({
  type: optionalNull(Schema.String),
@@ -401,13 +400,45 @@ 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
@@ -423,7 +454,7 @@ export interface ParserState {
  readonly completedCompactions: ReadonlySet<string>
  readonly id: string
  readonly name: string
-  readonly routeID: string
+  readonly providerMetadataKey: string
  readonly tools: ToolStream.State<string>
  readonly hasFunctionCall: boolean
  readonly lifecycle: Lifecycle.State
@@ -476,15 +507,15 @@ 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, routeID: string) => {
-  const metadata = providerMetadata?.[routeID]
+const itemID = (providerMetadata: ProviderMetadata | undefined, providerMetadataKey: string) => {
+  const metadata = providerMetadata?.[providerMetadataKey]
  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, routeID: string): OpenResponsesInputItem => {
-  const id = itemID(part.providerMetadata, routeID)
+const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenResponsesInputItem => {
+  const id = itemID(part.providerMetadata, providerMetadataKey)
  return {
    type: "function_call",
    ...(id === undefined ? {} : { id }),
@@ -495,10 +526,10 @@ const lowerToolCall = (part: ToolCallPart, routeID: string): OpenResponsesInputI
  }
 }

-const lowerReasoning = (part: ReasoningPart, routeID: string): OpenResponsesReasoningInput | undefined => {
-  const metadata = part.providerMetadata?.[routeID]
+const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenResponsesReasoningInput | undefined => {
+  const metadata = part.providerMetadata?.[providerMetadataKey]
  if (!ProviderShared.isRecord(metadata)) return undefined
-  const id = itemID(part.providerMetadata, routeID)
+  const id = itemID(part.providerMetadata, providerMetadataKey)
  const encryptedContent =
    typeof metadata.reasoningEncryptedContent === "string" || metadata.reasoningEncryptedContent === null
      ? metadata.reasoningEncryptedContent
@@ -521,7 +552,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?.[request.model.route.id]?.detail,
+    part.providerMetadata?.[metadataKey(request.model)]?.detail,
  )
  const url =
    typeof part.data === "string" && (part.data.startsWith("https://") || part.data.startsWith("http://"))
@@ -608,12 +639,12 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
  adapter: ProviderAdapter,
 ) {
  const input: LoweredInputItem[] = []
-  const routeID = request.model.route.id
+  const providerMetadataKey = metadataKey(request.model)

  for (const message of request.messages) {
    const metadata = yield* ProviderShared.validateWith(
      Schema.decodeUnknownEffect(Schema.UndefinedOr(MessageMetadata)),
-    )(message.providerMetadata?.[routeID])
+    )(message.providerMetadata?.[providerMetadataKey])
    if (message.role === "system") {
      input.push({
        role: "developer",
@@ -638,8 +669,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?.[routeID]
-          const id = itemID(part.providerMetadata, routeID) ?? metadata?.itemId
+          const partMetadata = part.providerMetadata?.[providerMetadataKey]
+          const id = itemID(part.providerMetadata, providerMetadataKey) ?? metadata?.itemId
          const partPhase = messagePhase(partMetadata?.phase)
          const phase = partPhase === undefined ? metadata?.phase : partPhase
          const group = groups.at(-1)
@@ -652,7 +683,8 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
            type: "message" as const,
            ...(group.id === undefined ? {} : { id: group.id }),
            role: "assistant" as const,
-            status: metadata?.status,
+            // Replayed text is a finished input item, even if generation was cut short.
+            status: "completed",
            content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
            ...(group.phase === undefined ? {} : { phase: group.phase }),
          })),
@@ -675,7 +707,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
        }
        if (part.type === "reasoning") {
          flushText()
-          const reasoning = lowerReasoning(part, routeID)
+          const reasoning = lowerReasoning(part, providerMetadataKey)
          if (!reasoning) continue
          const existing = reasoning.id === undefined ? undefined : reasoningItems[reasoning.id]
          if (existing) {
@@ -691,12 +723,12 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
        if (part.type === "tool-call") {
          flushText()
          if (part.providerExecuted === true) continue
-          input.push(lowerToolCall(part, routeID))
+          input.push(lowerToolCall(part, providerMetadataKey))
          continue
        }
        if (part.type === "tool-result" && part.providerExecuted === true) {
          flushText()
-          const id = itemID(part.providerMetadata, routeID)
+          const id = itemID(part.providerMetadata, providerMetadataKey)
          const hosted =
            part.result.type !== "json"
              ? undefined
@@ -819,11 +851,13 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
      projected.tools.length === 0
        ? undefined
        : yield* Effect.forEach(projected.tools, (tool) =>
-            lowerTool(
-              adapter.name,
-              tool,
-              ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
-            ),
+            tool.native !== undefined && adapter.nativeTool
+              ? adapter.nativeTool(tool.native)
+              : lowerTool(
+                  adapter.name,
+                  tool,
+                  ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
+                ),
          ),
    tool_choice:
      allowedToolChoice(request) ??
@@ -844,7 +878,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, routeID: string) => {
+export const mapUsage = (usage: OpenResponsesUsage | null | undefined, providerMetadataKey: string) => {
  if (!usage) return undefined
  const cached = usage.input_tokens_details?.cached_tokens
  const cacheWrite = usage.input_tokens_details?.cache_write_tokens
@@ -858,7 +892,7 @@ export const mapUsage = (usage: OpenResponsesUsage | null | undefined, routeID:
    cacheWriteInputTokens: cacheWrite,
    reasoningTokens: reasoning,
    totalTokens: ProviderShared.totalTokens(usage.input_tokens, usage.output_tokens, usage.total_tokens),
-    providerMetadata: { [routeID]: usage },
+    providerMetadata: { [providerMetadataKey]: usage },
  })
 }

@@ -874,8 +908,10 @@ 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.routeID]: metadata,
+  [state.providerMetadataKey]: metadata,
 })

 export type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
@@ -1347,7 +1383,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.routeID),
+    usage: mapUsage(event.response?.usage, current.providerMetadataKey),
    providerMetadata:
      event.response?.id || event.response?.service_tier
        ? providerMetadata(current, {
@@ -1484,7 +1520,7 @@ export const initial = (request: LLMRequest, adapter: ProviderAdapter = BASE_ADA
  completedCompactions: new Set<string>(),
  id: adapter.id,
  name: adapter.name,
-  routeID: request.model.route.id,
+  providerMetadataKey: metadataKey(request.model),
  hasFunctionCall: false,
  tools: ToolStream.empty<string>(),
  lifecycle: Lifecycle.initial(),
@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect"
-import { Tool } from "@opencode-ai/schema/tool"
+import { Tool } from "@opencode/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 routeID: string
+  readonly providerMetadataKey: string
  readonly tools: ToolStream.State<number>
  readonly pendingTools: Partial<Record<number, PendingToolDelta>>
  readonly toolCallEvents: ReadonlyArray<LLMEvent>
@@ -329,17 +329,18 @@ const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part: MediaPart
 const openAICompatibleReasoningContent = (native: unknown) =>
  isRecord(native) && typeof native.reasoning_content === "string" ? native.reasoning_content : undefined

-const reasoningField = (part: ReasoningPart, routeID: string) => {
-  const field = part.providerMetadata?.[routeID]?.reasoningField
+const reasoningField = (part: ReasoningPart, providerMetadataKey: string) => {
+  const field = part.providerMetadata?.[providerMetadataKey]?.reasoningField
  return typeof field === "string" ? field : undefined
 }

-const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown, routeID: string) => {
+const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown, providerMetadataKey: string) => {
  const observed = parts.flatMap((part) => {
-    const details = part.providerMetadata?.[routeID]?.reasoningDetails
+    const details = part.providerMetadata?.[providerMetadataKey]?.reasoningDetails
    return Array.isArray(details) ? details : []
  })
-  if (parts.some((part) => Array.isArray(part.providerMetadata?.[routeID]?.reasoningDetails))) return observed
+  if (parts.some((part) => Array.isArray(part.providerMetadata?.[providerMetadataKey]?.reasoningDetails)))
+    return observed
  if (isRecord(native) && Array.isArray(native.reasoning_details)) return native.reasoning_details
 }

@@ -371,7 +372,7 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
  message: OpenAIChatRequestMessage,
  configuredField: string | undefined,
  requireReasoning: boolean,
-  options: LoweringOptions & { readonly routeID: string },
+  options: LoweringOptions & { readonly providerMetadataKey: string },
 ) {
  const content: TextPart[] = []
  const reasoning: ReasoningPart[] = []
@@ -393,13 +394,13 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
    }
  }
  const text = reasoning.map((part) => part.text).join("")
-  const details = reasoningDetails(reasoning, message.native?.openaiCompatible, options.routeID)
+  const details = reasoningDetails(reasoning, message.native?.openaiCompatible, options.providerMetadataKey)
  const observedField = reasoning
-    .map((part) => reasoningField(part, options.routeID))
+    .map((part) => reasoningField(part, options.providerMetadataKey))
    .find((value) => value !== undefined)
  const nativeReasoning = openAICompatibleReasoningContent(message.native?.openaiCompatible)
  const fullyStructured = reasoning.every((part) =>
-    Array.isArray(part.providerMetadata?.[options.routeID]?.reasoningDetails),
+    Array.isArray(part.providerMetadata?.[options.providerMetadataKey]?.reasoningDetails),
  )
  const field = (() => {
    if (configuredField !== undefined && (requireReasoning || reasoning.length > 0 || nativeReasoning !== undefined))
@@ -468,7 +469,7 @@ const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (
  message: OpenAIChatRequestMessage,
  reasoningField: string | undefined,
  requireReasoning: boolean,
-  options: LoweringOptions & { readonly routeID: string },
+  options: LoweringOptions & { readonly providerMetadataKey: string },
 ) {
  if (message.role === "user") return [yield* lowerUserMessage(message, options)]
  if (message.role === "assistant")
@@ -504,7 +505,7 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
  const mistral = ["mistral", "devstral", "codestral", "pixtral", "mixtral"].some((family) => modelID.includes(family))
  const lowering = {
    ...options,
-    routeID: request.model.route.id,
+    providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
    toolCallID: (id: string) => {
      if (mistral)
        return id
@@ -832,7 +833,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"], routeID: string): Usage | undefined => {
+const mapUsage = (usage: OpenAIChatEvent["usage"], providerMetadataKey: string): Usage | undefined => {
  if (!usage) return undefined
  const input = usage.prompt_tokens ?? undefined
  const output = usage.completion_tokens ?? undefined
@@ -851,7 +852,7 @@ const mapUsage = (usage: OpenAIChatEvent["usage"], routeID: string): Usage | und
    cacheWriteInputTokens: cacheWrite,
    reasoningTokens: reasoning,
    totalTokens: ProviderShared.totalTokens(input, output, usage.total_tokens ?? undefined),
-    providerMetadata: { [routeID]: usage },
+    providerMetadata: { [providerMetadataKey]: usage },
  })
 }

@@ -926,11 +927,11 @@ const conflictingDetailValue = (previous: unknown, current: unknown) =>
  previous !== undefined && previous !== null && current !== undefined && current !== null && previous !== current

 const reasoningMetadata = (
-  routeID: string,
+  providerMetadataKey: string,
  field: ParserState["reasoningField"],
  details?: ReadonlyArray<unknown>,
 ) => ({
-  [routeID]: {
+  [providerMetadataKey]: {
    ...(field ? { reasoningField: field } : {}),
    ...(details ? { reasoningDetails: details } : {}),
  },
@@ -954,8 +955,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.routeID) ??
-      (choiceUsage ? mapUsage(choiceUsage, state.routeID) : undefined) ??
+      mapUsage(event.usage, state.providerMetadataKey) ??
+      (choiceUsage ? mapUsage(choiceUsage, state.providerMetadataKey) : undefined) ??
      state.usage
    const rawFinishReason = choice?.finish_reason
    const finishReason = rawFinishReason
@@ -994,7 +995,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.routeID, reasoningField)
+    const deltaMetadata = reasoningMetadata(state.providerMetadataKey, 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 (
@@ -1083,7 +1084,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>

    return [
      {
-        routeID: state.routeID,
+        providerMetadataKey: state.providerMetadataKey,
        tools: finished?.tools ?? tools,
        pendingTools,
        toolCallEvents: finished?.events ?? state.toolCallEvents,
@@ -1127,7 +1128,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.routeID,
+    state.providerMetadataKey,
    state.reasoningField,
    state.reasoningDetailsObserved ? [...state.reasoningDetails] : undefined,
  )
@@ -1137,7 +1138,7 @@ const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state: Pars
          state.lifecycle,
          events,
          "reasoning-0",
-          reasoningMetadata(state.routeID, state.reasoningField),
+          reasoningMetadata(state.providerMetadataKey, state.reasoningField),
        )
      : state.lifecycle
  const ended = Lifecycle.reasoningEnd(started, events, "reasoning-0", metadata)
@@ -1165,7 +1166,7 @@ export const protocol = Protocol.make({
  stream: {
    event: OpenAIChatStreamEvent,
    initial: (request) => ({
-      routeID: request.model.route.id,
+      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
      tools: ToolStream.empty<number>(),
      pendingTools: {},
      toolCallEvents: [],
@@ -1189,6 +1190,7 @@ 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,
@@ -15,6 +15,7 @@ export type OpenAICompatibleChatLanguageModelInput = RouteRoutedLanguageModelInp
 */
 export const route = Route.make({
  id: ADAPTER,
+  providerMetadataKey: "openai",
  protocol: OpenAIChat.protocol,
  endpoint: Endpoint.path("/chat/completions"),
  framing: OpenAIChat.framing,
@@ -13,6 +13,7 @@ export type OpenAICompatibleResponsesLanguageModelInput = RouteRoutedLanguageMod
 */
 export const route = Route.make({
  id: ADAPTER,
+  providerMetadataKey: "openresponses",
  protocol: OpenResponses.protocol,
  endpoint: Endpoint.path(OpenResponses.PATH),
  transport: OpenResponses.httpTransport,
@@ -313,6 +313,7 @@ export const route = Route.make({
  compact: { endpoint: ResponsesCompaction.make(adapter), trigger: ResponsesCheckpoint.make(checkpointBody) },
  id: ADAPTER,
  provider: "openai",
+  providerMetadataKey: "openai",
  protocol,
  endpoint,
  auth,
@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer"
-import { Tool } from "@opencode-ai/schema/tool"
+import { Tool } from "@opencode/schema/tool"
 import { Effect, Schema, Stream } from "effect"
 import * as Sse from "effect/unstable/encoding/Sse"
 import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
@@ -0,0 +1,11 @@
+// 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"
@@ -93,7 +93,7 @@ export const make = <Body>(body: RouteBody<Body>): TriggerCompactOperation =>
          result = new CompactionCheckpointResponse({
            checkpoint,
            responseID,
-            usage: OpenResponses.mapUsage(event.response?.usage, request.model.route.id),
+            usage: OpenResponses.mapUsage(event.response?.usage, OpenResponses.metadataKey(request.model)),
          })
          return [next, [LLMEvent.finish({ reason: { normalized: "stop" } })]] as const
        }),
@@ -102,6 +102,7 @@ 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,
@@ -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, request.model.route.id),
+      usage: OpenResponses.mapUsage(result.usage, OpenResponses.metadataKey(request.model)),
    })
  })

@@ -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 = model.route.id
+  const key = OpenResponses.metadataKey(model)
  if (item.type === "reasoning") {
    const summary = item.summary.length ? item.summary : [{ text: "" }]
    return Message.assistant(
@@ -0,0 +1,75 @@
+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"
@@ -0,0 +1,39 @@
+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"
@@ -1,6 +1,10 @@
 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>>
@@ -0,0 +1,144 @@
+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"
@@ -0,0 +1 @@
+export { model, type Settings } from "../alibaba.js"
@@ -0,0 +1,3 @@
+import type { Alibaba } from "../alibaba.js"
+export { messagesModel as model } from "../alibaba.js"
+export type Settings = Alibaba.Settings<Alibaba.MessagesOptionsInput>
@@ -0,0 +1,3 @@
+import type { Alibaba } from "../alibaba.js"
+export { responsesModel as model } from "../alibaba.js"
+export type Settings = Alibaba.Settings<Alibaba.ResponsesOptionsInput>
@@ -1,9 +1,10 @@
 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 { OpenAIResponses } from "../protocols/openai-responses.js"
+import { OpenResponses } from "../protocols/open-responses.js"
 import { BedrockAuth, type Credentials } from "../protocols/utils/bedrock-auth.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"

 export const id = ProviderID.make("amazon-bedrock")
@@ -22,30 +23,31 @@ export type Config = RouteDefaultsInput & {
  readonly providerOptions?: OpenAIProviderOptionsInput
 }

-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
-}
+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
+  }

 const responsesRoute = Route.make({
  id: "bedrock-mantle-responses",
  provider: id,
-  protocol: OpenAIResponses.protocol,
-  endpoint: OpenAIResponses.route.endpoint,
-  auth: OpenAIResponses.route.auth,
-  transport: OpenAIResponses.httpTransport,
-  defaults: OpenAIResponses.route.defaults,
+  providerMetadataKey: "mantle",
+  protocol: OpenResponses.protocol,
+  endpoint: Endpoint.path(OpenResponses.PATH),
+  transport: OpenResponses.httpTransport,
+  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 })

 const chatRoute = OpenAIChat.route.with({
  id: "bedrock-mantle-chat",
  provider: id,
+  providerMetadataKey: "mantle",
 })

 export const routes = [responsesRoute, chatRoute]
@@ -77,9 +79,12 @@ 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 Error("Amazon Bedrock Mantle bearer auth requires apiKey")
+    throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock Mantle bearer auth requires apiKey" })
  if (input.auth === "sigv4" && input.apiKey !== undefined)
-    throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Amazon Bedrock Mantle SigV4 auth does not accept apiKey",
+    })
  const configuredResponsesRoute = configuredRoute(responsesRoute, input)
  const configuredChatRoute = configuredRoute(chatRoute, input)
  const modelDefaults = defaults(input)
@@ -103,18 +108,29 @@ export const configure = (input: Config = {}) => {

 export const provider = configure()

-const fromSettings = (settings: Settings) =>
+const fromSettings = ({
+  apiKey,
+  auth,
+  baseURL,
+  body,
+  credentials,
+  headers,
+  profile,
+  region,
+  topP,
+  ...providerOptions
+}: Settings) =>
  configure({
-    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,
+    apiKey,
+    auth,
+    baseURL,
+    credentials,
+    generation: topP === undefined ? undefined : { topP },
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    profile,
+    providerOptions,
+    region,
  })

 export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
@@ -1,6 +1,6 @@
 import type { RouteDefaultsInput } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, 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,12 +39,14 @@ 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 Error("Amazon Bedrock bearer auth requires apiKey")
-  if (auth === "sigv4" && apiKey !== undefined) throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey")
+    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" })
  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 }),
  })
@@ -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 { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, 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,8 +36,12 @@ 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,
@@ -59,17 +63,20 @@ export const provider = {

 export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, authToken, baseURL, body, headers, provider, ...providerOptions },
 ) => {
-  if (settings.apiKey !== undefined && settings.authToken !== undefined)
-    throw new Error("Anthropic-compatible apiKey cannot be combined with authToken")
+  if (apiKey !== undefined && authToken !== undefined)
+    throw new ProviderConfigurationError({
+      provider: ProviderID.make(provider ?? id),
+      message: "Anthropic-compatible apiKey cannot be combined with authToken",
+    })
  return configure({
-    ...(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,
+    ...(authToken === undefined ? { apiKey: apiKey } : { auth: Auth.bearer(authToken) }),
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    provider,
+    providerOptions,
  }).model(modelID)
 }

@@ -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 { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, 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,15 +54,18 @@ export const configure = (input: Config = {}) => {
 export const provider = configure()
 export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, authToken, baseURL, body, headers, ...providerOptions },
 ) => {
-  if (settings.apiKey !== undefined && settings.authToken !== undefined)
-    throw new Error("Anthropic apiKey cannot be combined with authToken")
+  if (apiKey !== undefined && authToken !== undefined)
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Anthropic apiKey cannot be combined with authToken",
+    })
  return configure({
-    ...(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,
+    ...(authToken === undefined ? { apiKey: apiKey } : { auth: Auth.bearer(authToken) }),
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
 }
@@ -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 { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, 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,19 +151,29 @@ export const provider = {
  configure,
 }

-const config = (settings: Settings): Config => {
+const config = ({
+  apiKey,
+  apiVersion,
+  baseURL,
+  body,
+  headers,
+  queryParams,
+  resourceName,
+  useDeploymentBasedUrls,
+  ...providerOptions
+}: Settings): Config => {
  const common = {
-    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,
+    apiKey,
+    apiVersion,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
+    queryParams: queryParams === undefined ? undefined : { ...queryParams },
+    useDeploymentBasedUrls,
  }
-  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")
+  if (baseURL !== undefined) return { ...common, baseURL }
+  if (resourceName !== undefined) return { ...common, resourceName }
+  throw new ProviderConfigurationError({ provider: id, message: "Azure requires resourceName or baseURL" })
 }

 export const responsesModel: ProviderPackage.Definition<
@@ -15,15 +15,16 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "baseten-chat",
  provider: id,
+  providerMetadataKey: "baseten",
  protocol: OpenAIChat.protocol,
  endpoint: Endpoint.path("/chat/completions", { baseURL }),
  framing: OpenAIChat.framing,
@@ -47,13 +48,16 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as Baseten from "./baseten.js"
@@ -15,15 +15,16 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "cerebras-chat",
  provider: id,
+  providerMetadataKey: "cerebras",
  protocol: OpenAIChat.protocol,
  endpoint: Endpoint.path("/chat/completions", { baseURL }),
  framing: OpenAIChat.framing,
@@ -51,11 +52,14 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
@@ -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 { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"

 export const id = ProviderID.make("cloudflare-ai-gateway")
@@ -27,15 +27,19 @@ 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 Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied")
+  if (!input.accountId)
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "CloudflareAIGateway.configure requires accountId unless baseURL is supplied",
+    })
  return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`
 }

@@ -53,6 +57,7 @@ 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,
@@ -84,14 +89,25 @@ export const configure = (input: LanguageModelOptions) => {

 export const provider = { id, configure }

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    gatewayApiKey: settings.gatewayApiKey,
+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,
    baseURL: baseURL(settings),
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
+}

 export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js"
@@ -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 { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"

 export const id = ProviderID.make("cloudflare-workers-ai")
@@ -21,20 +21,25 @@ 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 Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied")
+  if (!input.accountId)
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "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,
@@ -58,13 +63,15 @@ export const configure = (input: LanguageModelOptions) => {

 export const provider = { id, configure }

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
+  const { accountId: _, apiKey, baseURL: _url, body, headers, ...providerOptions } = settings
+  return configure({
+    apiKey,
    baseURL: baseURL(settings),
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
+}

 export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js"
@@ -15,15 +15,16 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "deepinfra-chat",
  provider: id,
+  providerMetadataKey: "deepinfra",
  protocol: OpenAIChat.protocol,
  endpoint: Endpoint.path("/chat/completions", { baseURL }),
  framing: OpenAIChat.framing,
@@ -54,11 +55,14 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
@@ -15,15 +15,16 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "deepseek-chat",
  provider: id,
+  providerMetadataKey: "deepseek",
  protocol: OpenAIChat.protocol,
  endpoint: Endpoint.path("/chat/completions", { baseURL }),
  framing: OpenAIChat.framing,
@@ -51,13 +52,16 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as DeepSeek from "./deepseek.js"
@@ -15,15 +15,16 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "fireworks-chat",
  provider: id,
+  providerMetadataKey: "fireworks",
  protocol: OpenAIChat.protocol,
  endpoint: Endpoint.path("/chat/completions", { baseURL }),
  framing: OpenAIChat.framing,
@@ -47,13 +48,16 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as Fireworks from "./fireworks.js"
@@ -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 { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"

@@ -16,18 +16,19 @@ export type Config = RouteDefaultsInput &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly accessToken?: string
-  readonly apiKey?: never
-  readonly baseURL?: string
-  readonly location?: string
-  readonly project?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly accessToken?: string
+    readonly apiKey?: never
+    readonly baseURL?: string
+    readonly location?: string
+    readonly project?: string
+  }

 const route = Route.make({
  id: "google-vertex-chat",
  provider: id,
+  providerMetadataKey: "vertex",
  protocol: OpenAIChat.protocol,
  endpoint: Endpoint.path("/chat/completions"),
  framing: OpenAIChat.framing,
@@ -36,7 +37,8 @@ const route = Route.make({
 export const routes = [route]

 const configuredRoute = (input: Config) => {
-  if ("apiKey" in input && input.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
+  if ("apiKey" in input && input.apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Chat does not support API keys" })
  const {
    accessToken: _accessToken,
    auth: _auth,
@@ -72,15 +74,19 @@ export const provider = {
  configure,
 }

-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")
+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" })
  return configure({
-    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,
+    accessToken,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    location,
+    project,
+    providerOptions,
  }).model(modelID)
 }
@@ -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 { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"

 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
@@ -25,18 +25,19 @@ export type Config = RouteDefaultsInput &
    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
  }

-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
-}
+export type Settings = ProviderPackage.Settings &
+  AnthropicMessages.ProviderOptionsInput & {
+    readonly accessToken?: string
+    readonly apiKey?: never
+    readonly baseURL?: string
+    readonly location?: string
+    readonly project?: string
+  }

 const route = Route.make({
  id: "google-vertex-messages",
  provider: id,
+  providerMetadataKey: "anthropic",
  protocol: Protocol.make({
    id: AnthropicMessages.protocol.id,
    body: {
@@ -66,7 +67,7 @@ export const routes = [route]

 const configuredRoute = (input: Config) => {
  if ("apiKey" in input && input.apiKey !== undefined)
-    throw new Error("Google Vertex Messages does not support API keys")
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Messages does not support API keys" })
  const {
    accessToken: _accessToken,
    auth: _auth,
@@ -104,16 +105,17 @@ export const provider = {

 export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { accessToken, apiKey, baseURL, body, headers, location, project, ...providerOptions },
 ) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Messages does not support API keys")
+  if (apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Messages does not support API keys" })
  return configure({
-    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,
+    accessToken,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    location,
+    project,
+    providerOptions,
  }).model(modelID)
 }
@@ -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 { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"

@@ -16,18 +16,19 @@ export type Config = RouteDefaultsInput &
    readonly providerOptions?: OpenResponsesProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly accessToken?: string
-  readonly apiKey?: never
-  readonly baseURL?: string
-  readonly location?: string
-  readonly project?: string
-  readonly providerOptions?: OpenResponsesProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenResponsesProviderOptionsInput & {
+    readonly accessToken?: string
+    readonly apiKey?: never
+    readonly baseURL?: string
+    readonly location?: string
+    readonly project?: string
+  }

 const route = Route.make({
  id: "google-vertex-responses",
  provider: id,
+  providerMetadataKey: "vertex",
  protocol: OpenResponses.protocol,
  endpoint: Endpoint.path(OpenResponses.PATH),
  transport: OpenResponses.httpTransport,
@@ -38,7 +39,7 @@ export const routes = [route]

 const configuredRoute = (input: Config) => {
  if ("apiKey" in input && input.apiKey !== undefined)
-    throw new Error("Google Vertex Responses does not support API keys")
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Responses does not support API keys" })
  const {
    accessToken: _accessToken,
    auth: _auth,
@@ -76,16 +77,17 @@ export const provider = {

 export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { accessToken, apiKey, baseURL, body, headers, location, project, ...providerOptions },
 ) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Responses does not support API keys")
+  if (apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Responses does not support API keys" })
  return configure({
-    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,
+    accessToken,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    location,
+    project,
+    providerOptions,
  }).model(modelID)
 }
@@ -1,8 +1,10 @@
 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 }
@@ -35,12 +37,18 @@ export const host = (location: string) => {

 export const requireProject = (value: string | undefined) => {
  if (value) return value
-  throw new Error("Google Vertex requires a project when baseURL is not configured")
+  throw new ProviderConfigurationError({
+    provider: id,
+    message: "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 Error("Google Vertex apiKey cannot be combined with accessToken or auth")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "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
 }
@@ -68,7 +76,10 @@ const adc = (project?: string) => {

 export const oauth = (input: OAuthOptions, project?: string) => {
  if (input.accessToken !== undefined && input.auth !== undefined)
-    throw new Error("Google Vertex accessToken cannot be combined with auth")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "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)
@@ -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 { ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"

 export interface GeminiOptionsInput extends Gemini.OptionsInput {
@@ -26,6 +26,7 @@ export type Config = RouteDefaultsInput &
  }

 export type Settings = ProviderPackage.Settings &
+  GeminiProviderOptionsInput &
  (
    | { readonly accessToken?: string; readonly apiKey?: never }
    | { readonly accessToken?: never; readonly apiKey?: string }
@@ -33,7 +34,6 @@ 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) {
@@ -68,6 +68,7 @@ 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)
@@ -92,7 +93,10 @@ const configuredRoute = (input: Config, modelID: string | ModelID) => {
  const apiKey = GoogleVertexShared.apiKey(input)
  const endpointModel = String(modelID).startsWith("endpoints/")
  if (apiKey !== undefined && endpointModel)
-    throw new Error("Google Vertex tuned models do not support Express Mode API keys")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "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 =
@@ -120,16 +124,22 @@ export const provider = {
  id,
  configure,
 }
-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")
+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",
+    })
  return configure({
-    ...(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,
+    ...(apiKey === undefined ? { accessToken: accessToken } : { apiKey: apiKey }),
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    location,
+    project,
+    providerOptions,
  }).model(modelID)
 }
@@ -20,11 +20,11 @@ export type Config = RouteDefaultsInput &
    readonly providerOptions?: Gemini.ProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: Gemini.ProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  Gemini.ProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 const auth = (options: ProviderAuthOption<"optional">) => {
  if ("auth" in options && options.auth) return options.auth
@@ -57,13 +57,16 @@ export const configure = (input: Config = {}) => {
 }

 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export const image = provider.image
@@ -26,11 +26,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: ProviderOptions
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: ProviderOptions
-}
+export type Settings = ProviderPackage.Settings &
+  ProviderOptions & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 const Options = Schema.Struct({
  includeReasoning: Schema.optional(Schema.Boolean),
@@ -71,6 +71,7 @@ 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,
@@ -102,13 +103,16 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as Groq from "./groq.js"
@@ -1,3 +1,4 @@
+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"
@@ -16,7 +17,10 @@ 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"
@@ -24,3 +28,4 @@ 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"
@@ -0,0 +1,182 @@
+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"
@@ -0,0 +1,2 @@
+export { chatModel as model } from "../meta.js"
+export type { Settings } from "../meta.js"
@@ -0,0 +1,2 @@
+export { messagesModel as model } from "../meta.js"
+export type { Settings } from "../meta.js"
@@ -0,0 +1,2 @@
+export { model } from "../meta.js"
+export type { Settings } from "../meta.js"
@@ -0,0 +1,144 @@
+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"
@@ -0,0 +1,16 @@
+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)
@@ -0,0 +1 @@
+export { model, type Settings, type MessagesOptionsInput } from "../minimax.js"
@@ -0,0 +1,16 @@
+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)
@@ -14,11 +14,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: ProviderOptions
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: ProviderOptions
-}
+export type Settings = ProviderPackage.Settings &
+  ProviderOptions & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = MistralChat.route
 export const routes = [route]
@@ -39,13 +39,16 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)

 export * as Mistral from "./mistral.js"
@@ -0,0 +1,148 @@
+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"
@@ -0,0 +1 @@
+export { model, type Settings } from "../moonshot.js"
@@ -0,0 +1,16 @@
+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)
@@ -0,0 +1,16 @@
+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)
@@ -16,12 +16,12 @@ export type Config = RouteDefaultsInput &
    readonly providerOptions?: OpenResponsesProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL: string
-  readonly provider?: string
-  readonly providerOptions?: OpenResponsesProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenResponsesProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL: string
+    readonly provider?: string
+  }

 export const routes = [OpenAICompatibleResponses.route]

@@ -48,13 +48,13 @@ export const provider = {

 export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, baseURL, body, headers, provider, ...providerOptions },
 ) =>
  configure({
-    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,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    provider,
+    providerOptions,
  }).model(modelID)
@@ -14,12 +14,12 @@ type GenericModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL: string
-  readonly provider?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL: string
+    readonly provider?: string
+  }

 export const routes = [OpenAICompatibleChat.route]

@@ -45,14 +45,17 @@ export const provider = {
  configure,
 }

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, provider, ...providerOptions },
+) =>
  configure({
-    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,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    provider,
+    providerOptions,
  }).model(modelID)

 export * as OpenAICompatible from "./openai-compatible.js"
@@ -57,14 +57,14 @@ export const imageGeneration = (options: ImageGenerationOptions = {}) =>
    },
  })

-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
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+    readonly organization?: string
+    readonly project?: string
+    readonly queryParams?: Readonly<Record<string, string>>
+  }

 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "OPENAI_API_KEY")

@@ -116,19 +116,28 @@ export const configure = (input: Config = {}) => {

 export const provider = configure()

-const config = (settings: Settings): Config => {
+const config = ({
+  apiKey,
+  baseURL,
+  body,
+  headers: given,
+  organization,
+  project,
+  queryParams,
+  ...providerOptions
+}: Settings): Config => {
  const headers = {
-    ...(settings.organization === undefined ? {} : { "OpenAI-Organization": settings.organization }),
-    ...(settings.project === undefined ? {} : { "OpenAI-Project": settings.project }),
-    ...settings.headers,
+    ...(organization === undefined ? {} : { "OpenAI-Organization": organization }),
+    ...(project === undefined ? {} : { "OpenAI-Project": project }),
+    ...given,
  }
  return {
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
+    apiKey,
+    baseURL,
    headers: Object.keys(headers).length === 0 ? undefined : headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
+    queryParams: queryParams === undefined ? undefined : { ...queryParams },
  }
 }

@@ -77,11 +77,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenRouterProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenRouterProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenRouterProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 const OpenRouterBody = Schema.StructWithRest(Schema.Struct(OpenAIChat.bodyFields), [
  Schema.Record(Schema.String, Schema.Any),
@@ -162,6 +162,7 @@ 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,
@@ -190,12 +191,12 @@ export const configure = (input: LanguageModelOptions = {}) => {
 export const provider = configure()
 export const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptionsInput>["model"] = (
  modelID,
-  settings,
+  { apiKey, baseURL, body, headers, ...providerOptions },
 ) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
@@ -15,15 +15,16 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: OpenAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: OpenAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  OpenAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export const route = Route.make({
  id: "togetherai-chat",
  provider: id,
+  providerMetadataKey: "togetherai",
  protocol: OpenAIChat.protocol,
  endpoint: Endpoint.path("/chat/completions", { baseURL }),
  framing: OpenAIChat.framing,
@@ -51,11 +52,14 @@ export const configure = (input: LanguageModelOptions = {}) => {

 export const provider = configure()

-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
@@ -20,11 +20,11 @@ export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
    readonly providerOptions?: XAIProviderOptionsInput
  }

-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: XAIProviderOptionsInput
-}
+export type Settings = ProviderPackage.Settings &
+  XAIProviderOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export type { XAIImageOptions } from "../protocols/xai-images.js"

@@ -32,21 +32,27 @@ const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000

 const responsesRoute = Route.make({
  compact: { endpoint: XAIResponses.compact },
-  id: "xai-responses",
+  id: "openai-responses",
  provider: id,
+  providerMetadataKey: "xai",
  protocol: XAIResponses.protocol,
  endpoint: Endpoint.path("/responses", { baseURL }),
  transport: OpenResponsesChannel.transport({
-    id: "xai-responses",
+    id: "openai-responses",
    name: "xAI Responses",
    rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
+    // xAI continues a chain only from stored responses: with `store: false` (the route default) `previous_response_id`
+    // fails with "Response with id=… not found", so those steps are sent in full over the reused connection. It also
+    // rejects `instructions` next to `previous_response_id` and keeps the instructions of the response it continues.
+    continuation: ({ instructions: _instructions, ...request }) => (request.store === false ? undefined : request),
  }),
  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 })

 const chatRoute = Route.make({
-  id: "xai-chat",
+  id: "openai-compatible-chat",
  provider: id,
+  providerMetadataKey: "xai",
  protocol: OpenAIChat.protocol,
  endpoint: Endpoint.path("/chat/completions", { baseURL }),
  framing: OpenAIChat.framing,
@@ -104,13 +110,13 @@ export const model: ProviderPackage.Definition<
  Settings,
  XAIProviderOptionsInput,
  typeof responsesRoute.compact
->["model"] = (modelID, settings) =>
+>["model"] = (modelID, { apiKey, baseURL, body, headers, ...providerOptions }) =>
  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
  }).model(modelID)
 export const responses = provider.responses
 export const chat = provider.chat
@@ -0,0 +1,95 @@
+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"
@@ -0,0 +1 @@
+export { model, type Settings } from "../zai-coding-plan.js"
@@ -0,0 +1,16 @@
+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)
@@ -0,0 +1,16 @@
+import type { ProviderPackage } from "../../provider-package.js"
+import { ZAICodingPlan } from "../zai-coding-plan.js"
+
+export type Settings = ZAICodingPlan.Settings<ZAICodingPlan.ResponsesOptionsInput>
+
+export const model: ProviderPackage.Definition<Settings, ZAICodingPlan.ResponsesOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
+  ZAICodingPlan.configure({
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
+  }).responses(modelID)
@@ -1,20 +1,53 @@
+import type { ProviderPackage } from "../provider-package.js"
+import { ZAIChat } from "../protocols/zai-chat.js"
 import { ZAIImages } from "../protocols/zai-images.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
 import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"

 export const id = ProviderID.make("zai")

-export type Config = ProviderAuthOption<"optional"> & {
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions.Input
-}
+export type ChatOptionsInput = ZAIChat.OptionsInput
+
+export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string
+    readonly providerOptions?: ChatOptionsInput
+  }
+
+export type Settings = ProviderPackage.Settings &
+  ChatOptionsInput & {
+    readonly apiKey?: string
+    readonly baseURL?: string
+  }

 export type { ZAIImageOptions } from "../protocols/zai-images.js"

 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "ZAI_API_KEY")

+const chatRoute = Route.make({
+  id: "zai-chat",
+  provider: id,
+  providerMetadataKey: "zai",
+  protocol: ZAIChat.protocol,
+  endpoint: Endpoint.path("/chat/completions", { baseURL: "https://api.z.ai/api/paas/v4" }),
+  framing: OpenAIChat.framing,
+})
+
+export const routes = [chatRoute]
+
 export const configure = (input: Config = {}) => {
+  const { apiKey: _apiKey, auth: _auth, baseURL, ...rest } = input
+  const chat = (modelID: string | ModelID) =>
+    chatRoute
+      .with({
+        ...rest,
+        endpoint: baseURL === undefined ? undefined : { baseURL },
+        auth: auth(input),
+      })
+      .model<ChatOptionsInput>({ id: modelID, compatibility: ZAIChat.compatibility })
  const image = (modelID: string | ModelID) =>
    ZAIImages.model({
      id: modelID,
@@ -26,6 +59,8 @@ export const configure = (input: Config = {}) => {

  return {
    id,
+    model: chat,
+    chat,
    image,
    configure,
  }
@@ -33,3 +68,18 @@ export const configure = (input: Config = {}) => {

 export const provider = configure()
 export const image = provider.image
+export const chat = provider.chat
+
+export const model: ProviderPackage.Definition<Settings, ChatOptionsInput>["model"] = (
+  modelID,
+  { apiKey, baseURL, body, headers, ...providerOptions },
+) =>
+  configure({
+    apiKey,
+    baseURL,
+    headers,
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
+  }).model(modelID)
+
+export * as ZAI from "./zai.js"
@@ -0,0 +1 @@
+export { model, type Settings } from "../zai.js"
@@ -23,6 +23,7 @@ import {
  LanguageModel,
  LLMEvent,
  InvalidProviderOutputError,
+  ProviderConfigurationError,
  ProviderID,
  mergeGenerationOptions,
  mergeHttpOptions,
@@ -42,9 +43,10 @@ export interface Route<
  Compact extends CompactionOperations | undefined = CompactionOperations | undefined,
 > {
  readonly compact: Compact
-  /** Route identity and namespace for metadata emitted and replayed by this route. */
  readonly id: string
  readonly provider?: ProviderID
+  /** ProviderMetadata namespace emitted and consumed by this route. */
+  readonly providerMetadataKey?: string
  readonly protocol: ProtocolID
  readonly endpoint: Endpoint.Definition<Body>
  readonly auth: Auth.Definition
@@ -112,6 +114,7 @@ export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
  readonly compact?: CompactionOperations
  readonly id?: string
  readonly provider?: string | ProviderID
+  readonly providerMetadataKey?: string
  readonly auth?: Auth.Definition
  readonly transport?: Transport<Body, Prepared, unknown>
  readonly endpoint?: EndpointPatch<Body>
@@ -126,7 +129,10 @@ const makeRouteLanguageModel = <Options extends ProviderOptions, Compact extends
  const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
  if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
  if (!endpointBaseURL(route.endpoint))
-    throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`)
+    throw new ProviderConfigurationError({
+      provider: ProviderID.make(provider),
+      message: `Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`,
+    })
  return LanguageModel.make<Options, Compact>({
    ...mapped,
    provider,
@@ -274,10 +280,12 @@ const resolveRequestOptions = (request: LLMRequest) => {

 export interface MakeInput<Body, Frame, Event, State> {
  readonly compact?: CompactionOperations
-  /** Route identity, also used as the namespace for emitted and replayed ProviderMetadata. */
+  /** Route id used in diagnostics and prepared request metadata. */
  readonly id: string
  /** Provider identity for route-owned model construction. */
  readonly provider?: string | ProviderID
+  /** ProviderMetadata namespace emitted and consumed by this route. */
+  readonly providerMetadataKey?: string
  /** Semantic API contract — owns body construction, body schema, and parsing. */
  readonly protocol: Protocol<Body, Frame, Event, State>
  /** Where the request is sent. */
@@ -294,10 +302,12 @@ export interface MakeInput<Body, Frame, Event, State> {

 export interface MakeTransportInput<Body, Prepared, Frame, Event, State> {
  readonly compact?: CompactionOperations
-  /** Route identity, also used as the namespace for emitted and replayed ProviderMetadata. */
+  /** Route id used in diagnostics and prepared request metadata. */
  readonly id: string
  /** Provider identity for route-owned model construction. */
  readonly provider?: string | ProviderID
+  /** ProviderMetadata namespace emitted and consumed by this route. */
+  readonly providerMetadataKey?: string
  /** Semantic API contract — owns body construction, body schema, and parsing. */
  readonly protocol: Protocol<Body, Frame, Event, State>
  /** Where the request is sent. */
@@ -370,6 +380,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
      compact: routeInput.compact,
      id: routeInput.id,
      provider: routeInput.provider === undefined ? undefined : ProviderID.make(routeInput.provider),
+      providerMetadataKey: routeInput.providerMetadataKey,
      protocol: protocol.id,
      endpoint: routeInput.endpoint,
      auth: routeInput.auth ?? Auth.none,
@@ -378,12 +389,17 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
      defaults: routeInput.defaults ?? {},
      body: protocol.body,
      with: (patch: RoutePatch<Body, Prepared>) => {
-        const { compact, id, provider, auth, transport, endpoint, ...defaults } = patch
+        const { compact, id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch
        return build({
          ...routeInput,
          compact: "compact" in patch ? compact : routeInput.compact,
          id: id ?? routeInput.id,
          provider: provider ?? routeInput.provider,
+          providerMetadataKey:
+            providerMetadataKey ??
+            (provider !== undefined && String(provider) !== String(routeInput.provider)
+              ? String(provider)
+              : routeInput.providerMetadataKey),
          auth: auth ?? routeInput.auth,
          endpoint: endpoint ? Endpoint.merge(routeInput.endpoint, endpoint) : routeInput.endpoint,
          transport: (transport as Transport<Body, Prepared, Frame> | undefined) ?? routeInput.transport,
@@ -524,6 +540,7 @@ export function make<Body, Prepared, Frame, Event, State>(
    compact: input.compact,
    id: input.id,
    provider: input.provider,
+    providerMetadataKey: input.providerMetadataKey,
    protocol,
    endpoint: input.endpoint,
    auth: input.auth,
@@ -115,8 +115,11 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
    }
    const onAbort = () => {
      cleanup()
-      if (ws.readyState !== globalThis.WebSocket.CLOSED && ws.readyState !== globalThis.WebSocket.CLOSING)
-        ws.close(1000)
+      if (ws.readyState === globalThis.WebSocket.CLOSED || ws.readyState === globalThis.WebSocket.CLOSING) return
+      // Node's ws reports an aborted handshake as an error event on the next tick; with no listener left
+      // after cleanup, EventEmitter would throw it as an uncaught exception.
+      ws.addEventListener("error", () => {}, { once: true })
+      ws.close(1000)
    }
    const onOpen = () => {
      cleanup()
@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { Tool } from "@opencode-ai/schema/tool"
+import { Tool } from "@opencode/schema/tool"
 import { ModelID, ProviderID, RouteID } from "./ids.js"

 export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"])
@@ -50,6 +50,19 @@ export class UnsupportedOperationError extends Schema.TaggedError<UnsupportedOpe
  route: Schema.optional(RouteID),
 }) {}

+/**
+ * Provider settings that are missing, conflicting, or unsupported, such as
+ * Azure without `resourceName` or `baseURL`. Thrown synchronously while a
+ * provider facade or package entrypoint configures a model, before any
+ * request exists, so it is not an `AIError` reason.
+ */
+export class ProviderConfigurationError extends Schema.TaggedError<ProviderConfigurationError>(
+  "AI.Error.ProviderConfiguration",
+)("ProviderConfiguration", {
+  provider: ProviderID,
+  message: Schema.String,
+}) {}
+
 export class NoRouteError extends Schema.TaggedError<NoRouteError>("AI.Error.NoRoute")("NoRoute", {
  ...ReasonFields,
  route: RouteID,
@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { LLM } from "@opencode-ai/schema/llm"
+import { LLM } from "@opencode/schema/llm"
 import { ContentBlockID, ToolCallID } from "./ids.js"
 import {
  Message,
@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { Tool } from "@opencode-ai/schema/tool"
+import { Tool } from "@opencode/schema/tool"
 import {
  CacheHint,
  CachePolicy,
@@ -15,7 +15,6 @@ import { ProviderID } from "./ids.js"
 export const MessageRole = Schema.Literals(["system", "user", "assistant", "tool"])
 export type MessageRole = Schema.Schema.Type<typeof MessageRole>

-/** Provider-specific data; LLM routes emit and replay it under their route ID. */
 export const ProviderMetadata = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown)).annotate({
  identifier: "LLM.ProviderMetadata",
 })
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`export { model, type Settings } from "../alibaba.js"`
				`@@ -0,0 +1 @@`
				`export { model, type Settings, type MessagesOptionsInput } from "../minimax.js"`