feat(ai): add media foundation with ModelRef, Media assets, and Image rewrite

docs(ai): add media generation design
feat(plugin): add experimental WebSocket handshake hook (#49131 )
2026-09-16 13:56:21 +00:00 · 2026-09-15 20:50:06 +05:30 · 2026-09-15 18:38:55 +05:30 · 2026-09-15 01:41:00 -05:00 · 2026-09-15 01:23:49 -05:00 · 2026-09-15 01:23:20 -05:00
3568 changed files with 286774 additions and 111531 deletions
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Preserve prompt cache prefixes when sessions move between locations with unchanged instructions.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Fix OpenCode Console device authorization URLs when the server returns an origin-rooted verification path.
@@ -0,0 +1,5 @@
+---
+"@opencode/core": patch
+---
+
+Correct directory page headings when the read offset is zero.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Prompt and synthetic inbox ID reuse is now idempotent: reusing an ID within the same Session succeeds and returns the first admission, ignoring the retried payload, metadata, and delivery mode. Previously reuse with a differing payload failed with a conflict. Cross-Session and cross-type reuse still fail, and control items keep their operation-specific conflict behavior.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Nested AGENTS.md instructions are re-injected after compaction. Previously the in-memory dedup claim outlived the synthetic message that compaction dropped from model-visible history, so nested instructions were silently lost for the rest of the process lifetime. The claim now only guards in-flight loads; the synthetic message metadata in durable history is the sole lasting ledger, so any history truncation (compaction, revert) self-heals on the next read in that subtree.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/plugin": patch
---
-
-Derive Promise plugin API request and response conversion from the canonical protocol schemas.
@@ -1,8 +0,0 @@
---
-"@opencode-ai/core": minor
-"@opencode-ai/schema": minor
-"@opencode-ai/protocol": minor
-"@opencode-ai/client": minor
---
-
-Remove the unused question request API and use session forms for question tool interactions.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Apply shared Session model-request preparation to transient generation.
@@ -1,9 +0,0 @@
---
-"@opencode-ai/core": minor
-"@opencode-ai/schema": minor
-"@opencode-ai/protocol": minor
-"@opencode-ai/client": minor
---
-
-Add an opt-in portable shell permission scanner. Opaque commands use normal shell authorization without inferring
-external directories, while the default tree-sitter path remains unchanged.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Simplify interrupt continuation: the steer-scoped resume decision now lives in SessionExecution as a post-cleanup inbox check, and the run coordinator drops its continuation state machine. Wakes arriving during cancellation cleanup now restart a normal full drain, and interrupting an idle session with continue now resumes pending steering input. Recovery-applied moves now end with the same full wake as inbox-admitted moves, retrying any stranded inbox work at the new location. Interrupting with continue now also resumes a next-in-line control item: between-turn manual compaction and moves run under any drain scope, while queued prompts remain parked.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Title generation and compaction summaries now build their model requests through the shared session request boundary, gaining unsupported-media filtering and image bounds while explicitly opting out of session context hooks: plugins that shape the agent conversation do not observe title or compaction requests. Title requests gain the fork-aware session prompt cache key, and compaction summaries in forked sessions reuse the fork root's prompt cache key instead of the fork's own.
@@ -1,6 +0,0 @@
---
-"@opencode-ai/plugin": patch
-"@opencode-ai/core": patch
---
-
-Add transport-neutral Session model request hooks and provider-scoped hook registration so eligible OpenAI Responses requests can prefer WebSocket without bypassing HTTP-only middleware.
@@ -2,3 +2,4 @@ packages/core/migration/**/snapshot.json linguist-generated
 packages/core/src/database/migration.gen.ts linguist-generated
 packages/core/src/models-dev/snapshot.txt linguist-generated
 packages/core/src/**/*.txt text eol=lf
+packages/httpapi-codegen/test/generated/*.ts text eol=lf
@@ -1,4 +1,4 @@
-name: typecheck
+name: check

 on:
  push:
@@ -8,7 +8,8 @@ on:
  workflow_dispatch:

 jobs:
-  typecheck:
+  check:
+    name: typecheck
    runs-on: blacksmith-4vcpu-ubuntu-2404
    steps:
      - name: Checkout repository
@@ -17,5 +18,5 @@ jobs:
      - name: Setup Bun
        uses: ./.github/actions/setup-bun

-      - name: Run typecheck
-        run: bun typecheck
+      - name: Run checks
+        run: bun run check
@@ -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 }}
@@ -5,6 +5,7 @@ on:
    branches:
      - dev
      - production
+      - beta
  workflow_dispatch:

 concurrency: ${{ github.workflow }}-${{ github.ref }}
@@ -15,7 +16,7 @@ permissions:

 jobs:
  deploy:
-    if: github.repository == 'anomalyco/opencode' && (github.ref_name == 'dev' || github.ref_name == 'production')
+    if: github.repository == 'anomalyco/opencode' && (github.ref_name == 'dev' || github.ref_name == 'production' || github.ref_name == 'beta')
    runs-on: ubuntu-latest
    environment: ${{ github.ref_name }}
    steps:
@@ -28,6 +29,7 @@ jobs:
          node-version: "24"

      - uses: aws-actions/configure-aws-credentials@7474bc4690e29a8392af63c5b98e7449536d5c3a # v4.3.1
+        if: github.ref_name != 'beta'
        with:
          role-to-assume: ${{ vars.AWS_DEPLOY_ROLE_ARN }}
          role-session-name: opencode-${{ github.run_id }}
@@ -11,6 +11,7 @@ on:
      - "bun.lock"
      - "package.json"
      - "packages/*/package.json"
+      - "services/*/package.json"
      - "flake.lock"
      - "nix/node_modules.nix"
      - "nix/scripts/**"
@@ -135,7 +135,16 @@ jobs:

            const linkedIssues = result.repository.pullRequest.closingIssuesReferences.totalCount;

-            if (linkedIssues === 0) {
+            // GitHub only populates closingIssuesReferences when a PR targets the repository's
+            // default branch (dev). PRs targeting other branches like v2 always return totalCount 0.
+            // Fall back to checking the PR description for closing keywords (e.g. Closes #123).
+            const body = pr.body || '';
+            const issueMatch = body.match(/### Issue for this PR\s*\n([\s\S]*?)(?=###|$)/);
+            const issueContent = issueMatch ? issueMatch[1].trim() : body;
+            const hasBodyIssueRef = /(closes|fixes|resolves)\s+#\d+/i.test(issueContent) || /#\d+/.test(issueContent);
+            const hasLinkedIssue = linkedIssues > 0 || hasBodyIssueRef;
+
+            if (!hasLinkedIssue) {
              await addLabel('needs:issue');
              await comment('issue', `Thanks for your contribution!

@@ -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:
@@ -47,8 +47,8 @@ jobs:
      - uses: ./.github/actions/setup-bun

      - name: Deploy update service
-        if: github.ref_name == 'v2' || github.ref_name == 'beta'
-        working-directory: packages/updates
+        if: github.ref_name == 'v2'
+        working-directory: services/update
        run: bun run deploy
        env:
          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
@@ -91,7 +91,7 @@ jobs:

      - uses: ./.github/actions/setup-bun
        with:
-          bun-version: 1.4.0
+          bun-version: 1.4.2

      - name: Setup git committer
        id: committer
@@ -113,7 +113,7 @@ jobs:
        id: build
        run: ./packages/cli/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
        env:
-          BUN_COMPILE_RELEASE: bun-v1.4.0
+          BUN_COMPILE_RELEASE: bun-v1.4.2
          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
          OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
          GH_REPO: ${{ needs.version.outputs.repo }}
@@ -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 }}
@@ -417,7 +386,6 @@ jobs:
      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0

      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name == 'beta'
        with:
          name: opencode-preview-cli
          path: packages/cli/dist
@@ -480,7 +448,7 @@ jobs:
          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
          OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
          OPENCODE_CLI_TARGET: ${{ matrix.settings.target }}
-          OPENCODE_CLI_DIST: ${{ (github.ref_name == 'beta' && format('{0}/packages/cli/dist', github.workspace)) || '' }}
+          OPENCODE_CLI_DIST: ${{ github.workspace }}/packages/cli/dist

      - name: Build
        run: bun run build
@@ -671,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 }}
@@ -695,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 }}
@@ -22,6 +22,36 @@ env:
  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true

 jobs:
+  affected:
+    name: affected packages
+    runs-on: blacksmith-4vcpu-ubuntu-2404
+    outputs:
+      app: ${{ steps.packages.outputs.app }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          fetch-depth: 0
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
+        with:
+          bun-version-file: package.json
+
+      - name: Find affected packages
+        id: packages
+        env:
+          TURBO_SCM_BASE: ${{ github.event_name == 'pull_request' && format('{0}^1', github.sha) || github.event.before }}
+          TURBO_SCM_HEAD: ${{ github.sha }}
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            echo "app=true" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          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:
    name: unit (${{ matrix.settings.name }})
    strategy:
@@ -41,6 +71,7 @@ jobs:
        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
+          fetch-depth: 0

      - name: Setup Node
        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
@@ -80,9 +111,34 @@ jobs:

      - name: Run unit tests
        timeout-minutes: 20
-        run: GITHUB_ACTIONS=false bun turbo test
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            GITHUB_ACTIONS=false bun turbo test
+            exit 0
+          fi
+          GITHUB_ACTIONS=false bun turbo test --affected
        env:
          OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: ${{ runner.os == 'Windows' && 'true' || 'false' }}
+          TURBO_SCM_BASE: ${{ github.event_name == 'pull_request' && format('{0}^1', github.sha) || github.event.before }}
+          TURBO_SCM_HEAD: ${{ github.sha }}
+
+      - name: Verify published codemode package
+        if: runner.os == 'Linux'
+        working-directory: packages/codemode
+        run: bun run script/publish.ts --dry-run
+
+      - name: Verify packed workerd SDK
+        if: runner.os == 'Linux'
+        timeout-minutes: 15
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            bun turbo verify:package --filter=@opencode/sdk
+            exit 0
+          fi
+          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 }}

      - name: Verify compiled service lifecycle
        if: always()
@@ -117,12 +173,12 @@ jobs:

      - name: Check generated documentation
        if: runner.os == 'Linux'
-        working-directory: packages/www
+        working-directory: services/www
        run: bun run check:generated

  e2e:
    name: e2e (${{ matrix.settings.name }})
-    if: github.ref_name != 'v2' && github.head_ref != 'v2'
+    needs: affected
    strategy:
      fail-fast: false
      matrix:
@@ -133,32 +189,38 @@ jobs:
            host: blacksmith-4vcpu-windows-2025
    runs-on: ${{ matrix.settings.host }}
    env:
+      E2E_ENABLED: ${{ needs.affected.outputs.app == 'true' && github.ref_name != 'v2' && github.head_ref != 'v2' }}
      PLAYWRIGHT_BROWSERS_PATH: ${{ github.workspace }}/.playwright-browsers
    defaults:
      run:
        shell: bash
    steps:
      - name: Checkout repository
+        if: env.E2E_ENABLED == 'true'
        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
        with:
          token: ${{ secrets.GITHUB_TOKEN }}

      - name: Setup Node
+        if: env.E2E_ENABLED == 'true'
        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
        with:
          # Playwright 1.59 hangs while extracting Chromium with Node 24.16.
          node-version: "24.15"

      - name: Setup Bun
+        if: env.E2E_ENABLED == 'true'
        uses: ./.github/actions/setup-bun

      - name: Read Playwright version
+        if: env.E2E_ENABLED == 'true'
        id: playwright-version
        run: |
          version=$(node -e 'console.log(require("./package.json").workspaces.catalog["@playwright/test"])')
          echo "version=$version" >> "$GITHUB_OUTPUT"

      - name: Cache Playwright browsers
+        if: env.E2E_ENABLED == 'true'
        id: playwright-cache
        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
        with:
@@ -166,23 +228,30 @@ jobs:
          key: ${{ runner.os }}-${{ runner.arch }}-playwright-${{ steps.playwright-version.outputs.version }}-chromium

      - name: Install Playwright system dependencies
-        if: runner.os == 'Linux'
+        if: env.E2E_ENABLED == 'true' && runner.os == 'Linux'
        working-directory: packages/app
        run: bunx playwright install-deps chromium

      - name: Install Playwright browsers
-        if: steps.playwright-cache.outputs.cache-hit != 'true'
+        if: env.E2E_ENABLED == 'true' && steps.playwright-cache.outputs.cache-hit != 'true'
        working-directory: packages/app
        run: bunx playwright install chromium

-      - name: Run app e2e tests
-        run: bun --cwd packages/app test:e2e:local
+      - name: Run app e2e tests against production build
+        if: env.E2E_ENABLED == 'true'
+        run: bun --cwd packages/app test:e2e:built
        env:
          CI: true
        timeout-minutes: 30

+      - name: Verify service worker precaching and upgrades
+        if: env.E2E_ENABLED == 'true'
+        working-directory: packages/app
+        run: bunx playwright test --config e2e/service-worker/playwright.config.ts
+        timeout-minutes: 5
+
      - name: Upload Playwright artifacts
-        if: always()
+        if: always() && env.E2E_ENABLED == 'true'
        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
        with:
          name: playwright-${{ matrix.settings.name }}-${{ github.run_attempt }}
@@ -32,6 +32,7 @@ target
 # Local dev files
 opencode-dev
 UPCOMING_CHANGELOG.md
+RELEASE_REVIEW.md
 logs/
 *.bun-build
 tsconfig.tsbuildinfo
@@ -17,4 +17,4 @@ if (process.versions.bun !== expectedBunVersion) {
  console.warn(`Warning: Bun version ${process.versions.bun} differs from expected ${expectedBunVersion}`);
 }
 '
-bun typecheck
+bun run check
@@ -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"],
@@ -1,51 +1,22 @@
 {
  "$schema": "https://raw.githubusercontent.com/nicolo-ribaudo/oxc-project.github.io/refs/heads/json-schema/src/public/.oxlintrc.schema.json",
-  "options": {
-    "typeAware": true
-  },
  "categories": {
-    "suspicious": "warn"
+    "correctness": "off",
+    "suspicious": "off",
+    "pedantic": "off",
+    "perf": "off",
+    "style": "off",
+    "restriction": "off",
+    "nursery": "off"
  },
  "rules": {
-    "typescript/no-base-to-string": "warn",
-    // Effect uses `function*` with Effect.gen/Effect.fnUntraced that don't always yield
-    "require-yield": "off",
-    // SolidJS uses `let ref: T | undefined` for JSX ref bindings assigned at runtime
-    "no-unassigned-vars": "off",
-    // SolidJS tracks reactive deps by reading properties inside createEffect
-    "no-unused-expressions": "off",
-    // Intentional control char matching (ANSI escapes, null byte sanitization)
-    "no-control-regex": "off",
-    // SST and plugin tools require triple-slash references
-    "triple-slash-reference": "off",
-
-    // Suspicious category: suppress noisy rules
-    // Effect's nested function* closures inherently shadow outer scope
-    "no-shadow": "off",
-    // Namespace-heavy codebase makes this too noisy
-    "unicorn/consistent-function-scoping": "off",
-    // Opinionated — .sort()/.reverse() mutation is fine in this codebase
-    "unicorn/no-array-sort": "off",
-    "unicorn/no-array-reverse": "off",
-    // Not relevant — this isn't a DOM event handler codebase
-    "unicorn/prefer-add-event-listener": "off",
-    // Bundler handles module resolution
-    "unicorn/require-module-specifiers": "off",
-    // postMessage target origin not relevant for this codebase
-    "unicorn/require-post-message-target-origin": "off",
-    // Side-effectful constructors are intentional in some places
-    "no-new": "off",
-
-    // Type-aware: catch unhandled promises
-    "typescript/no-floating-promises": "warn",
-    // Warn when spreading non-plain objects (Headers, class instances, etc.)
-    "typescript/no-misused-spread": "warn"
-  },
-  "options": {
-    "typeAware": true
-  },
-  "options": {
-    "typeAware": true
+    "no-restricted-globals": [
+      "error",
+      {
+        "name": "Reflect",
+        "message": "Use typed property access or direct invocation. Suppress this rule only for genuine reflection."
+      }
+    ]
  },
  "ignorePatterns": ["**/node_modules", "**/dist", "**/.build", "**/.sst", "**/*.d.ts", "**/sdk.gen.ts"]
 }
@@ -1,15 +1,16 @@
 - After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`. Do not edit generated client files directly.
 - Keep runtime dependencies directed from Schema to Core and Protocol, then from Core and Protocol to Server. Client runtime code may depend on Schema and Protocol but never Core or Server; `sdk` composes Client, Core, and Server.
 - Current implementation changes belong in `packages/core`, `packages/cli`, `packages/server`, `packages/protocol`, `packages/schema`, and related generated client surfaces when required.
+- This repository does not use Changesets. Do not add `.changeset` files; follow the existing release workflow instead.
 - The default branch in this repo is `v2`.
- Base all new branches and worktrees on `v2`, or `origin/v2` when the local `v2` ref is unavailable. Do not base them on `dev`.
+- Default new branches and worktrees to `v2`, or `origin/v2` when the local `v2` ref is unavailable, and default pull requests to target `v2`. Use another base or target branch when the requester explicitly instructs it.
 - Local `main` ref may not exist; use `v2` or `origin/v2` for diffs.

 ## 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
@@ -45,6 +46,7 @@ Examples: `fix(tui): simplify thinking toggle styling`, `docs: update contributi
 ### General Principles

 - Keep things in one function unless composable or reusable
+- Validate unknown values once at the boundary that owns them. Pass typed values inward instead of repeating `typeof value === "object"` and property-existence checks. Do not defensively revalidate values already guaranteed by a schema, constructor, or internal type.
 - Do not extract single-use helpers preemptively. Inline the logic at the call site unless the helper is reused, hides a genuinely complex boundary, or has a clear independent name that improves the caller.
 - Before adding complexity for a speculative or vanishingly unlikely race or security edge case, explain the concrete failure mode, likelihood, and complexity cost to the user and get their buy-in. Do not silently expand scope for theoretical robustness.
 - Avoid `try`/`catch` where possible
@@ -82,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
@@ -168,9 +170,10 @@ const table = sqliteTable("session", {
 - Test actual implementation, do not duplicate logic into tests
 - Tests cannot run from repo root (guard: `do-not-run-tests-from-root`); run from package directories such as `packages/core`.

-## Type Checking
+## Checks

- Always run `bun typecheck` from package directories (for example, `packages/core`), never `tsc` directly.
+- Run `bun run check` from the repository root as the canonical full lint and type-check verification.
+- During focused iteration, run `bun typecheck` from the affected package directory (for example, `packages/core`). Never run `tsc` directly.

 ## V2 Session Core

@@ -181,7 +184,7 @@ const table = sqliteTable("session", {
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
 - Preserve one explicit `llm.stream(request)` call per Physical Attempt and reload projected history before durable continuation. A logical Step may use generic pre-output retries, one full-context retry after continuation rejection, incomplete-stream continuation, or one overflow-compaction rebuild. Generic retries retain the logical step number and do not consume another agent-step allowance. Do not delegate orchestration to an in-memory tool loop.
 - Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. A write-ahead execution claim marks a process-local busy period for restart recovery: terminal completion, failure, or user interruption releases it, while shutdown interruption and process death preserve it. Startup recovery resumes claimed top-level Sessions with durable per-execution attempt accounting. The claim is a recovery marker, not clustered ownership, fencing, or an exactly-once guarantee.
- Keep delivery vocabulary explicit. Prompts steer by default. Steers deliver in enqueue order at safe step boundaries, stopping before compaction or move control items. At an idle boundary, steers take priority; otherwise exactly one queued item delivers before the runner reevaluates continuation. Inbox items may be cancelled or changed between queue and steer before delivery. Promoting new user input resets the selected agent's step allowance; a batch of steers resets it once.
+- Keep delivery vocabulary explicit. Prompts steer by default. At safe step boundaries, steered compaction takes priority up to the first steered move control; other steers retain enqueue order. At an idle boundary, steers take priority; otherwise exactly one queued item delivers before the runner reevaluates continuation. Inbox items may be cancelled or changed between queue and steer before delivery. Promoting new user input resets the selected agent's step allowance; a batch of steers resets it once.
 - One step is one logical LLM call; its durable record covers only the model-visible span. Do not write "provider turn", and do not use bare "turn" for a single call: "turn" is reserved for the future assistant-turn unit containing all steps from prompt promotion until the session would go idle.
 - Keep event replay ownership separate from clustered Session execution ownership.
 - Keep the Instructions algebra and built-ins in `src/instructions`; keep instruction producers with their observed domains, and keep Session History selection plus `InstructionState` and `InstructionEntry` persistence Session-owned. `InstructionDiscovery` observes ambient global and upward-project instructions. The runner composes built-ins, discovery, guidance, and entries explicitly in `loadInstructions`; there is no instruction registry.
@@ -0,0 +1,279 @@
+# V2 HTTP API audit checklist
+
+**Source:** `packages/protocol/openapi.json`  
+**Current endpoint count:** 139
+**Last regenerated:** 2026-09-13
+
+## How to use this checklist
+
+Review endpoints in document order. For each endpoint, select one disposition and capture rationale or follow-up work in Notes. Mark **Reviewed** only after the disposition is agreed.
+
+### Review criteria
+
+- Resource and operation naming
+- HTTP method and idempotency
+- Request parameters and location scope
+- Response shape and error taxonomy
+- Authentication and authorization
+- Current production consumers
+- Stability level: public, experimental, or internal
+- Whether the generated client API is intuitive
+
+### Disposition legend
+
+- **Keep:** ship unchanged as a supported V2 API
+- **Change:** retain after a defined contract change
+- **Remove:** exclude from the official V2 API
+- **Experimental-only:** retain outside the stable API commitment
+
+## Progress
+
+- [x] Group 1: Foundation and placement (4)
+- [ ] Group 2: Configuration and capability catalogs (16)
+- [ ] Group 3: Credentials, integrations, MCP, and web search (22)
+- [ ] Group 4: Session lifecycle (12)
+- [ ] Group 5: Session execution and inputs (11)
+- [ ] Group 6: Session history and recovery (13)
+- [ ] Group 7: Inbox, permissions, and forms (19)
+- [ ] Group 8: Filesystem, worktrees, and VCS (12)
+- [ ] Group 9: PTYs, persistent terminals, and shells (24)
+- [ ] Group 10: Events, RPC, and experimental operations (6)
+
+## Resolved during audit
+
+### [x] `POST /api/plugin/await-activation`
+
+- **Decision:** Remove
+- **Notes:** Activation timing is an internal server concern. Catalog reads remain non-blocking.
+
+### [x] Location response wrappers
+
+- **Decision:** Reduce generic endpoint response locations to `{ directory }`.
+- **Notes:** Full project metadata remains available from `GET /api/location`; no consumers used it from wrapped responses.
+
+### [x] `GET /api/health` and `GET /api/server`
+
+- **Decision:** Merge and rename
+- **Replacement:** `GET /api/status` with operation ID `server.status`.
+- **Notes:** Returns `version`, `pid`, and connection `urls`; readiness is conveyed by HTTP status.
+
+### [x] `GET /api/project/current`
+
+- **Decision:** Remove
+- **Replacement:** `GET /api/location`, using `project` from the response.
+- **Notes:** The endpoint duplicated `Location.Info.project`; production callers were migrated.
+
+### [x] `POST /api/workspace` and `DELETE /api/workspace/{workspaceID}`
+
+- **Decision:** Remove
+- **Notes:** Provider-backed workspaces are not part of the V2 HTTP contract and can be introduced later. Core and the embedded SDK retain internal workspace support.
+
+## Group 1: Foundation and placement
+
+**Endpoints:** 4
+
+| Done | Method | Path | Operation ID | Decision | Notes |
+|---|---|---|---|---|---|
+| [x] 001–002 | `GET` | `/api/status` | `server.status` | Keep | Replaces the former health and server endpoints. |
+| [x] 003 | `GET` | `/api/location` | `location.get` | Keep | Workspace selectors and response fields removed until workspace support ships. |
+| [x] 004 | `GET` | `/api/project` | `project.list` | Keep | Removed unused `time.initialized`; the database column remains for migration data. |
+| [x] 005 | `PATCH` | `/api/project/{projectID}` | `project.update` | Keep | Request and response accepted as-is. |
+
+## Group 2: Configuration and capability catalogs
+
+**Endpoints:** 16
+
+| Done | Method | Path | Operation ID | Decision | Notes |
+|---|---|---|---|---|---|
+| [x] 008 | `GET` | `/api/agent` | `agent.list` | Keep | Request and response accepted as-is. |
+| [x] 009 | `GET` | `/api/agent/{agentID}` | `agent.get` | Keep | Request, response, and not-found error accepted as-is. |
+| [x] 010 | `GET` | `/api/plugin` | `plugin.list` | Keep | Request and response accepted as-is. |
+| [x] 012 | `POST` | `/api/plugin/check` | `plugin.check` | Keep | Request and response accepted as-is. |
+| [x] 013 | `POST` | `/api/plugin/update` | `plugin.update` | Keep | Request and errors accepted as-is. |
+| [x] 014 | `GET` | `/api/model` | `model.list` | Keep | Request and response accepted as-is. |
+| [x] 015 | `GET` | `/api/model/default` | `model.default` | Keep | Request and nullable response accepted as-is. |
+| [x] 016 | `GET` | `/api/provider` | `provider.list` | Keep | Request and response accepted as-is. |
+| [x] 017 | `GET` | `/api/provider/{providerID}` | `provider.get` | Keep | Request, response, and not-found error accepted as-is. |
+| [x] 018 | `GET` | `/api/command` | `command.list` | Keep | Request and response accepted as-is. |
+| [x] 019 | `GET` | `/api/skill` | `skill.list` | Keep | Renamed `location` to `path`; removed the skill-specific `slash` flag and slash-command behavior. |
+| [x] 020 | `GET` | `/api/reference` | `reference.list` | Keep | Removed duplicate `description` and `hidden` fields from nested `source`. |
+| [x] 021 | `GET` | `/api/config` | `config.get` | Keep | Compatibility entries removed; response now contains only documents and OpenCode directories. |
+| [x] 022 | `GET` | `/api/config/preferences` | `config.preferences` | Remove | Redundant special projection of global config. |
+| [x] 023 | `PATCH` | `/api/config/preferences` | `config.updatePreferences` | Remove | Redundant field-specific config mutation API. |
+| [ ] 024 | `GET` | `/api/config/shell` | `config.shells` |  |  |
+| [x] 024a | `PATCH` | `/api/experimental/config` | `experimental.config.update` | Change | Experimental global config mutation; initially accepts only `shell`. |
+
+## Group 3: Credentials, integrations, MCP, and web search
+
+**Endpoints:** 22
+
+| Done | Method | Path | Operation ID | Decision | Notes |
+|---|---|---|---|---|---|
+| [x] 025 | `GET` | `/api/integration` | `integration.list` | Keep | Full integration inventory is consumed by authentication and integration-selection clients. |
+| [x] 026 | `GET` | `/api/integration/{integrationID}` | `integration.get` | Change | Missing integration now returns typed `404` instead of optional data. |
+| [x] | `POST` | `/api/experimental/integration/wellknown` | `experimental.integration.wellknown.add` | Experimental-only | Retained outside the stable API commitment. |
+| [ ] 028 | `POST` | `/api/integration/{integrationID}/connect/key` | `integration.connect.key` |  |  |
+| [ ] 029 | `POST` | `/api/integration/{integrationID}/connect/oauth` | `integration.oauth.connect` |  |  |
+| [ ] 030 | `GET` | `/api/integration/{integrationID}/connect/oauth/{attemptID}` | `integration.oauth.status` |  |  |
+| [ ] 031 | `DELETE` | `/api/integration/{integrationID}/connect/oauth/{attemptID}` | `integration.oauth.cancel` |  |  |
+| [ ] 032 | `POST` | `/api/integration/{integrationID}/connect/oauth/{attemptID}/complete` | `integration.oauth.complete` |  |  |
+| [ ] 033 | `POST` | `/api/integration/{integrationID}/connect/command` | `integration.command.connect` |  |  |
+| [ ] 034 | `GET` | `/api/integration/{integrationID}/connect/command/{attemptID}` | `integration.command.status` |  |  |
+| [ ] 035 | `DELETE` | `/api/integration/{integrationID}/connect/command/{attemptID}` | `integration.command.cancel` |  |  |
+| [x] 036 | `GET` | `/api/mcp` | `mcp.list` | Keep | MCP inventory and connection status retained. |
+| [x] 037 | `PUT` | `/api/experimental/mcp/{server}` | `experimental.mcp.add` | Experimental-only | Runtime-only MCP override; does not persist configuration. |
+| [x] 038 | `DELETE` | `/api/experimental/mcp/{server}` | `experimental.mcp.remove` | Experimental-only | Runtime removal override; missing server returns `404`. |
+| [x] 039 | `POST` | `/api/experimental/mcp/{server}/connect` | `experimental.mcp.connect` | Experimental-only | Runtime connection override retained outside the stable API. |
+| [x] 040 | `POST` | `/api/experimental/mcp/{server}/disconnect` | `experimental.mcp.disconnect` | Experimental-only | Runtime disconnection override retained outside the stable API. |
+| [ ] 041 | `GET` | `/api/mcp/resource` | `mcp.resource.catalog` |  | Deferred for later review. |
+| [x] 042 | `PATCH` | `/api/credential/{credentialID}` | `credential.update` | Change | Removed redundant location query; credentials and events are global. |
+| [x] 043 | `DELETE` | `/api/credential/{credentialID}` | `credential.remove` | Change | Removed redundant location query; credentials and events are global. |
+| [x] 044 | `POST` | `/api/credential/{credentialID}/activate` | `credential.activate` | Change | Removed redundant location query; credentials and events are global. |
+| [x] 045 | `GET` | `/api/websearch/provider` | `websearch.providers` | Keep | Provider availability remains location-scoped; singular resource path retained. |
+| [x] 046 | `POST` | `/api/websearch` | `websearch.query` | Keep | Unknown provider remains an invalid request; published time documented as Unix epoch milliseconds. |
+
+## Group 4: Session lifecycle
+
+**Endpoints:** 12
+
+| Done | Method | Path | Operation ID | Decision | Notes |
+|---|---|---|---|---|---|
+| [x] 047 | `GET` | `/api/session` | `session.list` | Keep | Existing filtering, ordering, and cursor contract retained for now. |
+| [x] 048 | `POST` | `/api/session` | `session.create` | Keep | Existing creation contract retained; model reference includes optional variant. |
+| [x] 049 | `GET` | `/api/experimental/session/stats` | `experimental.session.stats` | Experimental-only | Session analytics retained outside the stable API commitment. |
+| [x] 050 | `GET` | `/api/session/active` | `session.active` | Keep | Status record retained for future active-state expansion. |
+| [x] 051 | `GET` | `/api/session/{sessionID}` | `session.get` | Keep | Specific session read and typed `404` retained. |
+| [x] 052 | `DELETE` | `/api/session/{sessionID}` | `session.remove` | Keep | Session and child deletion with typed `404` retained. |
+| [x] 053 | `POST` | `/api/session/{sessionID}/fork` | `session.fork` | Change | Request now accepts optional branded `before` message ID; omission copies full history. |
+| [x] 054 | `POST` | `/api/session/{sessionID}/agent` | `session.switchAgent` | Keep | Subsequent-execution agent selection retained. |
+| [x] 055 | `POST` | `/api/session/{sessionID}/model` | `session.switchModel` | Keep | Subsequent-execution model and optional variant selection retained. |
+| [x] 056 | `PATCH` | `/api/session/{sessionID}` | `session.rename` | Change | Title-only rename now uses the session resource path. |
+| [x] 057 | `POST` | `/api/session/{sessionID}/move` | `session.move` | Change | Removed inaccurate local-change transfer claim; delivery behavior retained. |
+| [x] 058 | `POST` | `/api/session/{sessionID}/background` | `session.background` | Keep | Backgroundable foreground tools transition to background observation; idle requests remain no-ops. |
+
+## Group 5: Session execution and inputs
+
+**Endpoints:** 11
+
+| Done | Method | Path | Operation ID | Decision | Notes |
+|---|---|---|---|---|---|
+| [x] 059 | `POST` | `/api/session/{sessionID}/prompt` | `session.prompt` | Keep | Durable admission, delivery mode, and admit-only resume control retained. |
+| [x] 060 | `POST` | `/api/session/{sessionID}/command` | `session.command` | Change | Renamed request field from `command` to `name`; `204` retained. |
+| [x] 061 | `POST` | `/api/experimental/session/{sessionID}/skill` | `experimental.session.skill` | Experimental-only | Skill ID is now the `id` field; standalone activation remains experimental. |
+| [x] 062 | `POST` | `/api/session/{sessionID}/synthetic` | `session.synthetic` | Keep | Durable synthetic admission and delivery controls retained. |
+| [x] 063 | `POST` | `/api/session/{sessionID}/shell` | `session.shell` | Change | Caller ID is now the optimistic shell message ID; server derives its event ID. |
+| [x] 064 | `POST` | `/api/session/{sessionID}/compact` | `session.compact` | Keep | Durable compaction admission and delivery controls retained. |
+| [x] 065 | `POST` | `/api/experimental/session/{sessionID}/wait` | `experimental.session.wait` | Experimental-only | Race-free idle barrier retained outside the stable API. |
+| [x] 066 | `POST` | `/api/session/{sessionID}/generate` | `session.generate` | Keep | Transient generation from session context retained. |
+| [x] 067 | `POST` | `/api/session/{sessionID}/interrupt` | `session.interrupt` | Change | Renamed `continue` to `resume` across public and internal interruption APIs. |
+| [x] 068 | `PUT` | `/api/experimental/session/{sessionID}/environment` | `experimental.session.environment` | Experimental-only | Process-local environment replacement retained outside the stable API. |
+| [x] 069 | `POST` | `/api/session/{sessionID}/view` | `session.view` | Change | Idle watermark now uses the standard epoch-millisecond timestamp schema. |
+
+## Group 6: Session history and recovery
+
+**Endpoints:** 13
+
+| Done | Method | Path | Operation ID | Decision | Notes |
+|---|---|---|---|---|---|
+| [x] 070 | `POST` | `/api/experimental/session/import` | `experimental.session.import` | Experimental-only | Existing projected transcript import contract retained outside the stable API. |
+| [x] 071 | `GET` | `/api/experimental/session/{sessionID}/export` | `experimental.session.export` | Experimental-only | Existing projected transcript export contract retained outside the stable API. |
+| [x] 072 | `POST` | `/api/session/{sessionID}/revert/stage` | `session.revert.stage` | Keep | Existing staged history and optional file restoration behavior retained. |
+| [x] 073 | `DELETE` | `/api/session/{sessionID}/revert` | `session.revert.clear` | Change | Clearing staged revert now deletes the session revert resource. |
+| [x] 074 | `POST` | `/api/session/{sessionID}/revert/commit` | `session.revert.commit` | Keep | Explicit staged-revert commit action retained. |
+| [x] 075 | `GET` | `/api/session/{sessionID}/context` | `session.context` | Keep | Active model-context projection retained. |
+| [x] 076 | `GET` | `/api/session/{sessionID}/diff` | `session.diff` | Keep | Turn-range structured diff contract retained. |
+| [x] 077 | `GET` | `/api/experimental/session/{sessionID}/instructions/entries` | `experimental.session.instructions.entry.list` | Experimental-only | API-managed durable context entries retained outside the stable API. |
+| [x] 078 | `PUT` | `/api/experimental/session/{sessionID}/instructions/entries/{key}` | `experimental.session.instructions.entry.put` | Experimental-only | API-managed durable context entries retained outside the stable API. |
+| [x] 079 | `DELETE` | `/api/experimental/session/{sessionID}/instructions/entries/{key}` | `experimental.session.instructions.entry.remove` | Experimental-only | API-managed durable context entries retained outside the stable API. |
+| [x] | `GET` | `/api/experimental/session/{sessionID}/log` | `session.log` | Experimental-only | Retained outside the stable API commitment. |
+| [x] 081 | `GET` | `/api/session/{sessionID}/message/{messageID}` | `session.message.get` | Change | Normalized specific-message operation ID. |
+| [x] 082 | `GET` | `/api/session/{sessionID}/message` | `session.message.list` | Change | Normalized session-scoped message-list operation ID. |
+
+## Group 7: Inbox, permissions, and forms
+
+**Endpoints:** 19
+
+| Done | Method | Path | Operation ID | Decision | Notes |
+|---|---|---|---|---|---|
+| [x] 083 | `GET` | `/api/session/{sessionID}/inbox` | `session.inbox.list` | Change | Inbox timestamps now use the standard nested `time.created` shape. |
+| [ ] 084 | `DELETE` | `/api/session/{sessionID}/inbox/{inboxID}` | `session.inbox.cancel` |  |  |
+| [ ] 085 | `POST` | `/api/session/{sessionID}/inbox/{inboxID}/steer` | `session.inbox.steer` |  |  |
+| [ ] 086 | `POST` | `/api/session/{sessionID}/inbox/{inboxID}/queue` | `session.inbox.queue` |  |  |
+| [ ] 087 | `GET` | `/api/form/request` | `form.request.list` |  |  |
+| [ ] 088 | `GET` | `/api/session/{sessionID}/form` | `session.form.list` |  |  |
+| [ ] 089 | `POST` | `/api/session/{sessionID}/form` | `session.form.create` |  |  |
+| [ ] 090 | `GET` | `/api/session/{sessionID}/form/{formID}` | `session.form.get` |  |  |
+| [ ] 091 | `GET` | `/api/session/{sessionID}/form/{formID}/state` | `session.form.state` |  |  |
+| [ ] 092 | `POST` | `/api/session/{sessionID}/form/{formID}/reply` | `session.form.reply` |  |  |
+| [ ] 093 | `POST` | `/api/session/{sessionID}/form/{formID}/cancel` | `session.form.cancel` |  |  |
+| [ ] 094 | `GET` | `/api/permission/request` | `permission.request.list` |  |  |
+| [ ] 095 | `GET` | `/api/permission/saved` | `permission.saved.list` |  |  |
+| [ ] 096 | `DELETE` | `/api/permission/saved/{id}` | `permission.saved.remove` |  |  |
+| [ ] 097 | `POST` | `/api/session/{sessionID}/permission` | `session.permission.create` |  |  |
+| [ ] 098 | `GET` | `/api/session/{sessionID}/permission` | `session.permission.list` |  |  |
+| [ ] 099 | `GET` | `/api/session/{sessionID}/permission/{requestID}` | `session.permission.get` |  |  |
+| [ ] 100 | `POST` | `/api/session/{sessionID}/permission/{requestID}/reply` | `session.permission.reply` |  |  |
+| [ ] 101 | `PUT` | `/api/session/{sessionID}/permission/rules` | `session.permission.rules` |  |  |
+
+## Group 8: Filesystem, worktrees, and VCS
+
+**Endpoints:** 12
+
+| Done | Method | Path | Operation ID | Decision | Notes |
+|---|---|---|---|---|---|
+| [ ] 102 | `GET` | `/api/fs/read/*` | `fs.read` |  |  |
+| [ ] 103 | `GET` | `/api/fs/list` | `fs.list` |  |  |
+| [ ] 104 | `GET` | `/api/fs/find` | `fs.find` |  |  |
+| [ ] 105 | `GET` | `/api/worktree` | `worktree.list` |  |  |
+| [ ] 106 | `POST` | `/api/worktree` | `worktree.create` |  |  |
+| [ ] 107 | `DELETE` | `/api/worktree` | `worktree.remove` |  |  |
+| [ ] 108 | `POST` | `/api/worktree/refresh` | `worktree.refresh` |  |  |
+| [ ] 109 | `GET` | `/api/vcs` | `vcs.get` |  |  |
+| [ ] 110 | `GET` | `/api/vcs/base` | `vcs.base` |  |  |
+| [ ] 111 | `GET` | `/api/vcs/status` | `vcs.status` |  |  |
+| [ ] 112 | `GET` | `/api/vcs/branches` | `vcs.branches` |  |  |
+| [ ] 113 | `GET` | `/api/vcs/diff` | `vcs.diff` |  |  |
+
+## Group 9: PTYs, persistent terminals, and shells
+
+**Endpoints:** 24
+
+| Done | Method | Path | Operation ID | Decision | Notes |
+|---|---|---|---|---|---|
+| [ ] 114 | `GET` | `/api/pty` | `pty.list` |  |  |
+| [ ] 115 | `POST` | `/api/pty` | `pty.create` |  |  |
+| [ ] 116 | `GET` | `/api/pty/{ptyID}` | `pty.get` |  |  |
+| [ ] 117 | `PUT` | `/api/pty/{ptyID}` | `pty.update` |  |  |
+| [ ] 118 | `DELETE` | `/api/pty/{ptyID}` | `pty.remove` |  |  |
+| [ ] 119 | `POST` | `/api/pty/{ptyID}/connect-token` | `pty.connect.token` |  |  |
+| [ ] 120 | `GET` | `/api/pty/{ptyID}/connect` | `pty.connect` |  |  |
+| [x] | `GET` | `/api/experimental/session/{sessionID}/terminal/read` | `server.experimental.persistentPty.read` | Experimental-only | Retained outside the stable API commitment. |
+| [x] | `GET` | `/api/experimental/session/{sessionID}/terminal` | `server.experimental.persistentPty.list` | Experimental-only | Retained outside the stable API commitment. |
+| [x] | `POST` | `/api/experimental/session/{sessionID}/terminal` | `server.experimental.persistentPty.create` | Experimental-only | Retained outside the stable API commitment. |
+| [x] | `POST` | `/api/experimental/persistent-pty/shutdown` | `server.experimental.persistentPty.shutdown` | Experimental-only | Retained outside the stable API commitment. |
+| [x] | `POST` | `/api/experimental/persistent-pty/handoff` | `server.experimental.persistentPty.handoff` | Experimental-only | Retained outside the stable API commitment. |
+| [x] | `GET` | `/api/experimental/persistent-pty/{ptyID}` | `server.experimental.persistentPty.get` | Experimental-only | Retained outside the stable API commitment. |
+| [x] | `PUT` | `/api/experimental/persistent-pty/{ptyID}` | `server.experimental.persistentPty.update` | Experimental-only | Retained outside the stable API commitment. |
+| [x] | `DELETE` | `/api/experimental/persistent-pty/{ptyID}` | `server.experimental.persistentPty.remove` | Experimental-only | Retained outside the stable API commitment. |
+| [x] | `GET` | `/api/experimental/persistent-pty/{ptyID}/snapshot` | `server.experimental.persistentPty.snapshot` | Experimental-only | Retained outside the stable API commitment. |
+| [x] | `POST` | `/api/experimental/persistent-pty/{ptyID}/connect-token` | `server.experimental.persistentPty.connectToken` | Experimental-only | Retained outside the stable API commitment. |
+| [x] | `GET` | `/api/experimental/persistent-pty/{ptyID}/connect` | `persistentPty.connect` | Experimental-only | Retained outside the stable API commitment. |
+| [ ] 132 | `GET` | `/api/shell` | `shell.list` |  |  |
+| [ ] 133 | `POST` | `/api/shell` | `shell.create` |  |  |
+| [ ] 134 | `GET` | `/api/shell/{id}` | `shell.get` |  |  |
+| [ ] 135 | `DELETE` | `/api/shell/{id}` | `shell.remove` |  |  |
+| [ ] 136 | `PATCH` | `/api/shell/{id}/timeout` | `shell.timeout` |  |  |
+| [ ] 137 | `GET` | `/api/shell/{id}/output` | `shell.output` |  |  |
+
+## Group 10: Events, RPC, and experimental operations
+
+**Endpoints:** 6
+
+| Done | Method | Path | Operation ID | Decision | Notes |
+|---|---|---|---|---|---|
+| [ ] 138 | `POST` | `/api/generate` | `generate.text` |  |  |
+| [ ] 139 | `POST` | `/api/rpc/{rpcID}/{method}` | `rpc.call` |  |  |
+| [ ] 140 | `GET` | `/api/event` | `event.subscribe` |  |  |
+| [ ] 141 | `GET` | `/api/debug/location` | `debug.location.list` |  |  |
+| [ ] 142 | `DELETE` | `/api/debug/location` | `debug.location.evict` |  |  |
+| [x] | `GET` | `/api/experimental/migration/v1` | `experimental.migration.v1.status` | Experimental-only | Retained outside the stable API commitment. |
@@ -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", "@opencode-ai/sdk", "@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-builder", "electron-publish", "blume"]
+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"
@@ -1,4 +1,5 @@
 import { domain } from "./stage"
+import { createWebApp } from "./webapp"

 const GITHUB_APP_ID = new sst.Secret("GITHUB_APP_ID")
 const GITHUB_APP_PRIVATE_KEY = new sst.Secret("GITHUB_APP_PRIVATE_KEY")
@@ -59,11 +60,4 @@ new sst.cloudflare.x.Astro("Web", {
  },
 })

-new sst.cloudflare.StaticSite("WebApp", {
-  domain: "app." + domain,
-  path: "packages/app",
-  build: {
-    command: "bun turbo build",
-    output: "./dist",
-  },
-})
+createWebApp("app." + domain)
@@ -235,6 +235,7 @@ const bucketNew = new sst.cloudflare.Bucket("ZenDataNew")
 const DISCORD_INCIDENT_WEBHOOK_URL = new sst.Secret("DISCORD_INCIDENT_WEBHOOK_URL")
 const AWS_SES_ACCESS_KEY_ID = new sst.Secret("AWS_SES_ACCESS_KEY_ID")
 const AWS_SES_SECRET_ACCESS_KEY = new sst.Secret("AWS_SES_SECRET_ACCESS_KEY")
+const ENTERPRISE_SALES_INBOX_EMAIL = new sst.Secret("ENTERPRISE_SALES_INBOX_EMAIL")

 const SALESFORCE_CLIENT_ID = new sst.Secret("SALESFORCE_CLIENT_ID")
 const SALESFORCE_CLIENT_SECRET = new sst.Secret("SALESFORCE_CLIENT_SECRET")
@@ -263,6 +264,7 @@ new sst.cloudflare.x.SolidStart("Console", {
    EMAILOCTOPUS_API_KEY,
    AWS_SES_ACCESS_KEY_ID,
    AWS_SES_SECRET_ACCESS_KEY,
+    ENTERPRISE_SALES_INBOX_EMAIL,
    SALESFORCE_CLIENT_ID,
    SALESFORCE_CLIENT_SECRET,
    SALESFORCE_INSTANCE_URL,
@@ -0,0 +1,19 @@
+export function createWebApp(domain: string) {
+  return new sst.cloudflare.StaticSite("WebApp", {
+    domain,
+    path: "packages/app",
+    environment:
+      $app.stage === "beta"
+        ? {
+            OPENCODE_CHANNEL: "beta",
+            VITE_OPENCODE_SERVER_MODE: "none",
+            VITE_SENTRY_ENVIRONMENT: "beta",
+          }
+        : undefined,
+    build: {
+      // Preserve Sentry credentials and run source-map uploads on every deployment.
+      command: "bun run build",
+      output: "./dist",
+    },
+  })
+}
@@ -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 ""
@@ -4,7 +4,7 @@
  bun,
  nodejs,
  darwin,
-  electron_41,
+  callPackage,
  makeWrapper,
  writableTmpDirAsHomeHook,
  autoPatchelfHook,
@@ -13,7 +13,7 @@
  opencode,
 }:
 let
-  electron = electron_41;
+  electron = callPackage ./electron.nix { };
 in
 stdenv.mkDerivation (finalAttrs: {
  pname = "opencode-desktop";
@@ -48,7 +48,7 @@ stdenv.mkDerivation (finalAttrs: {
    desktopName = "OpenCode";
    exec = "opencode-desktop %U";
    icon = "ai.opencode.desktop";
-    # Electron 41 derives X11 WM_CLASS from app.name.
+    # Electron derives X11 WM_CLASS from app.name.
    startupWMClass = "OpenCode";
    categories = [ "Development" ];
  });
@@ -67,12 +67,10 @@ stdenv.mkDerivation (finalAttrs: {
    # https://github.com/electron/electron/issues/31121
    # mac builds use a .app bundle which doesnt have this issue
    + lib.optionalString stdenv.isLinux ''
-      BASE_PATH=packages/desktop
-      FILES=(src/main/windows.ts)
-      for file in "''${FILES[@]}"; do
-        substituteInPlace $BASE_PATH/$file \
-          --replace-fail "process.resourcesPath" "'$out/opt/opencode-desktop/resources'"
-      done
+      substituteInPlace \
+        packages/desktop/src/main/windows/appearance.ts \
+        packages/desktop/src/main/service/desktop-cli.ts \
+        --replace-fail "process.resourcesPath" "'$out/opt/opencode-desktop/resources'"
    '';

  preBuild = ''
@@ -89,6 +87,11 @@ stdenv.mkDerivation (finalAttrs: {

    cd packages/desktop

+    export OPENCODE_CLI_DIST="$TMPDIR/desktop-cli"
+    cli_package=$(bun -e 'import { getCurrentCli } from "./scripts/utils.ts"; console.log(getCurrentCli().package.replace("@opencode/", ""))')
+    mkdir -p "$OPENCODE_CLI_DIST/$cli_package/bin"
+    cp ${lib.getExe opencode} "$OPENCODE_CLI_DIST/$cli_package/bin/opencode"
+
    bun run build
    npx electron-builder --dir \
      --config electron-builder.config.ts \
@@ -0,0 +1,13 @@
+{ callPackage, path }:
+let
+  version = (builtins.fromJSON (builtins.readFile ../packages/desktop/package.json)).devDependencies.electron;
+in
+(callPackage (path + "/pkgs/development/tools/electron/binary/generic.nix") { }) version {
+  # Electron 42.10.1 SHASUMS256.txt; update with the desktop package version.
+  aarch64-linux = "20e68d6c4e47f3ebf59de7c6b1f8b8bec6a6ebda6a451132f9b465f3f13ce467";
+  x86_64-linux = "2452b27112d92387471fa2488aafac85d79ea3f2ee1216c0abd5150d6c12362b";
+  aarch64-darwin = "ac7194a3dfd81930ba35355c01620262c1254752859b42dcb8f4b9e4d174a871";
+  x86_64-darwin = "4489aba55477a0082266cb690db1c829503ba3338048599d8fd243953df37dab";
+  # fetchzip hashes the unpacked headers, not the release tarball.
+  headers = "sha256-4eUy3BZVvxTl7KUOsxio7769lL6ag/ecbeK+qLURWMI=";
+}
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-P8AZ2THuXiET4hiSYTwGGdTgbm2l3XGZGJxQwg6lusE=",
-    "aarch64-linux": "sha256-73LxDeDPQspY4Bn/gbGU43j/k7gBZ5ywMMpUjDl3elg=",
-    "aarch64-darwin": "sha256-sc9YyTAFlbWxlFb9vwFYLs6IYd3SRoju9mQufzeQdd8=",
-    "x86_64-darwin": "sha256-nnk637DELjzGB3t9aLDYbHz5h3Dd3nvWcWGdaQk8yPM="
+    "x86_64-linux": "sha256-E5T4o3wNivOg8q4wRV7yE4CUNaUq4QNPxZsnvLaGUcg=",
+    "aarch64-linux": "sha256-xQQi7LgxInZQVCznASfa0Pm+cNGBo5j4Tfp0E/bKnNw=",
+    "aarch64-darwin": "sha256-qxb371dCf7WG09VvQE+HZ/x3EURpFIr11bdnQwGTHhw=",
+    "x86_64-darwin": "sha256-xi1qiYr41hzbgAQl+I3xdtnkiPx2SIcA/0OMpN78qXw="
  }
 }
@@ -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
      ]
    );
  };
@@ -8,6 +8,7 @@
  makeBinaryWrapper,
  models-dev,
  ripgrep,
+  wayland,
  installShellFiles,
  versionCheckHook,
  writableTmpDirAsHomeHook,
@@ -62,9 +63,10 @@ stdenvNoCC.mkDerivation (finalAttrs: {
  installPhase = ''
    runHook preInstall

-    install -Dm755 dist/cli-*/bin/opencode2 $out/bin/opencode2
+    install -Dm755 dist/cli-*/bin/opencode $out/bin/opencode

-    wrapProgram $out/bin/opencode2 \
+    # OpenTUI dlopens Wayland for clipboard images.
+    wrapProgram $out/bin/opencode \
      --prefix PATH : ${
        lib.makeBinPath (
          [
@@ -73,13 +75,21 @@ stdenvNoCC.mkDerivation (finalAttrs: {
          # bun runs sysctl to detect if running on rosetta2
          ++ lib.optional stdenvNoCC.hostPlatform.isDarwin sysctl
        )
-      }
+      } ${lib.optionalString stdenvNoCC.hostPlatform.isLinux ''
+        --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ wayland ]}
+      ''}
+
+    ln -s opencode $out/bin/opencode2

    runHook postInstall
  '';

  postInstall = lib.optionalString (stdenvNoCC.buildPlatform.canExecute stdenvNoCC.hostPlatform) ''
    # trick yargs into also generating zsh completions
+    installShellCompletion --cmd opencode \
+      --bash <($out/bin/opencode completion) \
+      --zsh <(SHELL=/bin/zsh $out/bin/opencode completion)
+
    installShellCompletion --cmd opencode2 \
      --bash <($out/bin/opencode2 completion) \
      --zsh <(SHELL=/bin/zsh $out/bin/opencode2 completion)
@@ -101,7 +111,7 @@ stdenvNoCC.mkDerivation (finalAttrs: {
    description = "The open source coding agent";
    homepage = "https://opencode.ai";
    license = lib.licenses.mit;
-    mainProgram = "opencode2";
+    mainProgram = "opencode";
    inherit (node_modules.meta) platforms;
  };
 })
@@ -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.3",
  "private": true,
  "type": "module",
-  "packageManager": "bun@1.3.14",
+  "packageManager": "bun@1.4.2",
  "scripts": {
-    "dev": "bun run --cwd packages/cli --conditions=browser src/index.ts",
-    "dev:live": "OPENCODE_TUI_CHANNEL=dev OPENCODE_PASSWORD=\"$(opencode2 service get password)\" bun run dev --server \"$(opencode2 service status)\"",
+    "dev": "bun run --cwd packages/cli src/index.ts",
+    "dev:live": "sh -c 'OPENCODE_TUI_CHANNEL=dev OPENCODE_PASSWORD=\"$(opencode service get password)\" exec bun run dev \"$@\" --server \"$(opencode service status)\"' --",
+    "dev:vite": "bun run --cwd packages/cli --conditions=browser dev/vite.ts",
+    "dev:vite:live": "sh -c 'OPENCODE_TUI_CHANNEL=dev OPENCODE_PASSWORD=\"$(opencode service get password)\" exec bun run dev:vite \"$@\" --server \"$(opencode service status)\"' --",
    "dev: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",
@@ -22,12 +24,12 @@
    "test:lint-rules": "ast-grep test -c script/ast-grep/sgconfig.yml",
    "test:effect-simplification-rules": "ast-grep test -c script/ast-grep/effect-simplifications/sgconfig.yml",
    "typecheck": "bun turbo typecheck --concurrency=3",
+    "check": "bun run lint && bun run typecheck",
    "typecheck:profile": "bun script/profile-typecheck.ts",
    "typecheck:profile:packages": "bun script/profile-typecheck-packages.ts",
    "upgrade-opentui": "bun run script/upgrade-opentui.ts",
    "postinstall": "bun run --cwd packages/core fix-node-pty",
    "prepare": "husky",
-    "reserve-packages": "bun script/reserve-package-names.ts",
    "random": "echo 'Random script'",
    "sso": "aws sso login --sso-session=opencode --no-browser",
    "test": "echo 'do not run tests from root' && exit 1"
@@ -35,28 +37,29 @@
  "workspaces": {
    "packages": [
      "packages/*",
+      "services/*",
      "packages/console/*",
      "packages/stats/*"
    ],
    "catalog": {
-      "@effect/opentelemetry": "4.0.0-rc.110",
-      "@effect/platform-node": "4.0.0-rc.110",
-      "@effect/platform-node-shared": "4.0.0-rc.110",
-      "@effect/sql-sqlite-bun": "4.0.0-rc.110",
+      "@effect/opentelemetry": "4.0.0-rc.112",
+      "@effect/platform-node": "4.0.0-rc.112",
+      "@effect/platform-node-shared": "4.0.0-rc.112",
+      "@effect/sql-sqlite-bun": "4.0.0-rc.112",
      "@npmcli/arborist": "9.4.0",
-      "@types/bun": "1.3.13",
+      "@types/bun": "1.4.0",
      "@types/cross-spawn": "6.0.6",
      "@octokit/rest": "22.0.0",
      "@hono/standard-validator": "0.2.0",
      "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.7",
-      "@opentui/keymap": "0.5.7",
-      "@opentui/solid": "0.5.7",
+      "@opentui/core": "0.5.10",
+      "@opentui/keymap": "0.5.10",
+      "@opentui/solid": "0.5.10",
      "@tanstack/solid-virtual": "3.13.37",
-      "@shikijs/stream": "4.2.0",
+      "@shikijs/stream": "4.4.3",
      "@standard-schema/spec": "1.1.0",
      "ulid": "3.0.1",
-      "@kobalte/core": "0.13.11",
+      "@kobalte/core": "0.13.13",
      "@corvu/drawer": "0.2.4",
      "@types/luxon": "3.7.1",
      "@types/node": "24.12.2",
@@ -67,13 +70,16 @@
      "@openauthjs/openauth": "0.0.0-20250322224806",
      "@pierre/diffs": "1.2.10",
      "opentui-spinner": "0.0.7",
-      "@solid-primitives/storage": "4.3.3",
+      "@solid-primitives/event-listener": "2.4.6",
+      "@solid-primitives/media": "2.3.6",
+      "@solid-primitives/resize-observer": "2.2.0",
+      "@solid-primitives/storage": "4.4.0",
      "@tailwindcss/vite": "4.1.11",
-      "diff": "8.0.2",
-      "dompurify": "3.3.1",
-      "drizzle-kit": "1.0.0-rc.2",
-      "drizzle-orm": "1.0.0-rc.2",
-      "effect": "4.0.0-rc.110",
+      "diff": "8.0.4",
+      "dompurify": "3.4.14",
+      "drizzle-kit": "1.0.0-rc.5-ab785fc",
+      "drizzle-orm": "1.0.0-rc.5-169397b",
+      "effect": "4.0.0-rc.112",
      "ai": "6.0.168",
      "cross-spawn": "7.0.6",
      "hono": "4.10.7",
@@ -81,28 +87,27 @@
      "fuzzysort": "3.1.0",
      "get-east-asian-width": "1.6.0",
      "luxon": "3.6.1",
-      "marked": "18.0.7",
+      "marked": "18.0.11",
      "marked-shiki": "1.2.1",
-      "remend": "1.3.0",
+      "remend": "1.3.1",
      "@playwright/test": "1.59.1",
      "semver": "7.7.4",
      "typescript": "5.8.2",
      "@typescript/native-preview": "7.0.0-dev.20251207.1",
      "zod": "4.1.8",
      "remeda": "2.26.0",
-      "resolve.exports": "2.0.3",
      "sst": "4.13.1",
-      "shiki": "4.2.0",
+      "shiki": "4.4.3",
      "solid-list": "0.3.0",
      "string-width": "7.2.0",
      "tailwindcss": "4.1.11",
-      "vite": "7.1.4",
+      "vite": "7.3.6",
      "@solidjs/meta": "0.29.4",
-      "@solidjs/router": "0.15.4",
+      "@solidjs/router": "1.0.0",
      "@solidjs/start": "https://pkg.pr.new/@solidjs/start@dfb2020",
-      "@sentry/solid": "10.36.0",
-      "@sentry/vite-plugin": "4.6.0",
-      "solid-js": "1.9.10",
+      "@sentry/solid": "10.71.0",
+      "@sentry/vite-plugin": "5.4.0",
+      "solid-js": "1.9.15",
      "solid-sonner": "0.3.1",
      "vite-plugin-solid": "2.11.10",
      "@lydell/node-pty": "1.2.0-beta.12"
@@ -111,6 +116,7 @@
  "devDependencies": {
    "@actions/artifact": "5.0.1",
    "@ast-grep/cli": "0.44.0",
+    "@opencode/client": "workspace:*",
    "@types/react": "19.2.17",
    "@types/react-dom": "19.2.3",
    "@tsconfig/bun": "catalog:",
@@ -127,8 +133,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:"
  },
@@ -145,10 +151,6 @@
    "esbuild",
    "node-pty",
    "protobufjs",
-    "tree-sitter",
-    "tree-sitter-bash",
-    "tree-sitter-powershell",
-    "web-tree-sitter",
    "electron"
  ],
  "overrides": {
@@ -158,7 +160,9 @@
    "@effect/platform-node-shared": "catalog:",
    "@types/bun": "catalog:",
    "@types/node": "catalog:",
-    "effect": "catalog:"
+    "bun-types": "1.4.2",
+    "effect": "catalog:",
+    "solid-js": "catalog:"
  },
  "patchedDependencies": {
    "@ai-sdk/openai-compatible@2.0.41": "patches/@ai-sdk%2Fopenai-compatible@2.0.41.patch",
@@ -166,15 +170,16 @@
    "@npmcli/agent@4.0.2": "patches/@npmcli%2Fagent@4.0.2.patch",
    "@silvia-odwyer/photon-node@0.3.4": "patches/@silvia-odwyer%2Fphoton-node@0.3.4.patch",
    "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
-    "drizzle-orm@1.0.0-rc.2": "patches/drizzle-orm@1.0.0-rc.2.patch",
-    "solid-js@1.9.10": "patches/solid-js@1.9.10.patch",
+    "solid-js@1.9.15": "patches/solid-js@1.9.15.patch",
    "@ai-sdk/mistral@3.0.51": "patches/@ai-sdk%2Fmistral@3.0.51.patch",
    "gcp-metadata@8.1.2": "patches/gcp-metadata@8.1.2.patch",
    "pacote@21.5.0": "patches/pacote@21.5.0.patch",
    "@ai-sdk/google@3.0.73": "patches/@ai-sdk%2Fgoogle@3.0.73.patch",
    "@pierre/trees@1.0.0-beta.4": "patches/@pierre%2Ftrees@1.0.0-beta.4.patch",
-    "@modelcontextprotocol/sdk@1.29.0": "patches/@modelcontextprotocol%2Fsdk@1.29.0.patch",
    "@tanstack/virtual-core@3.17.8": "patches/@tanstack%2Fvirtual-core@3.17.8.patch",
-    "@ff-labs/fff-bun@0.10.5": "patches/@ff-labs%2Ffff-bun@0.10.5.patch"
+    "@ff-labs/fff-bun@0.10.5": "patches/@ff-labs%2Ffff-bun@0.10.5.patch",
+    "ghostty-web@github:anomalyco/ghostty-web#83c0a07": "patches/ghostty-web@0.3.0.patch",
+    "vite@8.2.2": "patches/vite@8.2.2.patch",
+    "@modelcontextprotocol/client@2.0.0": "patches/@modelcontextprotocol%2Fclient@2.0.0.patch"
  }
 }
@@ -10,15 +10,32 @@

 ## Conventions

-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.
+Per-type constructors live on the type, not as top-level re-exports. Use `Message.system(...)`, `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `Message.media(...)`, `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.
+
+Modality namespaces mirror `LLM` exactly: `Image.request`, `Image.generate`, `Image.stream` (later `Video`, `Speech`, `Transcription`). Common request fields (`images`, `mask`, `n`, `size`, `aspectRatio`, `seed`, `format`) lower natively or fail with a typed `AIError`; provider-native controls always live under `providerOptions`, never under a modality-specific `options` key.
+
+Media payloads are always `Media.Asset` (`src/media.ts`). Construct them with `Media.bytes`, `Media.base64`, `Media.url`, `Media.ref`, `Media.fromDataUrl`, or `Media.file`; never introduce a parallel `data: string | Uint8Array` shape. `MediaPart.media`, `ImageRequest.images`/`mask`, `ImageResponse.images`, and the `media` `LLMEvent` all share it. Protocols branch on `asset.source.type` and `asset.kind` and use `ProviderShared.inlineMedia` / `requireInlineMedia` / `mediaUrl` / `MediaInput.refID` rather than re-deriving base64 or URL handling.
+
+`schema/messages.ts → media.ts → route/executor-service.ts` is an accepted runtime dependency from the schema layer on the executor service tag: `Media.Asset.bytes()` must be able to download `url` sources, and the tag lives in that leaf module precisely so the schema barrel never imports the executor implementation (which imports the schema barrel back). Do not move the tag into `route/executor.ts` or import `route/executor.ts` from `src/schema/*` or `src/media.ts`.
+
+Nothing in `src/*` except `src/promise.ts` may know about Promises. `@opencode/ai/promise` (`AI.make({ layer? })`, default `ai`) is the single Promise/`AsyncIterable` surface for LLM and media; it runs the Effect APIs in one `ManagedRuntime` and rethrows `AIError` unchanged.

 - 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

 - Use `testEffect(...)` from `test/lib/effect.ts` for tests requiring Effect layers.
 - Keep provider tests fixture-first. Live provider calls must stay behind `RECORD=true` and required API-key checks.

+## Errors
+
+- `AIError` wraps a union of tagged reason errors. It stores only `reason`, derives `message` from the reason, and exposes the reason as its `cause`.
+- Each reason owns its readable `message`, category-specific fields, and optional `body`, `http`, and underlying exception in `cause`.
+- `reason.body` is the sole original-response or triggering-event payload field. Preserve original text before schema decoding removes fields; do not replace the complete event with only its nested error.
+- `reason.http` describes an observed HTTP response with required `url`, `status`, and response `headers`. Do not invent status codes or derive a separate request ID from headers.
+- Reclassification and transport recovery must preserve the reason's body, HTTP context, and underlying cause. Error `message` and `cause` are non-enumerable: copy them explicitly when constructing an enriched reason with its constructor or `AIErrorReason.make`.
+
 ## Architecture

 This package is an Effect Schema-first LLM core. The Schema classes in `src/schema/` are the canonical runtime data model. Convenience functions in `src/llm.ts` are thin constructors that return those same Schema class instances; they should improve callsites without creating a second model.
@@ -73,10 +90,14 @@ export const route = Route.make({

 Route defaults are request-shaping defaults such as `headers`, `limits`, `generation`, `providerOptions`, and `http`. Endpoint host/query belongs on the route endpoint. Selected `LanguageModel` values carry only model id, provider id, and the configured route value. Model capability/catalog metadata lives outside this package; protocol support is enforced by request lowering and typed `AIError`s.

-The four-axis decomposition is the reason DeepSeek, TogetherAI, Cerebras, Baseten, Fireworks, and DeepInfra all reuse `OpenAIChat.protocol` verbatim — each provider deployment is a 5-15 line `Route.make(...)` call instead of a 300-400 line route clone. Bug fixes in one protocol propagate to every consumer of that protocol in a single commit.
+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.

+### Media Routes
+
+Media does not fit the SSE-frames-to-event-state-machine LLM route. `MediaRoute.make(...)` (`src/route/media.ts`) composes a `MediaProtocol` kind with `Endpoint` and `Auth` and owns the transport plumbing: `http` option merging, URL/query rendering, auth headers, JSON vs multipart encoding, and handing the response back to the protocol. `MediaProtocol.inline` (`src/route/media-protocol.ts`) is `body.from(request)` plus `response.decode(response, context)`; use `MediaProtocol.decodeJson` / `text` / `bytes` so decode failures retain the raw body and HTTP context. `MediaProtocol.JobProtocol` is the queued shape and `Job` (`src/job.ts`) is the provider-neutral handle over a `JobRoute` (`status`, `result`, `cancel`, `pollHint`); the first video route implements it. Image protocol files follow the same section order as LLM protocols and declare unsupported common fields once through `MediaInput.rejectUnsupported`.
+
 ### URL Construction

 `Endpoint` owns `{ baseURL, path, query }`. Each protocol route includes a canonical endpoint when the provider has one (e.g. `https://api.openai.com/v1`); provider helpers override endpoint fields by configuring the route before selecting a model. Generic OpenAI-compatible routes have no canonical URL and require configuration before execution.
@@ -85,10 +106,11 @@ For providers where the URL is derived from typed inputs (Azure resource name, B

 ### Provider Facades

-Provider-facing APIs are configured facades over route values. Endpoint/auth/resource/API-version setup happens before model selection, and model selectors accept only a model or deployment id:
+Provider-facing APIs are configured facades over route values. Endpoint/auth/resource/API-version setup happens before model selection, and model selectors accept only a model or deployment id. Every facade is wrapped in `ModelRef.facade(...)`, which makes it callable: `openai("gpt-4o-mini")` returns a `ModelRef` with lazy per-modality routes derived from the facade's own selectors (`model` → `llm`, `image` → `image`). `LLM.request` and `Image.request` resolve their route from the ref at request time, so one value names a model for every modality while named selectors stay the single source of truth:

 ```ts
 const openai = OpenAI.configure({ apiKey, baseURL })
+const ref = openai("gpt-4o-mini") // ModelRef: LLM.request → .responses, Image.request → .image
 const model = openai.responses("gpt-4o-mini")

 const azure = Azure.configure({ resourceName, apiKey, apiVersion: "v1" })
@@ -107,18 +129,20 @@ Keep provider facades small and explicit:
 - Prefer `apiKey` as provider-specific sugar and `auth` as the explicit override; keep them mutually exclusive in provider option types with `ProviderAuthOption`.
 - Resolve `apiKey` → `Auth` with `AuthOptions.bearer(options, "<PROVIDER>_API_KEY")` (it honors an explicit `auth` override and falls back to `Auth.config(envVar)` so missing keys surface a typed `Authentication` error rather than a runtime crash).
 - Use separate top-level facades for products with different required setup, such as `CloudflareAIGateway` and `CloudflareWorkersAI`.
+- Give every named provider its own file and top-level export. Keep its endpoint, auth defaults, and route setup in that file. Compose shared protocols directly; do not nest named provider presets under generic compatible facades or keep their endpoints in a shared provider profile registry.

 `Provider.make(...)` remains available for simple static provider definitions, but new built-in providers should prefer plain configured facades unless a helper removes real duplication without adding runtime behavior.

 ### Provider Package Entrypoints

-Catalog-selected native providers use package-like export paths from `@opencode-ai/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",
 })
 ```

@@ -155,6 +179,10 @@ Native chronological system messages are route/model-specific. Open Responses lo

 The wrapped-user fallback preserves ordering while visibly lowering authority. Never silently pass a raw chronological `role: "system"` through a route that might reject it. Do not insert raw retrieved documents, tool output, or web content into privileged chronological system updates; keep untrusted content in ordinary user/tool channels.

+### Effort Updates
+
+`Message.effort({ effort, previous })` is a chronological "reasoning effort changed here" marker (`undefined` means the model default). Changing a top-level effort invalidates the whole provider prompt cache, so protocols with a native per-message update (`Protocol.supportsEffortUpdates`) keep the top-level effort at the first marker's `previous` and lower each marker in place: Anthropic Messages emits an empty `role: "system"` message with `output_config.effort` plus the `mid-conversation-output-config-2026-07-01` beta, and OpenAI Responses emits `configuration_update` items. `applyEffortUpdates` runs in `prepareRequest` and strips the markers for every other route, so a protocol without support keeps today's plain top-level behaviour. When the last marker disagrees with the effort the request asks for (reverted or forked history), `resolveEffortUpdates` strips the markers and falls back to a plain top-level change.
+
 ### Tools

 Tool loops are represented in common messages and events:
@@ -213,7 +241,7 @@ Errors must be expressed as `ToolFailure`. The runtime catches it and emits a `t
 - Input failed the `parameters` Schema.
 - The handler returned a `ToolFailure`.

-Provider-defined / hosted tools (Anthropic `web_search` / `code_execution` / `web_fetch`, OpenAI Responses `web_search_call` / `file_search_call` / `code_interpreter_call` / `mcp_call` / `local_shell_call` / `image_generation_call` / `computer_use_call`) pass through the runtime untouched:
+Provider-defined / hosted tools (Anthropic `web_search` / `code_execution` / `web_fetch`, OpenAI Responses `web_search_call` / `file_search_call` / `code_interpreter_call` / `mcp_call` / `image_generation_call` / `computer_use_call`) pass through the runtime untouched:

 - Routes surface the model's call as a `tool-call` event with `providerExecuted: true`, and the provider's result as a matching `tool-result` event with `providerExecuted: true`.
 - Callers detect `providerExecuted` on `tool-call` and **skip local dispatch** — no handler is invoked and no `tool-error` is raised for "unknown tool". The provider already executed it.
@@ -1,17 +1,17 @@
-# @opencode-ai/ai
+# @opencode/ai

-Schema-first AI primitives for opencode. Provider quirks live in adapters, not in calling code.
+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")
+const openai = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY })

 const request = LLM.request({
-  model,
+  model: openai("gpt-4o-mini"), // the request namespace picks the route; `.responses(...)` / `.chat(...)` stay explicit
  system: "You are concise.",
  prompt: "Say hello in one short sentence.",
  generation: { maxTokens: 40 },
@@ -29,31 +29,391 @@ 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.

-## Image generation
-
-Use `Image.generate` with an image model for direct asset generation:
+The same configured facade names image models. `Image.request` resolves the provider's image route from the ref and
+returns `Media.Asset`s with lazily decoded bytes:

 ```ts
-import { Image, ImageInput } from "@opencode-ai/ai"
-import { OpenAI } from "@opencode-ai/ai/providers"
+import { NodeFileSystem } from "@effect/platform-node"
+import { Image, ImageClient, Media } from "@opencode/ai"
+
+const image = Effect.gen(function* () {
+  const response = yield* Image.generate({
+    model: openai("gpt-image-2"),
+    prompt: "A robot tending a rooftop garden",
+    size: "1024x1024",
+    providerOptions: { quality: "high" }, // typed per image model
+  })
+  yield* Media.write(response.image, "./garden.png")
+})
+
+// `asset.bytes()` / `Media.write` also need the executor, so merge it into the environment instead of hiding it.
+const imageLayer = ImageClient.layer.pipe(Layer.provideMerge(RequestExecutor.fetchLayer))
+
+await Effect.runPromise(image.pipe(Effect.provide(imageLayer), Effect.provide(NodeFileSystem.layer)))
+```
+
+Prefer promises? `@opencode/ai/promise` exposes the same LLM and image APIs over one managed runtime:
+
+```ts
+import { AI } from "@opencode/ai/promise"
+
+const ai = AI.make()
+const text = await ai.llm.generate({ model: openai("gpt-4o-mini"), prompt: "Say hello." })
+const generated = await ai.image.generate({ model: openai("gpt-image-2"), prompt: "A lighthouse" })
+for await (const event of ai.llm.stream({ model: openai("gpt-4o-mini"), prompt: "Stream hello." })) {
+  // LLMEvent
+}
+await ai.dispose()
+```
+
+## 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, Media } from "@opencode/ai"
+
+const generation = Image.generate({
+  model: meta("muse-image-1.0"),
+  prompt: "A flat black square on a white background.",
+  n: 1,
+  providerOptions: { reasoningStrength: "low" },
+})
+
+const edit = Image.generate({
+  model: meta("muse-image-1.0"),
+  prompt: "Make the square purple.",
+  images: [Media.bytes(imageBytes, "image/webp")],
+  format: "png",
+  providerOptions: { reasoningStrength: "low" },
+})
+```
+
+The default image format is WEBP; `format` 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. `Image.request` mirrors `LLM.request`: the
+model is a callable-facade ref (`openai("gpt-image-2")`) or an explicit `.image(...)` model, common fields
+(`images`, `mask`, `n`, `size`, `aspectRatio`, `seed`, `format`) lower natively or fail typed, and
+`providerOptions` is inferred from the selected model:
+
+```ts
+import { Image, Media } from "@opencode/ai"
+import { OpenAI } from "@opencode/ai/providers"
+
+const openai = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY })

 const program = Effect.gen(function* () {
  const response = yield* Image.generate({
-    model: OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).image("gpt-image-2"),
+    model: openai("gpt-image-2"),
    prompt: "A robot tending a rooftop garden",
-    options: {
-      n: 2,
-      size: "1024x1024",
+    n: 2,
+    size: "1024x1024",
+    format: "webp",
+    providerOptions: {
      quality: "high", // inferred from the OpenAI image model
-      outputFormat: "webp",
      future_option: true, // unknown native options pass through unchanged
    },
  })

-  return response.images // GeneratedImage[] with owned bytes or a provider URL
+  return response.images // Media.Asset[] with owned bytes or a provider URL
 })
 ```

+`Media.Asset` is the one asset type shared by image requests, image responses, LLM messages, and tool results.
+`asset.source` is the serializable `Media.Source` (`bytes`, `base64`, `url`, or `ref`); `asset.bytes()`,
+`asset.base64()`, and `asset.dataUrl()` decode or download lazily and cache; `asset.materialize()` pulls a `url`
+asset into owned bytes before the provider URL expires. Construct assets with `Media.bytes`, `Media.base64`,
+`Media.url`, `Media.ref(provider, id)`, `Media.fromDataUrl`, or `Media.file(path)`.
+
 Pass ordered image inputs to the same method for editing, composition, or image-conditioned generation:

 ```ts
@@ -63,49 +423,45 @@ const response =
    model,
    prompt: "Combine these product photos into one studio scene",
    images: [
-      ImageInput.bytes(firstBytes, "image/png"),
-      ImageInput.url("https://example.com/second.webp"),
-      ImageInput.file("file_123"),
+      Media.bytes(firstBytes, "image/png"),
+      Media.url("https://example.com/second.webp"),
+      Media.ref("openai", "file_123"),
    ],
-    options,
+    providerOptions,
    http,
  })
 ```

-`ImageInput.fileUri(uri, mediaType)` represents provider file URIs such as Gemini Files. Raw strings are not
-accepted as image inputs, avoiding ambiguity between base64, URLs, and provider IDs. Empty or omitted `images`
-uses text-to-image generation; a non-empty array selects the provider's edit behavior without enforcing provider
-image-count limits locally. `images` is the only common image-editing field. OpenAI uses multipart for byte/data-URL
-edits and its JSON reference body for URL or file-ID edits. Its provider-specific `options.mask` accepts an
-`ImageInput` for inpainting:
+`Media.ref(provider, id)` represents provider file handles such as OpenAI file IDs or Gemini Files URIs; routes
+only forward refs that belong to their own provider. Raw strings are not accepted as image inputs, avoiding
+ambiguity between base64, URLs, and provider IDs. Empty or omitted `images` uses text-to-image generation; a
+non-empty array selects the provider's edit behavior without enforcing provider image-count limits locally. OpenAI
+uses multipart for byte/data-URL edits and its JSON reference body for URL or file-ID edits. The common `mask`
+field selects inpainting; routes that cannot honor it fail with `UnsupportedOperation`:

 ```ts
 yield *
  Image.generate({
-    model: OpenAI.configure({ apiKey }).image("gpt-image-2"),
+    model: openai("gpt-image-2"),
    prompt,
-    images: [ImageInput.bytes(sourceBytes, "image/png")],
-    options: { mask: ImageInput.bytes(maskBytes, "image/png") },
+    images: [Media.bytes(sourceBytes, "image/png")],
+    mask: Media.bytes(maskBytes, "image/png"),
  })
 ```

-The OpenAI adapter extracts this helper value into the edit request's native `mask` field rather than passing the
-tagged `ImageInput` object through as an ordinary option. On multipart requests, `http.body` can override option
-fields but not structural `model`, `prompt`, `image[]`, or `mask` fields, and the transport owns the multipart
-`Content-Type` boundary. For JSON requests, `http.body` remains the final raw-native overlay. Gemini does not fetch
-public HTTP URLs, and hosted Z.ai image generation does not accept image inputs. These cases fail with
-`InvalidRequest` before network I/O.
+On multipart requests, `http.body` can override option fields but not structural `model`, `prompt`, `image[]`,
+or `mask` fields, and the transport owns the multipart `Content-Type` boundary. For JSON requests, `http.body`
+remains the final raw-native overlay. Gemini does not fetch public HTTP URLs, and hosted Z.ai image generation does
+not accept image inputs. These cases fail with a typed `AIError` before network I/O.

 Provider-native image options belong to each request. Raw `http.body` fields have final precedence over them:

 ```ts
-const model = OpenAI.configure({ apiKey }).image("gpt-image-2")
-
 yield *
  Image.generate({
-    model,
+    model: openai("gpt-image-2"),
    prompt,
-    options: { quality: "medium" },
+    providerOptions: { quality: "medium" },
    http,
  })
 ```
@@ -115,11 +471,11 @@ xAI image models use the same request API with xAI-native controls:
 ```ts
 yield *
  Image.generate({
-    model: XAI.configure({ apiKey }).image("any-model-id"),
+    model: XAI.configure({ apiKey })("any-model-id"),
    prompt,
-    options: {
-      n: 2,
-      aspectRatio: "16:9",
+    n: 2,
+    aspectRatio: "16:9",
+    providerOptions: {
      resolution: "1k",
      responseFormat: "b64_json",
      future_option: true,
@@ -131,16 +487,16 @@ 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({
-    model: Google.configure({ apiKey }).image("any-model-id"),
+    model: Google.configure({ apiKey })("any-model-id"),
    prompt: "A robot tending a rooftop garden",
-    options: {
-      aspectRatio: "16:9",
+    aspectRatio: "16:9",
+    seed: 42,
+    providerOptions: {
      imageSize: "2K",
-      seed: 42,
      thinkingLevel: "HIGH",
      includeThoughts: true,
      futureOption: true,
@@ -162,9 +518,9 @@ Z.ai image models infer open Z.ai-native options from the selected model:
 ```ts
 yield *
  Image.generate({
-    model: ZAI.configure({ apiKey }).image("any-model-id"),
+    model: ZAI.configure({ apiKey })("any-model-id"),
    prompt,
-    options: {
+    providerOptions: {
      quality: "hd",
      userID: "user-123",
      future_option: true,
@@ -174,8 +530,8 @@ yield *
 ```

 Z.ai does not include trustworthy MIME metadata for output URLs, so generated images use
-`application/octet-stream`. Output URLs expire after 30 days; download and persist them promptly if they must
-remain available.
+`application/octet-stream` until materialized. Output URLs expire after 30 days; call `asset.materialize()` and
+persist the bytes promptly if they must remain available.

 Conversational image generation remains part of the LLM interaction. OpenAI Responses exposes it through its hosted image tool:

@@ -193,7 +549,7 @@ const program = Effect.gen(function* () {
 })
 ```

-The hosted result is represented as a provider-executed tool call and tool result. Its image is a `file` content item with a data URI, so retaining `response.message` preserves the generated image for continuation.
+The hosted result is represented as a provider-executed tool call and tool result, and the generated image is also emitted as a first-class `media` `LLMEvent` (`response.message` then carries a `media` part). Gemini image-capable models emit the same `media` event for inline image output. Retaining `response.message` preserves the generated image for continuation on both routes.

 ## Public API

@@ -202,34 +558,192 @@ The hosted result is represented as a provider-executed tool call and tool resul
 - **`Message.user(...)` / `Message.assistant(...)` / `Message.tool(...)`** — message constructors from the canonical schema model.
 - **`LanguageModel.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model.
 - **`LLMEvent.is.*`** — typed guards (`is.textDelta`, `is.toolCall`, `is.finish`, …) for filtering streams.
- **`Image.generate({...})`** — generate images through a provider-neutral image request and response model.
+- **`Image.request` / `Image.generate` / `Image.stream`** — generate images through a provider-neutral image request and response model.
 - **`ImageClient`** — Effect service and layer for image execution, parallel to `LLMClient`.
+- **`Media`** — the shared asset type (`Media.Asset`, `Media.Source`) and constructors used by messages, tool results, and media requests.
+- **`ModelRef`** — the value returned by calling a configured facade (`openai("gpt-5")`); each request namespace resolves its own route from it.
+- **`Job`** — provider-neutral async job handle (`await`, `refresh`, `cancel`, `events`) used by queued media routes.
+- **`@opencode/ai/promise`** — `AI.make({ layer? })` and a default `ai` client exposing `llm` and `image` as Promise / `AsyncIterable` APIs.

 ## 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 testLLM = TestLLM.layer({
-  fallback: TestLLM.text("Hello from the test model", "text-1"),
-})
-
-// TestLLM.clientLayer provides LLMClient.Service and consumes TestLLM.Service.
 const programWithTestClient = Effect.gen(function* () {
+  const test = yield* TestLLM.Test
+  yield* test.push(TestLLM.text("Hello from the test model", "text-1"))
  const result = yield* program
-  const test = yield* TestLLM.Service
-  console.log(test.requests)
+  console.log(yield* test.requests())
  return result
-}).pipe(Effect.provide(TestLLM.clientLayer), Effect.provide(testLLM))
+}).pipe(Effect.provide(TestLLM.testLayer()))
 ```

-`TestLLM.push(...)` scripts one-shot responses, `TestLLM.always(...)` changes the fallback, and
-`TestLLM.wait(...)` lets concurrent tests wait until a request has arrived. Every received canonical request is
-available on the yielded `TestLLM.Service`.
+`testLayer()` provides the same object under `LLMClient.Service` and `TestLLM.Test`. Production consumes the
+normal client; tests use the additional controls. Each layer build has fresh state.
+
+- `test.push(...)` queues one-shot responses in execution order. Each argument is one response.
+- `test.always(response)` installs a repeatable fallback. The layer's `fallback` option sets its initial value.
+- `test.serve(request => response)` installs a request-dependent fallback. `always` and `serve` replace each
+  other without changing queued replies; queued replies take precedence.
+- `test.requests()` returns an array snapshot. `transformRequest` changes only the recorded observation;
+  `serve` receives the original canonical request.
+- `test.wait(count)` waits for request arrivals, not output or completion, and supports concurrent waiters.
+- `test.gate()` returns a scoped gate with countable `started` notifications and a `release` Effect. Release
+  unblocks all requests captured by that gate; closing its scope also releases it. Effect-aware test runners
+  already provide Scope.
+
+Constructing `stream()` or `generate()` does not record a request, invoke a responder, or consume a script.
+Each execution does. An exhausted queue without a fallback defects immediately rather than waiting for a
+future reply.
+
+Generation responses remain canonical event arrays or arbitrary `Stream<LLMEvent, AIError>` values. The client consumes
+supplied streams directly, preserving failure identity, finalizers, incomplete output, and post-finish tails;
+it does not repair or truncate them.
+
+For explicit compaction, script a `CompactionResponse` through `push`, `always`, or `serve`. Its `replacement` contains the next context window, including retained user messages. The client returns that result and usage directly, with the same lazy request recording and gates. Generation and compaction reject fixtures for the wrong operation instead of converting between response shapes.
+
+For `compact(request, { mechanism: "trigger" })`, script a `CompactionCheckpointResponse` instead. It carries `checkpoint`, `responseID`, and optional `usage`. Endpoint and trigger calls reject each other's fixtures; both share the same queue, gates, lazy recording, and fallback controls.
+
+The published legacy `Service`, `layer`, `clientLayer`, and module-level controls remain available as adapters
+over the same implementation, including the legacy live `requests` array. New tests should use `Test` and
+`testLayer`.
+
+## Provider compaction
+
+Compaction is opt-in. The package supports automatic compaction in OpenAI/Azure Responses and Anthropic Messages (including Claude on Vertex), and explicit compaction calls in OpenAI/Azure/xAI Responses. Model and deployment support still depends on the provider.
+
+This is different from prompt caching, server-side history storage, or truncation. Compaction returns provider-owned context that must be replayed to continue the conversation.
+
+### Explicit compaction
+
+`LLMClient.compact(request)` (equivalently, `{ mechanism: "endpoint" }`) is the caller-controlled operation for OpenAI, Azure, and xAI Responses. It performs exactly one HTTP call to `/responses/compact`, using the selected route's endpoint, credentials, query, and HTTP middleware. It returns a `CompactionResponse` with `replacement: Message[]` and optional `usage`, not a normal generation response. This mechanism does not accept a WebSocket executor.
+
+Prefer this operation, where supported, when the application owns compaction policy and durable context updates.
+
+```ts
+const result = yield * LLMClient.compact(request)
+const next = LLMRequest.update(request, {
+  messages: result.replacement,
+})
+const response = yield * LLMClient.generate(next)
+```
+
+`replacement` replaces the complete input window. Do not append it to the original transcript or extract only the encrypted item: the provider may retain additional messages in its output. Retained user and assistant messages remain ordinary messages with typed text, media, or reasoning parts, in their original order. Provider-specific message IDs, status, and phase use `providerMetadata`, not a raw output array hidden in an assistant message. Unsupported returned item types fail explicitly.
+
+The selected model carries explicit-compaction capability through request construction and updates. Calls using unsupported routes fail type checking. When the model is selected dynamically, narrow the request with `LLMClient.canCompact(request)` before calling `LLMClient.compact`; a model or route switch does not inherit the old capability. Runtime validation still rejects unsupported calls from untyped consumers. Capability describes the route's API, not whether every model or custom deployment supports the operation.
+
+Generation-only body overlays such as `stream` and `store` are not sent to the compact endpoint. Supported compact controls such as service tier and prompt-cache settings preserve request defaults and HTTP-overlay precedence. Retained image and file detail settings survive serialization and replay.
+
+The input must still fit the model's context window. Explicit compaction is not an overflow-recovery operation. Anthropic does not expose this operation in this package; its in-band compaction remains available below. Compatible routes do not inherit an explicit compact endpoint simply because they use a Responses protocol.
+
+### Streamed checkpoint compaction
+
+OpenAI Responses also exposes a separate, explicitly selected mechanism:
+
+```ts
+const result =
+  yield *
+  LLMClient.compact(request, {
+    mechanism: "trigger",
+    webSocket, // Optional: without it, the request uses HTTP/SSE.
+  })
+
+result.checkpoint // Successful encrypted CompactionPart.
+result.responseID
+result.usage
+```
+
+This appends a native `compaction_trigger` control item to the full input and sends a normal Responses request, with tools and instructions retained, `stream: true`, `store: false`, and parallel tool calls enabled. It removes normal-answer text/output-format controls, forced tool choices, output-token/tool-call limits, and automatic `context_management`. Body overlays cannot replace `input` or supply `previous_response_id`/`conversation`; the complete canonical history is required for safe stateless replay. Request metadata, auth, headers, query parameters, service tier, and supported prompt-cache settings are preserved.
+
+Only a successful `response.completed` with a response ID and exactly one logical encrypted checkpoint succeeds. Repeated item events are correlated by ID/output slot, including ID-less checkpoints. Other output is ignored, not returned as assistant text or dispatched as tools. Failed, incomplete, malformed, and interrupted responses return errors rather than partial checkpoints.
+
+The result is **not a replacement window**. The caller selects retained history, combines it with `result.checkpoint`, and durably installs it before continuing. The operation does not choose a retention budget, prune messages, or modify the original request.
+
+The supplied WebSocket executor can reuse a compatible append baseline for the compaction request. On completion the protocol supplies no continuation checkpoint, clearing the old baseline so the next generation sends the newly installed window in full. Validation occurs before transport completion is acknowledged. There is no operation-level retry or fallback to `/responses/compact`; existing safe transport fallback may use SSE, with full history and no connection-local response ID.
+
+Trigger support is separate from endpoint support. Only the OpenAI Responses route advertises it; Azure, xAI, Chat, and compatible Responses routes do not inherit it. Untyped calls still fail before sending: missing route capabilities return `UnsupportedOperation`, while unknown mechanism names and invalid inputs return `InvalidRequest`. Dynamic callers must narrow for the selected mechanism:
+
+```ts
+if (LLMClient.canCompact(request, { mechanism: "trigger" })) {
+  const result = yield * LLMClient.compact(request, { mechanism: "trigger" })
+}
+```
+
+This capability describes protocol implementation, **not universal availability on OpenAI API deployments**. The host application owns subscription/deployment eligibility, OAuth, endpoint selection, and deployment-specific headers. Local protocol/socket tests do not establish live provider support.
+
+### Advanced: in-band compaction
+
+`providerOptions.contextManagement` lets the provider decide when to compact during an ordinary `generate` or `stream` call. This is an advanced option for callers that own persistence and recovery: persist the complete assistant message, including its checkpoint, before continuing. Enabling the option does not provide durable checkpoint storage, interruption recovery, or model-switch policy. Keep the prior context until a successful checkpoint has been persisted.
+
+Inside an `Effect.gen`, enable OpenAI compaction with typed provider options:
+
+```ts
+import { LLM, LLMClient, LLMRequest, Message } from "@opencode/ai"
+import { OpenAI } from "@opencode/ai/providers"
+
+const request = LLM.request({
+  model: OpenAI.configure({ apiKey }).responses("gpt-5.3-codex"),
+  messages,
+  providerOptions: {
+    contextManagement: [{ type: "compaction", compactThreshold: 200_000 }],
+  },
+})
+const response = yield * LLMClient.generate(request)
+const next = LLMRequest.update(request, {
+  messages: [...request.messages, response.message, Message.user("Continue")],
+})
+```
+
+`store: false` remains the default. Keep the entire `response.message`, not just `response.text`. Compaction events become ordered `CompactionPart`s alongside text and reasoning. The conversation contains everything needed to continue; there is no separate replay object or hidden provider transcript.
+
+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"
+
+CompactionPart.make({ provider: ProviderID.make("openai"), id: "cmp_123", encrypted: "..." })
+CompactionPart.make({ provider: ProviderID.make("anthropic"), text: "Summary of the conversation..." })
+```
+
+For Anthropic, use:
+
+```ts
+providerOptions: {
+  contextManagement: {
+    edits: [{
+      type: "compact_20260112",
+      trigger: { type: "input_tokens", value: 150_000 },
+      pauseAfterCompaction: true,
+      instructions: "Summarize the task and decisions. Do not call tools while summarizing.",
+    }],
+  },
+}
+```
+
+- The trigger is optional (provider default: 150,000 tokens), with a minimum of 50,000.
+- Custom instructions replace Anthropic's default summarization instructions.
+- The route adds `compact-2026-01-12` to existing beta headers, including when replaying a checkpoint without enabling new compactions.
+- A pause is exposed as `response.finishReason.raw === "compaction"`. It occurs only if the threshold triggers compaction: `pauseAfterCompaction` does not mean "compact now". The caller explicitly issues the next request; the package never automatically resumes.
+- Anthropic can return a compaction block with `content: null` when summarization fails. This becomes a compaction part with `text: null`, which is **not** a successful replacement for prior history. The package never prunes history automatically.
+- `Usage` totals include all reported Anthropic `usage.iterations`, including compaction. `contextTokens` separately reports the final message iteration's inclusive input size, when available. A compaction-only pause does not report a post-compaction context size. Raw iteration usage remains in `providerMetadata`.
+
+### Recording tests
+
+Tests cover serialized round trips, real local HTTP plus a tool loop, WebSocket recovery, provider errors, malformed blocks, and usage accounting. Live provider tests are gated by `RECORD=true` and the relevant API keys:
+
+```sh
+# Run from packages/ai. Only records the selected new cassette group.
+RECORD=true RECORDED_PREFIX=openai-compaction bun test test/provider/compaction.recorded.test.ts
+RECORD=true RECORDED_PREFIX=xai-compaction bun test test/provider/compaction.recorded.test.ts
+RECORD=true RECORDED_PREFIX=anthropic-compaction bun test test/provider/compaction.recorded.test.ts
+```
+
+Provider references: [OpenAI](https://developers.openai.com/api/docs/guides/compaction), [Azure](https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/responses#server-side-compaction), [Anthropic](https://platform.claude.com/docs/en/build-with-claude/compaction), [xAI](https://docs.x.ai/developers/advanced-api-usage/context-compaction).

 ## Caching

@@ -237,7 +751,7 @@ Prompt caching is **on by default**. Every `LLMRequest` resolves to `cache: "aut

 ### Auto placement

-`"auto"` places up to four breakpoints — the last tool definition, the first system part, the last system part when distinct, and the final message boundary. These expose successively larger reusable prefixes for tools, the base agent, project instructions, and the active conversation. The rolling final-message boundary advances on every request so recent conversation prefixes remain reusable during tool loops.
+`"auto"` places up to four breakpoints — the last tool definition, the first system part, the last system part when distinct, and the final message boundary. These expose successively larger reusable prefixes for tool definitions, system instructions, and the active conversation. The rolling final-message boundary advances on every request so recent conversation prefixes remain reusable during tool loops.

 Tools precede every system and conversation block in the provider prefix, so tool definitions must remain byte-stable and deterministically ordered for downstream breakpoints to remain reusable.

@@ -296,7 +810,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({
@@ -305,31 +819,42 @@ const gateway = CloudflareAIGateway.configure({
 }).model("workers-ai/@cf/meta/llama-3.1-8b-instruct")
 ```

-Included providers: OpenAI, Anthropic, Google (Gemini), Google Vertex Gemini and Anthropic, Amazon Bedrock, Azure OpenAI, Cloudflare AI Gateway, Cloudflare Workers AI, GitHub Copilot, OpenRouter, xAI, Z.ai, plus generic OpenAI-compatible Chat and Responses entrypoints and an Anthropic Messages-compatible entrypoint.
+Included LLM providers: OpenAI, Anthropic, Google (Gemini), Google Vertex, Amazon Bedrock, Azure OpenAI, Baseten, Cerebras, Cloudflare AI Gateway, Cloudflare Workers AI, DeepInfra, DeepSeek, Fireworks, Groq, Mistral, OpenRouter, TogetherAI, and xAI. Z.ai currently exposes image generation. Generic Chat Completions, Responses, and Anthropic Messages-compatible entrypoints support custom endpoints.

-### Package-like entrypoints
-
-Native catalog integrations load provider behavior through package-like entrypoints. These are export paths from the same `@opencode-ai/ai` npm package, not independently published packages. Each entrypoint exports the same `model(modelID, settings)` contract, and `settings` contains serializable provider configuration plus common `headers` and `body` overlays.
+Each named provider owns its module, endpoint, authentication, and route setup. Providers with the same wire format compose the shared protocol directly:

 ```ts
-import { model } from "@opencode-ai/ai/providers/openai/responses"
+import { DeepSeek, Fireworks } from "@opencode/ai/providers"
+
+const deepseek = DeepSeek.configure({ apiKey }).model("deepseek-chat")
+const fireworks = Fireworks.configure({ apiKey }).model("accounts/fireworks/models/my-model")
+```
+
+The former `OpenAICompatible.baseten`, `.cerebras`, `.deepinfra`, `.deepseek`, `.fireworks`, `.groq`, and `.togetherai` presets are replaced by the top-level `Baseten`, `Cerebras`, `DeepInfra`, `DeepSeek`, `Fireworks`, `Groq`, and `TogetherAI` exports. Use `CloudflareAIGateway` and `CloudflareWorkersAI` directly; each has its own module. `OpenAICompatible` configures generic endpoints with an explicit `baseURL`.
+
+### Provider entrypoints
+
+Provider modules are available through dedicated exports from `@opencode/ai`. Each LLM entrypoint exports `model(modelID, settings)`, where `settings` contains provider configuration plus common `headers` and `body` overlays.
+
+```ts
+import { model } from "@opencode/ai/providers/openai/responses"

 const selected = model("gpt-5", {
  apiKey: process.env.OPENAI_API_KEY,
-  headers: { "x-application": "opencode" },
+  headers: { "x-application": "example" },
 })
 ```

-OpenAI Chat and OpenAI Responses are separate semantic entrypoints:
+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.

@@ -338,32 +863,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" })
 ```

-Provider facades such as `OpenAI.configure(...).responses(...)` remain the direct application API. Package-like entrypoints are the self-similar loading contract used when a catalog selects behavior by export path.
+Additional provider entrypoints include:

-Other provider exports listed above remain direct facades until they explicitly implement the package-like contract. Exporting a provider facade does not implicitly make it a catalog-loadable provider package.
+- `@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

@@ -390,7 +919,7 @@ LLM.request({

 ## Routes

-Adding a new model or deployment is usually 5-15 lines using `Route.make({ protocol, endpoint, auth, framing, ... })`. The route owns endpoint/auth/framing and the protocol owns body construction plus stream parsing. Transports are reusable IO templates that receive route endpoint/auth at compile time. Capability/catalog metadata lives outside this low-level package; unsupported request shapes fail during protocol lowering. See `AGENTS.md` for the architectural detail.
+Compose a route with `Route.make({ protocol, endpoint, auth, framing, ... })`. The route owns endpoint/auth/framing and the protocol owns body construction plus stream parsing. Transports receive the route's endpoint and auth when preparing requests. Unsupported request shapes fail during protocol lowering.

 ## Effect

@@ -0,0 +1,342 @@
+# Media generation in `@opencode/ai` — public API direction
+
+Status: proposal. Branch `media-support`.
+
+## Goal
+
+`@opencode/ai` becomes the one package you reach for to generate anything: text, images, video, speech, transcripts, and later music and realtime. The LLM surface already exists and is shaped by three constraints: Effect-first, used by OpenCode Core, usable externally. Media has a different priority order: **external DX first**, Effect and Promise as peers, Core as one consumer among many.
+
+The design below is derived from a survey of the raw provider APIs (OpenAI, Gemini/Veo/Imagen, xAI, Stability, BFL, fal, Replicate, Runway, Luma, Kling, MiniMax, ElevenLabs, Deepgram, Cartesia, AssemblyAI, Lyria) and from the Vercel AI SDK v7 (`generateImage`, `generateSpeech`, `transcribe`, `experimental_generateVideo`, `ImageModelV4`/`SpeechModelV4`/`TranscriptionModelV4`/`Experimental_VideoModelV4`).
+
+## What the survey forces
+
+1. **Three execution shapes, everywhere.** Inline sync (OpenAI images, all TTS, Gemini), async job with polling or webhook (every video provider, BFL, fal, Replicate, AssemblyAI), and bidirectional streams (ElevenLabs/Cartesia/Deepgram WS, realtime). Video has no sync provider at all.
+2. **Output is never just bytes.** base64, signed URLs with TTLs from 10 minutes (BFL) to 2 days (Veo), URLs that need auth plus redirect (Veo), separate download endpoints (Sora `/content?variant=`), raw bodies (Stability, TTS). Multi-output is the norm.
+3. **Inputs have roles.** First/last frame, mask, style/subject reference, source video for edit/extend, reference audio, prior generation id, provider-side file handles (`file_id`, `gs://`, `runway://`, `mm_file://`).
+4. **Partial streaming is modality-specific.** Images: a few whole partial frames. Audio: ordered chunks plus timestamp events. Jobs: status/progress/logs. Video: none.
+5. **Usage is a union**: tokens, seconds, characters (often only in headers), credits, compute time.
+6. **Moderation can be partial success** (Veo strips audio but returns video). Deprecations are constant (Sora API shuts down 2026-09-24, Imagen on Gemini API 2026-08-17).
+
+## Where Vercel is weak and we should not be
+
+- No streaming TTS at all.
+- Video job handle is experimental and only `start`/`getStatus`; polling loop is inside `generateVideo` with an injectable `delay`.
+- Unsupported inputs become silent `warnings` arrays, so a request can succeed while dropping your mask.
+- `n` is fanned out into hidden parallel calls (`maxImagesPerCall`), which obscures cost and idempotency.
+- Each modality has its own bespoke result type; the file abstraction is a lazy base64/bytes pair with no URL, expiry, or provider ref.
+- Effect's own `unstable/ai` has no media generation. Nothing in the Effect ecosystem owns this.
+
+## Design principles
+
+- **Same shape as LLM.** `X.request(...)` → Schema class; `X.generate(request)` / `X.stream(request)`; `XClient.Service` + `layer`; typed `AIError`. If you know `LLM`, you know `Video`.
+- **Execution shape is route policy, not API shape.** `Image.generate` returns an image whether the provider is inline or queued. Job control is available uniformly when you want it.
+- **Errors, not warnings.** Unsupported common fields fail at the protocol boundary with a typed `AIError`, as the LLM routes do today. Provider-side partial results (filtered audio, moderated sample) surface as `notices` on the response, never as silent drops.
+- **One asset type in, one asset type out**, shared with LLM messages and tool results.
+- **Typed per-model options**, no hidden fan-out, no implicit retries that spend money.
+- **Promise API is one mechanism for the whole package**, not a media-only wrapper.
+- **The request namespace names the modality; the model does not repeat it.** `Image.request({ model: openai("gpt-image-2") })`, not `openai.image("gpt-image-2")`.
+
+## Public API
+
+### Model selection — `ModelRef`
+
+Today a model value is built as `OpenAI.configure({ apiKey }).responses("gpt-5")` or `.image("gpt-image-2")`: `configure` fixes credentials, endpoint, and defaults; the selector fixes which of the provider's APIs to hit and binds the typed `providerOptions` generic. The selector exists because OpenAI has two LLM APIs. For media that is the exception, and the request namespace already names the modality, so repeating it in the model is ceremony.
+
+A configured facade is callable and returns a `ModelRef`. Each request namespace resolves its own route from the ref.
+
+```ts
+import { OpenAI, Google } from "@opencode/ai/providers"
+
+const openai = OpenAI.configure({ apiKey })      // OpenAI(...) alone uses env auth (OPENAI_API_KEY)
+
+LLM.request({ model: openai("gpt-5"), prompt })                 // → routes.llm   (default: responses)
+Image.request({ model: openai("gpt-image-2"), prompt })         // → routes.image
+Video.request({ model: openai("sora-2"), prompt })              // → routes.video
+Speech.request({ model: openai("gpt-4o-mini-tts"), text })      // → routes.speech
+Transcription.request({ model: openai("gpt-4o-transcribe"), audio })
+
+// Explicit selectors remain only where a provider has two APIs for one modality.
+LLM.request({ model: openai.chat("gpt-4o"), prompt })
+Image.request({ model: google.imagen("imagen-4.0-generate-001"), prompt })   // default is Gemini-native image
+```
+
+Mechanics:
+
+- `ModelRef<Routes>` carries `{ id, provider, routes }` where `Routes = { llm?: Route<…>; image?: ImageRoute<Opts>; video?: VideoRoute<Opts>; speech?: …; transcription?: … }`. Routes are lazy; unused protocols are not constructed.
+- `X.request<M extends XModel | ModelRef<{ x: XRoute<any> }>>` infers `providerOptions` from `M["routes"]["x"]`. Passing a ref whose provider has no `x` route is a compile error. Model-id validity stays a runtime provider error, as today.
+- Explicit selectors (`openai.chat`, `google.imagen`) return the concrete `XModel` directly, exactly as `.responses(...)` does now. `.model(id)` stays as an alias of the callable for LLM compatibility.
+- Provider package entrypoints keep `model(modelID, settings)` and gain the same resolution: `@opencode/ai/providers/openai` `model(...)` returns a ref; `@opencode/ai/providers/openai/responses` returns the concrete LLM model.
+- One default per modality per provider is part of the facade definition (OpenAI image → Images API, Google image → Gemini-native since Imagen on the Gemini API shuts down 2026-08-17).
+
+This applies to LLM in the same pass so the package has one way to name a model.
+
+### `Media` — the asset type
+
+Replaces `MediaPart.data: string | Uint8Array`, `ImageInput`, `GeneratedImage`, and aligns `Tool.FileContent`.
+
+```ts
+import { Media } from "@opencode/ai"
+
+Media.Source =
+  | { type: "bytes";  data: Uint8Array; mediaType: string }
+  | { type: "base64"; data: string;     mediaType: string }
+  | { type: "url";    url: string; mediaType?: string; expiresAt?: number; headers?: Record<string, string> }
+  | { type: "ref";    provider: ProviderID; id: string; mediaType?: string }   // file_id, gs://, runway://, prior generation
+
+class Media.Asset {
+  readonly source: Media.Source
+  readonly mediaType: string                    // always resolved (sniffed when the provider omits it)
+  readonly kind: "image" | "video" | "audio" | "document" | "other"
+  readonly info?: { width?; height?; durationSeconds?; sampleRate?; channels?; encoding?; format? }
+  readonly expiresAt?: number
+  readonly providerMetadata?: ProviderMetadata
+
+  bytes(): Effect<Uint8Array, AIError, RequestExecutor.Service>   // downloads/decodes lazily, cached
+  base64(): Effect<string, AIError, RequestExecutor.Service>
+  dataUrl(): Effect<string, AIError, RequestExecutor.Service>
+  materialize(): Effect<Media.Asset, AIError, RequestExecutor.Service>  // url/ref → bytes, before the URL dies
+}
+
+Media.bytes(data, mediaType?)      Media.base64(data, mediaType?)
+Media.url(url, options?)           Media.ref(provider, id)
+Media.file(path)                   // Bun/Node: reads + sniffs; Effect FileSystem variant for layers
+Media.write(asset, path)           // convenience, uses FileSystem
+```
+
+Raw-PCM outputs (Gemini TTS, Cartesia raw, Deepgram WS) carry `info.encoding/sampleRate/channels` because there is no container header.
+
+### Modality namespaces
+
+Each namespace mirrors `LLM` exactly.
+
+```ts
+import { Image, Video, Speech, Transcription } from "@opencode/ai"
+import { OpenAI, Google, ElevenLabs, Fal } from "@opencode/ai/providers"
+```
+
+#### Image
+
+```ts
+const request = Image.request({
+  model: openai("gpt-image-2"),
+  prompt: "A robot tending a rooftop garden",
+  images: [Media.file("./ref.png")],           // references / edit sources
+  mask: Media.file("./mask.png"),
+  n: 2,
+  size: "1536x1024",                            // or aspectRatio: "3:2"
+  seed: 7,
+  format: "webp",
+  providerOptions: { quality: "high", background: "transparent" },   // typed per model
+})
+
+const response = yield* Image.generate(request)   // ImageResponse
+response.image                                    // Media.Asset (first)
+response.images                                   // Media.Asset[]
+response.usage                                    // Usage union (see below)
+response.notices                                  // moderation / partial-result notices
+
+yield* Image.stream(request)                      // Stream<ImageEvent>
+// ImageEvent: job-queued | job-progress | image-partial { index, image } | image { index, image } | finish { usage }
+```
+
+Editing is not a separate function; `images`/`mask` on the request select the edit path in the route (OpenAI `/images/edits`, Gemini multimodal parts, xAI `/images/edits`). Routes that cannot honor `mask` fail with `Unsupported`.
+
+#### Video
+
+```ts
+const request = Video.request({
+  model: google("veo-3.1-generate-preview"),
+  prompt: "Panning wide shot of a calico kitten sleeping in the sunshine",
+  frames: { first: Media.file("./start.png"), last: Media.file("./end.png") },
+  references: [Media.url("https://…/style.png")],
+  video: Media.ref("openai", "video_123"),      // edit / extend / remix source
+  durationSeconds: 8,
+  aspectRatio: "16:9",
+  resolution: "1080p",
+  audio: true,
+  n: 1,
+  providerOptions: { personGeneration: "dont_allow", negativePrompt: "text, watermark" },
+})
+
+// Simple: wait for it.
+const response = yield* Video.generate(request, { poll: { interval: "10 seconds", timeout: "10 minutes" } })
+response.video                                     // Media.Asset (url with expiresAt, or bytes when the route downloads)
+yield* response.video.materialize()                // pull bytes before the URL expires
+
+// Explicit job control.
+const job = yield* Video.start(request)            // Job<VideoResponse>
+job.id; job.status; job.progress; job.token        // token is serializable JSON
+yield* job.await({ poll })                         // VideoResponse
+yield* job.cancel()
+
+// Resume from another process.
+const resumed = yield* Video.resume(model, token)  // Job<VideoResponse>
+
+// Progress as a stream.
+yield* Video.stream(request)                       // Stream<VideoEvent>: job-queued { position } | job-progress { progress, logs } | video { index, video } | finish
+```
+
+Webhooks: `Video.complete(model, token, webhook)` finishes a job from a webhook payload without polling. Token shape is route-owned and opaque (Veo operation name, fal `response_url`, Runway task id).
+
+#### Speech (TTS)
+
+```ts
+const request = Speech.request({
+  model: elevenlabs("eleven_v3"),
+  text: "Hello from OpenCode.",
+  voice: "JBFqnCBsd6RMkjVDRZzb",                  // name, uuid, or { id } — provider-normalized
+  format: "mp3",                                   // mp3 | wav | pcm | opus | aac | flac | (string & {})
+  speed: 1.0,
+  language: "en",
+  instructions: "Warm, unhurried.",
+  providerOptions: { stability: 0.5 },
+})
+
+const response = yield* Speech.generate(request)   // SpeechResponse: audio: Media.Asset, timestamps?, usage
+yield* Speech.stream(request)                      // Stream<SpeechEvent>: audio-delta { chunk } | timestamps { words } | finish
+```
+
+Streaming TTS is first-class on day one: OpenAI `stream_format: sse`, ElevenLabs `/stream`, Cartesia SSE, Deepgram chunked. Input-streaming TTS (WS, text arrives incrementally) is a later `Speech.session(...)` scoped resource, not part of `generate`.
+
+#### Transcription (STT)
+
+```ts
+const request = Transcription.request({
+  model: openai("gpt-4o-transcribe"),
+  audio: Media.file("./call.wav"),
+  language: "en",
+  prompt: "Names: Shoubhit, OpenCode.",
+  timestamps: "word",                              // none | segment | word
+  diarize: true,
+  providerOptions: { chunkingStrategy: "auto" },
+})
+
+const response = yield* Transcription.generate(request)
+response.text; response.segments; response.words; response.language; response.durationSeconds
+yield* Transcription.stream(request)               // Stream<TranscriptionEvent>: text-delta | segment | finish
+```
+
+Realtime STT over WebSocket is the same future `session` shape as input-streaming TTS.
+
+### `Job` — shared async execution
+
+```ts
+class Job<Response> {
+  readonly id: string
+  readonly model: MediaModel
+  readonly token: unknown                          // route-owned serializable JSON
+  readonly status: "queued" | "running" | "completed" | "failed" | "cancelled" | "expired"
+  readonly progress?: number                       // 0..1, normalized
+  readonly position?: number
+  readonly expiresAt?: number
+  refresh(): Effect<Job<Response>, AIError>
+  await(options?: { poll?: Poll }): Effect<Response, AIError>
+  cancel(): Effect<void, AIError>
+  events(options?): Stream<JobEvent, AIError>
+}
+
+Poll = { interval?: Duration; timeout?: Duration; schedule?: Schedule }   // route may override from provider hints (`openai-poll-after-ms`)
+```
+
+`Job` is not video-specific. Image routes on BFL, fal, and Replicate are jobs; `Image.start` exists for them. A route declares itself `inline` or `job`; `generate` on a job route is `start` then `await`.
+
+### Usage
+
+```ts
+Usage =
+  | { type: "tokens"; input; output; total; details? }
+  | { type: "seconds"; seconds }
+  | { type: "characters"; characters }
+  | { type: "credits"; credits }
+  | { type: "compute"; seconds }
+```
+
+Header-only usage (ElevenLabs `character-cost`, Deepgram `dg-char-count`) is lifted into `usage` by the route.
+
+### Promise API — `@opencode/ai/promise`
+
+Mirrors the `packages/plugin/src/effect` and `packages/plugin/src/promise` split that already exists in this repo. One mechanism for LLM and media.
+
+```ts
+import { AI } from "@opencode/ai/promise"
+
+const ai = AI.make()                                // ManagedRuntime over RequestExecutor.fetchLayer + all clients
+// AI.make({ layer }) to inject a custom executor / recorder / middleware
+
+const image = await ai.image.generate({ model, prompt })
+await image.image.bytes()
+
+for await (const event of ai.speech.stream({ model, text, voice })) { … }
+
+const job = await ai.video.start({ model, prompt })
+const video = await job.await({ poll: { interval: 10_000 }, signal })
+const resumed = ai.video.resume(model, JSON.parse(saved))
+
+const text = await ai.llm.generate({ model, prompt })   // closes today's gap: LLM has no promise API either
+for await (const event of ai.llm.stream(request)) { … }
+
+await ai.dispose()
+```
+
+Streams become `AsyncIterable` via `Stream.toAsyncIterable`. `AIError` is thrown as-is. `AbortSignal` maps to interruption. Nothing in `src/*` except this entrypoint knows about promises.
+
+### Providers
+
+Existing facades gain media routes behind the callable `ModelRef`; the modality routes each facade provides:
+
+| Facade | llm | image | video | speech | transcription | other |
+|---|---|---|---|---|---|---|
+| `OpenAI` | responses (default), chat | Images API | Sora (deprecated 2026-09-24) | ✓ | ✓ | |
+| `Google` | Gemini | Gemini-native (default), `imagen` | Veo | Gemini TTS | Gemini transcribe | |
+| `XAI` | ✓ | ✓ | ✓ | | | |
+| `ElevenLabs` | | | | ✓ | Scribe | soundEffect, music |
+| `Fal` | | ✓ | ✓ | | | |
+| `Replicate`, `Runway`, `Luma`, `Kling`, `MiniMax`, `Deepgram`, `Cartesia`, `AssemblyAI`, `BlackForestLabs`, `Stability` | | per provider | | | | |
+
+New facades follow the existing one-file-per-provider rule. Package entrypoints: `@opencode/ai/providers/openai` `model(id, settings)` returns the ref; modality-specific entrypoints such as `@opencode/ai/providers/openai/images` return the concrete model.
+
+`ImageModel<Options>` already gives typed `providerOptions` per model; `VideoModel`, `SpeechModel`, `TranscriptionModel` follow the same generic and `ModelRef` infers through to them. A shared `MediaModel` union is what `Job` and the promise client key on.
+
+### Routes and protocols
+
+Media does not fit the LLM four-axis route (SSE frames → event state machine) except for streaming TTS/STT. Reuse `Endpoint`, `Auth`, `Framing`, `RequestExecutor`, and add media protocol kinds:
+
+- `MediaProtocol.inline` — `body.from(request)` (JSON, multipart, or query), `response.decode(response)` (JSON, or binary body → `Media.Asset`).
+- `MediaProtocol.job` — `start`, `status`, `result`, `cancel`, optional `download`, `pollHint`, `token` schema.
+- `MediaProtocol.stream` — framing + `step` state machine emitting modality events, same discipline as LLM protocols.
+
+`Route.make` for media composes one protocol kind with endpoint/auth. The existing `ImageRoute { generate(request, execute) }` is the ad-hoc version of `inline` and gets folded in.
+
+### LLM integration
+
+- `MediaPart` becomes `{ type: "media"; media: Media.Asset; … }` so protocols branch on `kind` and can pass `url`/`ref` sources through natively (OpenAI `image_url`, Gemini `fileData`).
+- New `LLMEvent`s: `media { media: Media.Asset }` so Gemini inline image output is first-class instead of dropped. OpenAI Responses `image_generation_call` keeps its single carrier — the provider-executed `tool-result` with `file` content — because Core consumes hosted tool-result content today and has no `media` event handling yet; it switches to the `media` carrier when Core adopts the event, so the image is never emitted twice.
+- `Message.assistant([...])` accepts media parts; Gemini multi-turn image editing replays them.
+- `Tool.FileContent` aligns with `Media.Source`.
+
+## Decisions
+
+All settled:
+
+1. **Callable facades + `ModelRef`** replace per-modality selectors as the primary way to name a model, for LLM and media alike. Explicit selectors stay only for providers with two APIs in one modality.
+2. **`providerOptions` everywhere** (rename current `Image.options`) for consistency with LLM.
+3. **No hidden `n` fan-out.** `n` lowers natively; routes that cannot do `n > 1` fail typed. Callers use `Effect.all` / `Promise.all` explicitly.
+4. **Errors over warnings** for unsupported common fields; `notices` for provider-side partial results only.
+5. **`Media.Asset` is a class** (lazy bytes, cached) with `Media.Source` as the serializable Schema for wire/persistence. `Asset.from(source)` / `asset.source` round-trip losslessly. Same pattern as `LanguageModel` today.
+6. **Promise entrypoint**: `@opencode/ai/promise` exporting `AI.make(options?: { layer? })` plus a module-level default `ai` for scripts, covering LLM too.
+7. **Modality set for v1**: `Image`, `Video`, `Speech`, `Transcription`. `Music`/`SoundEffect` and `session` (bidirectional WS, realtime) are designed-for but deferred.
+8. **Sora is skipped** (API shuts down 2026-09-24). Video launches with Veo, xAI, fal, Runway.
+
+## Build order
+
+Foundation + Image ship together as the reference implementation, serially. Video, Speech, and Transcription then proceed in parallel on separate branches. Image jobs and partial streaming come last, after Video has hardened `Job`.
+
+## Phasing
+
+1. **Foundation** — `ModelRef` + callable facades (LLM included, `.responses`/`.chat`/`.model` kept), `Media`, `Job`, `Poll`, `Usage` union, `MediaProtocol` kinds, `@opencode/ai/promise` with `llm` + `image`. Port the five existing image protocols onto it. Unify `MediaPart` and add the `media` LLM event (fixes Gemini image output being dropped).
+2. **Video** — Veo, xAI, fal, Runway first. Then Luma, Kling, MiniMax, Replicate.
+3. **Speech + Transcription** — OpenAI, ElevenLabs, Gemini TTS, Deepgram, Cartesia, AssemblyAI. Streaming TTS from the start.
+4. **Image jobs and partials** — BFL, fal, Replicate, Stability; OpenAI `partial_images` streaming.
+5. **Later** — ElevenLabs music/SFX, Lyria, `Speech.session` / `Transcription.session`, realtime.
+
+Core adoption (session attachments beyond png/jpeg/gif/webp/pdf, image-generation tool, TUI rendering) comes after phase 1 and is a Core concern.
@@ -1,7 +1,19 @@
 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 { NodeFileSystem } from "@effect/platform-node"
+import {
+  Image,
+  ImageClient,
+  LLM,
+  LLMClient,
+  LLMRequest,
+  Media,
+  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.
@@ -16,15 +28,20 @@ import { OpenAI } from "@opencode-ai/ai/providers"

 const apiKey = Config.redacted("OPENAI_API_KEY")

-// 1. Pick a model. The provider helper records provider identity, protocol
-// choice, capabilities, deployment options, authentication, and defaults.
-const model = OpenAI.configure({
+// 1. Configure a provider. The configured facade records provider identity,
+// deployment options, authentication, and defaults. Calling it with a model id
+// returns a `ModelRef`: `LLM.request` resolves the default LLM route
+// (Responses for OpenAI) and `Image.request` resolves the image route, so one
+// value names a model for every modality. `.responses(...)` / `.chat(...)`
+// remain available when you need a specific API.
+const openai = OpenAI.configure({
  apiKey,
  generation: { maxTokens: 160 },
  providerOptions: {
    store: false,
  },
-}).model("gpt-4o-mini")
+})
+const model = openai("gpt-4o-mini")

 // 2. Build a provider-neutral request. This is useful when reusing one request
 // across generate and stream examples.
@@ -209,18 +226,39 @@ const FakeEcho = {
  }),
 }

+// 8. Image generation uses the same facade and the same request/generate shape.
+// `response.image` is a `Media.Asset`: bytes decode lazily and are cached, and
+// `Media.write` persists them through the Effect `FileSystem`.
+const generateImage = Effect.gen(function* () {
+  const response = yield* Image.generate({
+    model: openai("gpt-image-1-mini"),
+    prompt: "A flat black circle centered on a plain white background.",
+    size: "1024x1024",
+    format: "jpeg",
+    providerOptions: { quality: "low" },
+  })
+
+  console.log("\n== image ==")
+  console.log("media type:", response.image.mediaType)
+  console.log("bytes:", (yield* response.image.bytes()).byteLength)
+  console.log("usage", Formatter.formatJson(response.usage, { space: 2 }))
+  yield* Media.write(response.image, "tutorial-image.jpg").pipe(Effect.provide(NodeFileSystem.layer))
+})
+
 // Provide the LLM runtime and the HTTP request executor once. Keep one path
 // enabled at a time so the tutorial can demonstrate generate, stream, or
 // tool-loop behavior without spending tokens on every example.
 const requestExecutorLayer = RequestExecutor.fetchLayer
 const llmClientLayer = LLMClient.layer.pipe(Layer.provide(requestExecutorLayer))
+const imageClientLayer = ImageClient.layer.pipe(Layer.provide(requestExecutorLayer))

 const program = Effect.gen(function* () {
  // yield* generateOnce
  // yield* streamText
  // yield* generateStructuredObject
  // yield* generateDynamicObject.pipe(Effect.andThen((response) => Effect.sync(() => console.log(response.object))))
+  // yield* generateImage
  yield* streamWithTools
-}).pipe(Effect.provide(Layer.mergeAll(requestExecutorLayer, llmClientLayer)))
+}).pipe(Effect.provide(Layer.mergeAll(requestExecutorLayer, llmClientLayer, imageClientLayer)))

 Effect.runPromise(program)
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.17.20",
-  "name": "@opencode-ai/ai",
+  "version": "2.0.3",
+  "name": "@opencode/ai",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -15,22 +15,24 @@
  ],
  "exports": {
    ".": "./src/index.ts",
+    "./promise": "./src/promise.ts",
    "./testing": "./src/testing.ts",
    "./*": "./src/*.ts"
  },
  "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:",
    "typescript": "catalog:"
  },
  "dependencies": {
+    "@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"

@@ -7,7 +7,8 @@ import { AwsV4Signer } from "aws4fetch"
 import { Config, ConfigProvider, Effect, FileSystem, PlatformError, Redacted } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest, type HttpClientResponse } from "effect/unstable/http"
 import * as ProviderShared from "../src/protocols/shared"
-import * as Cloudflare from "../src/providers/cloudflare"
+import { CloudflareAIGateway } from "../src/providers/cloudflare-ai-gateway.js"
+import { CloudflareWorkersAI } from "../src/providers/cloudflare-workers-ai.js"

 type Provider = {
  readonly id: string
@@ -120,11 +121,11 @@ const PROVIDERS: ReadonlyArray<Provider> = [
    ],
    validate: (env) =>
      validateChat({
-        url: `${Cloudflare.aiGatewayBaseURL({
+        url: `${CloudflareAIGateway.baseURL({
          accountId: env.CLOUDFLARE_ACCOUNT_ID,
          gatewayId: env.CLOUDFLARE_GATEWAY_ID || undefined,
        })}/chat/completions`,
-        token: Redacted.make(envValue(env, Cloudflare.aiGatewayAuthEnvVars)),
+        token: Redacted.make(envValue(env, CloudflareAIGateway.authEnvVars)),
        tokenHeader: "cf-aig-authorization",
        model: "workers-ai/@cf/meta/llama-3.1-8b-instruct",
      }),
@@ -140,8 +141,8 @@ const PROVIDERS: ReadonlyArray<Provider> = [
    ],
    validate: (env) =>
      validateChat({
-        url: `${Cloudflare.workersAIBaseURL({ accountId: env.CLOUDFLARE_ACCOUNT_ID })}/chat/completions`,
-        token: Redacted.make(envValue(env, Cloudflare.workersAIAuthEnvVars)),
+        url: `${CloudflareWorkersAI.baseURL({ accountId: env.CLOUDFLARE_ACCOUNT_ID })}/chat/completions`,
+        token: Redacted.make(envValue(env, CloudflareWorkersAI.authEnvVars)),
        model: "@cf/meta/llama-3.1-8b-instruct",
      }),
  },
@@ -157,9 +158,9 @@ const PROVIDERS: ReadonlyArray<Provider> = [
    id: "togetherai",
    label: "TogetherAI",
    tier: "compatible",
-    note: "Existing OpenAI-compatible text/tool recorded tests",
-    vars: [{ name: "TOGETHER_AI_API_KEY" }],
-    validate: (env) => validateBearer("https://api.together.xyz/v1/models", Redacted.make(env.TOGETHER_AI_API_KEY)),
+    note: "Native Together AI text/tool recorded tests",
+    vars: [{ name: "TOGETHER_API_KEY" }],
+    validate: (env) => validateBearer("https://api.together.xyz/v1/models", Redacted.make(env.TOGETHER_API_KEY)),
  },
  {
    id: "minimax",
@@ -200,8 +201,8 @@ const PROVIDERS: ReadonlyArray<Provider> = [
  {
    id: "cerebras",
    label: "Cerebras",
-    tier: "optional",
-    note: "OpenAI-compatible bridge",
+    tier: "compatible",
+    note: "Native Cerebras text/tool/tool-loop recorded tests",
    vars: [{ name: "CEREBRAS_API_KEY" }],
    validate: (env) => validateBearer("https://api.cerebras.ai/v1/models", Redacted.make(env.CEREBRAS_API_KEY)),
  },
@@ -11,7 +11,8 @@
 // Manual `cache: CacheHint` placements on individual parts are preserved and
 // count against the four-breakpoint budget; auto only fills remaining slots.
 import { CacheHint, type CachePolicy, type CachePolicyObject } from "./schema/options.js"
-import { LLMRequest, Message, ToolDefinition, type ContentPart } from "./schema/messages.js"
+import { LLMRequest, Message, ToolDefinition, type ContentPart, type ToolEntry } from "./schema/messages.js"
+import { effortUpdate } from "./effort-updates.js"

 const AUTO: CachePolicyObject = {
  tools: true,
@@ -36,7 +37,12 @@ const resolve = (policy: CachePolicy | undefined): CachePolicyObject => {
 // Protocols whose wire format ignores inline cache markers (OpenAI's implicit
 // prefix caching, Gemini's implicit + out-of-band CachedContent). Skip the
 // whole policy pass for these — emitting hints would be harmless but pointless.
-const RESPECTS_INLINE_HINTS = new Set(["anthropic-messages", "bedrock-converse", "openrouter"])
+const RESPECTS_INLINE_HINTS = new Set([
+  "anthropic-messages",
+  "google-vertex-messages",
+  "bedrock-converse",
+  "openrouter",
+])

 const makeHint = (ttlSeconds: number | undefined): CacheHint =>
  ttlSeconds !== undefined ? new CacheHint({ type: "ephemeral", ttlSeconds }) : new CacheHint({ type: "ephemeral" })
@@ -45,18 +51,24 @@ interface Budget {
  remaining: number
 }

-const markLastTool = (
-  tools: ReadonlyArray<ToolDefinition>,
-  hint: CacheHint,
-  budget: Budget,
-): ReadonlyArray<ToolDefinition> => {
-  if (tools.length === 0) return tools
-  const last = tools.length - 1
-  if (tools[last]!.cache || budget.remaining === 0) return tools
+const markLastTool = (tools: ReadonlyArray<ToolEntry>, hint: CacheHint, budget: Budget): ReadonlyArray<ToolEntry> => {
+  const target = tools.at(-1)
+  if (target === undefined) return tools
+  if (target.type === "namespace") {
+    const nested = markLastTool(target.tools, hint, budget)
+    return nested === target.tools ? tools : [...tools.slice(0, -1), { ...target, tools: nested }]
+  }
+  if (target.cache || budget.remaining === 0) return tools
  budget.remaining -= 1
-  return tools.map((tool, i) => (i === last ? new ToolDefinition({ ...tool, cache: hint }) : tool))
+  return [...tools.slice(0, -1), new ToolDefinition({ ...target, cache: hint })]
 }

+const countToolHints = (tools: ReadonlyArray<ToolEntry>): number =>
+  tools.reduce(
+    (count, tool) => count + (tool.type === "tool" ? (tool.cache === undefined ? 0 : 1) : countToolHints(tool.tools)),
+    0,
+  )
+
 const markSystemBoundaries = (system: LLMRequest["system"], hint: CacheHint, budget: Budget): LLMRequest["system"] => {
  if (system.length === 0) return system
  let changed = false
@@ -110,14 +122,20 @@ const markMessages = (
    return markMessageAt(messages, lastIndexOfRole(messages, "user"), hint, budget)
  if (strategy === "latest-assistant")
    return markMessageAt(messages, lastIndexOfRole(messages, "assistant"), hint, budget)
-  const start = Math.max(0, messages.length - strategy.tail)
+  let start = messages.length
+  let remaining = strategy.tail
+  while (remaining > 0 && start > 0) {
+    start -= 1
+    if (effortUpdate(messages[start]!) === undefined) remaining -= 1
+  }
  let next = messages
-  for (let i = start; i < messages.length; i++) next = markMessageAt(next, i, hint, budget)
+  for (let i = start; i < messages.length; i++)
+    if (effortUpdate(messages[i]!) === undefined) next = markMessageAt(next, i, hint, budget)
  return next
 }

 const countHints = (request: LLMRequest) =>
-  request.tools.reduce((count, tool) => count + (tool.cache === undefined ? 0 : 1), 0) +
+  countToolHints(request.tools) +
  request.system.reduce((count, part) => count + (part.cache === undefined ? 0 : 1), 0) +
  request.messages.reduce(
    (count, message) =>
@@ -0,0 +1,25 @@
+// Changing the top-level reasoning effort invalidates the provider prompt cache. Protocols with a native
+// per-message update keep it frozen and lower `Message.effort(...)` markers instead; other routes strip them.
+import { LLMRequest, type EffortPart, type Message } from "./schema/messages.js"
+
+export const effortUpdate = (message: Message): EffortPart | undefined => {
+  if (message.role !== "system" || message.content.length !== 1) return undefined
+  const part = message.content[0]
+  return part.type === "effort" ? part : undefined
+}
+
+export const stripEffortUpdates = (request: LLMRequest) => {
+  const messages = request.messages.filter((message) => effortUpdate(message) === undefined)
+  return messages.length === request.messages.length ? request : LLMRequest.update(request, { messages })
+}
+
+export const applyEffortUpdates = (request: LLMRequest): LLMRequest =>
+  request.model.route.supportsEffortUpdates?.(request) ? request : stripEffortUpdates(request)
+
+// Reverted or forked history can leave the last marker disagreeing with the requested effort.
+export const resolveEffortUpdates = (request: LLMRequest, current: string | undefined) => {
+  const updates = request.messages.flatMap((message) => effortUpdate(message) ?? [])
+  if (updates.length === 0) return { request, effort: current }
+  if (updates.at(-1)?.effort !== current) return { request: stripEffortUpdates(request), effort: current }
+  return { request, effort: updates[0]?.previous }
+}
@@ -1,14 +1,21 @@
-import { Context, Effect, Layer } from "effect"
+import { Context, Effect, Layer, Stream } from "effect"
 import { RequestExecutor } from "./route/executor.js"
-import type { ImageOptions, ImageRequest, ImageRequestFor, ImageResponse } from "./image.js"
 import type { AIError } from "./schema/index.js"
-
-export type Execute = RequestExecutor.Interface["execute"]
+import {
+  responseEvents,
+  type ImageEvent,
+  type ImageOptions,
+  type ImageRequestFor,
+  type ImageResponse,
+} from "./image.js"

 export interface Interface {
  readonly generate: <Options extends ImageOptions>(
    request: ImageRequestFor<Options>,
  ) => Effect.Effect<ImageResponse, AIError>
+  readonly stream: <Options extends ImageOptions>(
+    request: ImageRequestFor<Options>,
+  ) => Stream.Stream<ImageEvent, AIError>
 }

 export class Service extends Context.Service<Service, Interface>()("@opencode/ImageClient") {}
@@ -21,12 +28,27 @@ export const generate = <Options extends ImageOptions>(
    return yield* client.generate(request)
  })

+export const stream = <Options extends ImageOptions>(
+  request: ImageRequestFor<Options>,
+): Stream.Stream<ImageEvent, AIError, Service> =>
+  Stream.unwrap(
+    Effect.gen(function* () {
+      const client = yield* Service
+      return client.stream(request)
+    }),
+  )
+
 export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
  Service,
  Effect.gen(function* () {
    const executor = yield* RequestExecutor.Service
+    const generate = <Options extends ImageOptions>(request: ImageRequestFor<Options>) =>
+      request.model.route.generate(request, executor.execute)
    return Service.of({
-      generate: (request) => request.model.route.generate(request, executor.execute),
+      generate,
+      // Inline routes have no partial frames yet; the stream is the completed response expanded into events.
+      stream: (request) =>
+        Stream.unwrap(generate(request).pipe(Effect.map((response) => Stream.fromIterable(responseEvents(response))))),
    })
  }),
 )
@@ -35,4 +57,5 @@ export const ImageClient = {
  Service,
  layer,
  generate,
+  stream,
 } as const
@@ -1,22 +1,32 @@
-import { Effect, Schema } from "effect"
+import { Effect, Schema, Stream } from "effect"
+import { Media } from "./media.js"
+import { ModelRef, type ResolveImageModel } from "./model-ref.js"
+import { Endpoint } from "./route/endpoint.js"
+import { MediaRoute } from "./route/media.js"
+import type { MediaProtocol } from "./route/media-protocol.js"
 import {
-  HttpOptions,
-  InvalidRequestReason,
  AIError,
+  HttpOptions,
+  InvalidRequestError,
+  MediaUsage,
  ModelID,
  ProviderID,
  ProviderMetadata,
-  Usage,
+  UnsupportedOperationError,
 } from "./schema/index.js"
-import { ImageClient, Service, type Execute as ImageExecute } from "./image-client.js"
+import { ImageClient, Service } from "./image-client.js"

-export interface ImageRoute<Options extends ImageOptions = ImageOptions> {
-  readonly id: string
-  readonly generate: (request: ImageRequestFor<Options>, execute: ImageExecute) => Effect.Effect<ImageResponse, AIError>
-}
+// ---------------------------------------------------------------------------
+// Model
+// ---------------------------------------------------------------------------

 export type ImageOptions = Record<string, unknown>

+export type ImageRoute<Options extends ImageOptions = ImageOptions> = MediaRoute.Route<
+  ImageRequestFor<Options>,
+  ImageResponse
+>
+
 export class ImageModel<Options extends ImageOptions = ImageOptions> {
  declare protected readonly _Options: (options: Options) => Options
  readonly id: ModelID
@@ -39,6 +49,26 @@ export class ImageModel<Options extends ImageOptions = ImageOptions> {
      http: input.http,
    })
  }
+
+  /** Compose an inline image protocol with its canonical path into a model for one deployment. */
+  static fromRoute<Options extends ImageOptions = ImageOptions>(
+    route: ImageModel.RouteInput<Options>,
+    input: MediaRoute.ModelInput,
+  ) {
+    return ImageModel.make<Options>({
+      id: input.id,
+      provider: route.provider,
+      http: input.http,
+      route: MediaRoute.make({
+        id: route.id,
+        provider: route.provider,
+        protocol: route.protocol,
+        endpoint: Endpoint.path(route.path, { baseURL: input.baseURL ?? route.baseURL }),
+        auth: input.auth,
+        headers: input.headers,
+      }),
+    })
+  }
 }

 export namespace ImageModel {
@@ -54,81 +84,87 @@ export namespace ImageModel {
    readonly id: string | ModelID
    readonly provider: string | ProviderID
  }
+
+  export interface RouteInput<Options extends ImageOptions = ImageOptions> {
+    readonly id: string
+    readonly provider: string | ProviderID
+    readonly protocol: MediaProtocol.Inline<ImageRequestFor<Options>, ImageResponse>
+    readonly path: Endpoint.EndpointPart<MediaProtocol.Body, ImageRequestFor<Options>>
+    /** Canonical base URL; `ModelInput.baseURL` overrides it per deployment. */
+    readonly baseURL?: string
+  }
 }

 export const ImageModelSchema = Schema.declare((value): value is ImageModel => value instanceof ImageModel, {
  expected: "Image.Model",
 })

-const ImageBytesInput = Schema.Struct({
-  type: Schema.Literal("bytes"),
-  data: Schema.Uint8Array,
-  mediaType: Schema.String,
-})
-const ImageUrlInput = Schema.Struct({
-  type: Schema.Literal("url"),
-  url: Schema.String,
-})
-const ImageFileIDInput = Schema.Struct({
-  type: Schema.Literal("file-id"),
-  id: Schema.String,
-})
-const ImageFileURIInput = Schema.Struct({
-  type: Schema.Literal("file-uri"),
-  uri: Schema.String,
-  mediaType: Schema.String,
-})
+// ---------------------------------------------------------------------------
+// Request
+// ---------------------------------------------------------------------------

-export const ImageInputSchema = Schema.Union([
-  ImageBytesInput,
-  ImageUrlInput,
-  ImageFileIDInput,
-  ImageFileURIInput,
-]).pipe(Schema.toTaggedUnion("type"))
-export type ImageInput = Schema.Schema.Type<typeof ImageInputSchema>
+export type ImageSize = `${number}x${number}`
+export const ImageSize = Schema.declare<ImageSize>(
+  (value): value is ImageSize => typeof value === "string" && /^\d+x\d+$/.test(value),
+  { title: "ImageSize" },
+)

-export const ImageInput = {
-  bytes: (data: Uint8Array, mediaType: string): ImageInput => ({ type: "bytes", data, mediaType }),
-  url: (url: string): ImageInput => ({ type: "url", url }),
-  file: (id: string): ImageInput => ({ type: "file-id", id }),
-  fileUri: (uri: string, mediaType: string): ImageInput => ({ type: "file-uri", uri, mediaType }),
-} as const
+export type ImageAspectRatio = `${number}:${number}`
+export const ImageAspectRatio = Schema.declare<ImageAspectRatio>(
+  (value): value is ImageAspectRatio => typeof value === "string" && /^\d+(?:\.\d+)?:\d+(?:\.\d+)?$/.test(value),
+  { title: "ImageAspectRatio" },
+)
+
+export type ImageFormat = "png" | "jpeg" | "webp" | (string & {})

 export class ImageRequest extends Schema.Class<ImageRequest>("Image.Request")({
  model: ImageModelSchema,
  prompt: Schema.String,
-  images: Schema.optional(Schema.Array(ImageInputSchema)),
-  options: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+  /** Edit sources or style/subject references, in order. */
+  images: Schema.optional(Schema.Array(Media.AssetSchema)),
+  /** Inpainting mask; routes that cannot honor it fail with `UnsupportedOperation`. */
+  mask: Schema.optional(Media.AssetSchema),
+  n: Schema.optional(Schema.Int),
+  size: Schema.optional(ImageSize),
+  aspectRatio: Schema.optional(ImageAspectRatio),
+  seed: Schema.optional(Schema.Number),
+  format: Schema.optional(Schema.String),
+  providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
  http: Schema.optional(HttpOptions),
 }) {
  declare protected readonly _ImageRequest: void
 }

-export type ImageRequestFor<Options extends ImageOptions = ImageOptions> = Omit<ImageRequest, "model" | "options"> & {
+export type ImageRequestFor<Options extends ImageOptions = ImageOptions> = Omit<
+  ImageRequest,
+  "model" | "providerOptions"
+> & {
  readonly model: ImageModel<Options>
-  readonly options?: Options
+  readonly providerOptions?: Options
 }

-export type ImageModelOptions<Model> = Model extends ImageModel<infer Options> ? Options : never
+export type ImageModelInput = ImageModel | ModelRef.WithImage

-export type ImageRequestInput<Model extends object = ImageModel> = Omit<
+export type ImageModelOptions<Model> = ResolveImageModel<Model> extends ImageModel<infer Options> ? Options : never
+
+export type ImageRequestInput<Model extends ImageModelInput = ImageModelInput> = Omit<
  ConstructorParameters<typeof ImageRequest>[0],
-  "model" | "options" | "http"
+  "model" | "providerOptions" | "http"
 > & {
  readonly model: Model
-  readonly options?: NoInfer<ImageModelOptions<Model>>
+  readonly format?: ImageFormat
+  readonly providerOptions?: NoInfer<ImageModelOptions<Model>>
  readonly http?: HttpOptions.Input
-} & (Model extends ImageModel<ImageModelOptions<Model>> ? unknown : never)
+}

-export class GeneratedImage extends Schema.Class<GeneratedImage>("Image.Generated")({
-  mediaType: Schema.String,
-  data: Schema.Union([Schema.String, Schema.Uint8Array]),
-  providerMetadata: Schema.optional(ProviderMetadata),
-}) {}
+// ---------------------------------------------------------------------------
+// Response and events
+// ---------------------------------------------------------------------------

 export class ImageResponse extends Schema.Class<ImageResponse>("Image.Response")({
-  images: Schema.Array(GeneratedImage),
-  usage: Schema.optional(Usage),
+  images: Schema.Array(Media.AssetSchema),
+  usage: Schema.optional(MediaUsage),
+  notices: Schema.optional(Schema.Array(Media.Notice)),
  providerMetadata: Schema.optional(ProviderMetadata),
 }) {
  get image() {
@@ -136,7 +172,57 @@ export class ImageResponse extends Schema.Class<ImageResponse>("Image.Response")
  }
 }

-export function request<const Model extends object>(
+export const ImageOutputEvent = Schema.Struct({
+  type: Schema.tag("image"),
+  index: Schema.Number,
+  image: Media.AssetSchema,
+}).annotate({ identifier: "Image.Event.Image" })
+
+export const ImageFinishEvent = Schema.Struct({
+  type: Schema.tag("finish"),
+  usage: Schema.optional(MediaUsage),
+  notices: Schema.optional(Schema.Array(Media.Notice)),
+  providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "Image.Event.Finish" })
+
+const imageEventTagged = Schema.Union([ImageOutputEvent, ImageFinishEvent]).pipe(Schema.toTaggedUnion("type"))
+export const ImageEvent = Object.assign(imageEventTagged, {
+  is: {
+    image: imageEventTagged.guards.image,
+    finish: imageEventTagged.guards.finish,
+  },
+})
+export type ImageEvent = Schema.Schema.Type<typeof imageEventTagged>
+
+/** Inline routes produce every image at once; expand the response into the streaming event shape. */
+export const responseEvents = (response: ImageResponse): ReadonlyArray<ImageEvent> => [
+  ...response.images.map((image, index) => ImageOutputEvent.make({ index, image })),
+  ImageFinishEvent.make({
+    usage: response.usage,
+    notices: response.notices,
+    providerMetadata: response.providerMetadata,
+  }),
+]
+
+// ---------------------------------------------------------------------------
+// Request-shaped call API
+// ---------------------------------------------------------------------------
+
+const resolveModel = (model: ImageModelInput): ImageModel => {
+  if (model instanceof ImageModel) return model
+  // Typed callers cannot reach the throw; it guards JS callers passing a ref without an image selector.
+  const selected = model.facade.image?.(model.id)
+  if (selected) return selected
+  throw new AIError({
+    reason: new UnsupportedOperationError({
+      operation: "image",
+      provider: model.provider,
+      message: `${model.provider} does not expose an image route for ${model.id}`,
+    }),
+  })
+}
+
+export function request<const Model extends ImageModelInput>(
  input: ImageRequestInput<Model>,
 ): ImageRequestFor<ImageModelOptions<Model>>
 export function request(input: ImageRequest): ImageRequest
@@ -144,28 +230,43 @@ export function request(input: ImageRequest | ImageRequestInput) {
  if (input instanceof ImageRequest) return input
  return new ImageRequest({
    ...input,
-    model: input.model as unknown as ImageModel,
+    model: resolveModel(input.model),
    http: input.http === undefined ? undefined : HttpOptions.make(input.http),
  })
 }

-export function generate<const Model extends object>(
+const requestEffect = (input: ImageRequest | ImageRequestInput) =>
+  Effect.try({
+    try: () => request(input),
+    catch: (error) =>
+      error instanceof AIError
+        ? error
+        : new AIError({
+            reason: new InvalidRequestError({
+              message: error instanceof Error ? error.message : String(error),
+              cause: error,
+            }),
+          }),
+  })
+
+export function generate<const Model extends ImageModelInput>(
  input: ImageRequestInput<Model>,
 ): Effect.Effect<ImageResponse, AIError, Service>
 export function generate(input: ImageRequest): Effect.Effect<ImageResponse, AIError, Service>
 export function generate(input: ImageRequest | ImageRequestInput) {
-  return Effect.try({
-    try: () => (input instanceof ImageRequest ? input : request(input)),
-    catch: (error) =>
-      new AIError({
-        module: "Image",
-        method: "generate",
-        reason: new InvalidRequestReason({ message: error instanceof Error ? error.message : String(error) }),
-      }),
-  }).pipe(Effect.flatMap((request) => ImageClient.generate(request as unknown as ImageRequestFor<ImageOptions>)))
+  return requestEffect(input).pipe(Effect.flatMap((request) => ImageClient.generate(request)))
+}
+
+export function stream<const Model extends ImageModelInput>(
+  input: ImageRequestInput<Model>,
+): Stream.Stream<ImageEvent, AIError, Service>
+export function stream(input: ImageRequest): Stream.Stream<ImageEvent, AIError, Service>
+export function stream(input: ImageRequest | ImageRequestInput) {
+  return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => ImageClient.stream(request))))
 }

 export const Image = {
  request,
  generate,
+  stream,
 } as const
@@ -11,9 +11,30 @@ export type {
  Service as LLMClientService,
 } from "./route/client.js"
 export * from "./schema/index.js"
-export { GeneratedImage, ImageInput, ImageInputSchema, ImageModel, ImageRequest, ImageResponse } from "./image.js"
-export type { ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute } from "./image.js"
+export {
+  ImageAspectRatio,
+  ImageEvent,
+  ImageModel,
+  ImageModelSchema,
+  ImageRequest,
+  ImageResponse,
+  ImageSize,
+} from "./image.js"
+export type {
+  ImageFormat,
+  ImageModelInput,
+  ImageModelOptions,
+  ImageOptions,
+  ImageRequestFor,
+  ImageRequestInput,
+  ImageRoute,
+} from "./image.js"
 export { Image } from "./image.js"
+export { Media } from "./media.js"
+export { ModelRef } from "./model-ref.js"
+export type { ResolveImageModel, ResolveLanguageModel } from "./model-ref.js"
+export { Job } from "./job.js"
+export type { Event as JobEvent, Poll, Route as JobRoute, Snapshot as JobSnapshot, Status as JobStatus } from "./job.js"
 export { Tool, ToolFailure, toDefinitions } from "./tool.js"
 export { ToolRuntime } from "./tool-runtime.js"
 export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime.js"
@@ -0,0 +1,137 @@
+import { Duration, Effect, Schedule, Schema, Stream } from "effect"
+import { AIError, TimeoutError } from "./schema/errors.js"
+
+export const Status = Schema.Literals(["queued", "running", "completed", "failed", "cancelled", "expired"])
+export type Status = Schema.Schema.Type<typeof Status>
+
+/** Provider-neutral view of one job observation. */
+export interface Snapshot {
+  readonly id: string
+  readonly status: Status
+  /** Normalized 0..1 when the provider reports progress. */
+  readonly progress?: number
+  readonly position?: number
+  readonly expiresAt?: number
+}
+
+/**
+ * Route-owned job operations. `token` is the route's serializable handle (operation name, task id, response URL)
+ * so a job can be resumed from another process; its shape is opaque to `Job`.
+ */
+export interface Route<Response> {
+  readonly status: (token: unknown) => Effect.Effect<Snapshot, AIError>
+  readonly result: (token: unknown) => Effect.Effect<Response, AIError>
+  readonly cancel?: (token: unknown) => Effect.Effect<void, AIError>
+  /** Provider polling hint (e.g. `openai-poll-after-ms`) that overrides the default interval for the next poll. */
+  readonly pollHint?: (snapshot: Snapshot) => Duration.Duration | undefined
+}
+
+export interface Poll {
+  readonly interval?: Duration.Input
+  readonly timeout?: Duration.Input
+  /** Full override of the polling schedule; `interval` and `pollHint` are ignored when supplied. */
+  readonly schedule?: Schedule.Schedule<unknown, Snapshot>
+}
+
+export const DEFAULT_POLL_INTERVAL = Duration.seconds(5)
+export const DEFAULT_POLL_TIMEOUT = Duration.minutes(10)
+
+export type Event =
+  | { readonly type: "job-queued"; readonly id: string; readonly position?: number }
+  | { readonly type: "job-progress"; readonly id: string; readonly progress?: number }
+  | { readonly type: "job-finished"; readonly id: string; readonly status: Status }
+
+const TERMINAL: ReadonlySet<Status> = new Set(["completed", "failed", "cancelled", "expired"])
+
+export class Job<Response> {
+  readonly id: string
+  readonly status: Status
+  readonly progress?: number
+  readonly position?: number
+  readonly expiresAt?: number
+
+  constructor(
+    readonly route: Route<Response>,
+    readonly token: unknown,
+    snapshot: Snapshot,
+  ) {
+    this.id = snapshot.id
+    this.status = snapshot.status
+    this.progress = snapshot.progress
+    this.position = snapshot.position
+    this.expiresAt = snapshot.expiresAt
+  }
+
+  get snapshot(): Snapshot {
+    return {
+      id: this.id,
+      status: this.status,
+      progress: this.progress,
+      position: this.position,
+      expiresAt: this.expiresAt,
+    }
+  }
+
+  get terminal() {
+    return TERMINAL.has(this.status)
+  }
+
+  refresh(): Effect.Effect<Job<Response>, AIError> {
+    return this.route.status(this.token).pipe(Effect.map((snapshot) => new Job(this.route, this.token, snapshot)))
+  }
+
+  /** Poll until the job reaches a terminal status, then fetch the result. Fails with a `Timeout` reason on deadline. */
+  await(options?: { readonly poll?: Poll }): Effect.Effect<Response, AIError> {
+    const timeout = Duration.fromInputUnsafe(options?.poll?.timeout ?? DEFAULT_POLL_TIMEOUT)
+    const settled = this.terminal ? Effect.succeed(this) : this.poll(options?.poll)
+    return settled.pipe(
+      // Non-completed terminal states also go through `result` so the route can surface its provider failure body.
+      Effect.flatMap((job) => job.route.result(job.token)),
+      Effect.timeoutOrElse({
+        duration: timeout,
+        orElse: () =>
+          new AIError({
+            reason: new TimeoutError({
+              message: `Job ${this.id} did not finish within ${Duration.format(timeout)}`,
+              timeoutMs: Duration.toMillis(timeout),
+            }),
+          }),
+      }),
+    )
+  }
+
+  cancel(): Effect.Effect<void, AIError> {
+    return this.route.cancel?.(this.token) ?? Effect.void
+  }
+
+  /** Status observations as a stream, ending after the first terminal observation. */
+  events(options?: { readonly poll?: Poll }): Stream.Stream<Event, AIError> {
+    const observations = this.terminal
+      ? Stream.make(this)
+      : Stream.fromEffectSchedule(this.refresh(), this.schedule(options?.poll)).pipe(
+          Stream.takeUntil((job) => job.terminal),
+        )
+    return observations.pipe(
+      Stream.map((job): Event => {
+        if (job.terminal) return { type: "job-finished", id: job.id, status: job.status }
+        if (job.status === "queued") return { type: "job-queued", id: job.id, position: job.position }
+        return { type: "job-progress", id: job.id, progress: job.progress }
+      }),
+    )
+  }
+
+  private poll(poll: Poll | undefined) {
+    return this.refresh().pipe(Effect.repeat({ schedule: this.schedule(poll), until: (job) => job.terminal }))
+  }
+
+  private schedule(poll: Poll | undefined): Schedule.Schedule<unknown, Job<Response>> {
+    if (poll?.schedule) return poll.schedule.pipe(Schedule.setInputType<Job<Response>>())
+    const interval = poll?.interval ?? DEFAULT_POLL_INTERVAL
+    const pollHint = this.route.pollHint
+    const spaced = Schedule.spaced(interval).pipe(Schedule.setInputType<Job<Response>>())
+    if (!pollHint) return spaced
+    return spaced.pipe(
+      Schedule.modifyDelay((metadata) => Effect.succeed(pollHint(metadata.input.snapshot) ?? interval)),
+    )
+  }
+}
@@ -3,7 +3,7 @@ import { LLMClient, Service } from "./route/client.js"
 import {
  GenerationOptions,
  HttpOptions,
-  InvalidProviderOutputReason,
+  InvalidProviderOutputError,
  AIError,
  LLMEvent,
  LLMRequest,
@@ -12,25 +12,30 @@ import {
  LanguageModel,
  SystemPart,
  ToolChoice,
-  ToolDefinition,
+  ToolEntry,
  type ContentPart,
  type LanguageModelProviderOptions,
+  type ToolEntryInput,
 } from "./schema/index.js"
 import { make as makeTool, toDefinitions, type ToolSchema } from "./tool.js"
+import { ModelRef, type ResolveLanguageModel } from "./model-ref.js"
+
+/** A concrete language model or a callable-facade ref whose provider exposes an LLM route. */
+export type LanguageModelInput = LanguageModel | ModelRef

 /** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */
-export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<
+export type RequestInput<SelectedModel extends LanguageModelInput = LanguageModelInput> = Omit<
  ConstructorParameters<typeof LLMRequest>[0],
  "model" | "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"
 > & {
-  readonly model: SelectedLanguageModel
+  readonly model: SelectedModel
  readonly system?: string | SystemPart | ReadonlyArray<SystemPart>
  readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>
  readonly messages?: ReadonlyArray<Message | Message.Input>
-  readonly tools?: ReadonlyArray<ToolDefinition.Input>
+  readonly tools?: ReadonlyArray<ToolEntryInput>
  readonly toolChoice?: ToolChoice.Input
  readonly generation?: GenerationOptions.Input
-  readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>
+  readonly providerOptions?: NoInfer<LanguageModelProviderOptions<ResolveLanguageModel<SelectedModel>>>
  readonly http?: HttpOptions.Input
 }

@@ -38,10 +43,14 @@ export const generate = LLMClient.generate

 export const stream = LLMClient.stream

-export const request = <const SelectedLanguageModel extends LanguageModel>(
-  input: RequestInput<SelectedLanguageModel>,
-) => {
+// The stored request keeps the concrete model; refs are resolved once here so nothing downstream knows about them.
+const resolveModel = (model: LanguageModelInput) => (model instanceof ModelRef ? model.facade.model(model.id) : model)
+
+export const request = <const SelectedModel extends LanguageModelInput>(
+  input: RequestInput<SelectedModel>,
+): LLMRequest<ResolveLanguageModel<SelectedModel>> => {
  const {
+    model,
    system: requestSystem,
    prompt,
    messages,
@@ -52,11 +61,12 @@ export const request = <const SelectedLanguageModel extends LanguageModel>(
    http: requestHttp,
    ...rest
  } = input
-  return new LLMRequest({
+  return new LLMRequest<ResolveLanguageModel<SelectedModel>>({
    ...rest,
+    model: resolveModel(model) as ResolveLanguageModel<SelectedModel>,
    system: SystemPart.content(requestSystem),
    messages: [...(messages?.map(Message.make) ?? []), ...(prompt === undefined ? [] : [Message.user(prompt)])],
-    tools: tools?.map(ToolDefinition.make) ?? [],
+    tools: tools?.map(ToolEntry.make) ?? [],
    toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined,
    generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration),
    providerOptions: requestProviderOptions,
@@ -68,8 +78,8 @@ const GENERATE_OBJECT_TOOL_NAME = "generate_object"

 const GENERATE_OBJECT_TOOL_DESCRIPTION = "Return the structured result by calling this tool."

-type GenerateObjectBase<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<
-  RequestInput<SelectedLanguageModel>,
+type GenerateObjectBase<SelectedModel extends LanguageModelInput = LanguageModelInput> = Omit<
+  RequestInput<SelectedModel>,
  "tools" | "toolChoice"
 >

@@ -90,13 +100,13 @@ export class GenerateObjectResponse<T> {

 export interface GenerateObjectOptions<
  S extends ToolSchema<any>,
-  SelectedLanguageModel extends LanguageModel = LanguageModel,
-> extends GenerateObjectBase<SelectedLanguageModel> {
+  SelectedModel extends LanguageModelInput = LanguageModelInput,
+> extends GenerateObjectBase<SelectedModel> {
  readonly schema: S
 }

-export interface GenerateObjectDynamicOptions<SelectedLanguageModel extends LanguageModel = LanguageModel>
-  extends GenerateObjectBase<SelectedLanguageModel> {
+export interface GenerateObjectDynamicOptions<SelectedModel extends LanguageModelInput = LanguageModelInput>
+  extends GenerateObjectBase<SelectedModel> {
  /** Raw JSON Schema object describing the expected output shape. */
  readonly jsonSchema: JsonSchema.JsonSchema
 }
@@ -116,9 +126,7 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (
  )
  if (!call || !LLMEvent.is.toolCall(call))
    return yield* new AIError({
-      module: "LLM",
-      method: "generateObject",
-      reason: new InvalidProviderOutputReason({
+      reason: new InvalidProviderOutputError({
        message: `generateObject: model did not call the forced \`${GENERATE_OBJECT_TOOL_NAME}\` tool`,
      }),
    })
@@ -126,10 +134,9 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (
    Effect.mapError(
      (error) =>
        new AIError({
-          module: "LLM",
-          method: "generateObject",
-          reason: new InvalidProviderOutputReason({
+          reason: new InvalidProviderOutputError({
            message: `generateObject: tool input failed schema decode: ${error.message}`,
+            cause: error,
          }),
        }),
    ),
@@ -149,11 +156,11 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (
 * 2. `jsonSchema: JsonSchema.JsonSchema` — `.object` is `unknown`. Use when
 *    the schema is only available at runtime (MCP, plugin manifests). Caller validates.
 */
-export function generateObject<const SelectedLanguageModel extends LanguageModel, S extends ToolSchema<any>>(
-  options: GenerateObjectOptions<S, SelectedLanguageModel>,
+export function generateObject<const SelectedModel extends LanguageModelInput, S extends ToolSchema<any>>(
+  options: GenerateObjectOptions<S, SelectedModel>,
 ): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, AIError, Service>
-export function generateObject<const SelectedLanguageModel extends LanguageModel>(
-  options: GenerateObjectDynamicOptions<SelectedLanguageModel>,
+export function generateObject<const SelectedModel extends LanguageModelInput>(
+  options: GenerateObjectDynamicOptions<SelectedModel>,
 ): Effect.Effect<GenerateObjectResponse<unknown>, AIError, Service>
 export function generateObject(options: GenerateObjectOptions<ToolSchema<any>> | GenerateObjectDynamicOptions) {
  if ("schema" in options) {
@@ -0,0 +1,307 @@
+export * as Media from "./media.js"
+
+import { Effect, Encoding, FileSystem, Schema, SchemaGetter } from "effect"
+import { HttpClientRequest } from "effect/unstable/http"
+import { ProviderID } from "./schema/ids.js"
+import { AIError, HttpContext, InvalidProviderOutputError, InvalidRequestError } from "./schema/errors.js"
+import { ProviderMetadata } from "./schema/options.js"
+import { Service } from "./route/executor-service.js"
+import { detectMediaType, extensionMediaType } from "./utils/media-type.js"
+
+export { detectMediaType } from "./utils/media-type.js"
+
+const OCTET_STREAM = "application/octet-stream"
+
+// ---------------------------------------------------------------------------
+// Source — the serializable wire/persistence form of a media asset
+// ---------------------------------------------------------------------------
+
+const BytesSource = Schema.Struct({
+  type: Schema.Literal("bytes"),
+  data: Schema.Uint8Array,
+  mediaType: Schema.String,
+})
+
+const Base64Source = Schema.Struct({
+  type: Schema.Literal("base64"),
+  data: Schema.String,
+  mediaType: Schema.String,
+})
+
+const UrlSource = Schema.Struct({
+  type: Schema.Literal("url"),
+  url: Schema.String,
+  mediaType: Schema.optional(Schema.String),
+  /** Epoch milliseconds after which the provider no longer serves the URL. */
+  expiresAt: Schema.optional(Schema.Number),
+  /** Headers required to fetch the URL, such as provider auth for Veo downloads. */
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+})
+
+/** A provider-side handle: OpenAI `file_id`, Gemini file URI, `gs://`, `runway://`, or a prior generation id. */
+const RefSource = Schema.Struct({
+  type: Schema.Literal("ref"),
+  provider: ProviderID,
+  id: Schema.String,
+  mediaType: Schema.optional(Schema.String),
+})
+
+export const Source = Schema.Union([BytesSource, Base64Source, UrlSource, RefSource])
+  .pipe(Schema.toTaggedUnion("type"))
+  .annotate({ identifier: "Media.Source" })
+export type Source = Schema.Schema.Type<typeof Source>
+
+// ---------------------------------------------------------------------------
+// Kind, Info, Notice
+// ---------------------------------------------------------------------------
+
+export const Kind = Schema.Literals(["image", "video", "audio", "document", "other"])
+export type Kind = Schema.Schema.Type<typeof Kind>
+
+export const kindOf = (mediaType: string): Kind => {
+  const lower = mediaType.toLowerCase()
+  if (lower.startsWith("image/")) return "image"
+  if (lower.startsWith("video/")) return "video"
+  if (lower.startsWith("audio/")) return "audio"
+  if (lower === "application/pdf" || lower.startsWith("text/")) return "document"
+  return "other"
+}
+
+/** Container-independent facts about the payload; raw PCM audio relies on these because it has no header. */
+export const Info = Schema.Struct({
+  width: Schema.optional(Schema.Number),
+  height: Schema.optional(Schema.Number),
+  durationSeconds: Schema.optional(Schema.Number),
+  sampleRate: Schema.optional(Schema.Number),
+  channels: Schema.optional(Schema.Number),
+  encoding: Schema.optional(Schema.String),
+  format: Schema.optional(Schema.String),
+}).annotate({ identifier: "Media.Info" })
+export type Info = Schema.Schema.Type<typeof Info>
+
+/** A provider-side partial result such as stripped audio or a moderated sample; never a silent drop. */
+export const Notice = Schema.Struct({
+  type: Schema.Literals(["moderated", "filtered", "other"]),
+  message: Schema.String,
+  providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "Media.Notice" })
+export type Notice = Schema.Schema.Type<typeof Notice>
+
+// ---------------------------------------------------------------------------
+// Asset
+// ---------------------------------------------------------------------------
+
+const invalid = (message: string, cause?: unknown) =>
+  new AIError({ reason: new InvalidRequestError({ message, cause }) })
+
+/** Synchronous view of an inline payload; `undefined` for `url` and `ref` sources, which carry no local bytes. */
+export interface Inline {
+  readonly mime: string
+  readonly base64: string
+  readonly dataUrl: string
+}
+
+export class Asset {
+  readonly source: Source
+  /** Derived from the source: declared type, sniffed magic bytes, then `application/octet-stream`. */
+  readonly mediaType: string
+  readonly kind: Kind
+  readonly info?: Info
+  /** Epoch milliseconds after which a `url` source stops resolving. */
+  readonly expiresAt?: number
+  readonly providerMetadata?: ProviderMetadata
+
+  // Derived payload forms are cached on the instance because every protocol lowering re-reads the same payload. The
+  // cache is check-then-set (concurrent first reads of a `url` source may both download) and is never observable
+  // through `source`, so round-tripping through `Media.from(asset.source)` stays lossless.
+  #bytes: Uint8Array | undefined
+  #base64: string | undefined
+
+  constructor(input: Asset.Input) {
+    this.source = input.source
+    this.mediaType =
+      input.source.mediaType ??
+      (input.source.type === "bytes" ? detectMediaType(input.source.data) : undefined) ??
+      OCTET_STREAM
+    this.kind = kindOf(this.mediaType)
+    this.info = input.info
+    this.expiresAt = input.source.type === "url" ? input.source.expiresAt : undefined
+    this.providerMetadata = input.providerMetadata
+  }
+
+  /** Inline payload without effects, for protocols that embed base64 or data URLs directly. */
+  inline(): Inline | undefined {
+    const source = this.source
+    if (source.type !== "bytes" && source.type !== "base64") return undefined
+    const base64 = source.type === "base64" ? source.data : (this.#base64 ??= Encoding.encodeBase64(source.data))
+    const mime = this.mediaType.toLowerCase()
+    return { mime, base64, dataUrl: `data:${mime};base64,${base64}` }
+  }
+
+  /** Decoded payload; downloads `url` sources through the request executor and caches the result. */
+  bytes(): Effect.Effect<Uint8Array, AIError, Service> {
+    return Effect.suspend(() => {
+      const source = this.source
+      if (source.type === "bytes") return Effect.succeed(source.data)
+      if (this.#bytes !== undefined) return Effect.succeed(this.#bytes)
+      if (source.type === "ref")
+        return Effect.fail(invalid(`Cannot materialize provider ref ${source.provider}:${source.id}`))
+      const decoded =
+        source.type === "base64"
+          ? Effect.fromResult(Encoding.decodeBase64(source.data)).pipe(
+              Effect.mapError((cause) => invalid(`Media asset contains invalid base64 data`, cause)),
+            )
+          : download(source)
+      return decoded.pipe(Effect.tap((data) => Effect.sync(() => (this.#bytes = data))))
+    })
+  }
+
+  base64(): Effect.Effect<string, AIError, Service> {
+    return Effect.suspend(() => {
+      const source = this.source
+      if (source.type === "base64") return Effect.succeed(source.data)
+      if (this.#base64 !== undefined) return Effect.succeed(this.#base64)
+      return this.bytes().pipe(Effect.map((data) => (this.#base64 = Encoding.encodeBase64(data))))
+    })
+  }
+
+  dataUrl(): Effect.Effect<string, AIError, Service> {
+    return this.base64().pipe(Effect.map((data) => `data:${this.mediaType};base64,${data}`))
+  }
+
+  /**
+   * The `AssetEncoded` JSON form with `bytes` sources as base64, matching `Schema.toCodecJson(AssetSchema)`, so a
+   * plain `JSON.stringify` of messages or events stays lossless and decodes back through the JSON codec.
+   */
+  toJSON() {
+    const source = this.source
+    return {
+      source: source.type === "bytes" ? { ...source, data: Encoding.encodeBase64(source.data) } : source,
+      info: this.info,
+      providerMetadata: this.providerMetadata,
+    }
+  }
+
+  /** Pull `url` sources into owned bytes before the URL expires. Inline sources return themselves. */
+  materialize(): Effect.Effect<Asset, AIError, Service> {
+    if (this.source.type === "bytes" || this.source.type === "base64") return Effect.succeed(this)
+    return this.bytes().pipe(
+      Effect.map((data) =>
+        bytes(data, this.source.mediaType, { info: this.info, providerMetadata: this.providerMetadata }),
+      ),
+    )
+  }
+}
+
+export namespace Asset {
+  export interface Input {
+    readonly source: Source
+    readonly info?: Info
+    readonly providerMetadata?: ProviderMetadata
+  }
+}
+
+/** JSON form of an asset: the serializable `Source` plus caller-supplied metadata. `bytes` sources encode as base64. */
+export const AssetEncoded = Schema.Struct({
+  source: Source,
+  info: Schema.optional(Info),
+  providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "Media.AssetEncoded" })
+
+const encodeAsset = (asset: Asset): typeof AssetEncoded.Type => ({
+  source: asset.source,
+  info: asset.info,
+  providerMetadata: asset.providerMetadata,
+})
+
+const AssetInstance = Schema.declare((value): value is Asset => value instanceof Asset, {
+  expected: "Media.Asset",
+})
+
+/** `Asset` in the type domain and `AssetEncoded` on the wire, so messages and events holding assets serialize. */
+export const AssetSchema = AssetEncoded.pipe(
+  Schema.decodeTo(AssetInstance, {
+    decode: SchemaGetter.transform((encoded) => new Asset(encoded)),
+    encode: SchemaGetter.transform(encodeAsset),
+  }),
+)
+
+const download = Effect.fn("Media.download")(function* (source: Extract<Source, { readonly type: "url" }>) {
+  const executor = yield* Service
+  const response = yield* executor.execute(
+    HttpClientRequest.get(source.url).pipe(HttpClientRequest.setHeaders(source.headers ?? {})),
+  )
+  const buffer = yield* response.arrayBuffer.pipe(
+    Effect.mapError(
+      (cause) =>
+        new AIError({
+          reason: new InvalidProviderOutputError({
+            message: `Failed to read media from ${source.url}`,
+            http: new HttpContext({ url: response.request.url, status: response.status, headers: response.headers }),
+            cause,
+          }),
+        }),
+    ),
+  )
+  return new Uint8Array(buffer)
+})
+
+// ---------------------------------------------------------------------------
+// Constructors
+// ---------------------------------------------------------------------------
+
+export type AssetOptions = Omit<Asset.Input, "source">
+
+export const from = (source: Source, options?: AssetOptions) => new Asset({ ...options, source })
+
+export const bytes = (data: Uint8Array, mediaType?: string, options?: AssetOptions) =>
+  from({ type: "bytes", data, mediaType: mediaType ?? detectMediaType(data) ?? OCTET_STREAM }, options)
+
+export const base64 = (data: string, mediaType: string, options?: AssetOptions) =>
+  from({ type: "base64", data, mediaType }, options)
+
+export const url = (
+  value: string,
+  options?: AssetOptions & Omit<Extract<Source, { readonly type: "url" }>, "type" | "url">,
+) => {
+  const { mediaType, expiresAt, headers, ...rest } = options ?? {}
+  return from({ type: "url", url: value, mediaType, expiresAt, headers }, rest)
+}
+
+export const ref = (provider: string | ProviderID, id: string, mediaType?: string, options?: AssetOptions) =>
+  from({ type: "ref", provider: ProviderID.make(provider), id, mediaType }, options)
+
+const DATA_URL = /^data:([^;,]+)(?:;[^,]*)*;base64,(.*)$/s
+
+/** Parse a `data:<mime>;base64,<data>` URL, or `undefined` when the value is not a base64 data URL. */
+export const parseDataUrl = (value: string, options?: AssetOptions) => {
+  const match = DATA_URL.exec(value)
+  return match === null ? undefined : base64(match[2], match[1], options)
+}
+
+/** Parse a `data:<mime>;base64,<data>` URL. Malformed input throws a typed `AIError` because constructors are sync. */
+export const fromDataUrl = (dataUrl: string, options?: AssetOptions) => {
+  const asset = parseDataUrl(dataUrl, options)
+  if (asset === undefined) throw invalid("Media data URLs must contain a MIME type and base64 data")
+  return asset
+}
+
+/** Read a file through `FileSystem` and sniff its media type from magic bytes, then the extension. */
+export const file = (path: string, options?: AssetOptions): Effect.Effect<Asset, AIError, FileSystem.FileSystem> =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const data = yield* fs
+      .readFile(path)
+      .pipe(Effect.mapError((cause) => invalid(`Failed to read media file ${path}`, cause)))
+    return bytes(data, detectMediaType(data) ?? extensionMediaType(path), options)
+  })
+
+/** Materialize an asset and write its bytes through `FileSystem`. */
+export const write = (asset: Asset, path: string): Effect.Effect<void, AIError, FileSystem.FileSystem | Service> =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const data = yield* asset.bytes()
+    yield* fs
+      .writeFile(path, data)
+      .pipe(Effect.mapError((cause) => invalid(`Failed to write media file ${path}`, cause)))
+  })
@@ -0,0 +1,54 @@
+import { ModelID, type ProviderID } from "./schema/ids.js"
+import type { LanguageModel } from "./schema/options.js"
+import type { ImageModel } from "./image.js"
+
+/**
+ * A provider-scoped model name bound to its configured facade. Callable facades return one of these so
+ * `LLM.request({ model: openai("gpt-5") })` and `Image.request({ model: openai("gpt-image-2") })` name a model once
+ * and let the request namespace pick the selector (`facade.model`, `facade.image`, …) on demand.
+ */
+export class ModelRef<S extends ModelRef.Selectors = ModelRef.Selectors> {
+  constructor(
+    readonly id: ModelID,
+    readonly facade: S,
+  ) {}
+
+  get provider() {
+    return this.facade.id
+  }
+}
+
+export namespace ModelRef {
+  /** The named selectors a configured provider facade exposes; `model` is the default LLM route. */
+  export interface Selectors {
+    readonly id: ProviderID
+    // oxlint-disable-next-line typescript-eslint/no-explicit-any
+    readonly model: (id: ModelID) => LanguageModel<any, any>
+    // oxlint-disable-next-line typescript-eslint/no-explicit-any
+    readonly image?: (id: ModelID) => ImageModel<any>
+  }
+
+  /** A ref whose provider exposes an image route. */
+  // oxlint-disable-next-line typescript-eslint/no-explicit-any
+  export type WithImage = ModelRef<Selectors & { readonly image: (id: ModelID) => ImageModel<any> }>
+
+  /** Make a configured facade callable: `openai("gpt-5")` returns a `ModelRef` over the facade's own selectors. */
+  export const facade = <const S extends Selectors>(selectors: S) =>
+    Object.assign((id: string | ModelID) => new ModelRef(ModelID.make(id), selectors), selectors)
+}
+
+/** The concrete `LanguageModel` a request will run against: either the model itself or the ref's `model` selector. */
+// oxlint-disable-next-line typescript-eslint/no-explicit-any
+export type ResolveLanguageModel<Model> =
+  Model extends LanguageModel<any, any> ? Model : Model extends ModelRef<infer S> ? ReturnType<S["model"]> : never
+
+/** The concrete `ImageModel` a request will run against: either the model itself or the ref's `image` selector. */
+// oxlint-disable-next-line typescript-eslint/no-explicit-any
+export type ResolveImageModel<Model> =
+  Model extends ImageModel<any>
+    ? Model
+    : Model extends ModelRef<infer S>
+      ? S extends { readonly image: (id: ModelID) => infer Selected }
+        ? Selected
+        : never
+      : never
@@ -0,0 +1,100 @@
+import { Effect, Layer, ManagedRuntime, Stream } from "effect"
+import { Image, ImageRequest, type ImageModelInput, type ImageRequestInput } from "./image.js"
+import { ImageClient } from "./image-client.js"
+import { LLM } from "./index.js"
+import { LLMClient } from "./route/client.js"
+import { RequestExecutor } from "./route/executor.js"
+import { LLMRequest } from "./schema/index.js"
+import type { LanguageModelInput, RequestInput } from "./llm.js"
+
+/**
+ * Promise-first entrypoint for scripts and non-Effect callers. One `ManagedRuntime` hosts the LLM and image clients
+ * over a request executor; every method runs the corresponding Effect API and rethrows `AIError` unchanged.
+ */
+export interface Options {
+  /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or middleware here. */
+  readonly layer?: Layer.Layer<RequestExecutor.Service>
+}
+
+export interface RunOptions {
+  readonly signal?: AbortSignal
+}
+
+export type Services =
+  | Layer.Success<typeof LLMClient.layer>
+  | Layer.Success<typeof ImageClient.layer>
+  | RequestExecutor.Service
+
+const abortEffect = (signal: AbortSignal | undefined) =>
+  signal === undefined
+    ? Effect.never
+    : Effect.callback<void>((resume) => {
+        if (signal.aborted) {
+          resume(Effect.void)
+          return
+        }
+        const onAbort = () => resume(Effect.void)
+        signal.addEventListener("abort", onAbort, { once: true })
+        return Effect.sync(() => signal.removeEventListener("abort", onAbort))
+      })
+
+export const make = (options: Options = {}) => {
+  const runtime = ManagedRuntime.make(
+    Layer.mergeAll(LLMClient.layer, ImageClient.layer).pipe(
+      Layer.provideMerge(options.layer ?? RequestExecutor.fetchLayer),
+    ),
+  )
+
+  /** Run any package Effect (for example `asset.bytes()`) inside this runtime. */
+  const run = <A, E>(effect: Effect.Effect<A, E, Services>, options?: RunOptions) =>
+    runtime.runPromise(effect, { signal: options?.signal })
+
+  const iterate = <A, E>(stream: Stream.Stream<A, E, Services>, options?: RunOptions): AsyncIterable<A> =>
+    Stream.toAsyncIterable(
+      Stream.unwrap(
+        runtime.contextEffect.pipe(
+          Effect.map(
+            (context): Stream.Stream<A, E> =>
+              stream.pipe(Stream.interruptWhen(abortEffect(options?.signal)), Stream.provideContext(context)),
+          ),
+        ),
+      ),
+    )
+
+  // The typed `generate`/`stream` overloads take a concrete input or a request, not the union; normalize once here.
+  const llmRequest = (input: RequestInput | LLMRequest) => (input instanceof LLMRequest ? input : LLM.request(input))
+  const imageRequest = (input: ImageRequestInput | ImageRequest) =>
+    input instanceof ImageRequest ? input : Image.request(input)
+
+  return {
+    run,
+    llm: {
+      request: LLM.request,
+      generate: <const Model extends LanguageModelInput>(
+        input: RequestInput<Model> | LLMRequest,
+        options?: RunOptions,
+      ) => run(LLM.generate(llmRequest(input)), options),
+      stream: <const Model extends LanguageModelInput>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) =>
+        iterate(LLM.stream(llmRequest(input)), options),
+    },
+    image: {
+      request: Image.request,
+      generate: <const Model extends ImageModelInput>(
+        input: ImageRequestInput<Model> | ImageRequest,
+        options?: RunOptions,
+      ) => run(Image.generate(imageRequest(input)), options),
+      stream: <const Model extends ImageModelInput>(
+        input: ImageRequestInput<Model> | ImageRequest,
+        options?: RunOptions,
+      ) => iterate(Image.stream(imageRequest(input)), options),
+    },
+    dispose: () => runtime.dispose(),
+  }
+}
+
+export type Client = ReturnType<typeof make>
+
+/** Default client over `RequestExecutor.fetchLayer` for scripts; the runtime builds its layer on first use. */
+export const ai = make()
+
+export * as AI from "./promise.js"
@@ -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,4 +1,4 @@
-import { Effect, Schema } from "effect"
+import { Effect, Encoding, Schema } from "effect"
 import { Route } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
@@ -25,6 +25,7 @@ import { BedrockAuth } from "./utils/bedrock-auth.js"
 import { BedrockCache } from "./utils/bedrock-cache.js"
 import { BedrockMedia } from "./utils/bedrock-media.js"
 import { Lifecycle } from "./utils/lifecycle.js"
+import { MistralToolID } from "./utils/mistral-tool-id.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { ToolStream } from "./utils/tool-stream.js"

@@ -106,7 +107,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,
    }),
@@ -212,11 +213,7 @@ const BedrockEvent = Schema.Struct({
      metrics: Schema.optional(Schema.Unknown),
    }),
  ),
-  internalServerException: Schema.optional(BedrockStreamException),
-  modelStreamErrorException: Schema.optional(BedrockStreamException),
-  validationException: Schema.optional(BedrockStreamException),
-  throttlingException: Schema.optional(BedrockStreamException),
-  serviceUnavailableException: Schema.optional(BedrockStreamException),
+  exception: Schema.optional(Schema.Struct({ type: Schema.String, details: BedrockStreamException })),
 })
 type BedrockEvent = Schema.Schema.Type<typeof BedrockEvent>

@@ -226,7 +223,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 },
  },
 })
@@ -262,30 +259,40 @@ const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
    tool: (name) => ({ tool: { name } }) as const,
  })

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

-const reasoningSignature = (part: ReasoningPart) => {
-  const bedrock = part.providerMetadata?.bedrock
-  return (
-    part.encrypted ??
-    (ProviderShared.isRecord(bedrock) && typeof bedrock.signature === "string" ? bedrock.signature : undefined)
+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, providerMetadataKey: string) => {
+  const metadata = part.providerMetadata?.[providerMetadataKey]
+  if (ProviderShared.isRecord(metadata) && typeof metadata.redactedData === "string") return metadata.redactedData
+}
+
+const removeEmptyToolInputKeys = (input: unknown): unknown => {
+  if (Array.isArray(input)) return input.map(removeEmptyToolInputKeys)
+  if (!ProviderShared.isRecord(input)) return input
+  return Object.fromEntries(
+    Object.entries(input).flatMap(([key, value]) => (key === "" ? [] : [[key, removeEmptyToolInputKeys(value)]])),
  )
 }

-const reasoningRedactedData = (part: ReasoningPart) => {
-  const bedrock = part.providerMetadata?.bedrock
-  return ProviderShared.isRecord(bedrock) && typeof bedrock.redactedData === "string" ? bedrock.redactedData : undefined
-}
-
-const lowerToolCall = (part: ToolCallPart): BedrockToolUseBlock => ({
+const lowerToolCall = (part: ToolCallPart, normalizeID: (id: string) => string): BedrockToolUseBlock => ({
  toolUse: {
-    toolUseId: part.id,
-    name: part.name,
-    input: part.input,
+    toolUseId: normalizeID(part.id),
+    // Models can emit names that Converse rejects when replayed in history.
+    name: part.name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "_",
+    input: removeEmptyToolInputKeys(part.input),
  },
 })

-const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent")(function* (part: ToolResultPart) {
+const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent")(function* (
+  part: ToolResultPart,
+  documentNames: Set<string>,
+) {
  if (part.result.type === "text" || part.result.type === "error")
    return [{ text: ProviderShared.toolResultText(part) }]
  if (part.result.type === "json") return [{ json: part.result.value }]
@@ -296,22 +303,21 @@ const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent
      content.push({ text: item.text })
      continue
    }
-    const media = yield* BedrockMedia.lower({
-      type: "media",
-      mediaType: item.mime,
-      data: item.uri,
-      filename: item.name,
-    })
-    content.push(media)
+    const media = yield* BedrockMedia.lower(ProviderShared.toolFileMedia(item), documentNames)
+    content.push(...media)
  }
  return content
 })

-const lowerToolResult = Effect.fn("BedrockConverse.lowerToolResult")(function* (part: ToolResultPart) {
+const lowerToolResult = Effect.fn("BedrockConverse.lowerToolResult")(function* (
+  part: ToolResultPart,
+  documentNames: Set<string>,
+  normalizeID: (id: string) => string,
+) {
  return {
    toolResult: {
-      toolUseId: part.id,
-      content: yield* lowerToolResultContent(part),
+      toolUseId: normalizeID(part.id),
+      content: yield* lowerToolResultContent(part, documentNames),
      status: part.result.type === "error" ? "error" : "success",
    },
  } satisfies BedrockToolResultBlock
@@ -322,6 +328,10 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
  breakpoints: BedrockCache.Breakpoints,
 ) {
  const messages: BedrockMessage[] = []
+  const documentNames = new Set<string>()
+  // Mistral can reject replay IDs even when they satisfy Converse's broader ID syntax.
+  const normalizeID = request.model.id.includes("mistral.") ? MistralToolID.normalizer(request) : (id: string) => id
+  const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider)

  for (const message of request.messages) {
    if (message.role === "system") {
@@ -344,7 +354,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
          continue
        }
        if (part.type === "media") {
-          content.push(yield* BedrockMedia.lower(part))
+          content.push(...(yield* BedrockMedia.lower(part, documentNames)))
          continue
        }
      }
@@ -369,21 +379,27 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
          continue
        }
        if (part.type === "reasoning") {
-          const signature = reasoningSignature(part)
-          const redactedData = reasoningRedactedData(part)
+          const signature = reasoningSignature(part, providerMetadataKey)
+          const redactedData = reasoningRedactedData(part, providerMetadataKey)
          if (signature === undefined && redactedData !== undefined) {
            content.push({ reasoningContent: { redactedContent: redactedData } })
            continue
          }
+          if (signature === undefined || signature.trim().length === 0) {
+            // Interrupted streams and model switches can leave unsigned reasoning.
+            // Preserve readable history as text rather than replay invalid reasoningContent.
+            if (part.text.trim().length > 0) content.push(...textWithCache(breakpoints, part.text, part.cache))
+            continue
+          }
          content.push({ reasoningContent: { reasoningText: { text: part.text, signature } } })
          continue
        }
        if (part.type === "tool-call") {
-          content.push(lowerToolCall(part))
+          content.push(lowerToolCall(part, normalizeID))
          continue
        }
      }
-      messages.push({ role: "assistant", content })
+      if (content.length > 0) messages.push({ role: "assistant", content })
      continue
    }

@@ -391,7 +407,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
    for (const part of message.content) {
      if (!ProviderShared.supportsContent(part, ["tool-result"]))
        return yield* ProviderShared.unsupportedContent("Bedrock Converse", "tool", ["tool-result"])
-      content.push(yield* lowerToolResult(part))
+      content.push(yield* lowerToolResult(part, documentNames, normalizeID))
      const cachePoint = BedrockCache.block(breakpoints, part.cache)
      if (cachePoint) content.push(cachePoint)
    }
@@ -406,49 +422,56 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (

 // System prompts share the cache-point convention: emit the text block, then
 // optionally a positional `cachePoint` marker.
-const lowerSystem = (
-  breakpoints: BedrockCache.Breakpoints,
-  system: ReadonlyArray<LLMRequest["system"][number]>,
-): BedrockSystemBlock[] => system.flatMap((part) => textWithCache(breakpoints, part.text, part.cache))
+const lowerSystem = (breakpoints: BedrockCache.Breakpoints, system: ReadonlyArray<LLMRequest["system"][number]>) => {
+  const content = system
+    .filter((part) => part.text.length > 0)
+    .flatMap((part) => textWithCache(breakpoints, part.text, part.cache))
+  return content.length === 0 ? undefined : content
+}

 const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request: LLMRequest) {
  const toolChoice = request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined
+  const flattened = ProviderShared.flattenToolRequest(request)
  const generation = request.generation
  // Bedrock-Claude shares Anthropic's 4-breakpoint cap. Spend the budget in
  // tools → system → messages order to favour the highest-impact prefixes.
-  const breakpoints = BedrockCache.breakpoints()
-  const toolConfig =
-    request.tools.length > 0
-      ? {
-          tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, request.tools),
-          // Converse has no native "none". Keep definitions stable for prompt
-          // caching and omit only the unsupported choice.
-          toolChoice,
-        }
-      : undefined
-  const system = request.system.length === 0 ? undefined : lowerSystem(breakpoints, request.system)
-  const messages = yield* lowerMessages(request, breakpoints)
+  const breakpoints = BedrockCache.breakpoints(request.model.id)
+  const toolConfig = (() => {
+    if (flattened.tools.length === 0) return undefined
+    return {
+      tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, flattened.tools),
+      // Converse has no native "none". Keep definitions stable for prompt
+      // caching and omit only the unsupported choice.
+      toolChoice,
+    }
+  })()
+  const system = lowerSystem(breakpoints, request.system)
+  const messages = yield* lowerMessages(flattened.request, breakpoints)
  if (breakpoints.dropped > 0) {
    yield* Effect.logWarning(
      `Bedrock Converse: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${BedrockCache.BEDROCK_BREAKPOINT_CAP} per request.`,
    )
  }
-  return {
-    modelId: request.model.id,
-    messages,
-    system,
-    inferenceConfig:
+  const inferenceConfig = (() => {
+    if (
      generation?.maxTokens === undefined &&
      generation?.temperature === undefined &&
      generation?.topP === undefined &&
      (generation?.stop === undefined || generation.stop.length === 0)
-        ? undefined
-        : {
-            maxTokens: generation?.maxTokens,
-            temperature: generation?.temperature,
-            topP: generation?.topP,
-            stopSequences: generation?.stop,
-          },
+    )
+      return undefined
+    return {
+      maxTokens: generation?.maxTokens,
+      temperature: generation?.temperature,
+      topP: generation?.topP,
+      stopSequences: generation?.stop,
+    }
+  })()
+  return {
+    modelId: request.model.id,
+    messages,
+    system,
+    inferenceConfig,
    toolConfig,
    // Converse's base inferenceConfig has no topK; Anthropic/Nova accept it
    // as a model-specific field, so it goes through additionalModelRequestFields.
@@ -464,13 +487,12 @@ const mapFinishReason = (reason: string): FinishReason => {
  if (reason === "max_tokens" || reason === "model_context_window_exceeded") return "length"
  if (reason === "tool_use") return "tool-calls"
  if (reason === "content_filtered" || reason === "guardrail_intervened") return "content-filter"
-  if (reason === "malformed_model_output" || reason === "malformed_tool_use") return "error"
  return "unknown"
 }

 // 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): Usage | undefined => {
+const mapUsage = (usage: BedrockUsageSchema | undefined, providerMetadataKey: string): Usage | undefined => {
  if (!usage) return undefined
  const inputTokens = ProviderShared.sumTokens(
    usage.inputTokens,
@@ -484,19 +506,31 @@ const mapUsage = (usage: BedrockUsageSchema | undefined): Usage | undefined => {
    cacheReadInputTokens: usage.cacheReadInputTokens,
    cacheWriteInputTokens: usage.cacheWriteInputTokens,
    totalTokens: ProviderShared.totalTokens(inputTokens, usage.outputTokens, usage.totalTokens),
-    providerMetadata: { bedrock: usage },
+    providerMetadata: { [providerMetadataKey]: usage },
  })
 }

 interface ParserState {
+  readonly providerMetadataKey: string
  readonly tools: ToolStream.State<number>
  // Bedrock splits the finish into `messageStop` (carries `stopReason`) and
-  // `metadata` (carries usage). Hold the terminal event in state so `onHalt`
-  // can emit exactly one finish after both chunks have had a chance to arrive.
-  readonly pendingFinish: { readonly reason: FinishReasonDetails; readonly usage?: Usage } | undefined
+  // `metadata` (carries usage). Hold both in state so `onHalt` can emit exactly
+  // one finish after both chunks have had a chance to arrive.
+  readonly finishReason: FinishReasonDetails | undefined
+  readonly usage: Usage | undefined
  readonly hasToolCalls: boolean
  readonly lifecycle: Lifecycle.State
  readonly reasoningSignatures: Readonly<Record<number, string>>
+  readonly reasoningRedactedContent: Readonly<Record<number, ReadonlyArray<Uint8Array>>>
+}
+
+const encodeRedactedContent = (chunks: ReadonlyArray<Uint8Array>) => {
+  const bytes = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0))
+  chunks.reduce((offset, chunk) => {
+    bytes.set(chunk, offset)
+    return offset + chunk.length
+  }, 0)
+  return Encoding.encodeBase64(bytes)
 }

 const step = (state: ParserState, event: BedrockEvent) =>
@@ -544,44 +578,60 @@ const step = (state: ParserState, event: BedrockEvent) =>
      const index = event.contentBlockDelta.contentBlockIndex
      const reasoning = event.contentBlockDelta.delta.reasoningContent
      const events: LLMEvent[] = []
-      const redactedData = reasoning.redactedContent ?? reasoning.data
-      const providerMetadata = reasoning.signature
-        ? bedrockMetadata({ signature: reasoning.signature })
-        : redactedData !== undefined
-          ? bedrockMetadata({ redactedData })
-          : undefined
-      const lifecycle =
-        reasoning.text !== undefined || providerMetadata !== undefined
-          ? Lifecycle.reasoningDelta(
-              state.lifecycle,
-              events,
-              `reasoning-${index}`,
-              reasoning.text ?? "",
-              providerMetadata,
-            )
-          : state.lifecycle
+      const redactedChunks = yield* (() => {
+        if (reasoning.redactedContent === undefined) return Effect.succeed(undefined)
+        return Effect.fromResult(Encoding.decodeBase64(reasoning.redactedContent)).pipe(
+          Effect.map((chunk) => [...(state.reasoningRedactedContent[index] ?? []), chunk]),
+          Effect.mapError((cause) =>
+            ProviderShared.eventError(
+              ADAPTER,
+              "Bedrock Converse reasoningContent.redactedContent contains invalid base64 data",
+              undefined,
+              cause,
+            ),
+          ),
+        )
+      })()
+      const redactedData = redactedChunks === undefined ? reasoning.data : encodeRedactedContent(redactedChunks)
+      const metadata = (() => {
+        if (reasoning.signature) return providerMetadata(state.providerMetadataKey, { signature: reasoning.signature })
+        if (redactedData !== undefined) return providerMetadata(state.providerMetadataKey, { redactedData })
+      })()
+      const lifecycle = (() => {
+        if (reasoning.text === undefined && metadata === undefined) return state.lifecycle
+        return Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text ?? "", metadata)
+      })()
+      const reasoningRedactedContent = (() => {
+        if (redactedChunks !== undefined) return { ...state.reasoningRedactedContent, [index]: redactedChunks }
+        if (reasoning.data === undefined) return state.reasoningRedactedContent
+        return Object.fromEntries(
+          Object.entries(state.reasoningRedactedContent).filter(([key]) => key !== String(index)),
+        )
+      })()
+      const reasoningSignatures = (() => {
+        if (!reasoning.signature) return state.reasoningSignatures
+        return { ...state.reasoningSignatures, [index]: reasoning.signature }
+      })()
      return [
        {
          ...state,
          lifecycle,
-          reasoningSignatures: reasoning.signature
-            ? { ...state.reasoningSignatures, [index]: reasoning.signature }
-            : state.reasoningSignatures,
+          reasoningSignatures,
+          reasoningRedactedContent,
        },
        events,
      ] as const
    }

    if (event.contentBlockDelta?.delta?.toolUse) {
-      const index = event.contentBlockDelta.contentBlockIndex
-      const result = ToolStream.appendExisting(
-        ADAPTER,
+      // A delta for a block that is not open, whether it already stopped or never
+      // started, has nothing to attach to and is dropped.
+      const result = ToolStream.append(
        state.tools,
-        index,
+        event.contentBlockDelta.contentBlockIndex,
        event.contentBlockDelta.delta.toolUse.input,
-        "Bedrock Converse tool delta is missing its tool call",
      )
-      if (ToolStream.isError(result)) return yield* result
+      if (!result) return [state, []] as const
      const events: LLMEvent[] = []
      const lifecycle = result.events.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
      events.push(...result.events)
@@ -593,16 +643,24 @@ const step = (state: ParserState, event: BedrockEvent) =>
      const result = yield* ToolStream.finish(ADAPTER, state.tools, index)
      const events: LLMEvent[] = []
      const resultEvents = result.events ?? []
-      const lifecycle = resultEvents.length
-        ? Lifecycle.stepStart(state.lifecycle, events)
-        : Lifecycle.reasoningEnd(
-            Lifecycle.textEnd(state.lifecycle, events, `text-${index}`),
-            events,
-            `reasoning-${index}`,
-            state.reasoningSignatures[index]
-              ? bedrockMetadata({ signature: state.reasoningSignatures[index] })
-              : undefined,
-          )
+      const lifecycle = (() => {
+        if (resultEvents.length) return Lifecycle.stepStart(state.lifecycle, events)
+        const metadata = (() => {
+          const signature = state.reasoningSignatures[index]
+          if (signature) return providerMetadata(state.providerMetadataKey, { signature })
+          const redactedContent = state.reasoningRedactedContent[index]
+          if (redactedContent)
+            return providerMetadata(state.providerMetadataKey, {
+              redactedData: encodeRedactedContent(redactedContent),
+            })
+        })()
+        return Lifecycle.reasoningEnd(
+          Lifecycle.textEnd(state.lifecycle, events, `text-${index}`),
+          events,
+          `reasoning-${index}`,
+          metadata,
+        )
+      })()
      events.push(...resultEvents)
      return [
        {
@@ -615,21 +673,30 @@ const step = (state: ParserState, event: BedrockEvent) =>
          reasoningSignatures: Object.fromEntries(
            Object.entries(state.reasoningSignatures).filter(([key]) => key !== String(index)),
          ),
+          reasoningRedactedContent: Object.fromEntries(
+            Object.entries(state.reasoningRedactedContent).filter(([key]) => key !== String(index)),
+          ),
        },
        events,
      ] as const
    }

    if (event.messageStop) {
+      if (
+        event.messageStop.stopReason === "malformed_model_output" ||
+        event.messageStop.stopReason === "malformed_tool_use"
+      )
+        return yield* ProviderShared.eventError(
+          ADAPTER,
+          `Bedrock Converse stopped with ${event.messageStop.stopReason}`,
+          ProviderShared.encodeJson(event),
+        )
      return [
        {
          ...state,
-          pendingFinish: {
-            reason: {
-              normalized: mapFinishReason(event.messageStop.stopReason),
-              raw: event.messageStop.stopReason,
-            },
-            usage: state.pendingFinish?.usage,
+          finishReason: {
+            normalized: mapFinishReason(event.messageStop.stopReason),
+            raw: event.messageStop.stopReason,
          },
        },
        [],
@@ -637,35 +704,24 @@ const step = (state: ParserState, event: BedrockEvent) =>
    }

    if (event.metadata) {
-      const usage = mapUsage(event.metadata.usage) ?? state.pendingFinish?.usage
+      const usage = mapUsage(event.metadata.usage, state.providerMetadataKey) ?? state.usage
      return [
        {
          ...state,
-          pendingFinish: {
-            reason: state.pendingFinish?.reason ?? { normalized: "stop" },
-            usage,
-          },
+          usage,
        },
        [],
      ] as const
    }

-    const exception = (
-      [
-        ["internalServerException", event.internalServerException],
-        ["modelStreamErrorException", event.modelStreamErrorException],
-        ["serviceUnavailableException", event.serviceUnavailableException],
-        ["throttlingException", event.throttlingException],
-        ["validationException", event.validationException],
-      ] as const
-    ).find((entry) => entry[1] !== undefined)
-    if (exception) {
+    if (event.exception) {
+      const message =
+        event.exception.details.message ?? event.exception.details.originalMessage ?? "Bedrock Converse stream error"
+      const body = ProviderShared.encodeJson(event)
      return yield* new AIError({
-        module: ADAPTER,
-        method: "stream",
        reason: classifyProviderFailure({
-          message: exception[1]?.message ?? exception[1]?.originalMessage ?? "Bedrock Converse stream error",
-          code: exception[0],
+          message,
+          rawBody: body,
        }),
      })
    }
@@ -675,23 +731,22 @@ const step = (state: ParserState, event: BedrockEvent) =>

 const framing = BedrockEventStream.framing(ADAPTER)

-const onHalt = (state: ParserState): ReadonlyArray<LLMEvent> =>
-  state.pendingFinish
-    ? (() => {
-        const events: LLMEvent[] = []
-        Lifecycle.finish(state.lifecycle, events, {
-          reason: {
-            ...state.pendingFinish.reason,
-            normalized:
-              state.pendingFinish.reason.normalized === "stop" && state.hasToolCalls
-                ? "tool-calls"
-                : state.pendingFinish.reason.normalized,
-          },
-          usage: state.pendingFinish.usage,
-        })
-        return events
-      })()
-    : []
+const onHalt = (state: ParserState): ReadonlyArray<LLMEvent> => {
+  if (!state.finishReason) return []
+  const normalized = (() => {
+    if (state.finishReason.normalized === "stop" && state.hasToolCalls) return "tool-calls"
+    return state.finishReason.normalized
+  })()
+  const events: LLMEvent[] = []
+  Lifecycle.finish(state.lifecycle, events, {
+    reason: {
+      ...state.finishReason,
+      normalized,
+    },
+    usage: state.usage,
+  })
+  return events
+}

 // =============================================================================
 // Protocol And Bedrock Route
@@ -708,15 +763,18 @@ export const protocol = Protocol.make({
  },
  stream: {
    event: BedrockEvent,
-    initial: () => ({
+    initial: (request) => ({
+      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
      tools: ToolStream.empty<number>(),
-      pendingFinish: undefined,
+      finishReason: undefined,
+      usage: undefined,
      hasToolCalls: false,
      lifecycle: Lifecycle.initial(),
      reasoningSignatures: {},
+      reasoningRedactedContent: {},
    }),
    step,
-    onHalt,
+    onHalt: (state) => Effect.succeed(onHalt(state)),
  },
 })

@@ -1,6 +1,7 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec"
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8"
-import { Effect, Stream } from "effect"
+import { Effect, Encoding, Stream } from "effect"
+import { AIError, AIErrorReason, InvalidProviderOutputError } from "../schema/index.js"
 import { Framing } from "../route/framing.js"
 import { ProviderShared } from "./shared.js"

@@ -21,6 +22,10 @@ interface FrameBufferState {

 const initialFrameBuffer: FrameBufferState = { buffer: new Uint8Array(0), offset: 0 }

+type FrameInput = { readonly _tag: "Chunk"; readonly bytes: Uint8Array } | { readonly _tag: "End" }
+
+const endOfStream: FrameInput = { _tag: "End" }
+
 const appendChunk = (state: FrameBufferState, chunk: Uint8Array): FrameBufferState => {
  const remaining = state.buffer.length - state.offset
  // Compact: drop the consumed prefix and append the new chunk in one alloc.
@@ -32,9 +37,23 @@ const appendChunk = (state: FrameBufferState, chunk: Uint8Array): FrameBufferSta
  return { buffer: next, offset: 0 }
 }

-const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8Array) =>
+const consumeFrames = (route: string) => (state: FrameBufferState, input: FrameInput) =>
  Effect.gen(function* () {
-    let cursor = appendChunk(state, chunk)
+    if (input._tag === "End") {
+      const remaining = state.buffer.subarray(state.offset)
+      if (remaining.length > 0)
+        return yield* new AIError({
+          reason: new InvalidProviderOutputError({
+            route,
+            classification: "incomplete-stream",
+            message: `Incomplete Bedrock Converse event-stream frame: ${remaining.length} buffered bytes remain at end of stream`,
+            body: Encoding.encodeBase64(remaining),
+          }),
+        })
+      return [state, []] as const
+    }
+
+    let cursor = appendChunk(state, input.bytes)
    const out: object[] = []
    while (cursor.buffer.length - cursor.offset >= 4) {
      const view = cursor.buffer.subarray(cursor.offset)
@@ -49,10 +68,14 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
            `Failed to decode Bedrock Converse event-stream frame: ${
              error instanceof Error ? error.message : String(error)
            }`,
+            Encoding.encodeBase64(view.subarray(0, totalLength)),
+            error,
          ),
      })
      cursor = { buffer: cursor.buffer, offset: cursor.offset + totalLength }

+      const payload = utf8.decode(decoded.body)
+      const body = ProviderShared.encodeJson({ headers: decoded.headers, body: payload })
      const messageType = decoded.headers[":message-type"]?.value
      if (messageType === "error") {
        const code = decoded.headers[":error-code"]?.value
@@ -61,6 +84,7 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
          route,
          [code, message].filter((value): value is string => typeof value === "string").join(": ") ||
            "Bedrock Converse event-stream error",
+          body,
        )
      }
      const eventType =
@@ -70,7 +94,6 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
            ? decoded.headers[":exception-type"]?.value
            : undefined
      if (typeof eventType !== "string") continue
-      const payload = utf8.decode(decoded.body)
      if (!payload) continue
      // The AWS event stream pads short payloads with a `p` field. Drop it
      // before handing the object to the chunk schema. JSON decode goes
@@ -80,9 +103,21 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
        route,
        payload,
        "Failed to parse Bedrock Converse event-stream payload",
+      ).pipe(
+        Effect.mapError(
+          (error) =>
+            new AIError({
+              reason: AIErrorReason.make({ ...error.reason, message: error.message, cause: error.reason.cause, body }),
+            }),
+        ),
      )) as Record<string, unknown>
      delete parsed.p
-      out.push({ [eventType]: parsed })
+      out.push({
+        ...(messageType === "exception"
+          ? { exception: { type: eventType, details: parsed } }
+          : { [eventType]: parsed }),
+        rawBody: body,
+      })
    }
    return [cursor, out] as const
  })
@@ -95,7 +130,13 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
 */
 export const framing = (route: string): Framing.Definition<object> => ({
  id: "aws-event-stream",
-  frame: (bytes) => bytes.pipe(Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
+  body: (frame) => ("rawBody" in frame && typeof frame.rawBody === "string" ? frame.rawBody : undefined),
+  frame: (bytes) =>
+    bytes.pipe(
+      Stream.map((bytes): FrameInput => ({ _tag: "Chunk", bytes })),
+      Stream.concat(Stream.succeed(endOfStream)),
+      Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route)),
+    ),
 })

 export * as BedrockEventStream from "./bedrock-event-stream.js"
@@ -1,11 +1,12 @@
-import { Effect, Schema } from "effect"
-import { Tool } from "@opencode-ai/schema/tool"
+import { Effect, Option, Schema } from "effect"
+import { Tool } from "@opencode/schema/tool"
 import { Route } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
 import { Protocol } from "../route/protocol.js"
 import {
+  AIError,
  LLMEvent,
  Usage,
  type FinishReason,
@@ -17,7 +18,9 @@ import {
  type ToolCallPart,
  type ToolDefinition,
 } from "../schema/index.js"
-import { JsonObject, optionalArray, ProviderShared } from "./shared.js"
+import { classifyProviderFailure } from "../provider-error.js"
+import { Media } from "../media.js"
+import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { GeminiToolSchema } from "./utils/gemini-tool-schema.js"
 import { Lifecycle } from "./utils/lifecycle.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
@@ -41,6 +44,13 @@ const requiresThoughtSignatureFallback = (modelID: string) => {
 // so their tool-result attachments lower as a separate user turn instead.
 const routesLegacyToolMedia = (modelID: string) => /gemini-2[.-]5(?:[.-]|$)/i.test(modelID)

+// Blacklist: Gemini 1.x/2.x ignore or reject explicit function call ids.
+// Every other model id (Gemini 3+, gemma, anything unrecognized) gets them.
+const omitsFunctionCallIds = (modelID: string) => {
+  const match = /^gemini(?:-live)?-(\d+)/i.exec(modelID)
+  return match !== null && Number(match[1]) < 3
+}
+
 export interface OptionsInput {
  readonly [key: string]: unknown
  readonly cachedContent?: string
@@ -75,10 +85,15 @@ export type ProviderOptionsInput = OptionsInput
 // =============================================================================
 // Request Body Schema
 // =============================================================================
+// Gemini is known to send explicit `null` for optional streaming fields
+// (usage counts, flags, whole subtrees), so every response-side optional uses
+// `optionalNull` instead of bare `Schema.optional`. The same part/content
+// schemas lower the outbound request body; encoding drops `undefined` keys,
+// so the shared schemas stay safe there.
 const GeminiTextPart = Schema.Struct({
  text: Schema.String,
-  thought: Schema.optional(Schema.Boolean),
-  thoughtSignature: Schema.optional(Schema.String),
+  thought: optionalNull(Schema.Boolean),
+  thoughtSignature: optionalNull(Schema.String),
 })

 const GeminiInlineDataPart = Schema.Struct({
@@ -86,16 +101,25 @@ const GeminiInlineDataPart = Schema.Struct({
    mimeType: Schema.String,
    data: Schema.String,
  }),
+  thoughtSignature: optionalNull(Schema.String),
 })
 type GeminiInlineDataPart = Schema.Schema.Type<typeof GeminiInlineDataPart>

+/** Gemini Files API reference; the only remote input Gemini accepts. */
+const GeminiFileDataPart = Schema.Struct({
+  fileData: Schema.Struct({
+    mimeType: Schema.String,
+    fileUri: Schema.String,
+  }),
+})
+
 const GeminiFunctionCallPart = Schema.Struct({
  functionCall: Schema.Struct({
-    id: Schema.optional(Schema.String),
+    id: optionalNull(Schema.String),
    name: Schema.String,
    args: Schema.optional(Schema.Unknown),
  }),
-  thoughtSignature: Schema.optional(Schema.String),
+  thoughtSignature: optionalNull(Schema.String),
 })

 const GeminiFunctionResponsePart = Schema.Struct({
@@ -110,16 +134,23 @@ const GeminiFunctionResponsePart = Schema.Struct({
 const GeminiContentPart = Schema.Union([
  GeminiTextPart,
  GeminiInlineDataPart,
+  GeminiFileDataPart,
  GeminiFunctionCallPart,
  GeminiFunctionResponsePart,
 ])
+const decodeGeminiContentPart = Schema.decodeUnknownOption(GeminiContentPart)

 const GeminiContent = Schema.Struct({
-  role: Schema.Literals(["user", "model"]),
-  parts: Schema.Array(GeminiContentPart),
+  role: optionalNull(Schema.Literals(["user", "model"])),
+  parts: optionalNull(Schema.Array(GeminiContentPart)),
 })
 type GeminiContent = Schema.Schema.Type<typeof GeminiContent>

+const GeminiResponseContent = Schema.Struct({
+  role: optionalNull(Schema.Literals(["user", "model"])),
+  parts: optionalNull(Schema.Array(Schema.Unknown)),
+})
+
 const GeminiSystemInstruction = Schema.Struct({
  parts: Schema.Array(Schema.Struct({ text: Schema.String })),
 })
@@ -179,37 +210,40 @@ const GeminiBody = Schema.Struct(GeminiBodyFields)
 export type GeminiBody = Schema.Schema.Type<typeof GeminiBody>

 const GeminiUsage = Schema.Struct({
-  cachedContentTokenCount: Schema.optional(Schema.Number),
-  thoughtsTokenCount: Schema.optional(Schema.Number),
-  promptTokenCount: Schema.optional(Schema.Number),
-  candidatesTokenCount: Schema.optional(Schema.Number),
-  totalTokenCount: Schema.optional(Schema.Number),
+  cachedContentTokenCount: optionalNull(Schema.Number),
+  thoughtsTokenCount: optionalNull(Schema.Number),
+  promptTokenCount: optionalNull(Schema.Number),
+  candidatesTokenCount: optionalNull(Schema.Number),
+  totalTokenCount: optionalNull(Schema.Number),
 })
 type GeminiUsage = Schema.Schema.Type<typeof GeminiUsage>

 const GeminiCandidate = Schema.Struct({
-  content: Schema.optional(GeminiContent),
-  finishReason: Schema.optional(Schema.String),
+  content: optionalNull(GeminiResponseContent),
+  finishReason: optionalNull(Schema.String),
 })

 const GeminiPromptFeedback = Schema.StructWithRest(
  Schema.Struct({
-    blockReason: Schema.optional(Schema.String),
-    blockReasonMessage: Schema.optional(Schema.String),
-    safetyRatings: Schema.optional(Schema.Unknown),
+    blockReason: optionalNull(Schema.String),
+    blockReasonMessage: optionalNull(Schema.String),
+    safetyRatings: optionalNull(Schema.Unknown),
  }),
  [Schema.Record(Schema.String, Schema.Unknown)],
 )
 type GeminiPromptFeedback = Schema.Schema.Type<typeof GeminiPromptFeedback>

 const GeminiEvent = Schema.Struct({
-  candidates: optionalArray(GeminiCandidate),
-  promptFeedback: Schema.optional(GeminiPromptFeedback),
-  usageMetadata: Schema.optional(GeminiUsage),
+  error: Schema.optional(Schema.Unknown),
+  candidates: optionalNull(Schema.Array(GeminiCandidate)),
+  promptFeedback: optionalNull(GeminiPromptFeedback),
+  usageMetadata: optionalNull(GeminiUsage),
 })
 type GeminiEvent = Schema.Schema.Type<typeof GeminiEvent>

 interface ParserState {
+  readonly route: string
+  readonly providerMetadataKey: string
  readonly finishReason?: string
  readonly hasToolCalls: boolean
  readonly promptFeedback?: GeminiPromptFeedback
@@ -217,6 +251,11 @@ interface ParserState {
  readonly lifecycle: Lifecycle.State
  readonly reasoningSignature?: string
  readonly textSignature?: string
+  readonly reasoningId?: string
+  readonly textId?: string
+  readonly nextReasoningId: number
+  readonly nextTextId: number
+  readonly seenCallIds?: ReadonlySet<string>
 }

 // =============================================================================
@@ -259,35 +298,34 @@ const lowerToolConfig = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
    tool: (name) => ({ functionCallingConfig: { mode: "ANY" as const, allowedFunctionNames: [name] } }),
  })

-const lowerUserPart = Effect.fn("Gemini.lowerUserPart")(function* (part: TextPart | MediaPart) {
+// Gemini does not fetch public URLs; inline payloads and Gemini Files references are the accepted inputs.
+const lowerContentPart = Effect.fn("Gemini.lowerContentPart")(function* (part: TextPart | MediaPart) {
  if (part.type === "text") return { text: part.text }
-  const media = ProviderShared.normalizeMedia(part)
+  const source = part.media.source
+  if (source.type === "ref" && source.provider === "google")
+    return { fileData: { mimeType: part.media.mediaType, fileUri: source.id } }
+  const media = yield* ProviderShared.requireInlineMedia("Gemini", part.media)
  return { inlineData: { mimeType: media.mime, data: media.base64 } }
 })

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

-const thoughtSignature = (providerMetadata: ProviderMetadata | undefined) => {
-  const google = providerMetadata?.google
-  return ProviderShared.isRecord(google) && typeof google.thoughtSignature === "string"
-    ? google.thoughtSignature
+const thoughtSignature = (metadata: ProviderMetadata | undefined, key: string) => {
+  const value = metadata?.[key]
+  return ProviderShared.isRecord(value) && typeof value.thoughtSignature === "string"
+    ? value.thoughtSignature
    : undefined
 }

-const functionCallId = (providerMetadata: ProviderMetadata | undefined) => {
-  const google = providerMetadata?.google
-  return ProviderShared.isRecord(google) && typeof google.functionCallId === "string"
-    ? google.functionCallId
-    : undefined
-}
-
-const lowerToolCall = (part: ToolCallPart) => ({
-  functionCall: { id: functionCallId(part.providerMetadata), name: part.name, args: part.input },
-  thoughtSignature: thoughtSignature(part.providerMetadata),
+const lowerToolCall = (part: ToolCallPart, omitIds: boolean, metadataKey: string) => ({
+  functionCall: { ...(omitIds ? {} : { id: part.id }), name: part.name, args: part.input },
+  thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey),
 })

 const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMRequest) {
  const contents: GeminiContent[] = []
+  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
  const flushMedia = () => {
@@ -303,8 +341,8 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
      const previous = contents.at(-1)
      // Gemini rejects a continuation whose function-response turn carries extra
      // parts, so an update after a tool result starts its own user turn.
-      if (previous?.role === "user" && !previous.parts.some((item) => "functionResponse" in item))
-        contents[contents.length - 1] = { role: "user", parts: [...previous.parts, { text: part.text }] }
+      if (previous?.role === "user" && !(previous.parts ?? []).some((item) => "functionResponse" in item))
+        contents[contents.length - 1] = { role: "user", parts: [...(previous.parts ?? []), { text: part.text }] }
      else contents.push({ role: "user", parts: [{ text: part.text }] })
      continue
    }
@@ -314,7 +352,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
      for (const part of message.content) {
        if (!ProviderShared.supportsContent(part, ["text", "media"]))
          return yield* ProviderShared.unsupportedContent("Gemini", "user", ["text", "media"])
-        parts.push(yield* lowerUserPart(part))
+        parts.push(yield* lowerContentPart(part))
      }
      contents.push({ role: "user", parts })
      continue
@@ -325,18 +363,33 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
      // Parallel Gemini 3 calls may carry one signature on the first call; unsigned sibling calls are valid.
      let hasSignedToolCall = false
      for (const part of message.content) {
-        if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
-          return yield* ProviderShared.unsupportedContent("Gemini", "assistant", ["text", "reasoning", "tool-call"])
+        if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call", "media"]))
+          return yield* ProviderShared.unsupportedContent("Gemini", "assistant", [
+            "text",
+            "reasoning",
+            "tool-call",
+            "media",
+          ])
        if (part.type === "text") {
-          parts.push({ text: part.text, thoughtSignature: thoughtSignature(part.providerMetadata) })
+          parts.push({ text: part.text, thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey) })
+          continue
+        }
+        // Generated images replay as model-role inline data so multi-turn image editing keeps the prior output.
+        if (part.type === "media") {
+          const lowered = yield* lowerContentPart(part)
+          parts.push({ ...lowered, thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey) })
          continue
        }
        if (part.type === "reasoning") {
-          parts.push({ text: part.text, thought: true, thoughtSignature: thoughtSignature(part.providerMetadata) })
+          parts.push({
+            text: part.text,
+            thought: true,
+            thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey),
+          })
          continue
        }
        if (part.type === "tool-call") {
-          const lowered = lowerToolCall(part)
+          const lowered = lowerToolCall(part, omitCallIds, metadataKey)
          const signature = lowered.thoughtSignature
          parts.push({
            ...lowered,
@@ -361,7 +414,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
      if (part.result.type !== "content") {
        parts.push({
          functionResponse: {
-            id: functionCallId(part.providerMetadata),
+            ...(omitCallIds ? {} : { id: part.id }),
            name: part.name,
            response: {
              name: part.name,
@@ -376,13 +429,13 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
      const media: GeminiInlineDataPart[] = []
      for (const item of content) {
        if (item.type === "text") continue
-        const value = ProviderShared.normalizeToolFile(item)
+        const value = yield* ProviderShared.requireInlineMedia("Gemini", ProviderShared.toolFileMedia(item).media)
        media.push({ inlineData: { mimeType: value.mime, data: value.base64 } })
      }
      if (legacyToolMedia && media.length > 0) (pendingMedia ??= []).push(...media)
      parts.push({
        functionResponse: {
-          id: functionCallId(part.providerMetadata),
+          ...(omitCallIds ? {} : { id: part.id }),
          name: part.name,
          response: {
            name: part.name,
@@ -395,8 +448,8 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
    // Gemini requires every response to a parallel call batch in one user turn,
    // so consecutive tool results join the open function-response turn.
    const previous = contents.at(-1)
-    if (previous?.role === "user" && previous.parts.some((item) => "functionResponse" in item))
-      contents[contents.length - 1] = { role: "user", parts: [...previous.parts, ...parts] }
+    if (previous?.role === "user" && (previous.parts ?? []).some((item) => "functionResponse" in item))
+      contents[contents.length - 1] = { role: "user", parts: [...(previous.parts ?? []), ...parts] }
    else contents.push({ role: "user", parts })
  }

@@ -438,7 +491,8 @@ function mapSafetySettings(value: unknown) {
 }

 const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMRequest) {
-  const hasTools = request.tools.length > 0
+  const flattened = ProviderShared.flattenToolRequest(request)
+  const hasTools = flattened.tools.length > 0
  const generation = request.generation
  const options = resolveOptions(request)
  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
@@ -456,7 +510,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque

  return {
    cachedContent: options.cachedContent,
-    contents: yield* lowerMessages(request),
+    contents: yield* lowerMessages(flattened.request),
    safetySettings: options.safetySettings,
    serviceTier: options.serviceTier,
    systemInstruction:
@@ -464,7 +518,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
    tools: hasTools
      ? [
          {
-            functionDeclarations: request.tools.map((tool) =>
+            functionDeclarations: flattened.tools.map((tool) =>
              lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
            ),
          },
@@ -484,24 +538,28 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
 // `cachedContentTokenCount` subset. `candidatesTokenCount` is *exclusive*
 // of `thoughtsTokenCount` — visible-only, not a total — so we sum the two
 // to produce the inclusive `outputTokens` the rest of the contract expects.
-const mapUsage = (usage: GeminiUsage | undefined) => {
+const mapUsage = (usage: GeminiUsage | undefined, metadataKey: string) => {
  if (!usage) return undefined
-  const cached = usage.cachedContentTokenCount
-  const nonCached = ProviderShared.subtractTokens(usage.promptTokenCount, cached)
+  // Explicit provider nulls decode as `null`; normalize to `undefined` so the
+  // token arithmetic below treats them like absent counts.
+  const promptTokens = usage.promptTokenCount ?? undefined
+  const cached = usage.cachedContentTokenCount ?? undefined
+  const thoughts = usage.thoughtsTokenCount ?? undefined
+  const visible = usage.candidatesTokenCount ?? undefined
+  const nonCached = ProviderShared.subtractTokens(promptTokens, cached)
  // `candidatesTokenCount` is visible-only; sum with thoughts to produce the
  // inclusive `outputTokens` the contract expects. Only compute the total
  // when the visible component is reported — otherwise we'd fabricate an
  // inclusive number from a partial breakdown.
-  const outputTokens =
-    usage.candidatesTokenCount !== undefined ? usage.candidatesTokenCount + (usage.thoughtsTokenCount ?? 0) : undefined
+  const outputTokens = visible !== undefined ? visible + (thoughts ?? 0) : undefined
  return new Usage({
-    inputTokens: usage.promptTokenCount,
+    inputTokens: promptTokens,
    outputTokens,
    nonCachedInputTokens: nonCached,
    cacheReadInputTokens: cached,
-    reasoningTokens: usage.thoughtsTokenCount,
-    totalTokens: ProviderShared.totalTokens(usage.promptTokenCount, outputTokens, usage.totalTokenCount),
-    providerMetadata: { google: usage },
+    reasoningTokens: thoughts,
+    totalTokens: ProviderShared.totalTokens(promptTokens, outputTokens, usage.totalTokenCount ?? undefined),
+    providerMetadata: providerMetadata(metadataKey, usage),
  })
 }

@@ -535,21 +593,33 @@ const mapFinishReason = (finishReason: string | undefined, hasToolCalls: boolean
 }

 const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
-  const promptBlockReason = state.finishReason === undefined ? state.promptFeedback?.blockReason : undefined
+  // `?? undefined` normalizes an explicit `null` blockReason back to absent so
+  // the "nothing to finish" check below keeps its meaning.
+  const promptBlockReason =
+    state.finishReason === undefined ? (state.promptFeedback?.blockReason ?? undefined) : undefined
  const finishReason = state.finishReason ?? promptBlockReason
  if (finishReason === undefined && state.usage === undefined) return []

  const events: LLMEvent[] = []
  let lifecycle = state.lifecycle
-  if (state.reasoningSignature !== undefined)
+  if (state.reasoningId !== undefined)
    lifecycle = Lifecycle.reasoningEnd(
      lifecycle,
      events,
-      "reasoning-0",
-      googleMetadata({ thoughtSignature: state.reasoningSignature }),
+      state.reasoningId,
+      state.reasoningSignature === undefined
+        ? undefined
+        : providerMetadata(state.providerMetadataKey, { thoughtSignature: state.reasoningSignature }),
+    )
+  if (state.textId !== undefined)
+    lifecycle = Lifecycle.textEnd(
+      lifecycle,
+      events,
+      state.textId,
+      state.textSignature === undefined
+        ? undefined
+        : providerMetadata(state.providerMetadataKey, { thoughtSignature: state.textSignature }),
    )
-  if (state.textSignature !== undefined)
-    lifecycle = Lifecycle.textEnd(lifecycle, events, "text-0", googleMetadata({ thoughtSignature: state.textSignature }))
  Lifecycle.finish(lifecycle, events, {
    reason: {
      normalized:
@@ -558,18 +628,51 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
    },
    usage: state.usage,
    providerMetadata:
-      state.promptFeedback === undefined ? undefined : googleMetadata({ promptFeedback: state.promptFeedback }),
+      state.promptFeedback === undefined
+        ? undefined
+        : providerMetadata(state.providerMetadataKey, { promptFeedback: state.promptFeedback }),
  })
  return events
 }

 const step = (state: ParserState, event: GeminiEvent) => {
+  if (ProviderShared.isRecord(event.error)) {
+    const body = ProviderShared.encodeJson(event)
+    return Effect.fail(
+      new AIError({
+        reason: classifyProviderFailure({
+          message:
+            typeof event.error.message === "string" && event.error.message.length > 0
+              ? event.error.message
+              : typeof event.error.status === "string" && event.error.status.length > 0
+                ? event.error.status
+                : "Gemini provider error",
+          status: typeof event.error.code === "number" ? event.error.code : undefined,
+          rawBody: body,
+        }),
+      }),
+    )
+  }
+  if ("error" in event)
+    return Effect.fail(
+      ProviderShared.eventError(state.route, `Invalid ${state.route} stream event`, ProviderShared.encodeJson(event)),
+    )
  const nextState = {
    ...state,
    promptFeedback: event.promptFeedback ?? state.promptFeedback,
-    usage: event.usageMetadata ? (mapUsage(event.usageMetadata) ?? 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")
+    return Effect.fail(
+      ProviderShared.eventError(
+        state.route,
+        `Gemini stopped with ${candidate.finishReason}`,
+        ProviderShared.encodeJson(event),
+      ),
+    )
  if (!candidate?.content)
    return Effect.succeed([
      { ...nextState, finishReason: candidate?.finishReason ?? nextState.finishReason },
@@ -581,36 +684,95 @@ const step = (state: ParserState, event: GeminiEvent) => {
  let lifecycle = nextState.lifecycle
  let reasoningSignature = nextState.reasoningSignature
  let textSignature = nextState.textSignature
+  let reasoningId = nextState.reasoningId
+  let textId = nextState.textId
+  let nextReasoningId = nextState.nextReasoningId
+  let nextTextId = nextState.nextTextId
+  // Supplier ids must be tracked across chunks of the same response, not just within one event's parts.
+  const seenCallIds = new Set(nextState.seenCallIds)

-  for (const part of candidate.content.parts) {
+  for (const input of candidate.content.parts ?? []) {
+    if (
+      ProviderShared.isRecord(input) &&
+      !("text" in input) &&
+      !("inlineData" in input) &&
+      !("functionCall" in input) &&
+      !("functionResponse" in input)
+    )
+      continue
+    const decoded = decodeGeminiContentPart(input)
+    if (Option.isNone(decoded))
+      return Effect.fail(
+        ProviderShared.eventError(ADAPTER, `Invalid ${state.route} stream event`, ProviderShared.encodeJson(event)),
+      )
+    const part = decoded.value
    const signature = "thoughtSignature" in part && part.thoughtSignature ? part.thoughtSignature : undefined
    // Gemini attaches replay signatures to thought parts, visible text, or function calls;
    // each block kind must retain the signature attached to its own parts.
    if (signature !== undefined && "thought" in part && part.thought) reasoningSignature = signature
    else if (signature !== undefined && "text" in part) textSignature = signature
+    // Image-capable Gemini models return generated images as inline data parts; surface them as first-class output.
+    if ("inlineData" in part) {
+      lifecycle = Lifecycle.stepStart(lifecycle, events)
+      events.push(
+        LLMEvent.media({
+          media: Media.base64(part.inlineData.data, part.inlineData.mimeType),
+          providerMetadata: signature
+            ? providerMetadata(state.providerMetadataKey, { thoughtSignature: signature })
+            : undefined,
+        }),
+      )
+      continue
+    }
    if ("text" in part && part.text.length > 0) {
      if (part.thought) {
+        if (textId !== undefined) {
+          lifecycle = Lifecycle.textEnd(
+            lifecycle,
+            events,
+            textId,
+            textSignature
+              ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature })
+              : undefined,
+          )
+          textId = undefined
+          textSignature = undefined
+        }
+        if (reasoningId === undefined) {
+          reasoningId = `reasoning-${nextReasoningId}`
+          nextReasoningId += 1
+        }
        lifecycle = Lifecycle.reasoningDelta(
          lifecycle,
          events,
-          "reasoning-0",
+          reasoningId,
          part.text,
-          signature ? googleMetadata({ thoughtSignature: signature }) : undefined,
+          signature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: signature }) : undefined,
        )
        continue
      }
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined,
-      )
+      if (reasoningId !== undefined) {
+        lifecycle = Lifecycle.reasoningEnd(
+          lifecycle,
+          events,
+          reasoningId,
+          reasoningSignature
+            ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
+            : undefined,
+        )
+        reasoningId = undefined
+        reasoningSignature = undefined
+      }
+      if (textId === undefined) {
+        textId = `text-${nextTextId}`
+        nextTextId += 1
+      }
      lifecycle = Lifecycle.textDelta(
        lifecycle,
        events,
-        "text-0",
+        textId,
        part.text,
-        textSignature ? googleMetadata({ thoughtSignature: textSignature }) : undefined,
+        textSignature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature }) : undefined,
      )
      textSignature = undefined
      continue
@@ -618,26 +780,45 @@ const step = (state: ParserState, event: GeminiEvent) => {

    if ("functionCall" in part) {
      const input = part.functionCall.args === undefined ? {} : part.functionCall.args
-      // Gemini 2.0+ and Vertex supply a unique function call ID on the part; when omitted (e.g. Gemini 1.5),
+      // Gemini 2.0+ supplies a unique function call ID on the part; when omitted (e.g. Gemini 1.5),
      // generate a globally unique ID rather than a per-request counter to prevent cross-request collisions in downstream registries.
-      const id = part.functionCall.id ?? `tool_${crypto.randomUUID().replaceAll("-", "")}`
-      const metadata = {
-        ...(part.functionCall.id === undefined ? {} : { functionCallId: part.functionCall.id }),
-        ...(part.thoughtSignature === undefined ? {} : { thoughtSignature: part.thoughtSignature }),
+      // A repeated supplier id would replay as two identical calls, so only the first occurrence keeps it.
+      // A `null` supplier id normalizes to absent so the generated-id fallback applies.
+      const supplied = part.functionCall.id ?? undefined
+      const duplicate = supplied !== undefined && seenCallIds.has(supplied)
+      if (supplied !== undefined) seenCallIds.add(supplied)
+      const id = supplied !== undefined && !duplicate ? supplied : `tool_${crypto.randomUUID().replaceAll("-", "")}`
+      if (reasoningId !== undefined) {
+        lifecycle = Lifecycle.reasoningEnd(
+          lifecycle,
+          events,
+          reasoningId,
+          reasoningSignature
+            ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
+            : undefined,
+        )
+        reasoningId = undefined
+        reasoningSignature = undefined
+      }
+      if (textId !== undefined) {
+        lifecycle = Lifecycle.textEnd(
+          lifecycle,
+          events,
+          textId,
+          textSignature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature }) : undefined,
+        )
+        textId = undefined
+        textSignature = undefined
      }
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined,
-      )
      lifecycle = Lifecycle.stepStart(lifecycle, events)
      events.push(
        LLMEvent.toolCall({
          id,
          name: part.functionCall.name,
          input,
-          providerMetadata: Object.keys(metadata).length > 0 ? googleMetadata(metadata) : undefined,
+          providerMetadata: part.thoughtSignature
+            ? providerMetadata(state.providerMetadataKey, { thoughtSignature: part.thoughtSignature })
+            : undefined,
        }),
      )
      hasToolCalls = true
@@ -651,6 +832,11 @@ const step = (state: ParserState, event: GeminiEvent) => {
      lifecycle,
      reasoningSignature,
      textSignature,
+      reasoningId,
+      textId,
+      nextReasoningId,
+      nextTextId,
+      seenCallIds,
      finishReason: candidate.finishReason ?? nextState.finishReason,
    },
    events,
@@ -672,9 +858,16 @@ export const protocol = Protocol.make({
  },
  stream: {
    event: Protocol.jsonEvent(GeminiEvent),
-    initial: () => ({ hasToolCalls: false, lifecycle: Lifecycle.initial() }),
+    initial: (request) => ({
+      route: `${request.model.provider}/${request.model.route.id}`,
+      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
+      hasToolCalls: false,
+      lifecycle: Lifecycle.initial(),
+      nextReasoningId: 0,
+      nextTextId: 0,
+    }),
    step,
-    onHalt: finish,
+    onHalt: (state) => Effect.succeed(finish(state)),
  },
 })

@@ -1,48 +1,36 @@
-import { Effect, Encoding, Schema } from "effect"
-import { Headers, HttpClientRequest } from "effect/unstable/http"
-import {
-  GeneratedImage,
-  ImageModel,
-  ImageResponse,
-  type ImageInput,
-  type ImageRequestFor,
-  type ImageRoute,
-} from "../image.js"
-import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
-import {
-  InvalidProviderOutputReason,
-  AIError,
-  Usage,
-  mergeHttpOptions,
-  mergeJsonRecords,
-  type HttpOptions,
-  type ProviderMetadata,
-} from "../schema/index.js"
+import { Effect, Schema } from "effect"
+import type { HttpClientResponse } from "effect/unstable/http"
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js"
+import { Media } from "../media.js"
+import { MediaProtocol } from "../route/media-protocol.js"
+import { MediaRoute } from "../route/media.js"
+import { ProviderID, mergeJsonRecords, type AIError } from "../schema/index.js"
 import { ProviderShared } from "./shared.js"
-import { ImageInputs } from "./utils/image-input.js"
+import { MediaInput } from "./utils/media-input.js"

 const ADAPTER = "google-images"
+const NAME = "Google Images"
+const PROVIDER = ProviderID.make("google")
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"

+// ---------------------------------------------------------------------------
+// 1. Public model input
+// ---------------------------------------------------------------------------
+
 export type GoogleImageString<Known extends string> = Known | (string & {})

+/** Provider-native options. Common fields (`aspectRatio`, `seed`, `images`) live on the request. */
 export type GoogleImageOptions = {
-  readonly aspectRatio?: GoogleImageString<
-    "1:1" | "2:3" | "3:2" | "3:4" | "4:3" | "4:5" | "5:4" | "9:16" | "16:9" | "21:9"
-  >
  readonly imageSize?: GoogleImageString<"1K" | "2K" | "4K">
-  readonly seed?: number
  readonly thinkingLevel?: GoogleImageString<"MINIMAL" | "LOW" | "MEDIUM" | "HIGH">
  readonly includeThoughts?: boolean
 } & Record<string, unknown>

-export type GoogleImageBody = Record<string, unknown> & {
-  readonly contents: ReadonlyArray<{
-    readonly role: "user"
-    readonly parts: ReadonlyArray<Record<string, unknown>>
-  }>
-  readonly generationConfig: Record<string, unknown>
-}
+export type Request = ImageRequestFor<GoogleImageOptions>
+
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------

 const GoogleUsage = Schema.StructWithRest(
  Schema.Struct({
@@ -93,30 +81,20 @@ const GoogleImageResponse = Schema.Struct({
  promptFeedback: Schema.optional(Schema.Unknown),
 })

-export interface ModelInput {
-  readonly id: string
-  readonly auth: AuthDefinition
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions
-}
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------

-const nativeOptions = (options: GoogleImageOptions | undefined) => {
-  const { aspectRatio, imageSize, seed, thinkingLevel, includeThoughts, ...native } = options ?? {}
-  const image = {
-    aspectRatio,
-    imageSize,
-  }
-  const thinkingConfig = {
-    thinkingLevel,
-    includeThoughts,
-  }
+const generationConfig = (request: Request) => {
+  const { imageSize, thinkingLevel, includeThoughts, ...native } = request.providerOptions ?? {}
+  const imageConfig = { aspectRatio: request.aspectRatio, imageSize }
+  const thinkingConfig = { thinkingLevel, includeThoughts }
  return (
    mergeJsonRecords(
      {
        responseModalities: ["IMAGE"],
-        imageConfig: Object.values(image).some((value) => value !== undefined) ? image : undefined,
-        seed,
+        imageConfig: Object.values(imageConfig).some((value) => value !== undefined) ? imageConfig : undefined,
+        seed: request.seed,
        thinkingConfig: Object.values(thinkingConfig).some((value) => value !== undefined) ? thinkingConfig : undefined,
      },
      native,
@@ -124,191 +102,208 @@ const nativeOptions = (options: GoogleImageOptions | undefined) => {
  )
 }

-const invalidOutput = (message: string, providerMetadata?: ProviderMetadata) =>
-  new AIError({
-    module: ADAPTER,
-    method: "generate",
-    reason: new InvalidProviderOutputReason({ message, route: ADAPTER, providerMetadata }),
-  })
-
-const applyQuery = (url: string, query: Record<string, string> | undefined) => {
-  if (!query) return url
-  const next = new URL(url)
-  Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value))
-  return next.toString()
-}
-
-export const model = (input: ModelInput) => {
-  const route: ImageRoute<GoogleImageOptions> = {
-    id: ADAPTER,
-    generate: Effect.fn("GoogleImages.generate")(function* (request: ImageRequestFor<GoogleImageOptions>, execute) {
-      const imageParts = yield* Effect.forEach(request.images ?? [], googleImagePart)
-      const http = mergeHttpOptions(request.model.http, request.http)
-      const requestBody = mergeJsonRecords(
-        {
-          contents: [{ role: "user", parts: [{ text: request.prompt }, ...imageParts] }],
-          generationConfig: nativeOptions(request.options),
-        },
-        http?.body,
-      ) as GoogleImageBody
-      const text = ProviderShared.encodeJson(requestBody)
-      const url = applyQuery(
-        `${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}/models/${request.model.id}:generateContent`,
-        http?.query,
-      )
-      const headers = yield* Auth.toEffect(input.auth)({
-        request,
-        method: "POST",
-        url,
-        body: text,
-        headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-      })
-      const response = yield* execute(
-        HttpClientRequest.post(url).pipe(
-          HttpClientRequest.setHeaders(headers),
-          HttpClientRequest.bodyText(text, "application/json"),
-        ),
-      )
-      const payload = yield* response.json.pipe(
-        Effect.mapError(() => invalidOutput("Failed to read the Google Images response")),
-      )
-      const decoded = yield* Schema.decodeUnknownEffect(GoogleImageResponse)(payload).pipe(
-        Effect.mapError(() => invalidOutput("Google Images returned an invalid response")),
-      )
-      const candidates = decoded.candidates ?? []
-      const candidateMetadata = candidates.map((candidate, candidateIndex) => ({
-        index: candidate.index ?? candidateIndex,
-        finishReason: candidate.finishReason,
-        finishMessage: candidate.finishMessage,
-        safetyRatings: candidate.safetyRatings,
-        citationMetadata: candidate.citationMetadata,
-        groundingMetadata: candidate.groundingMetadata,
-        parts: (candidate.content?.parts ?? []).map((part) =>
-          part.inlineData === undefined
-            ? {
-                type: "text",
-                text: part.text,
-                thought: part.thought,
-                thoughtSignature: part.thoughtSignature,
-              }
-            : {
-                type: "inlineData",
-                mediaType: part.inlineData.mimeType,
-                thought: part.thought,
-                thoughtSignature: part.thoughtSignature,
-              },
-        ),
-      }))
-      const encoded = candidates.flatMap((candidate, candidateIndex) =>
-        (candidate.content?.parts ?? []).flatMap((part, partIndex) =>
-          part.inlineData === undefined || part.thought === true
-            ? []
-            : [{ candidate, candidateIndex, partIndex, inlineData: part.inlineData }],
-        ),
-      )
-      const images = yield* Effect.forEach(encoded, (item) =>
-        Effect.fromResult(Encoding.decodeBase64(item.inlineData.data)).pipe(
-          Effect.mapError(() =>
-            invalidOutput(
-              `Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`,
-            ),
-          ),
-          Effect.map(
-            (data) =>
-              new GeneratedImage({
-                mediaType: item.inlineData.mimeType,
-                data,
-                providerMetadata: {
-                  google: {
-                    candidateIndex: item.candidate.index ?? item.candidateIndex,
-                    partIndex: item.partIndex,
-                    finishReason: item.candidate.finishReason,
-                    safetyRatings: item.candidate.safetyRatings,
-                    citationMetadata: item.candidate.citationMetadata,
-                    groundingMetadata: item.candidate.groundingMetadata,
-                    thoughtSignature: item.candidate.content?.parts[item.partIndex]?.thoughtSignature,
-                  },
-                },
-              }),
-          ),
-        ),
-      )
-      if (images.length === 0) {
-        const finishReasons = candidates.flatMap((candidate) =>
-          candidate.finishReason === undefined ? [] : [candidate.finishReason],
-        )
-        return yield* invalidOutput(
-          `Google Images returned no final images${
-            finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`
-          }; inspect reason.providerMetadata.google for prompt feedback and candidate details`,
-          {
-            google: {
-              promptFeedback: decoded.promptFeedback,
-              candidates: candidateMetadata,
-            },
-          },
-        )
-      }
-      const usage = decoded.usageMetadata
-      const outputTokens =
-        usage?.candidatesTokenCount === undefined
-          ? undefined
-          : usage.candidatesTokenCount + (usage.thoughtsTokenCount ?? 0)
-      return new ImageResponse({
-        images,
-        usage:
-          usage === undefined
-            ? undefined
-            : new Usage({
-                inputTokens: usage.promptTokenCount,
-                outputTokens,
-                nonCachedInputTokens: ProviderShared.subtractTokens(
-                  usage.promptTokenCount,
-                  usage.cachedContentTokenCount,
-                ),
-                cacheReadInputTokens: usage.cachedContentTokenCount,
-                reasoningTokens: usage.thoughtsTokenCount,
-                totalTokens: ProviderShared.totalTokens(usage.promptTokenCount, outputTokens, usage.totalTokenCount),
-                providerMetadata: { google: usage },
-              }),
-        providerMetadata: {
-          google: {
-            modelVersion: decoded.modelVersion,
-            responseId: decoded.responseId,
-            promptFeedback: decoded.promptFeedback,
-            candidates: candidateMetadata,
-          },
-        },
-      })
-    }),
-  }
-  return ImageModel.make<GoogleImageOptions>({ id: input.id, provider: "google", route, http: input.http })
-}
-
-const googleImagePart = (image: ImageInput): Effect.Effect<Record<string, unknown>, AIError> => {
-  if (image.type === "bytes")
-    return Effect.succeed({ inlineData: { mimeType: image.mediaType, data: Encoding.encodeBase64(image.data) } })
-  if (image.type === "file-uri") return Effect.succeed({ fileData: { mimeType: image.mediaType, fileUri: image.uri } })
-  if (image.type === "url")
-    return ImageInputs.decodeDataUrl(image.url, ADAPTER).pipe(
-      Effect.flatMap((decoded) => {
-        if (decoded === undefined)
-          return Effect.fail(
-            ImageInputs.invalid(
-              ADAPTER,
-              "Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file URI",
-            ),
-          )
-        return Effect.succeed({
-          inlineData: { mimeType: decoded.mediaType, data: Encoding.encodeBase64(decoded.data) },
-        })
-      }),
+// Gemini does not fetch public URLs; inline payloads or Gemini Files references are the only accepted inputs.
+const imagePart = (asset: Media.Asset): Effect.Effect<Record<string, unknown>, AIError> => {
+  const inline = asset.inline()
+  if (inline) return Effect.succeed({ inlineData: { mimeType: inline.mime, data: inline.base64 } })
+  const id = MediaInput.refID(asset, PROVIDER)
+  if (id) return Effect.succeed({ fileData: { mimeType: asset.mediaType, fileUri: id } })
+  if (asset.source.type === "ref")
+    return Effect.fail(
+      ProviderShared.invalidRequest(
+        "Google generateContent requires Gemini file references rather than other providers' file IDs",
+      ),
    )
  return Effect.fail(
-    ImageInputs.invalid(ADAPTER, "Google generateContent requires Gemini file URIs rather than provider file IDs"),
+    ProviderShared.invalidRequest(
+      "Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file reference",
+    ),
  )
 }

+const fromRequest = Effect.fn("GoogleImages.fromRequest")(function* (request: Request) {
+  if (request.n !== undefined && request.n > 1)
+    return yield* ProviderShared.unsupportedOperation({
+      operation: "image.n",
+      provider: PROVIDER,
+      route: ADAPTER,
+      message: `${NAME} generates one image per request; call it once per image instead of n=${request.n}`,
+    })
+  const parts = yield* Effect.forEach(request.images ?? [], imagePart)
+  return MediaProtocol.json(
+    mergeJsonRecords(
+      {
+        contents: [{ role: "user", parts: [{ text: request.prompt }, ...parts] }],
+        generationConfig: generationConfig(request),
+      },
+      request.http?.body,
+    ) ?? {},
+  )
+})
+
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+
+const decodeResponse = Effect.fn("GoogleImages.decodeResponse")(function* (
+  response: HttpClientResponse.HttpClientResponse,
+) {
+  const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, GoogleImageResponse)(response)
+  const decoded = output.value
+  const candidates = decoded.candidates ?? []
+  const candidateMetadata = candidates.map((candidate, candidateIndex) => ({
+    index: candidate.index ?? candidateIndex,
+    finishReason: candidate.finishReason,
+    finishMessage: candidate.finishMessage,
+    safetyRatings: candidate.safetyRatings,
+    citationMetadata: candidate.citationMetadata,
+    groundingMetadata: candidate.groundingMetadata,
+    parts: (candidate.content?.parts ?? []).map((part) =>
+      part.inlineData === undefined
+        ? { type: "text", text: part.text, thought: part.thought, thoughtSignature: part.thoughtSignature }
+        : {
+            type: "inlineData",
+            mediaType: part.inlineData.mimeType,
+            thought: part.thought,
+            thoughtSignature: part.thoughtSignature,
+          },
+    ),
+  }))
+  // Thought parts are drafts; only non-thought inline data is a final image.
+  const encoded = candidates.flatMap((candidate, candidateIndex) =>
+    (candidate.content?.parts ?? []).flatMap((part, partIndex) =>
+      part.inlineData === undefined || part.thought === true
+        ? []
+        : [
+            {
+              candidate,
+              candidateIndex,
+              partIndex,
+              inlineData: part.inlineData,
+              thoughtSignature: part.thoughtSignature,
+            },
+          ],
+    ),
+  )
+  const images = yield* Effect.forEach(encoded, (item) =>
+    MediaInput.decodedAsset(
+      output.invalid,
+      `${NAME} candidate ${item.candidateIndex} part ${item.partIndex}`,
+      item.inlineData.data,
+      item.inlineData.mimeType,
+      {
+        providerMetadata: {
+          google: {
+            candidateIndex: item.candidate.index ?? item.candidateIndex,
+            partIndex: item.partIndex,
+            finishReason: item.candidate.finishReason,
+            safetyRatings: item.candidate.safetyRatings,
+            citationMetadata: item.candidate.citationMetadata,
+            groundingMetadata: item.candidate.groundingMetadata,
+            thoughtSignature: item.thoughtSignature,
+          },
+        },
+      },
+    ),
+  )
+  if (images.length === 0) {
+    const finishReasons = candidates.flatMap((candidate) =>
+      candidate.finishReason === undefined ? [] : [candidate.finishReason],
+    )
+    return yield* output.invalid(
+      `${NAME} returned no final images${
+        finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`
+      }; inspect body for prompt feedback and candidate details`,
+    )
+  }
+  // Candidates that stopped for a safety or policy reason are partial results, not a silent drop.
+  const notices = [
+    ...(decoded.promptFeedback === undefined
+      ? []
+      : [
+          {
+            type: "filtered" as const,
+            message: `${NAME} reported prompt feedback`,
+            providerMetadata: { google: { promptFeedback: decoded.promptFeedback } },
+          },
+        ]),
+    ...candidates.flatMap((candidate, index) =>
+      candidate.finishReason === undefined || candidate.finishReason === "STOP"
+        ? []
+        : [
+            {
+              type: "filtered" as const,
+              message: `${NAME} candidate ${candidate.index ?? index} finished with ${candidate.finishReason}${
+                candidate.finishMessage === undefined ? "" : `: ${candidate.finishMessage}`
+              }`,
+              providerMetadata: {
+                google: {
+                  candidateIndex: candidate.index ?? index,
+                  finishReason: candidate.finishReason,
+                  finishMessage: candidate.finishMessage,
+                  safetyRatings: candidate.safetyRatings,
+                },
+              },
+            },
+          ],
+    ),
+  ]
+  const usage = decoded.usageMetadata
+  const outputTokens =
+    usage?.candidatesTokenCount === undefined ? undefined : usage.candidatesTokenCount + (usage.thoughtsTokenCount ?? 0)
+  return new ImageResponse({
+    images,
+    notices: notices.length === 0 ? undefined : notices,
+    usage:
+      usage === undefined
+        ? undefined
+        : {
+            type: "tokens",
+            input: usage.promptTokenCount,
+            output: outputTokens,
+            total: ProviderShared.totalTokens(usage.promptTokenCount, outputTokens, usage.totalTokenCount),
+            details: {
+              reasoningTokens: usage.thoughtsTokenCount,
+              cacheReadInputTokens: usage.cachedContentTokenCount,
+              google: usage,
+            },
+          },
+    providerMetadata: {
+      google: {
+        modelVersion: decoded.modelVersion,
+        responseId: decoded.responseId,
+        promptFeedback: decoded.promptFeedback,
+        candidates: candidateMetadata,
+      },
+    },
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+
+export const protocol = MediaProtocol.inline<Request, ImageResponse>({
+  id: ADAPTER,
+  name: NAME,
+  unsupported: ["mask", "size", "format"],
+  body: { from: fromRequest },
+  response: { decode: decodeResponse },
+})
+
+export const model = (input: MediaRoute.ModelInput) =>
+  ImageModel.fromRoute<GoogleImageOptions>(
+    {
+      id: ADAPTER,
+      provider: PROVIDER,
+      protocol,
+      baseURL: DEFAULT_BASE_URL,
+      path: ({ request }) => `/models/${request.model.id}:generateContent`,
+    },
+    input,
+  )
+
 export const GoogleImages = {
+  protocol,
  model,
 } as const
@@ -1,6 +1,7 @@
 export * as AnthropicMessages from "./anthropic-messages.js"
 export * as BedrockConverse from "./bedrock-converse.js"
 export * as Gemini from "./gemini.js"
+export * as MistralChat from "./mistral-chat.js"
 export * as OpenAIChat from "./openai-chat.js"
 export * as OpenAIImages from "./openai-images.js"
 export * as OpenAICompatibleChat from "./openai-compatible-chat.js"
@@ -0,0 +1,165 @@
+import { Effect, Schema } from "effect"
+import type { HttpClientResponse } from "effect/unstable/http"
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js"
+import { Media } from "../media.js"
+import { MediaProtocol } from "../route/media-protocol.js"
+import { MediaRoute } from "../route/media.js"
+import { ProviderID, mergeJsonRecords, type AIError } from "../schema/index.js"
+import { JsonObject, ProviderShared, optionalNull } from "./shared.js"
+import { MediaInput } from "./utils/media-input.js"
+
+const ADAPTER = "meta-images"
+const NAME = "Meta Images"
+const PROVIDER = ProviderID.make("meta")
+
+// ---------------------------------------------------------------------------
+// 1. Public model input
+// ---------------------------------------------------------------------------
+
+type OpenString<Known extends string> = Known | (string & {})
+
+/** Provider-native options. Common fields (`n`, `size`, `format`, `images`) live on the request. */
+export type ImageOptions = {
+  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
+}
+
+export type Request = ImageRequestFor<ImageOptions>
+
+// ---------------------------------------------------------------------------
+// 2. Request body and response schemas
+// ---------------------------------------------------------------------------
+
+const Body = Schema.StructWithRest(
+  Schema.Struct({
+    model: Schema.String,
+    prompt: Schema.String,
+    images: Schema.optional(Schema.Array(JsonObject)),
+    n: Schema.optional(Schema.Number),
+    /** Aspect ratio hint, not an exact output resolution. */
+    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),
+    }),
+  ),
+})
+
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+
+const isEdit = (request: Request) => (request.images?.length ?? 0) > 0
+
+const reference = (asset: Media.Asset): Effect.Effect<Record<string, unknown>, AIError> => {
+  const inline = asset.inline()
+  if (inline) return Effect.succeed({ image_url: inline.dataUrl })
+  const url = ProviderShared.mediaUrl(asset)
+  if (url) return Effect.succeed({ image_url: url })
+  return Effect.fail(ProviderShared.invalidRequest(`${NAME} accepts image bytes and URLs`))
+}
+
+const fromRequest = Effect.fn("MetaImages.fromRequest")(function* (request: Request) {
+  const images = yield* Effect.forEach(request.images ?? [], reference)
+  const { responseFormat, reasoningStrength, toolEnablement, ...native } = request.providerOptions ?? {}
+  const payload = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(
+    mergeJsonRecords(
+      {
+        model: request.model.id,
+        prompt: request.prompt,
+        images: images.length === 0 ? undefined : images,
+        n: request.n,
+        size: request.size,
+        output_format: request.format,
+        response_format: responseFormat,
+        reasoning_strength: reasoningStrength,
+        tool_enablement: toolEnablement,
+      },
+      native,
+      request.http?.body,
+    ),
+  )
+  return MediaProtocol.json(payload)
+})
+
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+
+const decodeResponse = Effect.fn("MetaImages.decodeResponse")(function* (
+  response: HttpClientResponse.HttpClientResponse,
+  context: MediaProtocol.DecodeContext<Request>,
+) {
+  const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, Response)(response)
+  const decoded = output.value
+  const requested = context.body.type === "json" ? context.body.value.output_format : undefined
+  const format = decoded.output_format ?? (typeof requested === "string" ? requested : "webp")
+  const mediaType = `image/${format}`
+  const images = yield* Effect.forEach(decoded.data, (item, index) => {
+    if (item.b64_json)
+      return MediaInput.decodedAsset(output.invalid, `${NAME} result ${index}`, item.b64_json, mediaType, {
+        info: { format },
+      })
+    if (item.url) return Effect.succeed(Media.url(item.url, { mediaType, info: { format } }))
+    return Effect.fail(output.invalid(`${NAME} result ${index} has neither image data nor a URL`))
+  })
+  if (images.length === 0) return yield* output.invalid(`${NAME} returned no images`)
+  return new ImageResponse({
+    images,
+    usage:
+      decoded.usage === undefined
+        ? undefined
+        : {
+            type: "tokens",
+            input: decoded.usage.input_tokens,
+            output: decoded.usage.output_tokens,
+            total: decoded.usage.total_tokens,
+            details: { meta: decoded.usage },
+          },
+    providerMetadata: { meta: { outputFormat: format } },
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+
+export const protocol = MediaProtocol.inline<Request, ImageResponse>({
+  id: ADAPTER,
+  name: NAME,
+  unsupported: ["mask", "aspectRatio", "seed"],
+  body: { from: fromRequest },
+  response: { decode: decodeResponse },
+})
+
+export const model = (input: MediaRoute.ModelInput & { readonly baseURL: string }) =>
+  ImageModel.fromRoute<ImageOptions>(
+    {
+      id: ADAPTER,
+      provider: PROVIDER,
+      protocol,
+      path: ({ request }) => `/images/${isEdit(request) ? "edits" : "generations"}`,
+    },
+    input,
+  )
+
+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"
@@ -0,0 +1,767 @@
+import { Effect, Schema } from "effect"
+import { Auth } from "../route/auth.js"
+import { Route } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
+import { Protocol } from "../route/protocol.js"
+import { HttpTransport } from "../route/transport/index.js"
+import {
+  AIError,
+  InvalidProviderOutputError,
+  LLMEvent,
+  ProviderInternalError,
+  UnknownProviderError,
+  Usage,
+  type FinishReasonDetails,
+  type LLMRequest,
+  type MediaPart,
+  type ToolCallPart,
+  type ToolDefinition,
+} from "../schema/index.js"
+import { classifyProviderFailure } from "../provider-error.js"
+import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
+import { Lifecycle } from "./utils/lifecycle.js"
+import { MistralToolID } from "./utils/mistral-tool-id.js"
+import { ToolStream } from "./utils/tool-stream.js"
+
+const ADAPTER = "mistral-chat"
+const DONE = "[DONE]" as const
+export const DEFAULT_BASE_URL = "https://api.mistral.ai/v1"
+export const PATH = "/chat/completions"
+
+const MistralTextContent = Schema.Struct({
+  type: Schema.Literal("text"),
+  text: Schema.String,
+})
+
+const MistralThinkingUnit = Schema.StructWithRest(
+  Schema.Struct({
+    type: Schema.optional(Schema.String),
+    text: Schema.optional(Schema.String),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
+type MistralThinkingUnit = Schema.Schema.Type<typeof MistralThinkingUnit>
+
+const MistralThinkingContent = Schema.StructWithRest(
+  Schema.Struct({
+    type: Schema.Literal("thinking"),
+    thinking: Schema.Array(MistralThinkingUnit),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
+type MistralThinkingContent = Schema.Schema.Type<typeof MistralThinkingContent>
+const isMistralThinkingContent = Schema.is(MistralThinkingContent)
+
+const MistralUserContent = Schema.Union([
+  MistralTextContent,
+  Schema.Struct({ type: Schema.Literal("image_url"), image_url: Schema.String }),
+  Schema.Struct({ type: Schema.Literal("document_url"), document_url: Schema.String }),
+])
+type MistralUserContent = Schema.Schema.Type<typeof MistralUserContent>
+
+const MistralAssistantToolCall = Schema.Struct({
+  id: Schema.String,
+  type: Schema.Literal("function"),
+  function: Schema.Struct({ name: Schema.String, arguments: Schema.String }),
+})
+type MistralAssistantToolCall = Schema.Schema.Type<typeof MistralAssistantToolCall>
+
+const MistralMessage = Schema.Union([
+  Schema.Struct({ role: Schema.Literal("system"), content: Schema.String }),
+  Schema.Struct({
+    role: Schema.Literal("user"),
+    content: Schema.Union([Schema.String, Schema.Array(MistralUserContent)]),
+  }),
+  Schema.Struct({
+    role: Schema.Literal("assistant"),
+    content: Schema.Union([Schema.String, Schema.Array(Schema.Union([MistralTextContent, MistralThinkingContent]))]),
+    tool_calls: optionalArray(MistralAssistantToolCall),
+    prefix: Schema.optional(Schema.Literal(true)),
+  }),
+  Schema.Struct({
+    role: Schema.Literal("tool"),
+    tool_call_id: Schema.String,
+    name: Schema.String,
+    content: Schema.Union([Schema.String, Schema.Array(MistralUserContent)]),
+  }),
+]).pipe(Schema.toTaggedUnion("role"))
+type MistralMessage = Schema.Schema.Type<typeof MistralMessage>
+
+const MistralTool = Schema.Struct({
+  type: Schema.Literal("function"),
+  function: Schema.Struct({
+    name: Schema.String,
+    description: Schema.String,
+    parameters: JsonObject,
+    strict: Schema.Literal(false),
+  }),
+})
+type MistralTool = Schema.Schema.Type<typeof MistralTool>
+
+const MistralOptions = Schema.Struct({
+  safePrompt: Schema.optional(Schema.Boolean),
+  documentImageLimit: Schema.optional(Schema.Number),
+  documentPageLimit: Schema.optional(Schema.Number),
+  parallelToolCalls: Schema.optional(Schema.Boolean),
+  reasoningEffort: Schema.optional(Schema.String),
+  promptMode: Schema.optional(Schema.Literal("reasoning")),
+  promptCacheKey: Schema.optional(Schema.String),
+})
+
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | (string & {})
+
+export type ProviderOptionsInput = {
+  readonly safePrompt?: boolean
+  readonly documentImageLimit?: number
+  readonly documentPageLimit?: number
+  readonly parallelToolCalls?: boolean
+  readonly reasoningEffort?: ReasoningEffort
+  readonly promptMode?: "reasoning"
+  readonly promptCacheKey?: string
+  readonly [key: string]: unknown
+}
+
+const MistralBody = Schema.Struct({
+  model: Schema.String,
+  messages: Schema.Array(MistralMessage),
+  tools: optionalArray(MistralTool),
+  tool_choice: Schema.optional(
+    Schema.Union([
+      Schema.Literals(["auto", "none", "any"]),
+      Schema.Struct({ type: Schema.Literal("function"), function: Schema.Struct({ name: Schema.String }) }),
+    ]),
+  ),
+  stream: Schema.Literal(true),
+  max_tokens: Schema.optional(Schema.Number),
+  random_seed: Schema.optional(Schema.Number),
+  temperature: Schema.optional(Schema.Number),
+  top_p: Schema.optional(Schema.Number),
+  frequency_penalty: Schema.optional(Schema.Number),
+  presence_penalty: Schema.optional(Schema.Number),
+  stop: optionalArray(Schema.String),
+  prompt_cache_key: Schema.optional(Schema.String),
+  safe_prompt: Schema.optional(Schema.Boolean),
+  document_image_limit: Schema.optional(Schema.Number),
+  document_page_limit: Schema.optional(Schema.Number),
+  parallel_tool_calls: Schema.optional(Schema.Boolean),
+  reasoning_effort: Schema.optional(Schema.String),
+  prompt_mode: Schema.optional(Schema.Literal("reasoning")),
+})
+export type MistralBody = Schema.Schema.Type<typeof MistralBody>
+
+const MistralUsageDetails = Schema.StructWithRest(Schema.Struct({ cached_tokens: optionalNull(Schema.Number) }), [
+  Schema.Record(Schema.String, Schema.Unknown),
+])
+
+const MistralUsage = Schema.StructWithRest(
+  Schema.Struct({
+    prompt_tokens: optionalNull(Schema.Number),
+    completion_tokens: optionalNull(Schema.Number),
+    total_tokens: optionalNull(Schema.Number),
+    num_cached_tokens: optionalNull(Schema.Number),
+    prompt_token_details: optionalNull(MistralUsageDetails),
+    prompt_tokens_details: optionalNull(MistralUsageDetails),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
+
+const MistralOutputContent = Schema.StructWithRest(
+  Schema.Struct({
+    type: Schema.String,
+    text: optionalNull(Schema.String),
+    thinking: optionalNull(Schema.Unknown),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
+type MistralOutputContent = Schema.Schema.Type<typeof MistralOutputContent>
+
+const MistralToolDelta = Schema.Struct({
+  index: optionalNull(Schema.Number),
+  id: optionalNull(Schema.String),
+  function: optionalNull(
+    Schema.Struct({
+      name: optionalNull(Schema.String),
+      arguments: optionalNull(Schema.Union([Schema.String, JsonObject])),
+    }),
+  ),
+})
+type MistralToolDelta = Schema.Schema.Type<typeof MistralToolDelta>
+
+const MistralChoice = Schema.StructWithRest(
+  Schema.Struct({
+    delta: optionalNull(
+      Schema.StructWithRest(
+        Schema.Struct({
+          content: optionalNull(Schema.Union([Schema.String, Schema.Array(MistralOutputContent)])),
+          tool_calls: optionalNull(Schema.Array(MistralToolDelta)),
+        }),
+        [Schema.Record(Schema.String, Schema.Unknown)],
+      ),
+    ),
+    finish_reason: optionalNull(Schema.String),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
+
+const MistralError = Schema.StructWithRest(
+  Schema.Struct({
+    message: Schema.String,
+    code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
+
+const MistralEvent = Schema.StructWithRest(
+  Schema.Struct({
+    choices: optionalNull(Schema.Array(MistralChoice)),
+    usage: optionalNull(MistralUsage),
+    error: optionalNull(MistralError),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
+type MistralEvent = Schema.Schema.Type<typeof MistralEvent>
+const MistralStreamEvent = Schema.Union([Schema.Literal(DONE), Protocol.jsonEvent(MistralEvent)])
+
+const lowerMedia = Effect.fn("MistralChat.lowerMedia")(function* (part: MediaPart) {
+  const mime = part.media.mediaType.toLowerCase()
+  const url =
+    ProviderShared.mediaUrl(part.media) ??
+    (yield* ProviderShared.requireInlineMedia("Mistral Chat", part.media)).dataUrl
+  if (mime.startsWith("image/")) return { type: "image_url" as const, image_url: url }
+  if (mime === "application/pdf") return { type: "document_url" as const, document_url: url }
+  return yield* ProviderShared.invalidRequest(`Mistral Chat does not support media type ${part.media.mediaType}`)
+})
+
+const lowerUser = Effect.fn("MistralChat.lowerUser")(function* (message: LLMRequest["messages"][number]) {
+  const content: MistralUserContent[] = []
+  for (const part of message.content) {
+    if (part.type === "text") {
+      content.push({ type: "text", text: part.text })
+      continue
+    }
+    if (part.type === "media") {
+      content.push(yield* lowerMedia(part))
+      continue
+    }
+    return yield* ProviderShared.unsupportedContent("Mistral Chat", "user", ["text", "media"])
+  }
+  if (content.every((part) => part.type === "text"))
+    return { role: "user" as const, content: content.map((part) => part.text).join("") }
+  return { role: "user" as const, content }
+})
+
+const lowerToolCall = (part: ToolCallPart, normalizeID: (id: string) => string): MistralAssistantToolCall => ({
+  id: normalizeID(part.id),
+  type: "function",
+  function: { name: part.name, arguments: ProviderShared.encodeJson(part.input) },
+})
+
+const lowerAssistant = Effect.fn("MistralChat.lowerAssistant")(function* (
+  message: LLMRequest["messages"][number],
+  normalizeID: (id: string) => string,
+  prefix: boolean,
+) {
+  const structured = message.content.some(
+    (part) => part.type === "reasoning" && isMistralThinkingContent(part.providerMetadata?.mistral?.thinking),
+  )
+  const content: Array<Schema.Schema.Type<typeof MistralTextContent> | MistralThinkingContent> = []
+  const text: string[] = []
+  const toolCalls: MistralAssistantToolCall[] = []
+  for (const part of message.content) {
+    if (part.type === "text") {
+      if (structured) content.push({ type: "text", text: part.text })
+      else text.push(part.text)
+      continue
+    }
+    if (part.type === "reasoning") {
+      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)
+      continue
+    }
+    if (part.type === "tool-call") {
+      toolCalls.push(lowerToolCall(part, normalizeID))
+      continue
+    }
+    return yield* ProviderShared.unsupportedContent("Mistral Chat", "assistant", ["text", "reasoning", "tool-call"])
+  }
+  return {
+    role: "assistant" as const,
+    content: structured ? content : text.join(""),
+    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+    ...(prefix ? { prefix: true as const } : {}),
+  }
+})
+
+const lowerToolResults = Effect.fn("MistralChat.lowerToolResults")(function* (
+  message: LLMRequest["messages"][number],
+  normalizeID: (id: string) => string,
+) {
+  const output: MistralMessage[] = []
+  for (const part of message.content) {
+    if (part.type !== "tool-result")
+      return yield* ProviderShared.unsupportedContent("Mistral Chat", "tool", ["tool-result"])
+    if (part.result.type !== "content") {
+      output.push({
+        role: "tool",
+        tool_call_id: normalizeID(part.id),
+        name: part.name,
+        content: ProviderShared.toolResultText(part),
+      })
+      continue
+    }
+    const content: MistralUserContent[] = []
+    for (const item of part.result.value) {
+      if (item.type === "text") {
+        content.push({ type: "text", text: item.text })
+        continue
+      }
+      content.push(yield* lowerMedia(ProviderShared.toolFileMedia(item)))
+    }
+    output.push({
+      role: "tool",
+      tool_call_id: normalizeID(part.id),
+      name: part.name,
+      content: content.some((item) => item.type !== "text")
+        ? content
+        : content.map((item) => (item.type === "text" ? item.text : "")).join(""),
+    })
+  }
+  return output
+})
+
+const lowerMessages = Effect.fn("MistralChat.lowerMessages")(function* (request: LLMRequest) {
+  const normalizeID = MistralToolID.normalizer(request)
+  const messages: MistralMessage[] =
+    request.system.length === 0 ? [] : [{ role: "system", content: ProviderShared.joinText(request.system) }]
+  for (const message of request.messages) {
+    if (message.role === "system") {
+      const update = yield* ProviderShared.wrappedSystemUpdate("Mistral Chat", message)
+      messages.push({
+        role: "user",
+        content: update.text,
+      })
+      continue
+    }
+    if (message.role === "user") {
+      messages.push(yield* lowerUser(message))
+      continue
+    }
+    if (message.role === "assistant") {
+      const hasToolCalls = message.content.some((part) => part.type === "tool-call")
+      const hasNativeThinking = message.content.some(
+        (part) => part.type === "reasoning" && isMistralThinkingContent(part.providerMetadata?.mistral?.thinking),
+      )
+      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)))
+      continue
+    }
+    messages.push(...(yield* lowerToolResults(message, normalizeID)))
+  }
+  return messages
+})
+
+const lowerTool = (tool: ToolDefinition): MistralTool => ({
+  type: "function",
+  function: { name: tool.name, description: tool.description, parameters: tool.inputSchema, strict: false },
+})
+
+export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (request: LLMRequest) {
+  const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(MistralOptions))(
+    request.providerOptions ?? {},
+  )
+  const selected = request.toolChoice?.type === "tool" ? request.toolChoice.name : undefined
+  if (request.toolChoice?.type === "tool" && !selected)
+    return yield* ProviderShared.invalidRequest("Mistral Chat tool choice requires a tool name")
+  if (options.reasoningEffort !== undefined && options.promptMode !== undefined)
+    return yield* ProviderShared.invalidRequest(
+      "Mistral Chat reasoningEffort and promptMode provider options are mutually exclusive",
+    )
+  const toolChoice = request.toolChoice
+    ? yield* ProviderShared.matchToolChoice("Mistral Chat", request.toolChoice, {
+        auto: () => "auto" as const,
+        none: () => "none" as const,
+        required: () => "any" as const,
+        tool: (name) => ({ type: "function" as const, function: { name } }),
+      })
+    : undefined
+  const flattened = ProviderShared.flattenToolRequest(request)
+  return {
+    model: request.model.id,
+    messages: yield* lowerMessages(flattened.request),
+    tools: flattened.tools.length > 0 ? flattened.tools.map(lowerTool) : undefined,
+    tool_choice: toolChoice,
+    stream: true as const,
+    max_tokens: request.generation?.maxTokens,
+    random_seed: request.generation?.seed,
+    temperature: request.generation?.temperature,
+    top_p: request.generation?.topP,
+    frequency_penalty: request.generation?.frequencyPenalty,
+    presence_penalty: request.generation?.presencePenalty,
+    stop: request.generation?.stop,
+    prompt_cache_key: request.cache === "none" ? undefined : (options.promptCacheKey ?? request.promptCacheKey),
+    safe_prompt: options.safePrompt,
+    document_image_limit: options.documentImageLimit,
+    document_page_limit: options.documentPageLimit,
+    parallel_tool_calls:
+      options.parallelToolCalls ?? (request.toolChoice?.disableParallelToolUse === true ? false : undefined),
+    reasoning_effort: options.reasoningEffort,
+    prompt_mode: options.promptMode,
+  }
+})
+
+type ToolKey = string | number
+interface PendingTool {
+  readonly id: string
+  readonly name?: string
+  readonly input: string
+}
+
+interface ActiveContent {
+  readonly type: "text" | "reasoning"
+  readonly id: string
+  readonly thinking?: MistralThinkingContent
+}
+
+export interface ParserState {
+  readonly tools: ToolStream.State<ToolKey>
+  readonly pendingTools: Partial<Record<ToolKey, PendingTool>>
+  readonly toolIDs: ReadonlyMap<string, string>
+  readonly usedToolIDs: ReadonlySet<string>
+  readonly completedTools: ReadonlyArray<LLMEvent>
+  readonly latestToolKey?: ToolKey
+  readonly generatedTools: number
+  readonly lifecycle: Lifecycle.State
+  readonly active?: ActiveContent
+  readonly nextContent: number
+  readonly usage?: Usage
+  readonly finishReason?: FinishReasonDetails
+}
+
+const mapUsage = (usage: MistralEvent["usage"]): Usage | undefined => {
+  if (!usage) return undefined
+  const input = usage.prompt_tokens ?? undefined
+  const reported =
+    usage.num_cached_tokens ??
+    usage.prompt_tokens_details?.cached_tokens ??
+    usage.prompt_token_details?.cached_tokens ??
+    undefined
+  const cached = input === undefined || reported === undefined ? undefined : Math.max(0, Math.min(input, reported))
+  const output = usage.completion_tokens ?? undefined
+  return new Usage({
+    inputTokens: input,
+    outputTokens: output,
+    nonCachedInputTokens: ProviderShared.subtractTokens(input, cached),
+    cacheReadInputTokens: cached,
+    totalTokens: ProviderShared.totalTokens(input, output, usage.total_tokens ?? undefined),
+    providerMetadata: { mistral: usage },
+  })
+}
+
+const mapFinishReason = (reason: string) => {
+  switch (reason) {
+    case "stop":
+      return "stop" as const
+    case "length":
+    case "model_length":
+      return "length" as const
+    case "tool_calls":
+      return "tool-calls" as const
+    case "content_filter":
+      return "content-filter" as const
+    case "error":
+    case "network_error":
+      return "error" as const
+    default:
+      return "unknown" as const
+  }
+}
+
+const thinkingUnits = (value: unknown): ReadonlyArray<MistralThinkingUnit> => {
+  if (typeof value === "string") return [{ type: "text", text: value }]
+  if (!Array.isArray(value)) return []
+  return value.filter(Schema.is(MistralThinkingUnit))
+}
+
+const thinkingText = (thinking: ReadonlyArray<MistralThinkingUnit>) =>
+  thinking.flatMap((unit) => (typeof unit.text === "string" ? [unit.text] : [])).join("")
+
+const thinkingMetadata = (thinking: MistralThinkingContent) => ({ mistral: { thinking } })
+
+const closeActive = (state: ParserState, events: LLMEvent[]) => {
+  if (!state.active) return state
+  const lifecycle =
+    state.active.type === "text"
+      ? Lifecycle.textEnd(state.lifecycle, events, state.active.id)
+      : Lifecycle.reasoningEnd(
+          state.lifecycle,
+          events,
+          state.active.id,
+          thinkingMetadata(state.active.thinking ?? { type: "thinking", thinking: [] }),
+          thinkingText(state.active.thinking?.thinking ?? []),
+        )
+  return { ...state, lifecycle, active: undefined }
+}
+
+const appendText = (state: ParserState, events: LLMEvent[], text: string) => {
+  if (text.length === 0) return state
+  const current = state.active?.type === "text" ? state : closeActive(state, events)
+  const active = current.active ?? { type: "text" as const, id: `text-${current.nextContent}` }
+  return {
+    ...current,
+    lifecycle: Lifecycle.textDelta(current.lifecycle, events, active.id, text),
+    active,
+    nextContent: current.active ? current.nextContent : current.nextContent + 1,
+  }
+}
+
+const appendThinking = (state: ParserState, events: LLMEvent[], part: MistralOutputContent) => {
+  const current = state.active?.type === "reasoning" ? state : closeActive(state, events)
+  const units = thinkingUnits(part.thinking)
+  const active = current.active ?? { type: "reasoning" as const, id: `reasoning-${current.nextContent}` }
+  const thinking = {
+    ...active.thinking,
+    ...part,
+    type: "thinking" as const,
+    thinking: [...(active.thinking?.thinking ?? []), ...units],
+  }
+  const text = thinkingText(units)
+  return {
+    ...current,
+    lifecycle:
+      text.length > 0
+        ? 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,
+  }
+}
+
+const appendContent = (
+  state: ParserState,
+  events: LLMEvent[],
+  content: string | ReadonlyArray<MistralOutputContent>,
+) => {
+  if (typeof content === "string") return appendText(state, events, content)
+  return content.reduce((current, part) => {
+    if (part.type === "text") return appendText(current, events, part.text ?? "")
+    if (part.type === "thinking") return appendThinking(current, events, part)
+    return closeActive(current, events)
+  }, state)
+}
+
+const normalizeStreamToolID = (state: ParserState, source: string) => {
+  if (MistralToolID.valid.test(source))
+    return { id: source, state: { ...state, usedToolIDs: new Set([...state.usedToolIDs, source]) } }
+  const previous = state.toolIDs.get(source)
+  if (previous) return { id: previous, state }
+  let attempt = 0
+  let id = MistralToolID.hash(source)
+  while (state.usedToolIDs.has(id)) id = MistralToolID.hash(`${source}:${++attempt}`)
+  return {
+    id,
+    state: {
+      ...state,
+      toolIDs: new Map([...state.toolIDs, [source, id]]),
+      usedToolIDs: new Set([...state.usedToolIDs, id]),
+    },
+  }
+}
+
+const toolText = (tool: MistralToolDelta) => {
+  const value = tool.function?.arguments
+  if (typeof value === "string") return value
+  return value === null || value === undefined ? "" : ProviderShared.encodeJson(value)
+}
+
+const appendTools = Effect.fn("MistralChat.appendTools")(function* (
+  initial: ParserState,
+  events: LLMEvent[],
+  deltas: ReadonlyArray<MistralToolDelta>,
+) {
+  if (deltas.length === 0) return initial
+  let state = closeActive(initial, events)
+  for (const [position, delta] of deltas.entries()) {
+    const wireID = delta.id?.trim() || undefined
+    const providedID = wireID === "null" ? undefined : wireID
+    const key =
+      delta.index ??
+      (providedID
+        ? `id:${providedID}`
+        : deltas.length > 1
+          ? `position:${position}`
+          : (state.latestToolKey ?? `missing:${state.generatedTools}`))
+    const existing = state.tools[key]
+    const pending = state.pendingTools[key]
+    const source = providedID ?? `generated:${String(key)}`
+    const normalized =
+      existing || pending ? { id: existing?.id ?? pending?.id ?? "", state } : normalizeStreamToolID(state, source)
+    state = normalized.state
+    const name = existing?.name ?? pending?.name ?? (delta.function?.name?.trim() || undefined)
+    const text = `${pending?.input ?? ""}${toolText(delta)}`
+    if (!name) {
+      state = {
+        ...state,
+        pendingTools: { ...state.pendingTools, [key]: { id: normalized.id, input: text } },
+        latestToolKey: key,
+        generatedTools: state.generatedTools + (!providedID && !pending ? 1 : 0),
+      }
+      continue
+    }
+    const result = ToolStream.appendOrStart(
+      ADAPTER,
+      state.tools,
+      key,
+      { id: normalized.id, name, text },
+      "Mistral Chat tool call delta is missing a name",
+    )
+    if (ToolStream.isError(result)) return yield* result
+    if (result.events.length > 0) state = { ...state, lifecycle: Lifecycle.stepStart(state.lifecycle, events) }
+    events.push(...result.events)
+    const pendingTools = { ...state.pendingTools }
+    delete pendingTools[key]
+    state = {
+      ...state,
+      tools: result.tools,
+      pendingTools,
+      latestToolKey: key,
+      generatedTools: state.generatedTools + (!providedID && !existing && !pending ? 1 : 0),
+    }
+  }
+  return state
+})
+
+const hasLateContent = (event: MistralEvent) => {
+  const delta = event.choices?.[0]?.delta
+  if (typeof delta?.content === "string" && delta.content.length > 0) return true
+  if (Array.isArray(delta?.content) && delta.content.length > 0) return true
+  return (delta?.tool_calls ?? []).some(
+    (tool) => Boolean(tool.id) || Boolean(tool.function?.name) || tool.function?.arguments !== undefined,
+  )
+}
+
+const step = Effect.fn("MistralChat.step")(function* (state: ParserState, event: MistralEvent) {
+  if (event.error) {
+    const body = ProviderShared.encodeJson(event)
+    return yield* new AIError({
+      reason: classifyProviderFailure({
+        message: event.error.message,
+        status: typeof event.error.code === "number" ? event.error.code : undefined,
+        rawBody: body,
+      }),
+    })
+  }
+  const events: LLMEvent[] = []
+  const usage = mapUsage(event.usage) ?? state.usage
+  if (state.finishReason) {
+    if (hasLateContent(event))
+      return yield* ProviderShared.eventError(
+        ADAPTER,
+        "Mistral Chat received content after the finish reason",
+        ProviderShared.encodeJson(event),
+      )
+    return [{ ...state, usage }, events] as const
+  }
+  const choice = event.choices?.[0]
+  const withContent = choice?.delta?.content == null ? state : appendContent(state, events, choice.delta.content)
+  const withTools = yield* appendTools(withContent, events, choice?.delta?.tool_calls ?? [])
+  if (!choice?.finish_reason) return [{ ...withTools, usage }, events] as const
+
+  const finishReason = {
+    normalized: mapFinishReason(choice.finish_reason),
+    raw: choice.finish_reason,
+  }
+  if (finishReason.normalized === "error") {
+    const details = {
+      message: `Mistral Chat stopped with ${finishReason.raw}`,
+      body: ProviderShared.encodeJson(event),
+    }
+    return yield* new AIError({
+      reason:
+        finishReason.raw === "network_error" ? new ProviderInternalError(details) : new UnknownProviderError(details),
+    })
+  }
+  const incomplete = finishReason.normalized === "length" || finishReason.normalized === "content-filter"
+  if (!incomplete && Object.keys(withTools.pendingTools).length > 0)
+    return yield* ProviderShared.eventError(
+      ADAPTER,
+      "Mistral Chat tool call delta is missing a name",
+      ProviderShared.encodeJson(event),
+    )
+  const finished =
+    !incomplete && Object.keys(withTools.tools).length > 0
+      ? yield* ToolStream.finishAll(ADAPTER, withTools.tools)
+      : undefined
+  return [
+    {
+      ...withTools,
+      tools: finished?.tools ?? withTools.tools,
+      completedTools: finished?.events ?? withTools.completedTools,
+      usage,
+      finishReason,
+    },
+    events,
+  ] as const
+})
+
+const finishEvents = Effect.fn("MistralChat.finishEvents")(function* (state: ParserState) {
+  if (!state.finishReason)
+    return yield* new AIError({
+      reason: new InvalidProviderOutputError({
+        message: "Mistral Chat stream ended without finish_reason",
+        classification: "incomplete-stream",
+        route: ADAPTER,
+      }),
+    })
+  const events: LLMEvent[] = []
+  const closed = closeActive(state, events)
+  const lifecycle = closed.completedTools.length > 0 ? Lifecycle.stepStart(closed.lifecycle, events) : closed.lifecycle
+  events.push(...closed.completedTools)
+  const reason =
+    state.finishReason.normalized === "stop" && closed.completedTools.some(LLMEvent.is.toolCall)
+      ? { ...state.finishReason, normalized: "tool-calls" as const }
+      : state.finishReason
+  Lifecycle.finish(lifecycle, events, { reason, usage: closed.usage })
+  return events
+})
+
+export const protocol = Protocol.make({
+  id: ADAPTER,
+  body: { schema: MistralBody, from: fromRequest },
+  stream: {
+    event: MistralStreamEvent,
+    initial: (): ParserState => ({
+      tools: ToolStream.empty<ToolKey>(),
+      pendingTools: {},
+      toolIDs: new Map(),
+      usedToolIDs: new Set(),
+      completedTools: [],
+      generatedTools: 0,
+      lifecycle: Lifecycle.initial(),
+      nextContent: 0,
+    }),
+    step: (state: ParserState, event) => (event === DONE ? Effect.succeed([state, []] as const) : step(state, event)),
+    terminal: (event) => event === DONE,
+    onHalt: finishEvents,
+  },
+})
+
+export const framing = Framing.sseWithDone
+export const httpTransport = HttpTransport.sseJson.with<MistralBody>().with({ framing })
+
+export const route = Route.make({
+  id: ADAPTER,
+  provider: "mistral",
+  providerMetadataKey: "mistral",
+  protocol,
+  endpoint: Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL }),
+  auth: Auth.none,
+  transport: httpTransport,
+})
+
+export * as MistralChat from "./mistral-chat.js"
@@ -1,6 +1,7 @@
 import { Effect, Schema, Stream } from "effect"
 import { Headers } from "effect/unstable/http"
 import { Framing } from "../route/framing.js"
+import type { HttpContext } from "../schema/index.js"
 import {
  HttpTransport,
  WebSocketTransport,
@@ -17,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
@@ -26,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 {
@@ -59,9 +60,9 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
      }),
    observe: (_create, frame) =>
      Effect.gen(function* () {
-        const event = yield* decodeEvent(frame).pipe(
-          Effect.mapError(() =>
-            ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame),
+        const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(
+          Effect.mapError((cause) =>
+            ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause),
          ),
        )
        if (terminal)
@@ -73,13 +74,13 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
        if (event.type === "error") {
          terminal = true
          yield* OpenResponses.decodeKnownErrorEvent(event).pipe(
-            Effect.mapError(() =>
-              ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame),
+            Effect.mapError((cause) =>
+              ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame, cause),
            ),
          )
          return {
            type: "provider-failure",
-            error: OpenResponses.providerFailure(options.id, event, `${options.name} stream error`),
+            error: OpenResponses.providerFailure(event, `${options.name} stream error`, frame),
          }
        }
        if (event.type === "response.failed") {
@@ -92,7 +93,7 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
            )
          return {
            type: "provider-failure",
-            error: OpenResponses.providerFailure(options.id, event, `${options.name} response failed`),
+            error: OpenResponses.providerFailure(event, `${options.name} response failed`, frame),
          }
        }
        if (event.type === "response.created") {
@@ -112,6 +113,8 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
          responseID = created
          return { type: "frame", frame }
        }
+        // Keepalives and provider notifications carry no response state and may precede response.created.
+        if (!event.type.startsWith("response.")) return { type: "frame", frame }
        if (!responseID)
          return yield* ProviderShared.eventError(
            options.id,
@@ -160,10 +163,15 @@ export const transport = <Body>(options: Options): Transport<Body, Prepared, str
                    request: create.request,
                    message: create.message,
                    base,
+                    continuation: options.continuation,
                  }),
                }
              })
            : undefined
+        if (input.webSocket && !channel)
+          yield* Effect.logWarning(`${options.name} does not offer WebSocket for this endpoint; using HTTP`, {
+            url: parts.url,
+          })
        return {
          http: {
            request: ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),
@@ -173,23 +181,37 @@ export const transport = <Body>(options: Options): Transport<Body, Prepared, str
          channel,
        }
      }),
-    execute: (prepared, request, runtime, executeOptions) => {
-      if (!executeOptions?.webSocket || !prepared.channel) return http.execute(prepared.http, request, runtime)
-      const exchange: WebSocketChannelExchange = {
-        id: request.id ?? "request",
-        connect: {
-          url: prepared.channel.url,
-          headers: prepared.channel.headers,
-          rotateAfterMs: prepared.channel.rotateAfterMs,
-        },
-        fallback: () =>
-          Stream.unwrap(
-            http.execute(prepared.http, request, runtime).pipe(Effect.map((execution) => execution.frames)),
-          ),
-        driver: prepared.channel.driver,
-      }
-      return executeOptions.webSocket.execute(exchange)
-    },
+    execute: (prepared, request, runtime, executeOptions) =>
+      Effect.gen(function* () {
+        if (!executeOptions?.webSocket || !prepared.channel) return yield* http.execute(prepared.http, request, runtime)
+        let fallbackHttp: HttpContext | undefined
+        const exchange: WebSocketChannelExchange = {
+          id: request.id ?? "request",
+          connect: {
+            url: prepared.channel.url,
+            headers: prepared.channel.headers,
+            rotateAfterMs: prepared.channel.rotateAfterMs,
+          },
+          fallback: () =>
+            Stream.unwrap(
+              http.execute(prepared.http, request, runtime).pipe(
+                Effect.map((execution) => {
+                  fallbackHttp = execution.http
+                  return execution.frames
+                }),
+              ),
+            ),
+          driver: prepared.channel.driver,
+        }
+        const execution = yield* executeOptions.webSocket.execute(exchange)
+        return {
+          frames: execution.frames,
+          complete: execution.complete,
+          get http() {
+            return fallbackHttp ?? execution.http
+          },
+        }
+      }),
  }
 }

@@ -1,4 +1,4 @@
-import { AIError, TransportReason } from "../schema/index.js"
+import { AIError, TransportError } from "../schema/index.js"
 import type { ChannelCheckpoint, ChannelObservation, WebSocketChannelDriver } from "../route/transport/index.js"
 import { Effect, Option, Schema } from "effect"
 import * as ProviderShared from "./shared.js"
@@ -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 => {
@@ -42,6 +48,7 @@ const canonical = (value: unknown): string => {
  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`
  if (!ProviderShared.isRecord(value)) return ProviderShared.encodeJson(value)
  return `{${Object.keys(value)
+    .filter((key) => value[key] !== undefined)
    .sort()
    .map((key) => `${ProviderShared.encodeJson(key)}:${canonical(value[key])}`)
    .join(",")}}`
@@ -57,7 +64,12 @@ const comparable = (value: unknown) => {
  if (value.type === "message" && value.role === "assistant")
    return {
      role: "assistant",
-      content: value.content,
+      // Annotations and logprobs describe the response, not the text replayed in model input.
+      content: Array.isArray(value.content)
+        ? value.content.map((part) =>
+            ProviderShared.isRecord(part) && part.type === "output_text" ? { type: part.type, text: part.text } : part,
+          )
+        : value.content,
      ...(value.phase === undefined ? {} : { phase: value.phase }),
    }
  if (value.type === "function_call")
@@ -99,17 +111,17 @@ const incremental = (
 const code = (event: OpenResponses.Event) => event.code || event.error?.code || event.response?.error?.code || undefined

 const rejected = (
-  input: DriverInput,
  observation: Extract<ChannelObservation, { readonly type: "provider-failure" }>,
  recovery: "retry-full" | "rotate-and-retry-full",
 ): ChannelObservation => ({
  type: "rejected",
  recovery,
  error: new AIError({
-    module: input.id,
-    method: "stream",
-    reason: new TransportReason({
+    reason: new TransportError({
      message: observation.error.message,
+      body: observation.error.reason.body,
+      http: observation.error.reason.http,
+      cause: observation.error.reason.cause,
      transport: "websocket",
      operation: "read",
      phase: "receive",
@@ -121,44 +133,76 @@ const rejected = (

 export const driver = (input: DriverInput): WebSocketChannelDriver => {
  const { previous_response_id: _previousResponseID, ...request } = input.request
-  let output: unknown[] = []
+  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(
-          Effect.mapError(() => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame)),
+        const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(
+          Effect.mapError((cause) =>
+            ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause),
+          ),
        )
        const observation = yield* input.base.observe(create, frame)
        if (event.type === "response.output_item.done" && event.item) output.push(event.item)
        if (observation.type === "provider-failure") {
          const rejection = code(event)
-          if (rejection === "previous_response_not_found") return rejected(input, observation, "retry-full")
-          if (rejection === "websocket_connection_limit_reached")
-            return rejected(input, observation, "rotate-and-retry-full")
+          if (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.
+        if (
+          Array.isArray(request.input) &&
+          request.input.some((item) => ProviderShared.isRecord(item) && item.type === "compaction_trigger")
+        )
+          return observation
        const responseID = event.response?.id
        if (!responseID || responseID.trim().length === 0) return observation
        return {
          ...observation,
          checkpoint: {
            protocol: PROTOCOL,
-            value: { version: VERSION, responseID, request, output: output.slice() } satisfies CheckpointValue,
+            value: {
+              version: VERSION,
+              responseID,
+              request,
+              // Completion can re-encrypt reasoning. Callers replay the item already emitted by output_item.done.
+              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)
+                      : item,
+                  )
+                : output.slice(),
+            } satisfies CheckpointValue,
          },
        }
      }),
  }
 }

-export const OpenResponsesContinuation = { driver } as const
+export * as OpenResponsesContinuation from "./open-responses-continuation.js"
@@ -1,13 +1,18 @@
 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"
+import { Framing } from "../route/framing.js"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
 import {
  AIError,
+  AIErrorReason,
+  InvalidProviderOutputError,
  LLMEvent,
+  ProviderInternalError,
+  UnknownProviderError,
  Usage,
  type FinishReason,
  type FinishReasonDetails,
@@ -51,7 +56,12 @@ const OpenAIChatFunction = Schema.Struct({

 const OpenAIChatTool = Schema.Struct({
  type: Schema.tag("function"),
-  function: OpenAIChatFunction,
+  function: Schema.Struct({
+    name: Schema.String,
+    description: Schema.String,
+    parameters: JsonObject,
+    strict: Schema.optional(Schema.Boolean),
+  }),
  cache_control: Schema.optional(OpenAIChatCacheControl),
 })
 type OpenAIChatTool = Schema.Schema.Type<typeof OpenAIChatTool>
@@ -133,6 +143,7 @@ export const bodyFields = {
  store: Schema.optional(Schema.Boolean),
  prompt_cache_key: Schema.optional(Schema.String),
  reasoning_effort: Schema.optional(OpenAIOptions.OpenAIReasoningEffort),
+  tool_stream: Schema.optional(Schema.Boolean),
  max_completion_tokens: Schema.optional(Schema.Number),
  max_tokens: Schema.optional(Schema.Number),
  temperature: Schema.optional(Schema.Number),
@@ -156,6 +167,9 @@ const OpenAIChatUsage = Schema.StructWithRest(
    prompt_tokens: optionalNull(Schema.Number),
    completion_tokens: optionalNull(Schema.Number),
    total_tokens: optionalNull(Schema.Number),
+    // Zai reports cache hits as top-level `cached_tokens`; DeepSeek uses `prompt_cache_hit_tokens`.
+    cached_tokens: optionalNull(Schema.Number),
+    prompt_cache_hit_tokens: optionalNull(Schema.Number),
    prompt_tokens_details: optionalNull(
      Schema.StructWithRest(
        Schema.Struct({
@@ -204,23 +218,36 @@ const OpenAIChatDelta = Schema.StructWithRest(
  [Schema.Record(Schema.String, Schema.Unknown)],
 )

-const OpenAIChatChoice = Schema.Struct({
-  delta: optionalNull(OpenAIChatDelta),
-  finish_reason: optionalNull(Schema.String),
-  native_finish_reason: optionalNull(Schema.String),
-})
+const OpenAIChatChoice = Schema.StructWithRest(
+  Schema.Struct({
+    delta: optionalNull(OpenAIChatDelta),
+    finish_reason: optionalNull(Schema.String),
+    native_finish_reason: optionalNull(Schema.String),
+    // Moonshot streams usage on `choice.usage` instead of top-level `usage`.
+    usage: optionalNull(OpenAIChatUsage),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)

-const OpenAIChatError = Schema.Struct({
-  code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
-  message: Schema.String,
-})
+const OpenAIChatError = Schema.StructWithRest(
+  Schema.Struct({
+    code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
+    message: Schema.String,
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)

-export const OpenAIChatEvent = Schema.Struct({
-  choices: optionalNull(Schema.Array(OpenAIChatChoice)),
-  usage: optionalNull(OpenAIChatUsage),
-  error: optionalNull(OpenAIChatError),
-})
+export const OpenAIChatEvent = Schema.StructWithRest(
+  Schema.Struct({
+    choices: optionalNull(Schema.Array(OpenAIChatChoice)),
+    usage: optionalNull(OpenAIChatUsage),
+    error: optionalNull(OpenAIChatError),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
 export type OpenAIChatEvent = Schema.Schema.Type<typeof OpenAIChatEvent>
+const DONE = "[DONE]" as const
+const OpenAIChatStreamEvent = Schema.Union([Schema.Literal(DONE), Protocol.jsonEvent(OpenAIChatEvent)])
 type OpenAIChatRequestMessage = LLMRequest["messages"][number]

 interface PendingToolDelta {
@@ -230,6 +257,7 @@ interface PendingToolDelta {
 }

 export interface ParserState {
+  readonly providerMetadataKey: string
  readonly tools: ToolStream.State<number>
  readonly pendingTools: Partial<Record<number, PendingToolDelta>>
  readonly toolCallEvents: ReadonlyArray<LLMEvent>
@@ -242,6 +270,7 @@ export interface ParserState {
  readonly reasoningEmitted: boolean
  readonly latestToolIndex?: number
  readonly nextToolIndex: number
+  readonly requireFinishReason: boolean
 }

 // =============================================================================
@@ -254,14 +283,21 @@ interface LoweringOptions {
  readonly cacheControl?: (
    cache: CacheHint | undefined,
  ) => Schema.Schema.Type<typeof OpenAIChatCacheControl> | undefined
+  readonly toolCallID?: (id: string) => string
 }

-const lowerTool = (tool: ToolDefinition, inputSchema: JsonSchema, options: LoweringOptions): OpenAIChatTool => ({
+const lowerTool = (
+  tool: ToolDefinition,
+  inputSchema: JsonSchema,
+  options: LoweringOptions,
+  supportsStrictMode: boolean,
+): OpenAIChatTool => ({
  type: "function",
  function: {
    name: tool.name,
    description: tool.description,
-    parameters: ToolSchemaProjection.openAI(inputSchema),
+    parameters: inputSchema,
+    ...(supportsStrictMode ? { strict: false } : {}),
  },
  cache_control: options.cacheControl?.(tool.cache),
 })
@@ -274,36 +310,38 @@ const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
    tool: (name) => ({ type: "function" as const, function: { name } }),
  })

-const lowerToolCall = (part: ToolCallPart): OpenAIChatAssistantToolCall => ({
-  id: part.id,
+const lowerToolCall = (part: ToolCallPart, options: LoweringOptions): OpenAIChatAssistantToolCall => ({
+  id: options.toolCallID?.(part.id) ?? part.id,
  type: "function",
  function: {
    name: part.name,
-    arguments: ProviderShared.encodeJson(part.input),
+    arguments: ProviderShared.encodeJson(part.input === undefined ? {} : part.input),
  },
 })

 const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part: MediaPart) {
-  const media = ProviderShared.normalizeMedia(part)
-  if (!media.mime.startsWith("image/"))
-    return yield* ProviderShared.invalidRequest(`OpenAI Chat does not support media type ${part.mediaType}`)
-  return { type: "image_url" as const, image_url: { url: media.dataUrl } }
+  if (part.media.kind !== "image")
+    return yield* ProviderShared.invalidRequest(`OpenAI Chat does not support media type ${part.media.mediaType}`)
+  const url =
+    ProviderShared.mediaUrl(part.media) ?? (yield* ProviderShared.requireInlineMedia("OpenAI Chat", part.media)).dataUrl
+  return { type: "image_url" as const, image_url: { url } }
 })

 const openAICompatibleReasoningContent = (native: unknown) =>
  isRecord(native) && typeof native.reasoning_content === "string" ? native.reasoning_content : undefined

-const reasoningField = (part: ReasoningPart) => {
-  const field = part.providerMetadata?.openai?.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) => {
+const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown, providerMetadataKey: string) => {
  const observed = parts.flatMap((part) => {
-    const details = part.providerMetadata?.openai?.reasoningDetails
+    const details = part.providerMetadata?.[providerMetadataKey]?.reasoningDetails
    return Array.isArray(details) ? details : []
  })
-  if (parts.some((part) => Array.isArray(part.providerMetadata?.openai?.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
 }

@@ -333,8 +371,9 @@ const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (

 const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(function* (
  message: OpenAIChatRequestMessage,
-  configuredField?: string,
-  options: LoweringOptions = {},
+  configuredField: string | undefined,
+  requireReasoning: boolean,
+  options: LoweringOptions & { readonly providerMetadataKey: string },
 ) {
  const content: TextPart[] = []
  const reasoning: ReasoningPart[] = []
@@ -351,25 +390,31 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
      continue
    }
    if (part.type === "tool-call") {
-      toolCalls.push(lowerToolCall(part))
+      toolCalls.push(lowerToolCall(part, options))
      continue
    }
  }
  const text = reasoning.map((part) => part.text).join("")
-  const details = reasoningDetails(reasoning, message.native?.openaiCompatible)
-  const observedField = reasoning.map(reasoningField).find((value) => value !== undefined)
+  const details = reasoningDetails(reasoning, message.native?.openaiCompatible, options.providerMetadataKey)
+  const observedField = reasoning
+    .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?.openai?.reasoningDetails))
+  const fullyStructured = reasoning.every((part) =>
+    Array.isArray(part.providerMetadata?.[options.providerMetadataKey]?.reasoningDetails),
+  )
  const field = (() => {
-    if (configuredField !== undefined) return configuredField
-    if (reasoning.length === 0) return undefined
+    if (configuredField !== undefined && (requireReasoning || reasoning.length > 0 || nativeReasoning !== undefined))
+      return configuredField
+    if (reasoning.length === 0) return requireReasoning ? "reasoning_content" : undefined
    if (observedField !== undefined) return observedField
    if (nativeReasoning !== undefined) return "reasoning_content"
-    if (!fullyStructured) return "reasoning_content"
+    if (!fullyStructured || requireReasoning) return "reasoning_content"
  })()
  const reasoningText = (() => {
-    if (configuredField !== undefined) return reasoning.length === 0 ? (nativeReasoning ?? "") : text
-    if (reasoning.length === 0) return nativeReasoning
+    if (configuredField !== undefined)
+      return reasoning.length === 0 ? (nativeReasoning ?? (requireReasoning ? "" : undefined)) : text
+    if (reasoning.length === 0) return nativeReasoning ?? (requireReasoning ? "" : undefined)
    return text
  })()
  const cached = message.content.findLast((part) => "cache" in part && part.cache !== undefined)
@@ -397,7 +442,7 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (
    if (part.result.type !== "content") {
      messages.push({
        role: "tool",
-        tool_call_id: part.id,
+        tool_call_id: options.toolCallID?.(part.id) ?? part.id,
        content: ProviderShared.toolResultText(part),
        cache_control: options.cacheControl?.(part.cache),
      })
@@ -407,27 +452,25 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (
    const text = content.filter((item) => item.type === "text").map((item) => item.text)
    messages.push({
      role: "tool",
-      tool_call_id: part.id,
+      tool_call_id: options.toolCallID?.(part.id) ?? part.id,
      content: text.join("\n"),
      cache_control: options.cacheControl?.(part.cache),
    })
    const files = content.filter((item) => item.type === "file")
-    images.push(
-      ...(yield* Effect.forEach(files, (item) =>
-        lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name }),
-      )),
-    )
+    images.push(...(yield* Effect.forEach(files, (item) => lowerMedia(ProviderShared.toolFileMedia(item)))))
  }
  return { messages, images }
 })

 const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (
  message: OpenAIChatRequestMessage,
-  reasoningField?: string,
-  options: LoweringOptions = {},
+  reasoningField: string | undefined,
+  requireReasoning: boolean,
+  options: LoweringOptions & { readonly providerMetadataKey: string },
 ) {
  if (message.role === "user") return [yield* lowerUserMessage(message, options)]
-  if (message.role === "assistant") return [yield* lowerAssistantMessage(message, reasoningField, options)]
+  if (message.role === "assistant")
+    return [yield* lowerAssistantMessage(message, reasoningField, requireReasoning, options)]
  return (yield* lowerToolMessages(message, options)).messages
 })

@@ -448,12 +491,43 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
          ]
        : [{ role: "system", content: ProviderShared.joinText(request.system) }]
  const messages = [...system]
+  const modelID = request.model.id.toLowerCase()
+  const requireReasoning =
+    request.model.compatibility?.requireReasoning ??
+    (request.model.compatibility?.reasoningField !== undefined ||
+      request.model.provider === "deepseek" ||
+      request.model.route.endpoint.baseURL?.toLowerCase().includes("deepseek.com") ||
+      modelID.includes("deepseek"))
+  const reasoningField = request.model.compatibility?.reasoningField
+  const mistral = ["mistral", "devstral", "codestral", "pixtral", "mixtral"].some((family) => modelID.includes(family))
+  const lowering = {
+    ...options,
+    providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
+    toolCallID: (id: string) => {
+      if (mistral)
+        return id
+          .replace(/[^a-zA-Z0-9]/g, "")
+          .slice(0, 9)
+          .padEnd(9, "0")
+      if (modelID.includes("claude")) return id.replace(/[^a-zA-Z0-9_-]/g, "_")
+      if (request.model.provider === "openai" || request.model.provider === "azure" || modelID.startsWith("openai/"))
+        return id.slice(0, 40)
+      return id
+    },
+  }
+  const requireAssistantAfterTool = request.model.compatibility?.requireAssistantAfterTool ?? mistral
+  const bridgeTools = () => {
+    if (requireAssistantAfterTool && messages.at(-1)?.role === "tool")
+      messages.push({ role: "assistant", content: "Done." })
+  }
  const pendingImages: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
  const flushImages = () => {
    if (pendingImages.length === 0) return
+    bridgeTools()
    messages.push({ role: "user", content: pendingImages.splice(0) })
  }
  for (const message of request.messages) {
+    if (message.role === "user") bridgeTools()
    if (message.role === "system") {
      const part = yield* ProviderShared.wrappedSystemUpdate("OpenAI Chat", message)
      if (pendingImages.length > 0) {
@@ -496,24 +570,156 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
        )
      continue
    }
+    if (
+      message.role === "assistant" &&
+      message.content.every((part) => part.type === "text" && part.text.trim() === "")
+    )
+      continue
    if (message.role === "tool") {
-      const lowered = yield* lowerToolMessages(message, options)
+      const lowered = yield* lowerToolMessages(message, lowering)
      messages.push(...lowered.messages)
      pendingImages.push(...lowered.images)
      continue
    }
    flushImages()
-    messages.push(...(yield* lowerMessage(message, request.model.compatibility?.reasoningField, options)))
+    messages.push(...(yield* lowerMessage(message, reasoningField, requireReasoning, lowering)))
  }
  flushImages()
  return messages
 })

-const lowerOptions = (request: LLMRequest) => {
+// Anthropic via LiteLLM and Amazon Bedrock require `tools` to be present
+// whenever the conversation history contains tool calls/results. Send an
+// explicit empty array when we have history but no active tools.
+const hasToolHistory = (messages: ReadonlyArray<LLMRequest["messages"][number]>) => {
+  for (const message of messages) {
+    if (message.role === "tool") return true
+    if (message.role === "assistant" && message.content.some((part) => part.type === "tool-call")) return true
+  }
+  return false
+}
+
+// Derive `max_tokens` vs `max_completion_tokens` from provider/baseURL when
+// explicit `compatibility.maxTokensField` is not set. Aligned with
+// models.dev provider naming: DeepSeek, Moonshot AI, Together AI, ZAI
+// (Zhipu + Coding Plan variants), Nvidia, Cerebras, Chutes, etc. still
+// require `max_tokens`.
+const detectMaxTokensField = (
+  provider: string,
+  baseURL: string | undefined,
+): "max_tokens" | "max_completion_tokens" => {
+  const p = provider.toLowerCase()
+  const url = (baseURL ?? "").toLowerCase()
+  if (
+    p === "deepseek" ||
+    url.includes("deepseek.com") ||
+    p === "moonshotai" ||
+    url.includes("api.moonshot.ai") ||
+    p === "togetherai" ||
+    url.includes("api.together.") ||
+    p === "zai" ||
+    p === "zai-coding-plan" ||
+    p === "zhipuai" ||
+    p === "zhipuai-coding-plan" ||
+    url.includes("api.z.ai") ||
+    url.includes("open.bigmodel.cn") ||
+    p === "nvidia" ||
+    url.includes("integrate.api.nvidia.com") ||
+    p === "cerebras" ||
+    url.includes("cerebras.ai") ||
+    url.includes("llm.chutes.ai") ||
+    p === "chutes" ||
+    p === "cloudflare-ai-gateway" ||
+    url.includes("gateway.ai.cloudflare.com") ||
+    p === "cloudflare-workers-ai" ||
+    url.includes("api.cloudflare.com")
+  )
+    return "max_tokens"
+  return "max_completion_tokens"
+}
+
+const detectSupportsStore = (provider: string, baseURL: string | undefined): boolean => {
+  const p = provider.toLowerCase()
+  const url = (baseURL ?? "").toLowerCase()
+  const isNvidia = p === "nvidia" || url.includes("integrate.api.nvidia.com")
+  const isMoonshot = p === "moonshotai" || p === "moonshotai-cn" || url.includes("api.moonshot.")
+  const isTogether = p === "togetherai" || p === "together" || url.includes("api.together.")
+  const isZai =
+    p === "zai" ||
+    p === "zai-coding-plan" ||
+    p === "zhipuai" ||
+    p === "zhipuai-coding-plan" ||
+    url.includes("api.z.ai") ||
+    url.includes("open.bigmodel.cn")
+  const isDeepSeek = p === "deepseek" || url.includes("deepseek.com")
+  const isCerebras = p === "cerebras" || url.includes("cerebras.ai")
+  const isXai = p === "xai" || url.includes("api.x.ai")
+  const isChutes = p === "chutes" || url.includes("chutes.ai")
+  const isCloudflareWorkersAI = p === "cloudflare-workers-ai" || url.includes("api.cloudflare.com")
+  const isCloudflareAiGateway = p === "cloudflare-ai-gateway" || url.includes("gateway.ai.cloudflare.com")
+  const isVercelAiGateway =
+    p === "vercel-ai-gateway" || url.includes("ai-gateway.vercel.sh") || url.includes("vercel.sh")
+  const isAntLing = p === "ant-ling" || url.includes("api.ant-ling.com")
+  const isOpencode = p === "opencode" || url.includes("opencode.ai")
+  const isNonStandard =
+    isNvidia ||
+    isCerebras ||
+    isXai ||
+    isTogether ||
+    isChutes ||
+    isDeepSeek ||
+    isZai ||
+    isMoonshot ||
+    isOpencode ||
+    isCloudflareWorkersAI ||
+    isCloudflareAiGateway ||
+    isVercelAiGateway ||
+    isAntLing
+  return !isNonStandard
+}
+
+const detectSupportsUsageInStreaming = (): boolean => true
+
+const detectSupportsStrictMode = (provider: string, baseURL: string | undefined): boolean => {
+  const p = provider.toLowerCase()
+  const url = (baseURL ?? "").toLowerCase()
+  const isMoonshot = p === "moonshotai" || p === "moonshotai-cn" || url.includes("api.moonshot.")
+  const isTogether = p === "togetherai" || p === "together" || url.includes("api.together.")
+  const isCloudflareAiGateway = p === "cloudflare-ai-gateway" || url.includes("gateway.ai.cloudflare.com")
+  const isNvidia = p === "nvidia" || url.includes("integrate.api.nvidia.com")
+  return !isMoonshot && !isTogether && !isCloudflareAiGateway && !isNvidia
+}
+
+const detectZaiToolStream = (provider: string, baseURL: string | undefined, modelID: string): boolean => {
+  const p = provider.toLowerCase()
+  const url = (baseURL ?? "").toLowerCase()
+  const isZai =
+    p === "zai" ||
+    p === "zai-coding-plan" ||
+    p === "zhipuai" ||
+    p === "zhipuai-coding-plan" ||
+    url.includes("api.z.ai") ||
+    url.includes("open.bigmodel.cn")
+  if (!isZai) return false
+  const id = modelID.toLowerCase()
+  if (id === "glm-4.5" || id === "glm-4.5-air" || id === "glm-4.5-flash" || id === "glm-4.5v") return false
+  return true
+}
+
+const lowerOptions = (request: LLMRequest, supportsStore: boolean) => {
  const options = OpenAIOptions.resolve(request)
+  // Default off: strict providers 400 on unknown body fields, so only send
+  // the key where compatibility explicitly allows it. Header-based affinity
+  // (x-session-affinity, x-grok-conv-id, ...) is unaffected.
+  const cacheKey =
+    (request.model.compatibility?.supportsPromptCacheKey ?? false) ? ProviderShared.promptCacheKey(request) : undefined
  return {
-    ...(options.store !== undefined ? { store: options.store } : {}),
-    ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
+    ...(supportsStore && options.store !== undefined ? { store: options.store } : {}),
+    // For providers that support `store`, ensure stateless `store:false` is sent
+    // even when no explicit `providerOptions.store` was supplied, mirroring the
+    // native OpenAI Chat default. Non-standard providers omit `store` entirely.
+    ...(supportsStore && options.store === undefined ? { store: false } : {}),
+    ...(cacheKey ? { prompt_cache_key: cacheKey } : {}),
    ...(options.reasoningEffort ? { reasoning_effort: options.reasoningEffort } : {}),
  }
 }
@@ -531,23 +737,40 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
    )
  const generation = request.generation
  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  const maxTokensField = request.model.compatibility?.maxTokensField ?? "max_tokens"
+  const flattened = ProviderShared.flattenToolRequest(request)
+  const provider = String(request.model.provider)
+  const baseURL = request.model.route.endpoint.baseURL
+  const detectedMaxTokensField = detectMaxTokensField(provider, baseURL)
+  const maxTokensField = request.model.compatibility?.maxTokensField ?? detectedMaxTokensField
+  const supportsStore = request.model.compatibility?.supportsStore ?? detectSupportsStore(provider, baseURL)
+  const supportsUsageInStreaming =
+    request.model.compatibility?.supportsUsageInStreaming ?? detectSupportsUsageInStreaming()
+  const supportsStrictMode =
+    request.model.compatibility?.supportsStrictMode ?? detectSupportsStrictMode(provider, baseURL)
+  const zaiToolStream =
+    request.model.compatibility?.zaiToolStream ?? detectZaiToolStream(provider, baseURL, request.model.id)
+  const hasHistory = hasToolHistory(request.messages)
+  const hasActiveTools = flattened.tools.length > 0
  return {
    model: request.model.id,
-    messages: yield* lowerMessages(request, options),
+    messages: yield* lowerMessages(flattened.request, options),
    tools:
-      request.tools.length === 0
-        ? undefined
-        : request.tools.map((tool) =>
+      flattened.tools.length === 0
+        ? hasHistory
+          ? []
+          : undefined
+        : flattened.tools.map((tool) =>
            lowerTool(
              tool,
              ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
              options,
+              supportsStrictMode,
            ),
          ),
-    tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
+    tool_choice: hasActiveTools && request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
    stream: true as const,
-    stream_options: { include_usage: true },
+    ...(supportsUsageInStreaming ? { stream_options: { include_usage: true } } : {}),
+    ...(zaiToolStream && hasActiveTools ? { tool_stream: true } : {}),
    ...(maxTokensField === "max_completion_tokens"
      ? { max_completion_tokens: generation?.maxTokens }
      : { max_tokens: generation?.maxTokens }),
@@ -557,7 +780,7 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
    presence_penalty: generation?.presencePenalty,
    seed: generation?.seed,
    stop: generation?.stop,
-    ...lowerOptions(request),
+    ...lowerOptions(request, supportsStore),
  }
 })

@@ -567,25 +790,58 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
 // Streaming parsers are small state machines: every event returns a new state
 // plus the common `LLMEvent`s produced by that event. Tool calls are accumulated
 // because OpenAI streams JSON arguments across multiple deltas.
-const mapFinishReason = (reason: string | null | undefined): FinishReason => {
-  if (reason === "stop") return "stop"
-  if (reason === "length") return "length"
-  if (reason === "content_filter") return "content-filter"
-  if (reason === "function_call" || reason === "tool_calls") return "tool-calls"
-  if (reason === "error") return "error"
-  return "unknown"
-}
+const mapFinishReason = Effect.fn("OpenAIChat.mapFinishReason")(function* (event: OpenAIChatEvent, reason: string) {
+  switch (reason) {
+    case "error":
+      return yield* new AIError({
+        reason: new UnknownProviderError({
+          message: "Provider reported an error (finish_reason: error)",
+          body: ProviderShared.encodeJson(event),
+        }),
+      })
+    case "network_error":
+      return yield* new AIError({
+        reason: new ProviderInternalError({
+          message: "Provider reported a network error (finish_reason: network_error)",
+          body: ProviderShared.encodeJson(event),
+        }),
+      })
+    case "stop":
+    case "end":
+      return "stop" as const
+    case "length":
+      return "length" as const
+    case "content_filter":
+      return "content-filter" as const
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls" as const
+    default:
+      return yield* new AIError({
+        reason: new UnknownProviderError({
+          message: `Provider finish_reason: ${reason}`,
+          body: ProviderShared.encodeJson(event),
+        }),
+      })
+  }
+})

 // OpenAI Chat reports `prompt_tokens` (inclusive total) with a
 // cached-read and cache-write subsets, and `completion_tokens` (inclusive
 // total) with a `reasoning_tokens` subset. We pass the inclusive totals
 // through and derive the non-cached breakdown so the `AI.Usage` contract is
 // satisfied on both sides.
-const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
+// Providers differ on cache-hit location: OpenAI uses
+// `prompt_tokens_details.cached_tokens`, DeepSeek uses
+// `prompt_cache_hit_tokens`, and Zai uses top-level `cached_tokens`.
+const mapUsage = (usage: OpenAIChatEvent["usage"], providerMetadataKey: string): Usage | undefined => {
  if (!usage) return undefined
  const input = usage.prompt_tokens ?? undefined
  const output = usage.completion_tokens ?? undefined
-  const cached = usage.prompt_tokens_details?.cached_tokens ?? undefined
+  const cached = (usage.prompt_tokens_details?.cached_tokens ??
+    (usage as { prompt_cache_hit_tokens?: number | null }).prompt_cache_hit_tokens ??
+    (usage as { cached_tokens?: number | null }).cached_tokens ??
+    undefined) as number | undefined
  const cacheWrite = usage.prompt_tokens_details?.cache_write_tokens ?? undefined
  const reasoning = usage.completion_tokens_details?.reasoning_tokens ?? undefined
  const nonCached = ProviderShared.subtractTokens(input, ProviderShared.sumTokens(cached, cacheWrite))
@@ -597,7 +853,7 @@ const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
    cacheWriteInputTokens: cacheWrite,
    reasoningTokens: reasoning,
    totalTokens: ProviderShared.totalTokens(input, output, usage.total_tokens ?? undefined),
-    providerMetadata: { openai: usage },
+    providerMetadata: { [providerMetadataKey]: usage },
  })
 }

@@ -671,8 +927,12 @@ const conflictingReasoningTextDetails = (previous: Record<string, unknown>, curr
 const conflictingDetailValue = (previous: unknown, current: unknown) =>
  previous !== undefined && previous !== null && current !== undefined && current !== null && previous !== current

-const reasoningMetadata = (field: ParserState["reasoningField"], details?: ReadonlyArray<unknown>) => ({
-  openai: {
+const reasoningMetadata = (
+  providerMetadataKey: string,
+  field: ParserState["reasoningField"],
+  details?: ReadonlyArray<unknown>,
+) => ({
+  [providerMetadataKey]: {
    ...(field ? { reasoningField: field } : {}),
    ...(details ? { reasoningDetails: details } : {}),
  },
@@ -680,24 +940,32 @@ const reasoningMetadata = (field: ParserState["reasoningField"], details?: Reado

 const step = (state: ParserState, event: OpenAIChatEvent) =>
  Effect.gen(function* () {
-    if (event.error)
+    if (event.error) {
+      const body = ProviderShared.encodeJson(event)
      return yield* new AIError({
-        module: ADAPTER,
-        method: "stream",
        reason: classifyProviderFailure({
          message: event.error.message,
-          code: event.error.code === undefined || event.error.code === null ? undefined : String(event.error.code),
          status: typeof event.error.code === "number" ? event.error.code : undefined,
+          rawBody: body,
        }),
      })
+    }
    const events: LLMEvent[] = []
-    const usage = mapUsage(event.usage) ?? state.usage
    const choice = event.choices?.[0]
+    // Moonshot (and a few other OpenAI-compatible providers) attach usage to
+    // `choice.usage` instead of the top-level `usage` field.
+    const choiceUsage = (choice as unknown as { usage?: OpenAIChatEvent["usage"] })?.usage
+    const usage =
+      mapUsage(event.usage, state.providerMetadataKey) ??
+      (choiceUsage ? mapUsage(choiceUsage, state.providerMetadataKey) : undefined) ??
+      state.usage
    const rawFinishReason = choice?.finish_reason
-    const finishReason =
-      rawFinishReason !== undefined && rawFinishReason !== null
-        ? { normalized: mapFinishReason(rawFinishReason), raw: choice?.native_finish_reason ?? rawFinishReason }
-        : state.finishReason
+    const finishReason = rawFinishReason
+      ? {
+          normalized: yield* mapFinishReason(event, rawFinishReason),
+          raw: choice?.native_finish_reason ?? rawFinishReason,
+        }
+      : state.finishReason
    const delta = choice?.delta
    const toolDeltas = delta?.tool_calls ?? []
    let tools = state.tools
@@ -716,7 +984,11 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
      toolDeltas.some((tool) => Boolean(tool.id) || Boolean(tool.function?.name) || Boolean(tool.function?.arguments))
    if (state.finishReason !== undefined) {
      if (hasLateContent)
-        return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat received content after the finish reason")
+        return yield* ProviderShared.eventError(
+          ADAPTER,
+          "OpenAI Chat received content after the finish reason",
+          ProviderShared.encodeJson(event),
+        )
      return [{ ...state, usage }, events] as const
    }

@@ -724,7 +996,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(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 (
@@ -735,25 +1007,12 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
      lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata)
    const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0")

-    if (delta?.content) {
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined),
-      )
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
-    }
+    // Reasoning is one response-wide channel: it stays open alongside text and
+    // refusal output so late reasoning deltas and details join the same block,
+    // and `finishEvents` closes it once with the complete metadata.
+    if (delta?.content) lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)

-    if (delta?.refusal) {
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined),
-      )
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.refusal)
-    }
+    if (delta?.refusal) lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.refusal)

    // Compatible providers may omit indexes. Prefer durable identity, then use
    // batch position for parallel deltas or the latest call for sparse chunks.
@@ -788,24 +1047,45 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
        { id: id || undefined, name: name || undefined, text },
        "OpenAI Chat tool call delta is missing id or name",
      )
-      if (ToolStream.isError(result)) return yield* result
+      if (ToolStream.isError(result))
+        return yield* new AIError({
+          reason: AIErrorReason.make({
+            ...result.reason,
+            message: result.message,
+            cause: result.reason.cause,
+            body: ProviderShared.encodeJson(event),
+          }),
+        })
      tools = result.tools
      if (result.events.length) lifecycle = Lifecycle.stepStart(lifecycle, events)
      events.push(...result.events)
    }

-    if (finishReason !== undefined && state.finishReason === undefined && Object.keys(pendingTools).length > 0)
-      return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat tool call delta is missing id or name")
+    const incompleteTools = finishReason?.normalized === "content-filter" || finishReason?.normalized === "length"
+    if (
+      finishReason !== undefined &&
+      !incompleteTools &&
+      state.finishReason === undefined &&
+      Object.keys(pendingTools).length
+    )
+      return yield* ProviderShared.eventError(
+        ADAPTER,
+        "OpenAI Chat tool call delta is missing id or name",
+        ProviderShared.encodeJson(event),
+      )

-    // Finalize accumulated tool inputs eagerly when finish_reason arrives so
-    // valid calls and malformed local calls settle independently.
+    // Filtering or truncation terminates the response without confirming pending tool calls.
    const finished =
-      finishReason !== undefined && state.finishReason === undefined && Object.keys(tools).length > 0
+      finishReason !== undefined &&
+      !incompleteTools &&
+      state.finishReason === undefined &&
+      Object.keys(tools).length > 0
        ? yield* ToolStream.finishAll(ADAPTER, tools)
        : undefined

    return [
      {
+        providerMetadataKey: state.providerMetadataKey,
        tools: finished?.tools ?? tools,
        pendingTools,
        toolCallEvents: finished?.events ?? state.toolCallEvents,
@@ -818,16 +1098,25 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
        reasoningEmitted,
        latestToolIndex,
        nextToolIndex,
+        requireFinishReason: state.requireFinishReason,
      },
      events,
    ] as const
  })

-const finishEvents = (state: ParserState): ReadonlyArray<LLMEvent> => {
+const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state: ParserState) {
+  if (state.finishReason === undefined && state.requireFinishReason)
+    return yield* new AIError({
+      reason: new InvalidProviderOutputError({
+        message: "OpenAI Chat stream ended without finish_reason",
+        classification: "incomplete-stream",
+        route: ADAPTER,
+      }),
+    })
  const events: LLMEvent[] = []
  const toolCallEvents =
    state.finishReason === undefined && Object.keys(state.tools).length > 0
-      ? Effect.runSync(ToolStream.finishAll(ADAPTER, state.tools)).events
+      ? (yield* ToolStream.finishAll(ADAPTER, state.tools)).events
      : state.toolCallEvents
  const hasToolCalls = toolCallEvents.length > 0
  const reason = state.finishReason
@@ -836,21 +1125,29 @@ const finishEvents = (state: ParserState): ReadonlyArray<LLMEvent> => {
        normalized:
          state.finishReason.normalized === "stop" && hasToolCalls ? "tool-calls" : state.finishReason.normalized,
      }
-    : { normalized: hasToolCalls ? ("tool-calls" as const) : ("unknown" as const) }
+    : { normalized: hasToolCalls ? ("tool-calls" as const) : ("stop" as const) }
+  // Snapshot details at publish time so the emitted event never observes later
+  // mutation of the accumulated `reasoningDetails` array.
  const metadata = reasoningMetadata(
+    state.providerMetadataKey,
    state.reasoningField,
-    state.reasoningDetailsObserved ? state.reasoningDetails : undefined,
+    state.reasoningDetailsObserved ? [...state.reasoningDetails] : undefined,
  )
  const started =
    state.reasoningDetailsObserved && !state.reasoningEmitted
-      ? Lifecycle.reasoningStart(state.lifecycle, events, "reasoning-0", reasoningMetadata(state.reasoningField))
+      ? Lifecycle.reasoningStart(
+          state.lifecycle,
+          events,
+          "reasoning-0",
+          reasoningMetadata(state.providerMetadataKey, state.reasoningField),
+        )
      : state.lifecycle
  const ended = Lifecycle.reasoningEnd(started, events, "reasoning-0", metadata)
  const lifecycle = toolCallEvents.length ? Lifecycle.stepStart(ended, events) : ended
  events.push(...toolCallEvents)
  Lifecycle.finish(lifecycle, events, { reason, usage: state.usage })
  return events
-}
+})

 // =============================================================================
 // Protocol And OpenAI Route
@@ -868,8 +1165,9 @@ export const protocol = Protocol.make({
    from: fromRequest,
  },
  stream: {
-    event: Protocol.jsonEvent(OpenAIChatEvent),
+    event: OpenAIChatStreamEvent,
    initial: (request) => ({
+      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
      tools: ToolStream.empty<number>(),
      pendingTools: {},
      toolCallEvents: [],
@@ -879,13 +1177,16 @@ export const protocol = Protocol.make({
      reasoningDetailsObserved: false,
      reasoningEmitted: false,
      nextToolIndex: 0,
+      requireFinishReason: request.model.compatibility?.requireFinishReason ?? true,
    }),
-    step,
+    step: (state: ParserState, event) => (event === DONE ? Effect.succeed([state, []] as const) : step(state, event)),
+    terminal: (event) => event === DONE,
    onHalt: finishEvents,
  },
 })

-export const httpTransport = HttpTransport.sseJson.with<OpenAIChatBody>()
+export const framing = Framing.sseWithDone
+export const httpTransport = HttpTransport.sseJson.with<OpenAIChatBody>().with({ framing })

 export const route = Route.make({
  id: ADAPTER,
@@ -1,6 +1,5 @@
 import { Route, type RouteRoutedLanguageModelInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { Framing } from "../route/framing.js"
 import * as OpenAIChat from "./openai-chat.js"

 const ADAPTER = "openai-compatible-chat"
@@ -19,7 +18,7 @@ export const route = Route.make({
  providerMetadataKey: "openai",
  protocol: OpenAIChat.protocol,
  endpoint: Endpoint.path("/chat/completions"),
-  framing: Framing.sse,
+  framing: OpenAIChat.framing,
 })

 export * as OpenAICompatibleChat from "./openai-compatible-chat.js"
@@ -17,6 +17,7 @@ export const route = Route.make({
  protocol: OpenResponses.protocol,
  endpoint: Endpoint.path(OpenResponses.PATH),
  transport: OpenResponses.httpTransport,
+  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 })

 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js"
@@ -1,50 +1,39 @@
-import { Effect, Encoding, Schema } from "effect"
-import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import {
-  ImageModel,
-  GeneratedImage,
-  ImageResponse,
-  type ImageInput,
-  type ImageRequestFor,
-  type ImageRoute,
-} from "../image.js"
-import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
-import {
-  InvalidProviderOutputReason,
-  AIError,
-  Usage,
-  mergeHttpOptions,
-  mergeJsonRecords,
-  type HttpOptions,
-} from "../schema/index.js"
+import { Effect, Schema } from "effect"
+import type { HttpClientResponse } from "effect/unstable/http"
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js"
+import { Media } from "../media.js"
+import { MediaProtocol } from "../route/media-protocol.js"
+import { MediaRoute } from "../route/media.js"
+import { ProviderID, mergeJsonRecords, type AIError } from "../schema/index.js"
 import { ProviderShared } from "./shared.js"
-import { ImageInputs } from "./utils/image-input.js"
-import { OpenAIImage } from "./utils/openai-image.js"
+import { MediaInput } from "./utils/media-input.js"

 const ADAPTER = "openai-images"
+const NAME = "OpenAI Images"
+const PROVIDER = ProviderID.make("openai")
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/images/generations"
 export const EDIT_PATH = "/images/edits"

+// ---------------------------------------------------------------------------
+// 1. Public model input
+// ---------------------------------------------------------------------------
+
 export type OpenAIImageString<Known extends string> = Known | (string & {})

+/** Provider-native options. Common fields (`n`, `size`, `format`, `images`, `mask`) live on the request. */
 export type OpenAIImageOptions = {
-  readonly mask?: ImageInput
-  readonly n?: number
-  readonly size?: OpenAIImageString<
-    "auto" | "256x256" | "512x512" | "1024x1024" | "1536x1024" | "1024x1536" | "1792x1024" | "1024x1792"
-  >
  readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">
  readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">
  readonly moderation?: OpenAIImageString<"auto" | "low">
-  readonly outputFormat?: OpenAIImageString<"png" | "jpeg" | "webp">
  readonly outputCompression?: number
 } & Record<string, unknown>

-export type OpenAIImageBody = Record<string, unknown> & {
-  readonly model: string
-  readonly prompt: string
-}
+export type Request = ImageRequestFor<OpenAIImageOptions>
+
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------

 const OpenAIImageResponse = Schema.Struct({
  data: Schema.Array(
@@ -66,205 +55,153 @@ const OpenAIImageResponse = Schema.Struct({
  ),
 })

-export interface ModelInput {
-  readonly id: string
-  readonly auth: AuthDefinition
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions
-}
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+
+/** Multipart field names the route owns; `http.body` overlays cannot smuggle replacements for them. */
+const RESERVED_FORM_FIELDS = new Set(["model", "prompt", "image", "image[]", "images", "mask"])

 const nativeOptions = (options: OpenAIImageOptions | undefined) => {
  if (!options) return undefined
-  const { mask: _, outputFormat, outputCompression, ...native } = options
-  return {
-    output_format: outputFormat,
-    output_compression: outputCompression,
-    ...native,
-  }
+  const { outputCompression, ...native } = options
+  return { output_compression: outputCompression, ...native }
 }

-const invalidOutput = (message: string) =>
-  new AIError({
-    module: ADAPTER,
-    method: "generate",
-    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
-  })
+const isEdit = (request: Request) => (request.images?.length ?? 0) > 0

-const applyQuery = (url: string, query: Record<string, string> | undefined) => {
-  if (!query) return url
-  const next = new URL(url)
-  Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value))
-  return next.toString()
-}
+const isInline = (asset: Media.Asset) => asset.inline() !== undefined

-export const model = (input: ModelInput) => {
-  const route: ImageRoute<OpenAIImageOptions> = {
-    id: ADAPTER,
-    generate: Effect.fn("OpenAIImages.generate")(function* (request: ImageRequestFor<OpenAIImageOptions>, execute) {
-      const mask = request.options?.mask
-      if (mask !== undefined && (request.images?.length ?? 0) === 0)
-        return yield* ImageInputs.invalid(ADAPTER, "An OpenAI image mask requires at least one input image")
-      const http = mergeHttpOptions(request.model.http, request.http)
-      const sourceImages = request.images ?? []
-      const multipartImages = yield* Effect.forEach(sourceImages, (image) => {
-        if (image.type === "bytes") return Effect.succeed({ data: image.data, mediaType: image.mediaType })
-        if (image.type === "url") return ImageInputs.decodeDataUrl(image.url, ADAPTER)
-        return Effect.undefined
-      })
-      const multipartMask =
-        mask === undefined
-          ? undefined
-          : mask.type === "bytes"
-            ? { data: mask.data, mediaType: mask.mediaType }
-            : mask.type === "url"
-              ? yield* ImageInputs.decodeDataUrl(mask.url, ADAPTER)
-              : undefined
-      const useMultipart =
-        sourceImages.length > 0 &&
-        multipartImages.every((image) => image !== undefined) &&
-        (mask === undefined || multipartMask !== undefined)
-      const path = sourceImages.length === 0 ? PATH : EDIT_PATH
-      const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${path}`, http?.query)
-
-      if (useMultipart) {
-        const form = new FormData()
-        form.append("model", request.model.id)
-        form.append("prompt", request.prompt)
-        Object.entries(mergeJsonRecords(nativeOptions(request.options), http?.body) ?? {}).forEach(([key, value]) => {
-          if (["model", "prompt", "image", "image[]", "images", "mask"].includes(key)) return
-          form.append(key, typeof value === "string" ? value : ProviderShared.encodeJson(value))
-        })
-        multipartImages.forEach((image, index) => {
-          if (image === undefined) return
-          form.append("image[]", imageBlob(image.data, image.mediaType), `image-${index}`)
-        })
-        if (multipartMask !== undefined)
-          form.append("mask", imageBlob(multipartMask.data, multipartMask.mediaType), "mask")
-        const headers = yield* Auth.toEffect(input.auth)({
-          request,
-          method: "POST",
-          url,
-          body: "[multipart/form-data]",
-          headers: Headers.remove(Headers.fromInput({ ...input.headers, ...http?.headers }), "content-type"),
-        })
-        const response = yield* execute(
-          HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyFormData(form)),
-        )
-        return yield* parseResponse(response, request.options, http?.body)
-      }
-
-      const references = sourceImages.map((image) => {
-        if (image.type === "bytes") return { image_url: ImageInputs.dataUrl(image) }
-        if (image.type === "url") return { image_url: image.url }
-        if (image.type === "file-id") return { file_id: image.id }
-        return undefined
-      })
-      if (references.some((image) => image === undefined))
-        return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts image URLs, data URLs, bytes, and file IDs")
-      const maskReference =
-        mask === undefined
-          ? undefined
-          : mask.type === "bytes"
-            ? { image_url: ImageInputs.dataUrl(mask) }
-            : mask.type === "url"
-              ? { image_url: mask.url }
-              : mask.type === "file-id"
-                ? { file_id: mask.id }
-                : undefined
-      if (mask !== undefined && maskReference === undefined)
-        return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts masks as URLs, data URLs, bytes, or file IDs")
-      const requestBody = mergeJsonRecords(
-        {
-          model: request.model.id,
-          prompt: request.prompt,
-          images: references.length === 0 ? undefined : references,
-          mask: maskReference,
-        },
-        nativeOptions(request.options),
-        http?.body,
-      ) as OpenAIImageBody
-      const text = ProviderShared.encodeJson(requestBody)
-      const headers = yield* Auth.toEffect(input.auth)({
-        request,
-        method: "POST",
-        url,
-        body: text,
-        headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-      })
-      const response = yield* execute(
-        HttpClientRequest.post(url).pipe(
-          HttpClientRequest.setHeaders(headers),
-          HttpClientRequest.bodyText(text, "application/json"),
-        ),
-      )
-      return yield* parseResponse(response, request.options, http?.body)
-    }),
-  }
-  return ImageModel.make<OpenAIImageOptions>({ id: input.id, provider: "openai", route, http: input.http })
-}
-
-const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (
-  response: HttpClientResponse.HttpClientResponse,
-  options: OpenAIImageOptions | undefined,
-  overlay: Record<string, unknown> | undefined,
-) {
-  const payload = yield* response.json.pipe(
-    Effect.mapError(() => invalidOutput("Failed to read the OpenAI Images response")),
-  )
-  const decoded = yield* Schema.decodeUnknownEffect(OpenAIImageResponse)(payload).pipe(
-    Effect.mapError(() => invalidOutput("OpenAI Images returned an invalid response")),
-  )
-  const requestBody = mergeJsonRecords(nativeOptions(options), overlay)
-  const format =
-    decoded.output_format ?? (typeof requestBody?.output_format === "string" ? requestBody.output_format : "png")
-  const images = yield* Effect.forEach(decoded.data, (item, index) => {
-    if (item.b64_json)
-      return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
-        Effect.mapError(() => invalidOutput(`OpenAI Images result ${index} contains invalid base64 data`)),
-        Effect.map(
-          (data) =>
-            new GeneratedImage({
-              mediaType: `image/${format}`,
-              data,
-              providerMetadata:
-                item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
-            }),
-        ),
-      )
-    if (item.url)
-      return Effect.succeed(
-        new GeneratedImage({
-          mediaType: `image/${format}`,
-          data: item.url,
-          providerMetadata:
-            item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
-        }),
-      )
-    return Effect.fail(invalidOutput(`OpenAI Images result ${index} has neither image data nor a URL`))
-  })
-  if (images.length === 0) return yield* invalidOutput("OpenAI Images returned no images")
-  return new ImageResponse({
-    images,
-    usage:
-      decoded.usage === undefined
-        ? undefined
-        : new Usage({
-            inputTokens: decoded.usage.input_tokens,
-            outputTokens: decoded.usage.output_tokens,
-            totalTokens: decoded.usage.total_tokens,
-            providerMetadata: { openai: decoded.usage },
-          }),
-    providerMetadata: { openai: { outputFormat: format } },
-  })
-})
-
-const imageBlob = (data: Uint8Array, mediaType: string) => {
+const blob = (data: Uint8Array, mediaType: string) => {
  const buffer = new ArrayBuffer(data.byteLength)
  new Uint8Array(buffer).set(data)
  return new Blob([buffer], { type: mediaType })
 }

+const reference = (asset: Media.Asset): Effect.Effect<Record<string, unknown>, AIError> => {
+  const inline = asset.inline()
+  if (inline) return Effect.succeed({ image_url: inline.dataUrl })
+  const url = ProviderShared.mediaUrl(asset)
+  if (url) return Effect.succeed({ image_url: url })
+  const id = MediaInput.refID(asset, PROVIDER)
+  if (id) return Effect.succeed({ file_id: id })
+  return Effect.fail(
+    ProviderShared.invalidRequest("OpenAI Images accepts image URLs, data URLs, bytes, and OpenAI file IDs"),
+  )
+}
+
+const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request: Request) {
+  const images = request.images ?? []
+  const mask = request.mask
+  if (mask !== undefined && images.length === 0)
+    return yield* ProviderShared.invalidRequest("An OpenAI image mask requires at least one input image")
+  const fields = mergeJsonRecords(
+    { n: request.n, size: request.size, output_format: request.format },
+    nativeOptions(request.providerOptions),
+    request.http?.body,
+  )
+
+  // Owned bytes go through multipart edits; remote URLs and file IDs use the JSON edits body instead.
+  if (images.length > 0 && images.every(isInline) && (mask === undefined || isInline(mask))) {
+    const form = new FormData()
+    form.append("model", request.model.id)
+    form.append("prompt", request.prompt)
+    Object.entries(fields ?? {}).forEach(([key, value]) => {
+      if (RESERVED_FORM_FIELDS.has(key)) return
+      form.append(key, typeof value === "string" ? value : ProviderShared.encodeJson(value))
+    })
+    const uploads = yield* Effect.forEach(images, (image) => MediaInput.inlineBytes(ADAPTER, image))
+    uploads.forEach((data, index) => form.append("image[]", blob(data, images[index].mediaType), `image-${index}`))
+    if (mask !== undefined)
+      form.append("mask", blob(yield* MediaInput.inlineBytes(ADAPTER, mask), mask.mediaType), "mask")
+    return MediaProtocol.multipart(form)
+  }
+
+  const references = yield* Effect.forEach(images, reference)
+  const maskReference = mask === undefined ? undefined : yield* reference(mask)
+  return MediaProtocol.json(
+    mergeJsonRecords(
+      {
+        model: request.model.id,
+        prompt: request.prompt,
+        images: references.length === 0 ? undefined : references,
+        mask: maskReference,
+      },
+      fields,
+    ) ?? {},
+  )
+})
+
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+
+const requestedFormat = (body: MediaProtocol.Body) => {
+  const value = body.type === "json" ? body.value.output_format : body.value.get("output_format")
+  return typeof value === "string" ? value : undefined
+}
+
+const decodeResponse = Effect.fn("OpenAIImages.decodeResponse")(function* (
+  response: HttpClientResponse.HttpClientResponse,
+  context: MediaProtocol.DecodeContext<Request>,
+) {
+  const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, OpenAIImageResponse)(response)
+  const decoded = output.value
+  const format = decoded.output_format ?? requestedFormat(context.body) ?? "png"
+  const mediaType = `image/${format}`
+  const images = yield* Effect.forEach(decoded.data, (item, index) => {
+    const providerMetadata =
+      item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } }
+    if (item.b64_json)
+      return MediaInput.decodedAsset(output.invalid, `${NAME} result ${index}`, item.b64_json, mediaType, {
+        info: { format },
+        providerMetadata,
+      })
+    if (item.url) return Effect.succeed(Media.url(item.url, { mediaType, info: { format }, providerMetadata }))
+    return Effect.fail(output.invalid(`${NAME} result ${index} has neither image data nor a URL`))
+  })
+  if (images.length === 0) return yield* output.invalid(`${NAME} returned no images`)
+  return new ImageResponse({
+    images,
+    usage:
+      decoded.usage === undefined
+        ? undefined
+        : {
+            type: "tokens",
+            input: decoded.usage.input_tokens,
+            output: decoded.usage.output_tokens,
+            total: decoded.usage.total_tokens,
+            details: { openai: decoded.usage },
+          },
+    providerMetadata: { openai: { outputFormat: format } },
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+
+export const protocol = MediaProtocol.inline<Request, ImageResponse>({
+  id: ADAPTER,
+  name: NAME,
+  unsupported: ["aspectRatio", "seed"],
+  body: { from: fromRequest },
+  response: { decode: decodeResponse },
+})
+
+export const model = (input: MediaRoute.ModelInput) =>
+  ImageModel.fromRoute<OpenAIImageOptions>(
+    {
+      id: ADAPTER,
+      provider: PROVIDER,
+      protocol,
+      baseURL: DEFAULT_BASE_URL,
+      path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH),
+    },
+    input,
+  )
+
 export const OpenAIImages = {
+  protocol,
  model,
 } as const
@@ -5,13 +5,17 @@ import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { HttpTransport } from "../route/transport/index.js"
-import { LLMRequest, type JsonSchema, type ToolDefinition } from "../schema/index.js"
+import { LLMRequest, mergeJsonRecords, type JsonSchema, type ToolDefinition, type ToolEntry } from "../schema/index.js"
+import { resolveEffortUpdates } from "../effort-updates.js"
 import { OpenResponses } from "./open-responses.js"
-import { optionalArray, ProviderShared } from "./shared.js"
+import { OpenResponsesOptions } from "./utils/open-responses-options.js"
+import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { OpenAIImage } from "./utils/openai-image.js"
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { OpenResponsesChannel } from "./open-responses-channel.js"
+import { ResponsesCompaction } from "./utils/responses-compaction.js"
+import { ResponsesCheckpoint } from "./utils/responses-checkpoint.js"

 const ADAPTER = "openai-responses"
 const NAME = "OpenAI Responses"
@@ -20,6 +24,14 @@ const WEBSOCKET_ROTATE_AFTER_MS = 55 * 60 * 1000
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = OpenResponses.PATH

+export const ContextManagement = Schema.Array(
+  Schema.Struct({
+    type: Schema.Literal("compaction"),
+    compactThreshold: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),
+  }),
+)
+export type ContextManagement = typeof ContextManagement.Type
+
 const OpenAIResponsesImageGenerationTool = Schema.Struct({
  type: Schema.tag("image_generation"),
  action: Schema.optional(Schema.Literals(["auto", "generate", "edit"])),
@@ -32,17 +44,77 @@ const OpenAIResponsesImageGenerationTool = Schema.Struct({
  size: Schema.optional(OpenAIImage.Size),
 })

-const OpenAIResponsesTools = Schema.Union([OpenResponses.Tool, OpenAIResponsesImageGenerationTool])
+const OpenAIResponsesHostedToolItem = Schema.Union([
+  Schema.StructWithRest(
+    Schema.Struct({
+      type: Schema.tag("computer_call"),
+      id: Schema.String,
+      status: Schema.optional(Schema.String),
+      call_id: Schema.optional(Schema.String),
+      action: optionalNull(JsonObject),
+      pending_safety_checks: Schema.optional(Schema.Array(JsonObject)),
+    }),
+    [JsonObject],
+  ),
+  Schema.StructWithRest(
+    Schema.Struct({
+      type: Schema.tag("web_search_preview_call"),
+      id: Schema.String,
+      status: Schema.optional(Schema.String),
+      action: optionalNull(JsonObject),
+    }),
+    [JsonObject],
+  ),
+  Schema.StructWithRest(
+    Schema.Struct({
+      type: Schema.tag("image_generation_call"),
+      id: Schema.String,
+      status: Schema.optional(Schema.String),
+      result: optionalNull(Schema.String),
+      output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
+      revised_prompt: optionalNull(Schema.String),
+    }),
+    [JsonObject],
+  ),
+])
+
+const OpenAIResponsesNamespace = Schema.Struct({
+  type: Schema.tag("namespace"),
+  name: Schema.String,
+  description: Schema.String,
+  tools: Schema.Array(OpenResponses.Tool),
+})
+
+const OpenAIResponsesTools = Schema.Union([
+  OpenResponses.Tool,
+  OpenAIResponsesNamespace,
+  OpenAIResponsesImageGenerationTool,
+])

 const OpenAIResponsesToolChoice = Schema.Union([
  OpenResponses.ToolChoice,
  Schema.Struct({ type: Schema.tag("image_generation") }),
 ])

+const OpenAIResponsesInputItem = Schema.Union([
+  OpenResponses.InputItem,
+  OpenAIResponsesHostedToolItem,
+  OpenResponses.ConfigurationUpdate,
+])
+
 const OpenAIResponsesCoreFields = {
  ...OpenResponses.coreFields,
+  input: Schema.Array(OpenAIResponsesInputItem),
  tools: optionalArray(OpenAIResponsesTools),
  tool_choice: Schema.optional(OpenAIResponsesToolChoice),
+  context_management: Schema.optional(
+    Schema.Array(
+      Schema.Struct({
+        type: Schema.Literal("compaction"),
+        compact_threshold: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),
+      }),
+    ),
+  ),
 }

 const OpenAIResponsesBody = Schema.Struct({
@@ -51,10 +123,31 @@ const OpenAIResponsesBody = Schema.Struct({
 })
 export type OpenAIResponsesBody = Schema.Schema.Type<typeof OpenAIResponsesBody>

-const extension = {
+/** Request control, never conversation content. */
+export const CompactionTrigger = Schema.Struct({ type: Schema.Literal("compaction_trigger") })
+const CheckpointBody = Schema.Struct({
+  ...OpenAIResponsesBody.fields,
+  input: Schema.Array(Schema.Union([OpenAIResponsesInputItem, CompactionTrigger])),
+  store: Schema.Literal(false),
+  prompt_cache_retention: optionalNull(Schema.String),
+  prompt_cache_options: optionalNull(
+    Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) }),
+  ),
+})
+
+const adapter = {
  id: ADAPTER,
  name: NAME,
-} satisfies OpenResponses.Extension
+  restoreHostedToolItem: (item: unknown) => (Schema.is(OpenAIResponsesHostedToolItem)(item) ? item : undefined),
+} satisfies OpenResponses.ProviderAdapter
+
+// Only GPT-6 Astra accepts `configuration_update`, and never alongside automatic `context_management` compaction.
+const supportsEffortUpdates = (request: LLMRequest) => {
+  if (request.providerOptions?.contextManagement !== undefined) return false
+  const override = request.model.compatibility?.supportsEffortUpdates
+  if (override !== undefined) return override
+  return /(?:^|\/)gpt-6-astra$/i.test(request.model.id)
+}

 const nativeImageToolInput = (tool: ToolDefinition) => {
  const native = tool.native?.openai
@@ -75,41 +168,98 @@ const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool: ToolDe
  return yield* OpenResponses.lowerTool(NAME, tool, inputSchema)
 })

-const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolDefinition>) =>
+// Native namespaces hold only function tools, so deeper levels flatten into
+// the leaf names the same way non-native protocols flatten the whole tree.
+const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (
+  tool: ToolEntry,
+  compatibility: Parameters<typeof ToolSchemaProjection.modelCompatibility>[1],
+) {
+  if (tool.type === "tool")
+    return yield* lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, compatibility))
+  // OpenAI requires a namespace description; fall back to a generic one so a
+  // missing description never blocks the request.
+  return {
+    type: "namespace" as const,
+    name: tool.name,
+    description: tool.description ?? `Tools in the ${tool.name} namespace.`,
+    tools: yield* Effect.forEach(ProviderShared.flattenTools(tool.tools), (leaf) =>
+      OpenResponses.lowerTool(NAME, leaf, ToolSchemaProjection.modelCompatibility(leaf.inputSchema, compatibility)),
+    ),
+  }
+})
+
+const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolEntry>) =>
  ProviderShared.matchToolChoice(NAME, toolChoice, {
    auto: () => "auto" as const,
    none: () => "none" as const,
    required: () => "required" as const,
    tool: (name) =>
-      tools.some((tool) => tool.name === name && nativeImageTool(tool) !== undefined)
+      tools.some((tool) => tool.type === "tool" && tool.name === name && nativeImageTool(tool) !== undefined)
        ? ({ type: "image_generation" } as const)
        : { type: "function" as const, name },
  })

+const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIResponsesBody))
+
 const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request: LLMRequest) {
-  const body = yield* OpenResponses.fromRequestWithExtension(
-    LLMRequest.update(request, { tools: [], toolChoice: undefined }),
-    extension,
-  )
+  const management = yield* ProviderShared.validateWith(
+    Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)),
+  )(request.providerOptions?.contextManagement)
+  const options = OpenResponsesOptions.resolve(request)
+  const updates = resolveEffortUpdates(request, options.reasoningEffort)
  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  return {
-    ...body,
+  return yield* decodeBody({
+    ...(yield* OpenResponses.lowerConversation(updates.request, adapter)),
+    ...OpenResponses.lowerGeneration(request, { ...options, reasoningEffort: updates.effort }),
+    context_management: management?.map((edit) => ({ type: edit.type, compact_threshold: edit.compactThreshold })),
    tools:
      request.tools.length === 0
        ? undefined
-        : yield* Effect.forEach(request.tools, (tool) =>
-            lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
-          ),
+        : yield* Effect.forEach(request.tools, (tool) => lowerToolEntry(tool, toolSchemaCompatibility)),
    tool_choice:
-      body.tool_choice ?? (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),
-  } satisfies OpenAIResponsesBody
+      request.tools.length === 0
+        ? undefined
+        : (OpenResponses.allowedToolChoice(request) ??
+          (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined)),
+  })
 })

+const checkpointBody = {
+  schema: CheckpointBody,
+  from: Effect.fn("OpenAIResponses.checkpointBody")(function* (request: LLMRequest) {
+    const native = yield* fromRequest(LLMRequest.update(request, { toolChoice: undefined }))
+    const overlay = request.http?.body
+    // Complete history is required for stateless replay and SSE recovery. Raw input overrides bypass that contract.
+    if (
+      overlay?.input !== undefined ||
+      overlay?.previous_response_id !== undefined ||
+      overlay?.conversation !== undefined
+    )
+      return yield* ProviderShared.invalidRequest(
+        "Trigger compaction requires complete canonical history, not an input or continuation override",
+      )
+    return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(CheckpointBody))({
+      ...mergeJsonRecords(native, overlay),
+      input: [...native.input, { type: "compaction_trigger" }],
+      stream: true,
+      store: false,
+      parallel_tool_calls: true,
+      tool_choice: undefined,
+      context_management: undefined,
+      text: undefined,
+      max_output_tokens: undefined,
+      max_tool_calls: undefined,
+    })
+  }),
+}
+
 const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item: ResponsesHostedTools.Item) {
  const isError = item.error !== undefined && item.error !== null
  if (item.type === "image_generation_call" && item.result) {
    yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(
-      Effect.mapError(() => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64")),
+      Effect.mapError((cause) =>
+        ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64", undefined, cause),
+      ),
    )
    const format = item.output_format ?? "png"
    return {
@@ -134,24 +284,20 @@ const HOSTED_TOOLS = {
    name: "code_interpreter",
    input: (item) => ({ code: item.code, container_id: item.container_id }),
  },
-  computer_use_call: { name: "computer_use", input: (item) => item.action ?? {} },
+  computer_call: { name: "computer_use", input: (item) => item.action ?? {} },
  image_generation_call: { name: "image_generation", input: () => ({}), result: hostedToolResult },
  mcp_call: {
    name: "mcp",
    input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
  },
-  local_shell_call: { name: "local_shell", input: (item) => item.action ?? {} },
 } as const satisfies ResponsesHostedTools.Definitions

-const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
-  if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")
-    return event.item_id
+const step = (state: OpenResponses.ParserState, input: OpenResponses.Event) => {
+  const event = OpenResponses.normalize(state, input)
+  if (event.type === "response.reasoning_text.delta")
+    return event.item_id !== undefined
      ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
      : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
-  if (event.type === "response.reasoning_text.done" || event.type === "response.reasoning_summary.done")
-    return event.item_id
-      ? Effect.succeed(OpenResponses.onReasoningDone(state, event))
-      : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
  if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
    return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
  return OpenResponses.step(state, event)
@@ -165,10 +311,11 @@ export const protocol = Protocol.make({
  },
  stream: {
    event: OpenResponses.protocol.stream.event,
-    initial: (request) => OpenResponses.initial(request, extension),
+    initial: (request) => OpenResponses.initial(request, adapter),
    step,
    terminal: OpenResponses.terminal,
  },
+  supportsEffortUpdates,
 })

 const endpoint = Endpoint.path<OpenAIResponsesBody>(PATH, { baseURL: DEFAULT_BASE_URL })
@@ -184,6 +331,7 @@ export const transport = channelTransport({
 })

 export const route = Route.make({
+  compact: { endpoint: ResponsesCompaction.make(adapter), trigger: ResponsesCheckpoint.make(checkpointBody) },
  id: ADAPTER,
  provider: "openai",
  providerMetadataKey: "openai",
@@ -191,7 +339,7 @@ export const route = Route.make({
  endpoint,
  auth,
  transport,
-  defaults: { providerOptions: { store: false } },
+  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 })

 export * as OpenAIResponses from "./openai-responses.js"
@@ -1,16 +1,21 @@
-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 } from "effect/unstable/http"
+import { Media } from "../media.js"
 import {
-  InvalidProviderOutputReason,
-  InvalidRequestReason,
+  InvalidProviderOutputError,
+  InvalidRequestError,
+  UnsupportedOperationError,
  AIError,
+  LLMRequest,
+  Message,
+  ToolDefinition,
  type ContentPart,
-  type LLMRequest,
  type MediaPart,
+  type ProviderID,
  type TextPart,
+  type ToolEntry,
  type ToolResultPart,
 } from "../schema/index.js"
 import { isRecord } from "../utils/record.js"
@@ -24,6 +29,17 @@ export const JsonObject = Schema.Record(Schema.String, Schema.Unknown)
 export const optionalArray = <const S extends Schema.Top>(schema: S) => Schema.optional(Schema.Array(schema))
 export const optionalNull = <const S extends Schema.Top>(schema: S) => Schema.optional(Schema.NullOr(schema))

+export const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64
+
+// OpenAI limits `prompt_cache_key` to 64 chars; DeepSeek and Zai inherit the same
+// limit via their OpenAI-compatible APIs. Clamp with unicode-aware slicing.
+export const promptCacheKey = (request: LLMRequest): string | undefined => {
+  if (request.cache === "none" || request.promptCacheKey === undefined) return undefined
+  const chars = Array.from(request.promptCacheKey)
+  if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH) return request.promptCacheKey
+  return chars.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH).join("")
+}
+
 /**
 * Streaming tool-call accumulator. Adapters that build a tool call across
 * multiple `tool-input-delta` chunks store the partial JSON input string here
@@ -32,6 +48,7 @@ export const optionalNull = <const S extends Schema.Top>(schema: S) => Schema.op
 export interface ToolAccumulator {
  readonly id: string
  readonly name: string
+  readonly namespace?: string
  readonly input: string
 }

@@ -85,17 +102,15 @@ export const sumTokens = (...values: ReadonlyArray<number | undefined>): number
  return values.reduce((acc: number, value) => acc + (value ?? 0), 0)
 }

-export const eventError = (route: string, message: string, raw?: string) =>
+export const eventError = (route: string, message: string, body?: string, cause?: unknown) =>
  new AIError({
-    module: "ProviderShared",
-    method: "stream",
-    reason: new InvalidProviderOutputReason({ route, message, raw }),
+    reason: new InvalidProviderOutputError({ route, message, body, cause }),
  })

 export const parseJson = (route: string, input: string, message: string) =>
  Effect.try({
    try: () => decodeJson(input),
-    catch: () => eventError(route, message, input),
+    catch: (cause) => eventError(route, message, input, cause),
  })

 /**
@@ -153,24 +168,33 @@ export const wrappedSystemUpdate = Effect.fn("ProviderShared.wrappedSystemUpdate
 export const parseToolInput = (route: string, name: string, raw: string) =>
  parseJson(route, raw || "{}", `Invalid JSON input for ${route} tool call ${name}`)

-export interface NormalizedMedia {
-  readonly mime: string
-  readonly base64: string
-  readonly dataUrl: string
+/** Inline view or a typed `InvalidRequest` for routes that cannot fetch URLs or dereference provider refs. */
+export const requireInlineMedia = (route: string, asset: Media.Asset): Effect.Effect<Media.Inline, AIError> => {
+  const inline = asset.inline()
+  return inline ? Effect.succeed(inline) : Effect.fail(inlineRequired(route, asset))
 }

-export const normalizeMedia = (part: MediaPart): NormalizedMedia => {
-  const mime = part.mediaType.toLowerCase()
-  if (typeof part.data !== "string") {
-    const base64 = Buffer.from(part.data).toString("base64")
-    return { mime, base64, dataUrl: `data:${mime};base64,${base64}` }
-  }
-  if (!part.data.startsWith("data:")) return { mime, base64: part.data, dataUrl: `data:${mime};base64,${part.data}` }
-  return { mime, base64: part.data.slice(part.data.indexOf(",") + 1), dataUrl: part.data }
-}
+export const inlineRequired = (route: string, asset: Media.Asset) =>
+  invalidRequest(
+    `${route} requires inline media (bytes or base64); ${asset.source.type} sources must be materialized first`,
+  )

-export const normalizeToolFile = (part: Tool.FileContent) =>
-  normalizeMedia({ type: "media", mediaType: part.mime, data: part.uri, filename: part.name })
+/** The remote URL of a `url` asset, for protocols that accept `http(s)` references natively. */
+export const mediaUrl = (asset: Media.Asset) => (asset.source.type === "url" ? asset.source.url : undefined)
+
+/**
+ * Lift a tool-result file into a `MediaPart`. Tool files carry either a data URL, an `http(s)` URL, or raw base64 in
+ * `uri`; the declared `mime` wins over any data-URL prefix so tool authors control the type the model sees.
+ */
+export const toolFileMedia = (item: Tool.FileContent): MediaPart => {
+  const parsed = Media.parseDataUrl(item.uri)
+  const asset = parsed
+    ? Media.from({ ...parsed.source, mediaType: item.mime })
+    : /^https?:\/\//.test(item.uri)
+      ? Media.url(item.uri, { mediaType: item.mime })
+      : Media.base64(item.uri, item.mime)
+  return Message.media(asset, { filename: item.name })
+}

 export const trimBaseUrl = (value: string) => value.replace(/\/+$/, "")

@@ -197,27 +221,41 @@ export const errorText = (error: unknown) => {

 /**
 * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty / `[DONE]`
- * keep-alive events so the protocol event schema sees one JSON string per
- * element. The SSE channel emits a
- * `Retry` control event on its error channel; we drop it here (we don't
- * implement client-driven retries). Decoder failures become provider output
- * errors so the public error channel stays `AIError`.
+ * decoder, optionally filters named events, and drops empty events. `[DONE]`
+ * is dropped by default or retained for protocols that use it as their stream
+ * boundary. Retry control events are ignored without interrupting the stream.
+ * Decoder failures become provider output errors so the public error channel
+ * stays `AIError`.
 */
 export const sseFraming = (
  bytes: Stream.Stream<Uint8Array, AIError>,
  events?: ReadonlySet<string>,
+  includeDone = false,
 ): Stream.Stream<string, AIError> =>
  bytes.pipe(
    Stream.decodeText(),
-    Stream.pipeThroughChannel(Sse.decode()),
-    Stream.catchTag("Retry", () => Stream.empty),
-    Stream.catchTag("SseError", (error) => Stream.fail(eventError("sse", error.message))),
+    Stream.mapAccumEffect(
+      () => {
+        const output: Sse.Event[] = []
+        return {
+          output,
+          parser: Sse.makeParser((event) => {
+            if (event._tag === "Event") output.push(event)
+          }),
+        }
+      },
+      (state, chunk) =>
+        Effect.gen(function* () {
+          const error = state.parser.feed(chunk)
+          if (error) return yield* eventError("sse", error.message, chunk, error)
+          return [state, state.output.splice(0)] as const
+        }),
+    ),
    Stream.filter(
      (event) =>
        (events === undefined || events.has(event.event)) &&
        event.data.length > 0 &&
-        (event.data !== "[DONE]" || (events !== undefined && event.event !== "message")),
+        (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message")),
    ),
    Stream.map((event) => event.data),
  )
@@ -225,13 +263,66 @@ export const sseFraming = (
 /**
 * Canonical invalid-request constructor shared by protocol lowering.
 */
-export const invalidRequest = (message: string) =>
+export const invalidRequest = (message: string, cause?: unknown) =>
  new AIError({
-    module: "ProviderShared",
-    method: "request",
-    reason: new InvalidRequestReason({ message }),
+    reason: new InvalidRequestError({ message, cause }),
  })

+/**
+ * Canonical constructor for operations the selected route does not implement.
+ * Prefer this over `invalidRequest` when the failure is a missing route
+ * capability rather than a malformed caller input, so consumers can branch on
+ * `reason._tag` plus `reason.operation` instead of matching message text.
+ */
+export const unsupportedOperation = (input: {
+  readonly operation: string
+  readonly message: string
+  readonly provider?: ProviderID
+  readonly route?: string
+  readonly cause?: unknown
+}) =>
+  new AIError({
+    reason: new UnsupportedOperationError({
+      operation: input.operation,
+      message: input.message,
+      provider: input.provider,
+      route: input.route,
+      cause: input.cause,
+    }),
+  })
+
+/**
+ * Lower namespaces to flat definitions for protocols without a native
+ * namespace construct. Leaf names join their namespace path with `_` because
+ * `.` is not broadly accepted in provider tool names.
+ */
+export const flattenTools = (tools: ReadonlyArray<ToolEntry>, path: ReadonlyArray<string> = []) => {
+  const flat = tools.flatMap((tool): ReadonlyArray<ToolDefinition> => {
+    if (tool.type === "namespace") return flattenTools(tool.tools, [...path, tool.name])
+    if (path.length === 0) return [tool]
+    return [new ToolDefinition({ ...tool, name: [...path, tool.name].join("_") })]
+  })
+  return [...new Map(flat.map((tool) => [tool.name, tool])).values()]
+}
+
+export const flattenToolRequest = (request: LLMRequest) => {
+  const messages = request.messages.map((message) => {
+    const content = message.content.map((part) => {
+      if ((part.type !== "tool-call" && part.type !== "tool-result") || part.namespace === undefined) return part
+      return { ...part, name: `${part.namespace}_${part.name}`, namespace: undefined }
+    })
+    return content.every((part, index) => part === message.content[index])
+      ? message
+      : new Message({ ...message, content })
+  })
+  return {
+    tools: flattenTools(request.tools),
+    request: messages.every((message, index) => message === request.messages[index])
+      ? request
+      : LLMRequest.update(request, { messages }),
+  }
+}
+
 export const matchToolChoice = <Auto, None, Required, Tool>(
  route: string,
  toolChoice: NonNullable<LLMRequest["toolChoice"]>,
@@ -278,7 +369,7 @@ export const unsupportedContent = (
 export const validateWith =
  <A, I, E extends { readonly message: string }>(decode: (input: I) => Effect.Effect<A, E>) =>
  (payload: I) =>
-    decode(payload).pipe(Effect.mapError((error) => invalidRequest(error.message)))
+    decode(payload).pipe(Effect.mapError((error) => invalidRequest(error.message, error)))

 /**
 * Build an HTTP POST with a JSON body. Sets `content-type: application/json`
@@ -2,13 +2,12 @@ import { AwsV4Signer } from "aws4fetch"
 import { Effect } from "effect"
 import { Headers } from "effect/unstable/http"
 import { Auth, type AuthInput } from "../../route/auth.js"
+import { AIError, AuthenticationError } from "../../schema/index.js"
 import { ProviderShared } from "../shared.js"

 /**
 * AWS credentials for SigV4 signing. Bedrock also supports Bearer API key auth,
- * which provider facades configure as route auth instead of SigV4. STS-vended
- * credentials should be refreshed by the consumer (rebuild the model) before
- * they expire; the route does not refresh.
+ * which provider facades configure as route auth instead of SigV4.
 */
 export interface Credentials {
  readonly region: string
@@ -17,6 +16,44 @@ export interface Credentials {
  readonly sessionToken?: string
 }

+/** Static credentials or an effect resolved before every request. */
+export type CredentialSource = Credentials | Effect.Effect<Credentials, AIError>
+
+export interface DefaultChainOptions {
+  readonly region: string
+  /** Shared config profile passed to the AWS default chain. */
+  readonly profile?: string
+}
+
+/**
+ * Resolve credentials through the AWS default provider chain: environment
+ * variables, shared config and SSO caches, web identity tokens, process
+ * credentials, and container or instance metadata. A fresh chain runs on every
+ * request so credentials rotated on disk without an expiration (for example
+ * shared-config keys rewritten by a corporate SSO tool) are always re-read;
+ * the SDK's own memoization would otherwise pin them for the process lifetime.
+ */
+export const defaultChain = (options: DefaultChainOptions): Effect.Effect<Credentials, AIError> =>
+  Effect.tryPromise({
+    try: async () => {
+      const { fromNodeProviderChain } = await import("@aws-sdk/credential-providers")
+      const identity = await fromNodeProviderChain(options.profile === undefined ? {} : { profile: options.profile })()
+      return {
+        region: options.region,
+        accessKeyId: identity.accessKeyId,
+        secretAccessKey: identity.secretAccessKey,
+        ...(identity.sessionToken === undefined ? {} : { sessionToken: identity.sessionToken }),
+      }
+    },
+    catch: (error) =>
+      new AIError({
+        reason: new AuthenticationError({
+          message: `AWS default credential chain failed: ${ProviderShared.errorText(error)}`,
+          cause: error,
+        }),
+      }),
+  })
+
 const signRequest = (input: {
  readonly url: string
  readonly body: string
@@ -48,16 +85,17 @@ const signRequest = (input: {

 /** Sign the exact JSON bytes with SigV4 using credentials configured on the route. */
 export const sigV4 = (
-  credentials: Credentials | undefined,
+  source: CredentialSource | undefined,
  options: { readonly service?: string; readonly name?: string } = {},
 ) =>
  Auth.custom((input: AuthInput) => {
    return Effect.gen(function* () {
-      if (!credentials) {
+      if (!source) {
        return yield* ProviderShared.invalidRequest(
          `${options.name ?? "Bedrock Converse"} requires either route bearer auth or AWS credentials configured on the route`,
        )
      }
+      const credentials = Effect.isEffect(source) ? yield* source : source
      const headersForSigning = Headers.set(input.headers, "content-type", "application/json")
      const signed = yield* signRequest({
        url: input.url,
@@ -74,4 +112,35 @@ export const sigV4 = (
 /** Bedrock route auth defaults to SigV4 and expects credentials from route configuration. */
 export const auth = sigV4(undefined)

+export const resolveRegion = (input: {
+  readonly region?: string
+  readonly credentials?: { readonly region: string }
+}) =>
+  input.region ?? input.credentials?.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1"
+
+export interface ResolveAuthInput {
+  readonly apiKey?: string
+  readonly credentials?: Credentials
+  readonly profile?: string
+}
+
+export interface ResolveAuthOptions {
+  readonly service?: string
+  readonly name?: string
+  /** `sigv4` ignores an ambient `AWS_BEARER_TOKEN_BEDROCK`; `bearer` is validated by the caller. */
+  readonly mode?: "bearer" | "sigv4"
+}
+
+/**
+ * Bearer wins over SigV4 and explicit static credentials win over the default
+ * chain, matching the AWS SDK's own precedence for `AWS_BEARER_TOKEN_BEDROCK`.
+ * The region is applied to the SigV4 scope so it always matches the endpoint host.
+ */
+export const resolveAuth = (input: ResolveAuthInput, region: string, options: ResolveAuthOptions = {}) => {
+  const apiKey = options.mode === "sigv4" ? undefined : (input.apiKey ?? process.env.AWS_BEARER_TOKEN_BEDROCK)
+  if (apiKey !== undefined) return Auth.bearer(apiKey)
+  if (input.credentials !== undefined) return sigV4({ ...input.credentials, region }, options)
+  return sigV4(defaultChain({ region, profile: input.profile }), options)
+}
+
 export * as BedrockAuth from "./bedrock-auth.js"
@@ -1,6 +1,6 @@
 import { Schema } from "effect"
 import type { CacheHint } from "../../schema/index.js"
-import { newBreakpoints, ttlBucket, type Breakpoints } from "./cache.js"
+import { newBreakpoints, ttlBucket } from "./cache.js"

 // Bedrock cache markers are positional: emit a `cachePoint` block immediately
 // after the content the caller wants treated as a cacheable prefix. Bedrock
@@ -13,24 +13,46 @@ export const CachePointBlock = Schema.Struct({
 })
 export type CachePointBlock = Schema.Schema.Type<typeof CachePointBlock>

-// Callers pass a shared counter through every `block()` call site so the
-// four-breakpoint budget is respected across `system`, `messages`, and `tools`.
+const LEGACY_CLAUDE = ["anthropic.claude-instant", "anthropic.claude-v1", "anthropic.claude-v2", "anthropic.claude-3-"]
+
+// These legacy Claude releases support explicit caching, but only for five minutes.
+const CLAUDE_5M = [
+  "anthropic.claude-3-5-sonnet-20241022-v2:0",
+  "anthropic.claude-3-5-haiku-20241022-v1:0",
+  "anthropic.claude-3-7-sonnet-20250219-v1:0",
+  "anthropic.claude-sonnet-4-20250514-v1:0",
+  "anthropic.claude-opus-4-20250514-v1:0",
+  "anthropic.claude-opus-4-1-20250805-v1:0",
+]
+
+// Callers share the four-breakpoint budget across system, messages, and tools.
 export const BEDROCK_BREAKPOINT_CAP = 4

-export type { Breakpoints } from "./cache.js"
-export const breakpoints = () => newBreakpoints(BEDROCK_BREAKPOINT_CAP)
+export const breakpoints = (modelID: string) => {
+  // Substring matching also handles regional prefixes and model-bearing ARNs.
+  const short = CLAUDE_5M.some((id) => modelID.includes(id))
+  return {
+    ...newBreakpoints(BEDROCK_BREAKPOINT_CAP),
+    // Assume modern Claude releases retain caching support; older generations need an explicit exception.
+    // Other model families use implicit caching where available.
+    supported: modelID.includes("anthropic.claude-") && (short || !LEGACY_CLAUDE.some((id) => modelID.includes(id))),
+    ttl1h: !short,
+  }
+}
+export type Breakpoints = ReturnType<typeof breakpoints>

 const DEFAULT_5M: CachePointBlock = { cachePoint: { type: "default" } }
 const DEFAULT_1H: CachePointBlock = { cachePoint: { type: "default", ttl: "1h" } }

 export const block = (breakpoints: Breakpoints, cache: CacheHint | undefined): CachePointBlock | undefined => {
+  if (!breakpoints.supported) return undefined
  if (cache?.type !== "ephemeral" && cache?.type !== "persistent") return undefined
  if (breakpoints.remaining <= 0) {
    breakpoints.dropped += 1
    return undefined
  }
  breakpoints.remaining -= 1
-  return ttlBucket(cache.ttlSeconds) === "1h" ? DEFAULT_1H : DEFAULT_5M
+  return breakpoints.ttl1h && ttlBucket(cache.ttlSeconds) === "1h" ? DEFAULT_1H : DEFAULT_5M
 }

 export * as BedrockCache from "./bedrock-cache.js"
@@ -1,4 +1,4 @@
-import { Effect, Schema } from "effect"
+import { Effect, Encoding, Schema } from "effect"
 import type { MediaPart } from "../../schema/index.js"
 import { ProviderShared } from "../shared.js"

@@ -57,28 +57,64 @@ const documentBlock = (name: string, format: DocumentFormat, bytes: string): Doc
  },
 })

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

 export * as BedrockMedia from "./bedrock-media.js"
@@ -1,34 +0,0 @@
-import { Effect, Encoding } from "effect"
-import type { ImageInput } from "../../image.js"
-import { InvalidRequestReason, AIError } from "../../schema/index.js"
-
-const invalid = (module: string, message: string) =>
-  new AIError({
-    module,
-    method: "generate",
-    reason: new InvalidRequestReason({ message }),
-  })
-
-export const dataUrl = (input: Extract<ImageInput, { readonly type: "bytes" }>) =>
-  `data:${input.mediaType};base64,${Encoding.encodeBase64(input.data)}`
-
-export const decodeDataUrl = (
-  url: string,
-  module: string,
-): Effect.Effect<{ readonly mediaType: string; readonly data: Uint8Array } | undefined, AIError> => {
-  if (!url.startsWith("data:")) return Effect.undefined
-  const match = /^data:([^;,]+);base64,(.*)$/s.exec(url)
-  if (!match) return Effect.fail(invalid(module, "Image data URLs must contain a MIME type and base64 data"))
-  return Effect.fromResult(Encoding.decodeBase64(match[2])).pipe(
-    Effect.mapError(() => invalid(module, "Image data URL contains invalid base64 data")),
-    Effect.map((data) => ({ mediaType: match[1], data })),
-  )
-}
-
-export const invalidImageInput = invalid
-
-export const ImageInputs = {
-  dataUrl,
-  decodeDataUrl,
-  invalid: invalidImageInput,
-} as const
@@ -62,22 +62,31 @@ export const reasoningEnd = (
  events: LLMEvent[],
  id: string,
  providerMetadata?: ProviderMetadata,
+  /** Authoritative complete value; replaces accumulated deltas when present. */
+  text?: string,
 ): State => {
  if (!state.reasoning.has(id)) return state
  const stepped = stepStart(state, events)
-  events.push(LLMEvent.reasoningEnd({ id, providerMetadata }))
+  events.push(LLMEvent.reasoningEnd({ id, text, providerMetadata }))
  const reasoning = new Set(stepped.reasoning)
  reasoning.delete(id)
  return { ...stepped, reasoning }
 }

-export const textEnd = (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata): State => {
+export const textEnd = (
+  state: State,
+  events: LLMEvent[],
+  id: string,
+  providerMetadata?: ProviderMetadata,
+  /** Authoritative complete value; replaces accumulated deltas when present. */
+  text?: string,
+): State => {
  if (!state.text.has(id)) return state
  const stepped = stepStart(state, events)
-  events.push(LLMEvent.textEnd({ id, providerMetadata }))
-  const text = new Set(stepped.text)
-  text.delete(id)
-  return { ...stepped, text }
+  events.push(LLMEvent.textEnd({ id, text, providerMetadata }))
+  const open = new Set(stepped.text)
+  open.delete(id)
+  return { ...stepped, text: open }
 }

 const closeOpenBlocks = (state: State, events: LLMEvent[]): State => {
@@ -0,0 +1,33 @@
+import { Effect, Encoding } from "effect"
+import { Media } from "../../media.js"
+import type { AIError, ProviderID } from "../../schema/index.js"
+import { ProviderShared } from "../shared.js"
+
+/** Owned bytes for multipart uploads; decodes `base64` sources and rejects remote sources. */
+export const inlineBytes = (route: string, asset: Media.Asset): Effect.Effect<Uint8Array, AIError> => {
+  if (asset.source.type === "bytes") return Effect.succeed(asset.source.data)
+  const inline = asset.inline()
+  if (!inline) return Effect.fail(ProviderShared.inlineRequired(route, asset))
+  return Effect.fromResult(Encoding.decodeBase64(inline.base64)).pipe(
+    Effect.mapError((cause) => ProviderShared.invalidRequest(`${route} media contains invalid base64 data`, cause)),
+  )
+}
+
+/** Provider file handle when the ref belongs to this provider; refs from other providers are never forwarded. */
+export const refID = (asset: Media.Asset, provider: ProviderID) =>
+  asset.source.type === "ref" && asset.source.provider === provider ? asset.source.id : undefined
+
+/** Decode a provider's base64 output once into an owned `bytes` asset, sniffing the type when it is not declared. */
+export const decodedAsset = (
+  invalid: (message: string, cause?: unknown) => AIError,
+  label: string,
+  data: string,
+  mediaType: string | undefined,
+  options?: Media.AssetOptions,
+) =>
+  Effect.fromResult(Encoding.decodeBase64(data)).pipe(
+    Effect.mapError((cause) => invalid(`${label} contains invalid base64 data`, cause)),
+    Effect.map((bytes) => Media.bytes(bytes, mediaType, options)),
+  )
+
+export * as MediaInput from "./media-input.js"
@@ -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"
@@ -0,0 +1,34 @@
+import type { LLMRequest } from "../../schema/index.js"
+
+export const valid = /^[A-Za-z0-9]{9}$/
+
+export const hash = (value: string) => {
+  const hash = (seed: number) => {
+    let result = seed
+    for (const char of value) result = Math.imul(result ^ char.charCodeAt(0), 16777619)
+    return (result >>> 0).toString(36)
+  }
+  return `${hash(2166136261).padStart(7, "0")}${hash(2246822519).padStart(7, "0")}`.slice(-9)
+}
+
+export const normalizer = (request: LLMRequest) => {
+  const ids = request.messages.flatMap((message) =>
+    message.content.flatMap((part) => (part.type === "tool-call" || part.type === "tool-result" ? [part.id] : [])),
+  )
+  // Reserve valid IDs before projecting any history, including IDs encountered later.
+  const used = new Set(ids.filter((id) => valid.test(id)))
+  const normalized = new Map<string, string>()
+  return (id: string) => {
+    if (valid.test(id)) return id
+    const previous = normalized.get(id)
+    if (previous) return previous
+    let attempt = 0
+    let candidate = hash(id)
+    while (used.has(candidate)) candidate = hash(`${id}:${++attempt}`)
+    used.add(candidate)
+    normalized.set(id, candidate)
+    return candidate
+  }
+}
+
+export * as MistralToolID from "./mistral-tool-id.js"
@@ -1,12 +1,7 @@
 import { Option, Schema } from "effect"
-import type { LLMRequest } from "../../schema/index.js"
+import { ReasoningEffort, ReasoningEfforts, type LLMRequest } from "../../schema/index.js"

-export const ReasoningEfforts = ["none", "minimal", "low", "medium", "high", "xhigh", "max"] as const
-export type ReasoningEffort = (typeof ReasoningEfforts)[number] | (string & {})
-export const ReasoningEffort = Schema.declare<ReasoningEffort>(
-  (value): value is ReasoningEffort => typeof value === "string",
-  { title: "ReasoningEffort" },
-)
+export { ReasoningEffort, ReasoningEfforts }

 export const TextVerbosities = ["low", "medium", "high"] as const
 export type TextVerbosity = (typeof TextVerbosities)[number] | (string & {})
@@ -28,7 +23,10 @@ export const ResponseIncludables = [
 export type ResponseIncludable = (typeof ResponseIncludables)[number] | (string & {})

 export const ServiceTiers = ["auto", "default", "flex", "priority"] as const
-export type ServiceTier = (typeof ServiceTiers)[number]
+export type ServiceTier = (typeof ServiceTiers)[number] | (string & {})
+export const ServiceTier = Schema.declare<ServiceTier>((value): value is ServiceTier => typeof value === "string", {
+  title: "ServiceTier",
+})

 export const Truncations = ["auto", "disabled"] as const
 export type Truncation = (typeof Truncations)[number]
@@ -38,7 +36,7 @@ export const ResponseIncludableSchema = Schema.declare<ResponseIncludable>(
  (value): value is ResponseIncludable => typeof value === "string",
  { title: "ResponseIncludable" },
 )
-export const ServiceTierSchema = Schema.Literals(ServiceTiers)
+export const ServiceTierSchema = ServiceTier
 export const TruncationSchema = Schema.Literals(Truncations)

 export const AllowedTools = Schema.Struct({
@@ -52,7 +50,6 @@ export const StreamOptions = Schema.Struct({
 })

 export const Options = Schema.Struct({
-  instructions: Schema.optional(Schema.String),
  store: Schema.optional(Schema.Boolean),
  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
  safetyIdentifier: Schema.optional(Schema.String),
@@ -9,8 +9,8 @@ export type OpenAITextVerbosity = OpenResponsesOptions.TextVerbosity
 // in lockstep with `openai-node/src/resources/responses/responses.ts`.
 export const OpenAIResponseIncludables = OpenResponsesOptions.ResponseIncludables
 export type OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludable
-export const OpenAIServiceTiers = OpenResponsesOptions.ServiceTiers
-export type OpenAIServiceTier = OpenResponsesOptions.ServiceTier
+export const OpenAIServiceTiers = [...OpenResponsesOptions.ServiceTiers, "scale"] as const
+export type OpenAIServiceTier = (typeof OpenAIServiceTiers)[number] | (string & {})

 export const OpenAIReasoningEffort = OpenResponsesOptions.ReasoningEffort
 export const OpenAITextVerbosity = OpenResponsesOptions.TextVerbosity
@@ -0,0 +1,64 @@
+/*
+ * Adapted from partial-json by the Promplate Dev Team:
+ * https://github.com/promplate/partial-json-parser-js/blob/main/src/options.ts
+ * Licensed under the MIT License; see partial-json.ts for the complete notice.
+ */
+
+/**
+ * allow partial strings like `"hello \u12` to be parsed as `"hello `
+ */
+export const STR = 0b000000001
+
+/**
+ * allow partial numbers like `123.` to be parsed as `123`
+ */
+export const NUM = 0b000000010
+
+/**
+ * allow partial arrays like `[1, 2,` to be parsed as `[1, 2]`
+ */
+export const ARR = 0b000000100
+
+/**
+ * allow partial objects like `{"a": 1, "b":` to be parsed as `{"a": 1}`
+ */
+export const OBJ = 0b000001000
+
+/**
+ * allow `nu` to be parsed as `null`
+ */
+export const NULL = 0b000010000
+
+/**
+ * allow `tr` to be parsed as `true`, and `fa` to be parsed as `false`
+ */
+export const BOOL = 0b000100000
+
+/**
+ * allow `Na` to be parsed as `NaN`
+ */
+export const NAN = 0b001000000
+
+/**
+ * allow `Inf` to be parsed as `Infinity`
+ */
+export const INFINITY = 0b010000000
+
+/**
+ * allow `-Inf` to be parsed as `-Infinity`
+ */
+export const _INFINITY = 0b100000000
+
+export const INF = INFINITY | _INFINITY
+export const SPECIAL = NULL | BOOL | INF | NAN
+export const ATOM = STR | NUM | SPECIAL
+export const COLLECTION = ARR | OBJ
+export const ALL = ATOM | COLLECTION
+
+/**
+ * Control what types you allow to be partially parsed.
+ * The default is to allow all types to be partially parsed, which in most cases is the best option.
+ */
+export const Allow = { STR, NUM, ARR, OBJ, NULL, BOOL, NAN, INFINITY, _INFINITY, INF, SPECIAL, ATOM, COLLECTION, ALL }
+
+export default Allow
@@ -0,0 +1,282 @@
+/*
+ * Adapted from partial-json by the Promplate Dev Team:
+ * https://github.com/promplate/partial-json-parser-js
+ *
+ * MIT License
+ *
+ * Copyright (c) 2023 Promplate Dev Team
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Schema } from "effect"
+import { Allow } from "./partial-json-options.js"
+export * from "./partial-json-options.js"
+
+export class PartialJSON extends Error {}
+export class MalformedJSON extends Error {}
+
+const decodeJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown))
+
+/** Parse complete or incomplete JSON, restricted by the supplied partial-value flags. */
+export function parseJSON(jsonString: string, allowPartial = Allow.ALL): unknown {
+  if (typeof jsonString !== "string") throw new TypeError(`expecting str, got ${typeof jsonString}`)
+  const input = jsonString.trim()
+  if (!input) throw new Error(`${jsonString} is empty`)
+  try {
+    return decodeJson(input)
+  } catch {}
+
+  const repaired = repairJSON(input)
+  if (repaired !== input) {
+    try {
+      return decodeJson(repaired)
+    } catch {}
+  }
+
+  try {
+    return _parseJSON(input, allowPartial)
+  } catch (error) {
+    if (repaired !== input) return _parseJSON(repaired, allowPartial)
+    throw error
+  }
+}
+
+const repairJSON = (input: string) => {
+  let repaired = ""
+  let quoted = false
+
+  for (let index = 0; index < input.length; index++) {
+    const character = input[index]
+    if (!quoted) {
+      repaired += character
+      if (character === '"') quoted = true
+      continue
+    }
+
+    if (character === '"') {
+      repaired += character
+      quoted = false
+      continue
+    }
+
+    if (character === "\\") {
+      const next = input[index + 1]
+      if (next === "u" && /^[0-9a-fA-F]{4}$/.test(input.slice(index + 2, index + 6))) {
+        repaired += input.slice(index, index + 6)
+        index += 5
+        continue
+      }
+      if (next !== undefined && '"\\/bfnrtu'.includes(next)) {
+        repaired += `\\${next}`
+        index++
+        continue
+      }
+      repaired += "\\\\"
+      continue
+    }
+
+    const code = character.charCodeAt(0)
+    repaired += code <= 0x1f ? `\\u${code.toString(16).padStart(4, "0")}` : character
+  }
+
+  return repaired
+}
+
+const _parseJSON = (jsonString: string, allow: number) => {
+  const length = jsonString.length
+  let index = 0
+
+  const markPartialJSON = (message: string): never => {
+    throw new PartialJSON(`${message} at position ${index}`)
+  }
+
+  const throwMalformedError = (message: string): never => {
+    throw new MalformedJSON(`${message} at position ${index}`)
+  }
+
+  const parseAny = (): unknown => {
+    skipBlank()
+    if (index >= length) markPartialJSON("Unexpected end of input")
+    if (jsonString[index] === '"') return parseStr()
+    if (jsonString[index] === "{") return parseObj()
+    if (jsonString[index] === "[") return parseArr()
+    if (
+      jsonString.substring(index, index + 4) === "null" ||
+      (Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index)))
+    ) {
+      index += 4
+      return null
+    }
+    if (
+      jsonString.substring(index, index + 4) === "true" ||
+      (Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index)))
+    ) {
+      index += 4
+      return true
+    }
+    if (
+      jsonString.substring(index, index + 5) === "false" ||
+      (Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index)))
+    ) {
+      index += 5
+      return false
+    }
+    if (
+      jsonString.substring(index, index + 8) === "Infinity" ||
+      (Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index)))
+    ) {
+      index += 8
+      return Infinity
+    }
+    if (
+      jsonString.substring(index, index + 9) === "-Infinity" ||
+      (Allow._INFINITY & allow &&
+        1 < length - index &&
+        length - index < 9 &&
+        "-Infinity".startsWith(jsonString.substring(index)))
+    ) {
+      index += 9
+      return -Infinity
+    }
+    if (
+      jsonString.substring(index, index + 3) === "NaN" ||
+      (Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index)))
+    ) {
+      index += 3
+      return NaN
+    }
+    return parseNum()
+  }
+
+  const parseStr = (): string => {
+    const start = index
+    let escape = false
+    index++
+    while (index < length && (jsonString[index] !== '"' || (escape && jsonString[index - 1] === "\\"))) {
+      escape = jsonString[index] === "\\" ? !escape : false
+      index++
+    }
+    if (jsonString.charAt(index) === '"') {
+      try {
+        return decodeJson(jsonString.substring(start, ++index - Number(escape))) as string
+      } catch (error) {
+        throwMalformedError(String(error))
+      }
+    }
+    if (Allow.STR & allow) {
+      try {
+        return decodeJson(`${jsonString.substring(start, index - Number(escape))}"`) as string
+      } catch {
+        return decodeJson(`${jsonString.substring(start, jsonString.lastIndexOf("\\"))}"`) as string
+      }
+    }
+    return markPartialJSON("Unterminated string literal")
+  }
+
+  const parseObj = (): Record<string, unknown> => {
+    index++
+    skipBlank()
+    const object: Record<string, unknown> = {}
+    try {
+      while (jsonString[index] !== "}") {
+        skipBlank()
+        if (index >= length && Allow.OBJ & allow) return object
+        const key = parseStr()
+        skipBlank()
+        index++
+        try {
+          Object.defineProperty(object, key, {
+            value: parseAny(),
+            enumerable: true,
+            configurable: true,
+            writable: true,
+          })
+        } catch (error) {
+          if (Allow.OBJ & allow) return object
+          throw error
+        }
+        skipBlank()
+        if (jsonString[index] === ",") index++
+      }
+    } catch {
+      if (Allow.OBJ & allow) return object
+      return markPartialJSON("Expected '}' at end of object")
+    }
+    index++
+    return object
+  }
+
+  const parseArr = (): unknown[] => {
+    index++
+    const array: unknown[] = []
+    try {
+      while (jsonString[index] !== "]") {
+        array.push(parseAny())
+        skipBlank()
+        if (jsonString[index] === ",") index++
+      }
+    } catch {
+      if (Allow.ARR & allow) return array
+      return markPartialJSON("Expected ']' at end of array")
+    }
+    index++
+    return array
+  }
+
+  const parseNum = (): unknown => {
+    if (index === 0) {
+      if (jsonString === "-") throwMalformedError("Not sure what '-' is")
+      try {
+        return decodeJson(jsonString)
+      } catch (error) {
+        if (Allow.NUM & allow) {
+          try {
+            return decodeJson(jsonString.substring(0, jsonString.lastIndexOf("e")))
+          } catch {}
+        }
+        throwMalformedError(String(error))
+      }
+    }
+
+    const start = index
+    if (jsonString[index] === "-") index++
+    while (jsonString[index] && !",]}".includes(jsonString[index])) index++
+    if (index === length && !(Allow.NUM & allow)) markPartialJSON("Unterminated number literal")
+
+    try {
+      return decodeJson(jsonString.substring(start, index))
+    } catch (error) {
+      if (jsonString.substring(start, index) === "-") markPartialJSON("Not sure what '-' is")
+      try {
+        return decodeJson(jsonString.substring(start, jsonString.lastIndexOf("e")))
+      } catch {
+        throwMalformedError(String(error))
+      }
+    }
+  }
+
+  const skipBlank = () => {
+    while (index < length && " \n\r\t".includes(jsonString[index])) index++
+  }
+
+  return parseAny()
+}
+
+export const parse = parseJSON
@@ -0,0 +1,122 @@
+import { Effect, Schema, Stream } from "effect"
+import { Route, type RouteBody, type TriggerCompactOperation } from "../../route/client.js"
+import { Protocol } from "../../route/protocol.js"
+import { CompactionCheckpointResponse, HttpOptions, LLMEvent, LLMRequest } from "../../schema/index.js"
+import { OpenResponses } from "../open-responses.js"
+import { ProviderShared } from "../shared.js"
+
+interface State {
+  readonly parser: Pick<OpenResponses.ParserState, "id" | "provider" | "outputItems">
+  readonly checkpoints: Readonly<Record<string, CompactionCheckpointResponse["checkpoint"]>>
+  readonly responseID?: string
+}
+
+const onOutputItem = Effect.fn("ResponsesCheckpoint.onOutputItem")(function* (
+  state: State,
+  input: OpenResponses.Event,
+) {
+  const event = OpenResponses.normalize(state.parser, input)
+  const item = event.item
+  if (!item) return state
+  const parser =
+    event.output_index === undefined || state.parser.outputItems[event.output_index] === item.id
+      ? state.parser
+      : { ...state.parser, outputItems: { ...state.parser.outputItems, [event.output_index]: item.id } }
+  const next = parser === state.parser ? state : { ...state, parser }
+  if (event.type === "response.output_item.added" || item.type !== "compaction") return next
+  if (
+    event.output_index !== undefined &&
+    Object.entries(state.parser.outputItems).some(
+      ([index, id]) => id === item.id && Number(index) !== event.output_index,
+    )
+  )
+    return yield* ProviderShared.eventError(parser.id, "Compaction checkpoint appeared in multiple output slots")
+  if (!item.encrypted_content)
+    return yield* ProviderShared.eventError(parser.id, "Compaction output is missing its encrypted content")
+  const previous = state.checkpoints[item.id]
+  if (previous && previous.encrypted !== item.encrypted_content)
+    return yield* ProviderShared.eventError(parser.id, "Compaction output changed after completion")
+  if (previous) return next
+  return {
+    ...next,
+    checkpoints: {
+      ...state.checkpoints,
+      [item.id]: { type: "compaction", provider: parser.provider, id: item.id, encrypted: item.encrypted_content },
+    },
+  } satisfies State
+})
+
+/** Collect a trigger response before acknowledging transport completion. No generation output escapes. */
+export const make = <Body>(body: RouteBody<Body>): TriggerCompactOperation =>
+  Effect.fn("ResponsesCheckpoint.execute")(function* (request, executor, options) {
+    const source = request.model.route
+    let result: CompactionCheckpointResponse | undefined
+    // Route registries erase the frame type. The codec validates that boundary before parsing.
+    const event: Schema.Codec<OpenResponses.Event, unknown> = OpenResponses.protocol.stream.event
+    const protocol = Protocol.make({
+      id: source.protocol,
+      body,
+      stream: {
+        event,
+        initial: (request: LLMRequest): State => ({
+          parser: { id: source.id, provider: request.model.provider, outputItems: {} },
+          checkpoints: {},
+        }),
+        terminal: OpenResponses.terminal,
+        step: Effect.fn("ResponsesCheckpoint.step")(function* (state: State, event: OpenResponses.Event) {
+          if (event.response?.id && state.responseID && event.response.id !== state.responseID)
+            return yield* ProviderShared.eventError(source.id, "Compaction response ID changed during execution")
+          if (event.type === "response.created") return [{ ...state, responseID: event.response?.id }, []] as const
+          if (event.type === "error" || event.type === "response.failed")
+            return yield* OpenResponses.providerFailure(event, "Compaction request failed")
+          if (event.type === "response.incomplete")
+            return yield* ProviderShared.eventError(source.id, "Compaction response was incomplete")
+          if (event.type === "response.output_item.added" || event.type === "response.output_item.done")
+            return [yield* onOutputItem(state, event), []] as const
+          if (event.type !== "response.completed") return [state, []] as const
+          const responseID = event.response?.id
+          if (!responseID?.trim())
+            return yield* ProviderShared.eventError(source.id, "Compaction response is missing its response ID")
+          if (event.response?.status !== undefined && event.response.status !== "completed")
+            return yield* ProviderShared.eventError(source.id, "Compaction response did not complete successfully")
+          let next = state
+          for (const [index, item] of (event.response?.output ?? []).entries()) {
+            next = yield* onOutputItem(next, { type: "response.output_item.done", output_index: index, item })
+          }
+          const checkpoints = Object.values(next.checkpoints)
+          const checkpoint = checkpoints[0]
+          if (checkpoints.length !== 1 || !checkpoint)
+            return yield* ProviderShared.eventError(
+              source.id,
+              "Compaction response must contain exactly one checkpoint",
+            )
+          result = new CompactionCheckpointResponse({
+            checkpoint,
+            responseID,
+            usage: OpenResponses.mapUsage(event.response?.usage, OpenResponses.metadataKey(request.model)),
+          })
+          return [next, [LLMEvent.finish({ reason: { normalized: "stop" } })]] as const
+        }),
+      },
+    })
+    const route = Route.make({
+      id: source.id,
+      provider: source.provider,
+      providerMetadataKey: source.providerMetadataKey,
+      protocol,
+      endpoint: source.endpoint,
+      auth: source.auth,
+      transport: source.transport,
+    })
+    const native = yield* body.from(request)
+    // The body builder already applied and validated overlays. Do not let transport reapply them.
+    const preparedRequest = LLMRequest.update(request, {
+      http: request.http === undefined ? undefined : new HttpOptions({ ...request.http, body: undefined }),
+    })
+    const prepared = yield* route.prepareTransport(native, preparedRequest, options)
+    yield* route.streamPrepared(prepared, preparedRequest, { http: executor }, options).pipe(Stream.runDrain)
+    if (!result) return yield* ProviderShared.eventError(source.id, "Compaction response ended without a checkpoint")
+    return result
+  })
+
+export * as ResponsesCheckpoint from "./responses-checkpoint.js"
@@ -0,0 +1,179 @@
+import { Effect, Schema, Stream } from "effect"
+import {
+  AIError,
+  InvalidProviderOutputError,
+  CompactionPart,
+  CompactionResponse,
+  HttpOptions,
+  LLMRequest,
+  Message,
+  type ContentPart,
+  mergeJsonRecords,
+} from "../../schema/index.js"
+import type { CompactOperation } from "../../route/client.js"
+import { stripEffortUpdates } from "../../effort-updates.js"
+import { Endpoint } from "../../route/endpoint.js"
+import { RequestExecutor } from "../../route/executor.js"
+import { HttpTransport } from "../../route/transport/index.js"
+import { OpenResponses } from "../open-responses.js"
+import { JsonObject, optionalNull, ProviderShared } from "../shared.js"
+import { Media } from "../../media.js"
+
+const Body = Schema.Struct({
+  model: Schema.String,
+  input: Schema.Array(Schema.Unknown),
+  instructions: optionalNull(Schema.String),
+  previous_response_id: optionalNull(Schema.String),
+  service_tier: optionalNull(Schema.String),
+  prompt_cache_key: optionalNull(Schema.String),
+  prompt_cache_retention: optionalNull(Schema.String),
+  prompt_cache_options: optionalNull(
+    Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) }),
+  ),
+})
+
+const Text = Schema.Union([OpenResponses.OpenResponsesInputText, OpenResponses.OpenResponsesOutputText])
+const File = Schema.Union([
+  Schema.Struct({
+    ...OpenResponses.OpenResponsesInputFile.fields,
+    file_url: Schema.String,
+    file_data: Schema.optional(Schema.Never),
+  }),
+  Schema.Struct({
+    ...OpenResponses.OpenResponsesInputFile.fields,
+    file_data: Schema.String,
+    file_url: Schema.optional(Schema.Never),
+  }),
+])
+const MessageFields = {
+  type: Schema.Literal("message"),
+  id: Schema.optional(Schema.String),
+  status: Schema.optional(Schema.String),
+  phase: Schema.optional(OpenResponses.MessagePhase),
+}
+const Response = Schema.Struct({
+  object: Schema.Literal("response.compaction"),
+  output: Schema.Array(
+    Schema.Union([
+      OpenResponses.CompactionItem,
+      OpenResponses.OpenResponsesReasoningItem,
+      Schema.Struct({
+        ...MessageFields,
+        role: Schema.Literal("user"),
+        content: Schema.Array(Schema.Union([Text, OpenResponses.OpenResponsesInputImage, File])).check(
+          Schema.isMinLength(1),
+        ),
+      }),
+      Schema.Struct({
+        ...MessageFields,
+        role: Schema.Literal("assistant"),
+        content: Schema.Array(Text).check(Schema.isMinLength(1)),
+      }),
+    ]),
+  ),
+  usage: Schema.optional(Schema.StructWithRest(OpenResponses.OpenResponsesUsage, [JsonObject])),
+})
+
+export const make = (adapter: OpenResponses.ProviderAdapter): CompactOperation =>
+  Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
+    const route = request.model.route
+    // The standalone compaction endpoint rejects histories containing configuration updates.
+    const native = yield* OpenResponses.lowerConversation(stripEffortUpdates(request), adapter)
+    const body = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(
+      mergeJsonRecords(
+        {
+          ...native,
+          service_tier: request.providerOptions?.serviceTier,
+          prompt_cache_key: ProviderShared.promptCacheKey(request),
+        },
+        request.http?.body,
+      ),
+    )
+    const url = Endpoint.render(route.endpoint, { request, body: native })
+    url.pathname = `${url.pathname.replace(/\/$/, "")}/compact`
+    const parts = yield* HttpTransport.jsonRequestParts({
+      request: LLMRequest.update(request, {
+        http: request.http === undefined ? undefined : new HttpOptions({ ...request.http, body: undefined }),
+      }),
+      body,
+      endpoint: Endpoint.path(url.toString()),
+      auth: route.auth,
+      encodeBody: Schema.encodeSync(Schema.fromJsonString(Body)),
+    })
+    const response = yield* executor.execute(
+      ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),
+      options?.http,
+    )
+    const text = yield* RequestExecutor.responseStream(response).pipe(
+      Stream.decodeText(),
+      Stream.runFold(
+        () => "",
+        (text, chunk) => text + chunk,
+      ),
+    )
+    const invalid = (message: string, cause?: unknown) =>
+      new AIError({
+        reason: new InvalidProviderOutputError({
+          route: route.id,
+          message,
+          body: text,
+          cause,
+          http: RequestExecutor.responseHttp(response),
+        }),
+      })
+    const result = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(
+      Effect.mapError((cause) => invalid("Invalid compaction response", cause)),
+    )
+    if (!result.output.some((item) => item.type === "compaction"))
+      return yield* invalid("Compaction response did not contain a checkpoint")
+    return new CompactionResponse({
+      replacement: result.output.map((item) => toMessage(item, request.model)),
+      usage: OpenResponses.mapUsage(result.usage, OpenResponses.metadataKey(request.model)),
+    })
+  })
+
+function toMessage(item: (typeof Response.Type.output)[number], model: LLMRequest["model"]): Message {
+  if (item.type === "compaction")
+    return Message.assistant(
+      CompactionPart.make({ provider: model.provider, id: item.id ?? undefined, encrypted: item.encrypted_content }),
+    )
+
+  const key = OpenResponses.metadataKey(model)
+  if (item.type === "reasoning") {
+    const summary = item.summary.length ? item.summary : [{ text: "" }]
+    return Message.assistant(
+      summary.map((part) => ({
+        type: "reasoning" as const,
+        text: part.text,
+        providerMetadata: { [key]: { itemId: item.id, reasoningEncryptedContent: item.encrypted_content } },
+      })),
+    )
+  }
+
+  return Message.make({
+    role: item.role,
+    providerMetadata: { [key]: { itemId: item.id, type: item.type, status: item.status, phase: item.phase } },
+    content: item.content.map((part): ContentPart => {
+      if (part.type === "input_text" || part.type === "output_text") return { type: "text", text: part.text }
+      if (part.type === "input_image")
+        return {
+          type: "media",
+          media: replayMedia(part.image_url, "image/*"),
+          providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
+        }
+      return {
+        type: "media",
+        media: replayMedia(part.file_url === undefined ? part.file_data : part.file_url, "application/octet-stream"),
+        filename: part.filename,
+        providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
+      }
+    }),
+  })
+}
+
+/** Replayed compaction items carry either a data URL or a remote URL; the data URL's own type wins when present. */
+const replayMedia = (value: string, fallbackType: string) =>
+  Media.parseDataUrl(value) ??
+  (/^https?:\/\//.test(value) ? Media.url(value, { mediaType: fallbackType }) : Media.base64(value, fallbackType))
+
+export * as ResponsesCompaction from "./responses-compaction.js"
@@ -3,8 +3,7 @@ import { LLMEvent, type AIError, type ToolResultPart } from "../../schema/index.
 import { OpenResponses } from "../open-responses.js"
 import { Lifecycle } from "./lifecycle.js"

-export type Item = OpenResponses.StreamItem & {
-  readonly id: string
+export type Item = OpenResponses.OutputItem & {
  readonly status?: string
  readonly action?: unknown
  readonly queries?: unknown
@@ -27,44 +26,42 @@ export interface Definition {

 export type Definitions = Readonly<Record<string, Definition>>

-export const isItem = <Tools extends Definitions>(item: OpenResponses.StreamItem, tools: Tools): item is Item =>
-  item.type in tools && typeof item.id === "string" && item.id.length > 0
+export const isItem = <Tools extends Definitions>(item: OpenResponses.OutputItem, tools: Tools): item is Item =>
+  item.type in tools

 export const onDone: (
  state: OpenResponses.ParserState,
  item: Item,
  tools: Definitions,
-) => Effect.Effect<OpenResponses.StepResult, AIError> = Effect.fn("ResponsesHostedTools.onDone")(function* (
-  state,
-  item,
-  tools,
-) {
-  const tool = tools[item.type]
-  if (!tool) return [state, []] satisfies OpenResponses.StepResult
-  const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id })
-  const events: LLMEvent[] = []
-  const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-  events.push(
-    LLMEvent.toolCall({
-      id: item.id,
-      name: tool.name,
-      input: tool.input(item),
-      providerExecuted: true,
-      providerMetadata,
-    }),
-    LLMEvent.toolResult({
-      id: item.id,
-      name: tool.name,
-      result: tool.result
-        ? yield* tool.result(item)
-        : item.error !== undefined && item.error !== null
-          ? { type: "error", value: item.error }
-          : { type: "json", value: item },
-      providerExecuted: true,
-      providerMetadata,
-    }),
-  )
-  return [{ ...state, lifecycle }, events] satisfies OpenResponses.StepResult
-})
+) => Effect.Effect<OpenResponses.StepResult, AIError> = Effect.fn("ResponsesHostedTools.onDone")(
+  function* (state, item, tools) {
+    const tool = tools[item.type]
+    if (!tool) return [state, []] satisfies OpenResponses.StepResult
+    const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id })
+    const events: LLMEvent[] = []
+    const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
+    events.push(
+      LLMEvent.toolCall({
+        id: item.id,
+        name: tool.name,
+        input: tool.input(item),
+        providerExecuted: true,
+        providerMetadata,
+      }),
+      LLMEvent.toolResult({
+        id: item.id,
+        name: tool.name,
+        result: tool.result
+          ? yield* tool.result(item)
+          : item.error !== undefined && item.error !== null
+            ? { type: "error", value: item.error }
+            : { type: "json", value: item },
+        providerExecuted: true,
+        providerMetadata,
+      }),
+    )
+    return [{ ...state, lifecycle }, events] satisfies OpenResponses.StepResult
+  },
+)

 export * as ResponsesHostedTools from "./responses-hosted-tools.js"
@@ -2,20 +2,6 @@ import type { JsonSchema, LanguageModelToolSchemaCompatibility } from "../../sch
 import { isRecord } from "../../utils/record.js"
 import { GeminiToolSchema } from "./gemini-tool-schema.js"

-const removeNullSchemas = (value: unknown): unknown => {
-  if (Array.isArray(value)) return value.map(removeNullSchemas)
-  if (!isRecord(value)) return value
-  const fields = Object.fromEntries(
-    Object.entries(value)
-      .filter(([key]) => key !== "anyOf")
-      .map(([key, field]) => [key, removeNullSchemas(field)]),
-  )
-  if (!Array.isArray(value.anyOf)) return fields
-  const variants = value.anyOf.filter((variant) => !isRecord(variant) || variant.type !== "null").map(removeNullSchemas)
-  if (variants.length === 1 && isRecord(variants[0])) return { ...fields, ...variants[0] }
-  return { ...fields, anyOf: variants }
-}
-
 const tupleItemsSchema = (items: ReadonlyArray<unknown>) => {
  const projected = items.map(moonshotNode)
  if (projected.length === 0) return {}
@@ -45,24 +31,7 @@ const moonshot = (schema: JsonSchema): JsonSchema => {
  return isRecord(projected) ? projected : {}
 }

-const openAI = (schema: JsonSchema): JsonSchema => {
-  const variants = Array.isArray(schema.anyOf) ? schema.anyOf.filter(isRecord) : []
-  const flattened =
-    variants.length === 0
-      ? { ...schema, type: "object" }
-      : {
-          ...Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "anyOf")),
-          type: "object",
-          properties: variants.reduce(
-            (properties, variant) => ({ ...(isRecord(variant.properties) ? variant.properties : {}), ...properties }),
-            {},
-          ),
-          additionalProperties: false,
-        }
-  const normalized = removeNullSchemas(flattened)
-  return isRecord(normalized) ? normalized : { type: "object" }
-}
-
+const openAI = (schema: JsonSchema): JsonSchema => schema
 const responses = openAI

 const gemini = (schema: JsonSchema): JsonSchema => GeminiToolSchema.convert(schema) ?? {}
@@ -1,8 +1,10 @@
-import { Effect } from "effect"
-import { AIError, LLMEvent, type ProviderMetadata, type ToolCall, type ToolInputError } from "../../schema/index.js"
+import { Effect, Option } from "effect"
+import { AIError, LLMEvent, type ProviderMetadata, type ToolCall } from "../../schema/index.js"
 import { eventError, parseToolInput, type ToolAccumulator } from "../shared.js"
+import { parse } from "./partial-json.js"

 type StreamKey = string | number
+const parsePartialInput = Option.liftThrowable(parse)

 /**
 * One pending streamed tool call. Providers emit the tool identity and JSON
@@ -53,6 +55,7 @@ const inputStart = (tool: PendingTool) =>
  LLMEvent.toolInputStart({
    id: tool.id,
    name: tool.name,
+    namespace: tool.namespace,
    providerExecuted: tool.providerExecuted ? true : undefined,
    providerMetadata: tool.providerMetadata,
  })
@@ -61,39 +64,47 @@ const inputDelta = (tool: PendingTool, text: string) =>
  LLMEvent.toolInputDelta({
    id: tool.id,
    name: tool.name,
+    namespace: tool.namespace,
    text,
+    input: Option.getOrElse(parsePartialInput(tool.input), () => ({})),
  })

 const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
  const raw = inputOverride ?? tool.input
  return parseToolInput(route, tool.name, raw).pipe(
-    Effect.map((input): ToolCall | ToolInputError =>
-      LLMEvent.toolCall({
-        id: tool.id,
-        name: tool.name,
-        input,
-        providerExecuted: tool.providerExecuted ? true : undefined,
-        providerMetadata: tool.providerMetadata,
-      }),
-    ),
    Effect.catch((error) =>
      tool.providerExecuted
        ? Effect.fail(error)
        : Effect.succeed(
-            LLMEvent.toolInputError({
-              id: tool.id,
-              name: tool.name,
-              raw,
-            }),
+            Option.getOrElse(
+              Option.map(parsePartialInput(raw), (input) => input ?? {}),
+              () => ({}),
+            ),
          ),
    ),
+    Effect.map(
+      (input): ToolCall =>
+        LLMEvent.toolCall({
+          id: tool.id,
+          name: tool.name,
+          namespace: tool.namespace,
+          input,
+          providerExecuted: tool.providerExecuted ? true : undefined,
+          providerMetadata: tool.providerMetadata,
+        }),
+    ),
  )
 }

-const finishEvents = (tool: PendingTool, event: ToolCall | ToolInputError): ReadonlyArray<LLMEvent> =>
-  event.type === "tool-input-error"
-    ? [event]
-    : [LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }), event]
+const finishEvents = (tool: PendingTool, event: ToolCall): ReadonlyArray<LLMEvent> => [
+  LLMEvent.toolInputEnd({
+    id: tool.id,
+    name: tool.name,
+    namespace: tool.namespace,
+    providerMetadata: tool.providerMetadata,
+  }),
+  event,
+]

 /** Store the updated tool and produce the optional public delta event. */
 const appendTool = <K extends StreamKey>(
@@ -147,6 +158,7 @@ export const appendOrStart = <K extends StreamKey>(
  const tool = {
    id,
    name,
+    namespace: current?.namespace,
    input: `${current?.input ?? ""}${delta.text}`,
    providerExecuted: current?.providerExecuted,
    providerMetadata: current?.providerMetadata,
@@ -156,6 +168,17 @@ export const appendOrStart = <K extends StreamKey>(
  return appendTool(tools, key, tool, delta.text)
 }

+/**
+ * Append argument text to a started tool. Returns `undefined` when no tool is
+ * open under `key`, for protocols that ignore deltas without a matching block.
+ */
+export const append = <K extends StreamKey>(tools: State<K>, key: K, text: string): AppendOutcome<K> | undefined => {
+  const current = tools[key]
+  if (!current) return undefined
+  if (text.length === 0) return { tools, tool: current, events: [] }
+  return appendTool(tools, key, { ...current, input: `${current.input}${text}` }, text)
+}
+
 /**
 * Append argument text to a tool that must already have been started. This keeps
 * protocols honest when their stream grammar promises a start event before any
@@ -167,16 +190,11 @@ export const appendExisting = <K extends StreamKey>(
  key: K,
  text: string,
  missingToolMessage: string,
-): AppendOutcome<K> | AIError => {
-  const current = tools[key]
-  if (!current) return eventError(route, missingToolMessage)
-  if (text.length === 0) return { tools, tool: current, events: [] }
-  return appendTool(tools, key, { ...current, input: `${current.input}${text}` }, text)
-}
+): AppendOutcome<K> | AIError => append(tools, key, text) ?? eventError(route, missingToolMessage)

 /**
 * Finalize one pending tool call: parse the accumulated raw JSON, remove it
- * from state, and return either a call or a non-executable local input error.
+ * from state, and recover incomplete local arguments when needed.
 * Missing keys are a no-op because some providers emit stop events for
 * non-tool content blocks.
 */
@@ -1,68 +1,38 @@
-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, type Definition as AuthDefinition } from "../route/auth.js"
-import {
-  InvalidProviderOutputReason,
-  AIError,
-  Usage,
-  mergeHttpOptions,
-  mergeJsonRecords,
-  type HttpOptions,
-} from "../schema/index.js"
+import { Effect, Schema } from "effect"
+import type { HttpClientResponse } from "effect/unstable/http"
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js"
+import { Media } from "../media.js"
+import { MediaProtocol } from "../route/media-protocol.js"
+import { MediaRoute } from "../route/media.js"
+import { ProviderID, mergeJsonRecords, type AIError } from "../schema/index.js"
 import { ProviderShared, optionalNull } from "./shared.js"
-import { ImageInputs } from "./utils/image-input.js"
+import { MediaInput } from "./utils/media-input.js"

 const ADAPTER = "xai-images"
+const NAME = "xAI Images"
+const PROVIDER = ProviderID.make("xai")
 export const DEFAULT_BASE_URL = "https://api.x.ai/v1"
 export const PATH = "/images/generations"
 export const EDIT_PATH = "/images/edits"

+// ---------------------------------------------------------------------------
+// 1. Public model input
+// ---------------------------------------------------------------------------
+
 export type XAIImageString<Known extends string> = Known | (string & {})

+/** Provider-native options. Common fields (`n`, `aspectRatio`, `images`) live on the request. */
 export type XAIImageOptions = {
-  readonly n?: number
-  readonly aspectRatio?: XAIImageString<
-    | "1:1"
-    | "3:4"
-    | "4:3"
-    | "9:16"
-    | "16:9"
-    | "2:3"
-    | "3:2"
-    | "9:19.5"
-    | "19.5:9"
-    | "9:20"
-    | "20:9"
-    | "1:2"
-    | "2:1"
-    | "auto"
-  >
-  readonly aspect_ratio?: XAIImageString<
-    | "1:1"
-    | "3:4"
-    | "4:3"
-    | "9:16"
-    | "16:9"
-    | "2:3"
-    | "3:2"
-    | "9:19.5"
-    | "19.5:9"
-    | "9:20"
-    | "20:9"
-    | "1:2"
-    | "2:1"
-    | "auto"
-  >
  readonly resolution?: XAIImageString<"1k" | "2k">
  readonly responseFormat?: XAIImageString<"url" | "b64_json">
  readonly response_format?: XAIImageString<"url" | "b64_json">
 } & Record<string, unknown>

-type XAIImageBody = Record<string, unknown> & {
-  readonly model: string
-  readonly prompt: string
-}
+export type Request = ImageRequestFor<XAIImageOptions>
+
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------

 const XAIImageResponse = Schema.Struct({
  data: Schema.Array(
@@ -76,127 +46,109 @@ const XAIImageResponse = Schema.Struct({
  usage: Schema.optional(Schema.Unknown),
 })

-export interface ModelInput {
-  readonly id: string
-  readonly auth: AuthDefinition
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions
-}
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------

 const nativeOptions = (options: XAIImageOptions | undefined) => {
  if (!options) return undefined
-  const { aspectRatio, responseFormat, ...native } = options
-  return {
-    aspect_ratio: aspectRatio,
-    response_format: responseFormat,
-    ...native,
-  }
+  const { responseFormat, ...native } = options
+  return { response_format: responseFormat, ...native }
 }

-const invalidOutput = (message: string) =>
-  new AIError({
-    module: ADAPTER,
-    method: "generate",
-    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
-  })
+const isEdit = (request: Request) => (request.images?.length ?? 0) > 0

-const applyQuery = (url: string, query: Record<string, string> | undefined) => {
-  if (!query) return url
-  const next = new URL(url)
-  Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value))
-  return next.toString()
+const reference = (asset: Media.Asset): Effect.Effect<Record<string, unknown>, AIError> => {
+  const inline = asset.inline()
+  if (inline) return Effect.succeed({ url: inline.dataUrl, type: "image_url" as const })
+  const url = ProviderShared.mediaUrl(asset)
+  if (url) return Effect.succeed({ url, type: "image_url" as const })
+  const id = MediaInput.refID(asset, PROVIDER)
+  if (id) return Effect.succeed({ file_id: id })
+  return Effect.fail(ProviderShared.invalidRequest(`${NAME} accepts image URLs, data URLs, bytes, and xAI file IDs`))
 }

-export const model = (input: ModelInput) => {
-  const route: ImageRoute<XAIImageOptions> = {
-    id: ADAPTER,
-    generate: Effect.fn("XAIImages.generate")(function* (request: ImageRequestFor<XAIImageOptions>, execute) {
-      const http = mergeHttpOptions(request.model.http, request.http)
-      const imageReferences = (request.images ?? []).map((image) => {
-        if (image.type === "bytes") return { url: ImageInputs.dataUrl(image), type: "image_url" as const }
-        if (image.type === "url") return { url: image.url, type: "image_url" as const }
-        if (image.type === "file-id") return { file_id: image.id }
-        return undefined
-      })
-      if (imageReferences.some((image) => image === undefined))
-        return yield* ImageInputs.invalid(ADAPTER, "xAI Images accepts image URLs, data URLs, bytes, and file IDs")
-      const requestBody = mergeJsonRecords(
+const fromRequest = Effect.fn("XAIImages.fromRequest")(function* (request: Request) {
+  const references = yield* Effect.forEach(request.images ?? [], reference)
+  return MediaProtocol.json(
+    mergeJsonRecords(
+      {
+        model: request.model.id,
+        prompt: request.prompt,
+        // xAI takes one edit source as `image` and several as `images`.
+        image: references.length === 1 ? references[0] : undefined,
+        images: references.length > 1 ? references : undefined,
+        n: request.n,
+        aspect_ratio: request.aspectRatio,
+      },
+      nativeOptions(request.providerOptions),
+      request.http?.body,
+    ) ?? {},
+  )
+})
+
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+
+const decodeResponse = Effect.fn("XAIImages.decodeResponse")(function* (
+  response: HttpClientResponse.HttpClientResponse,
+) {
+  const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, XAIImageResponse)(response)
+  const decoded = output.value
+  const images = yield* Effect.forEach(decoded.data, (item, index) => {
+    const providerMetadata =
+      item.revised_prompt === undefined || item.revised_prompt === null
+        ? undefined
+        : { xai: { revisedPrompt: item.revised_prompt } }
+    if (item.b64_json)
+      return MediaInput.decodedAsset(
+        output.invalid,
+        `${NAME} result ${index}`,
+        item.b64_json,
+        item.mime_type ?? undefined,
        {
-          model: request.model.id,
-          prompt: request.prompt,
-          image: imageReferences.length === 1 ? imageReferences[0] : undefined,
-          images: imageReferences.length > 1 ? imageReferences : undefined,
+          providerMetadata,
        },
-        nativeOptions(request.options),
-        http?.body,
-      ) as XAIImageBody
-      const text = ProviderShared.encodeJson(requestBody)
-      const url = applyQuery(
-        `${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${imageReferences.length === 0 ? PATH : EDIT_PATH}`,
-        http?.query,
      )
-      const headers = yield* Auth.toEffect(input.auth)({
-        request,
-        method: "POST",
-        url,
-        body: text,
-        headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-      })
-      const response = yield* execute(
-        HttpClientRequest.post(url).pipe(
-          HttpClientRequest.setHeaders(headers),
-          HttpClientRequest.bodyText(text, "application/json"),
-        ),
-      )
-      const payload = yield* response.json.pipe(
-        Effect.mapError(() => invalidOutput("Failed to read the xAI Images response")),
-      )
-      const decoded = yield* Schema.decodeUnknownEffect(XAIImageResponse)(payload).pipe(
-        Effect.mapError(() => invalidOutput("xAI Images returned an invalid response")),
-      )
-      const images = yield* Effect.forEach(decoded.data, (item, index) => {
-        const mediaType = item.mime_type ?? "application/octet-stream"
-        if (item.b64_json)
-          return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
-            Effect.mapError(() => invalidOutput(`xAI Images result ${index} contains invalid base64 data`)),
-            Effect.map(
-              (data) =>
-                new GeneratedImage({
-                  mediaType,
-                  data,
-                  providerMetadata:
-                    item.revised_prompt === undefined || item.revised_prompt === null
-                      ? undefined
-                      : { xai: { revisedPrompt: item.revised_prompt } },
-                }),
-            ),
-          )
-        if (item.url)
-          return Effect.succeed(
-            new GeneratedImage({
-              mediaType,
-              data: item.url,
-              providerMetadata:
-                item.revised_prompt === undefined || item.revised_prompt === null
-                  ? undefined
-                  : { xai: { revisedPrompt: item.revised_prompt } },
-            }),
-          )
-        return Effect.fail(invalidOutput(`xAI Images result ${index} has neither image data nor a URL`))
-      })
-      if (images.length === 0) return yield* invalidOutput("xAI Images returned no images")
-      const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined
-      return new ImageResponse({
-        images,
-        usage: usage === undefined ? undefined : new Usage({ providerMetadata: { xai: usage } }),
-        providerMetadata: usage === undefined ? undefined : { xai: { usage } },
-      })
-    }),
-  }
-  return ImageModel.make<XAIImageOptions>({ id: input.id, provider: "xai", route, http: input.http })
-}
+    if (item.url)
+      return Effect.succeed(Media.url(item.url, { mediaType: item.mime_type ?? undefined, providerMetadata }))
+    return Effect.fail(output.invalid(`${NAME} result ${index} has neither image data nor a URL`))
+  })
+  if (images.length === 0) return yield* output.invalid(`${NAME} returned no images`)
+  const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined
+  // xAI reports image counts rather than tokens, seconds, or credits; the raw record stays in provider metadata.
+  return new ImageResponse({
+    images,
+    providerMetadata: usage === undefined ? undefined : { xai: { usage } },
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+
+export const protocol = MediaProtocol.inline<Request, ImageResponse>({
+  id: ADAPTER,
+  name: NAME,
+  unsupported: ["mask", "size", "seed", "format"],
+  body: { from: fromRequest },
+  response: { decode: decodeResponse },
+})
+
+export const model = (input: MediaRoute.ModelInput) =>
+  ImageModel.fromRoute<XAIImageOptions>(
+    {
+      id: ADAPTER,
+      provider: PROVIDER,
+      protocol,
+      baseURL: DEFAULT_BASE_URL,
+      path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH),
+    },
+    input,
+  )

 export const XAIImages = {
+  protocol,
  model,
 } as const
--- a/Show More
+++ b/Show More