refactor(core): use shared tool transform lifecycle

.changeset/calm-moves-cache.md

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

.changeset/device-authorization-url.md

@@ -0,0 +1,5 @@
+---
+"@opencode-ai/core": patch
+---
+
+Fix OpenCode Console device authorization URLs when the server returns an origin-rooted verification path.

.changeset/directory-page-heading.md

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

.changeset/idempotent-prompt-reuse.md

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

.changeset/nested-instruction-reinjection.md

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

.changeset/promise-plugin-adapter.md

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

.changeset/quiet-forms-replace-questions.md

@@ -0,0 +1,8 @@
+---
+"@opencode-ai/core": minor
+"@opencode-ai/schema": minor
+"@opencode-ai/protocol": minor
+"@opencode-ai/client": minor
+---
+
+Remove the unused question request API and use session forms for question tool interactions.

.changeset/share-session-model-request.md

@@ -0,0 +1,5 @@
+---
+"@opencode-ai/core": patch
+---
+
+Apply shared Session model-request preparation to transient generation.

.changeset/shell-permission-scan.md

@@ -0,0 +1,9 @@
+---
+"@opencode-ai/core": minor
+"@opencode-ai/schema": minor
+"@opencode-ai/protocol": minor
+"@opencode-ai/client": minor
+---
+
+Add an opt-in portable shell permission scanner. Opaque commands use normal shell authorization without inferring
+external directories, while the default tree-sitter path remains unchanged.

.changeset/shell-scanner-compatibility.md

@@ -0,0 +1,10 @@
+---
+"@opencode-ai/core": patch
+---
+
+Make the experimental portable shell scanner authoritative, with no Tree-sitter
+fallback. Scan common Bash and PowerShell control flow, heredocs, functions,
+expressions, quoting, and substitutions natively. Preserve existing redirect and
+declaration permission matching, and make PowerShell saved approvals cover the
+original command spelling. Parser failures remain visible without changing the
+permission engine. The default Tree-sitter path is unchanged.

.changeset/steer-resume-simplified.md

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

.changeset/terminal-form-recovery.md

@@ -0,0 +1,6 @@
+---
+"@opencode-ai/client": patch
+"@opencode-ai/plugin": patch
+---
+
+Add form reply and cancellation operations that reconcile terminal forms in the local TUI projection.

.changeset/unify-request-envelope.md

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

.changeset/websocket-request-hooks.md

@@ -0,0 +1,6 @@
+---
+"@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.

.gitattributes

@@ -2,4 +2,3 @@ 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

.github/workflows/deploy.yml

@@ -5,7 +5,6 @@ on:
     branches:
       - dev
       - production
-      - beta
   workflow_dispatch:
 
 concurrency: ${{ github.workflow }}-${{ github.ref }}
@@ -16,7 +15,7 @@ permissions:
 
 jobs:
   deploy:
-    if: github.repository == 'anomalyco/opencode' && (github.ref_name == 'dev' || github.ref_name == 'production' || github.ref_name == 'beta')
+    if: github.repository == 'anomalyco/opencode' && (github.ref_name == 'dev' || github.ref_name == 'production')
     runs-on: ubuntu-latest
     environment: ${{ github.ref_name }}
     steps:
@@ -29,7 +28,6 @@ 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 }}

.github/workflows/test.yml

@@ -237,19 +237,13 @@ jobs:
         working-directory: packages/app
         run: bunx playwright install chromium
 
-      - name: Run app e2e tests against production build
+      - name: Run app e2e tests
         if: env.E2E_ENABLED == 'true'
-        run: bun --cwd packages/app test:e2e:built
+        run: bun --cwd packages/app test:e2e:local
         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() && env.E2E_ENABLED == 'true'
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2

.oxlintrc.json

@@ -41,5 +41,11 @@
     // Warn when spreading non-plain objects (Headers, class instances, etc.)
     "typescript/no-misused-spread": "warn"
   },
+  "options": {
+    "typeAware": true
+  },
+  "options": {
+    "typeAware": true
+  },
   "ignorePatterns": ["**/node_modules", "**/dist", "**/.build", "**/.sst", "**/*.d.ts", "**/sdk.gen.ts"]
 }

AGENTS.md

@@ -1,7 +1,6 @@
 - 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`.
 - Local `main` ref may not exist; use `v2` or `origin/v2` for diffs.
@@ -46,7 +45,6 @@ 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

bunfig.toml

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

infra/app.ts

@@ -1,5 +1,4 @@
 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")
@@ -60,4 +59,11 @@ new sst.cloudflare.x.Astro("Web", {
   },
 })
 
-createWebApp("app." + domain)
+new sst.cloudflare.StaticSite("WebApp", {
+  domain: "app." + domain,
+  path: "packages/app",
+  build: {
+    command: "bun turbo build",
+    output: "./dist",
+  },
+})

infra/webapp.ts

@@ -1,18 +0,0 @@
-export function createWebApp(domain: string) {
-  return new sst.cloudflare.StaticSite("WebApp", {
-    domain,
-    path: "packages/app",
-    environment:
-      $app.stage === "beta"
-        ? {
-            OPENCODE_CHANNEL: "beta",
-            VITE_SENTRY_ENVIRONMENT: "beta",
-          }
-        : undefined,
-    build: {
-      // Preserve Sentry credentials and run source-map uploads on every deployment.
-      command: "bun run build",
-      output: "./dist",
-    },
-  })
-}

nix/desktop.nix

@@ -4,7 +4,7 @@
   bun,
   nodejs,
   darwin,
-  callPackage,
+  electron_41,
   makeWrapper,
   writableTmpDirAsHomeHook,
   autoPatchelfHook,
@@ -13,7 +13,7 @@
   opencode,
 }:
 let
-  electron = callPackage ./electron.nix { };
+  electron = electron_41;
 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 derives X11 WM_CLASS from app.name.
+    # Electron 41 derives X11 WM_CLASS from app.name.
     startupWMClass = "OpenCode";
     categories = [ "Development" ];
   });
@@ -67,10 +67,12 @@ 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 ''
-      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'"
+      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
     '';
 
   preBuild = ''

nix/electron.nix

@@ -1,13 +0,0 @@
-{ 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=";
-}

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-JStMvgtXBA5GrhyBJ5FtdqD8LWkcaPA9NXef+c2xUzw=",
-    "aarch64-linux": "sha256-WQxF+yS0ZImW0KW620XnZUBsKAJDoJ1jLDOMBaXI2/E=",
-    "aarch64-darwin": "sha256-km7G6s45dfFdW3Z6lFrs4NohD+vmwN1vR8PmEL0WCto=",
-    "x86_64-darwin": "sha256-YFbkcHpuspgTp+B+th3IJ3cnu5C2gEUSiy3NDXpD8UA="
+    "x86_64-linux": "sha256-NV1PD2fCgWEKsr9kR0pV9jgkC400dzoF7/DnI/fY5yI=",
+    "aarch64-linux": "sha256-TDTdwE0mcHLrrKPDwPPBk3qIDl/PXJrLX6Zbwp7EH3I=",
+    "aarch64-darwin": "sha256-6MEoiV1UKAWgC7C6PR4USCP/LLZXROfBfPg6sb2VVWg=",
+    "x86_64-darwin": "sha256-8JV6YVZFq1BC++zpARxBWhQ+wuNJrWgTZJ6jfQhDybs="
   }
 }

package.json

@@ -39,24 +39,24 @@
       "packages/stats/*"
     ],
     "catalog": {
-      "@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",
+      "@effect/opentelemetry": "4.0.0-rc.111",
+      "@effect/platform-node": "4.0.0-rc.111",
+      "@effect/platform-node-shared": "4.0.0-rc.111",
+      "@effect/sql-sqlite-bun": "4.0.0-rc.111",
       "@npmcli/arborist": "9.4.0",
       "@types/bun": "1.3.13",
       "@types/cross-spawn": "6.0.6",
       "@octokit/rest": "22.0.0",
       "@hono/standard-validator": "0.2.0",
       "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.9",
-      "@opentui/keymap": "0.5.9",
-      "@opentui/solid": "0.5.9",
+      "@opentui/core": "0.5.8",
+      "@opentui/keymap": "0.5.8",
+      "@opentui/solid": "0.5.8",
       "@tanstack/solid-virtual": "3.13.37",
-      "@shikijs/stream": "4.4.3",
+      "@shikijs/stream": "4.2.0",
       "@standard-schema/spec": "1.1.0",
       "ulid": "3.0.1",
-      "@kobalte/core": "0.13.13",
+      "@kobalte/core": "0.13.11",
       "@corvu/drawer": "0.2.4",
       "@types/luxon": "3.7.1",
       "@types/node": "24.12.2",
@@ -67,16 +67,13 @@
       "@openauthjs/openauth": "0.0.0-20250322224806",
       "@pierre/diffs": "1.2.10",
       "opentui-spinner": "0.0.7",
-      "@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",
+      "@solid-primitives/storage": "4.3.3",
       "@tailwindcss/vite": "4.1.11",
-      "diff": "8.0.4",
-      "dompurify": "3.4.14",
+      "diff": "8.0.2",
+      "dompurify": "3.3.1",
       "drizzle-kit": "1.0.0-rc.5-ab785fc",
       "drizzle-orm": "1.0.0-rc.5-169397b",
-      "effect": "4.0.0-rc.112",
+      "effect": "4.0.0-rc.111",
       "ai": "6.0.168",
       "cross-spawn": "7.0.6",
       "hono": "4.10.7",
@@ -84,9 +81,9 @@
       "fuzzysort": "3.1.0",
       "get-east-asian-width": "1.6.0",
       "luxon": "3.6.1",
-      "marked": "18.0.11",
+      "marked": "18.0.7",
       "marked-shiki": "1.2.1",
-      "remend": "1.3.1",
+      "remend": "1.3.0",
       "@playwright/test": "1.59.1",
       "semver": "7.7.4",
       "typescript": "5.8.2",
@@ -95,17 +92,17 @@
       "remeda": "2.26.0",
       "resolve.exports": "2.0.3",
       "sst": "4.13.1",
-      "shiki": "4.4.3",
+      "shiki": "4.2.0",
       "solid-list": "0.3.0",
       "string-width": "7.2.0",
       "tailwindcss": "4.1.11",
-      "vite": "7.3.6",
+      "vite": "7.1.4",
       "@solidjs/meta": "0.29.4",
-      "@solidjs/router": "1.0.0",
+      "@solidjs/router": "0.15.4",
       "@solidjs/start": "https://pkg.pr.new/@solidjs/start@dfb2020",
-      "@sentry/solid": "10.71.0",
-      "@sentry/vite-plugin": "5.4.0",
-      "solid-js": "1.9.15",
+      "@sentry/solid": "10.36.0",
+      "@sentry/vite-plugin": "4.6.0",
+      "solid-js": "1.9.10",
       "solid-sonner": "0.3.1",
       "vite-plugin-solid": "2.11.10",
       "@lydell/node-pty": "1.2.0-beta.12"
@@ -161,8 +158,7 @@
     "@effect/platform-node-shared": "catalog:",
     "@types/bun": "catalog:",
     "@types/node": "catalog:",
-    "effect": "catalog:",
-    "solid-js": "catalog:"
+    "effect": "catalog:"
   },
   "patchedDependencies": {
     "@ai-sdk/openai-compatible@2.0.41": "patches/@ai-sdk%2Fopenai-compatible@2.0.41.patch",
@@ -170,7 +166,7 @@
     "@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",
-    "solid-js@1.9.15": "patches/solid-js@1.9.15.patch",
+    "solid-js@1.9.10": "patches/solid-js@1.9.10.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",

packages/ai/AGENTS.md

@@ -19,14 +19,6 @@ Per-type constructors live on the type, not as top-level re-exports. Use `Messag
 - 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.

packages/ai/README.md

@@ -214,147 +214,22 @@ the requests sent by code under test:
 import { Effect } from "effect"
 import { TestLLM } from "@opencode-ai/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
-  console.log(yield* test.requests())
+  const test = yield* TestLLM.Service
+  console.log(test.requests)
   return result
-}).pipe(Effect.provide(TestLLM.testLayer()))
+}).pipe(Effect.provide(TestLLM.clientLayer), Effect.provide(testLLM))
 ```
 
-`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`. The client returns that replacement window directly, including retained user messages and usage, with the same lazy request recording and gates. Generation and compaction reject fixtures for the wrong operation instead of converting between response shapes.
-
-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 Bedrock Messages), and explicit compaction calls in OpenAI/Azure/xAI Responses. Model and deployment support still depends on the provider.
-
-This is different from prompt caching, server-side history storage, or truncation. Compaction returns provider-owned context that must be replayed to continue the conversation.
-
-### Automatic compaction
-
-Inside an `Effect.gen`, enable OpenAI compaction with typed provider options:
-
-```ts
-import { LLM, LLMClient, LLMRequest, Message } from "@opencode-ai/ai"
-import { OpenAI } from "@opencode-ai/ai/providers"
-
-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/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"`. 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`.
-
-Bedrock's Converse API does not support this feature. Select the native Claude Messages route explicitly; the default `.model(...)` remains Converse:
-
-```ts
-import { AmazonBedrock } from "@opencode-ai/ai/providers"
-
-const model = AmazonBedrock.configure({ region: "us-east-1", credentials }).messages("us.anthropic.claude-opus-4-6-v1")
-```
-
-The corresponding package entrypoint is `@opencode-ai/ai/providers/amazon-bedrock/messages`. It uses InvokeModelWithResponseStream, AWS event-stream framing, bearer or SigV4 auth, and `anthropic_beta` in the request body.
-
-### Explicit compaction
-
-`LLMClient.compact(request)` performs exactly one HTTP call to `/responses/compact`, using the selected route's endpoint, credentials, query, and HTTP middleware. It returns a `CompactionResponse` containing replacement `messages` and usage, not a normal generation response.
-
-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.
-
-```ts
-const compacted = yield * LLMClient.compact(request)
-const next = LLMRequest.update(request, {
-  messages: [...compacted.messages, Message.user("Continue")],
-})
-const response = yield * LLMClient.generate(next)
-```
-
-Replace the prior window with `compacted.messages`. Do not append it to the original transcript or extract only the encrypted item: the provider may retain additional messages in its output. Retained user and assistant messages remain ordinary messages with typed text, media, or reasoning parts, in their original order. Provider-specific message IDs, status, and phase use `providerMetadata`, not a raw output array hidden in an assistant message. Unsupported returned item types fail explicitly. Generation-only body overlays such as `stream` and `store` are not sent to the compact endpoint.
-
-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. xAI supports this explicit path, not the automatic OpenAI option. Unsupported routes, including Bedrock Mantle, do not inherit an explicit compact endpoint simply because they use a Responses protocol.
-
-### Ownership and verification
-
-The AI package transports options and typed conversation parts. It does not schedule compaction, persist Session checkpoints, select history, switch providers, or replace Core's existing local compaction policy. Native compaction is not enabled for OpenCode Sessions by this feature; Session integration must persist these parts before enabling it. The AI SDK bridge rejects native compaction parts rather than dropping them. Provider-executed tool APIs and persistence changes are a separate follow-up.
-
-Tests cover serialized round trips, real local HTTP plus a tool loop, AWS binary frames and signing, provider errors, malformed blocks, and usage accounting. Live provider tests are gated by `RECORD=true` and the relevant API keys:
-
-```sh
-# Run from packages/ai. Only records the selected new cassette group.
-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), [Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/claude-messages-compaction.html), [xAI](https://docs.x.ai/developers/advanced-api-usage/context-compaction).
+`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`.
 
 ## Caching
 

packages/ai/src/cache-policy.ts

@@ -40,7 +40,6 @@ const RESPECTS_INLINE_HINTS = new Set([
   "anthropic-messages",
   "google-vertex-messages",
   "bedrock-converse",
-  "bedrock-messages",
   "openrouter",
 ])
 

packages/ai/src/image.ts

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect"
 import {
   HttpOptions,
-  InvalidRequestError,
+  InvalidRequestReason,
   AIError,
   ModelID,
   ProviderID,
@@ -158,10 +158,9 @@ export function generate(input: ImageRequest | ImageRequestInput) {
     try: () => (input instanceof ImageRequest ? input : request(input)),
     catch: (error) =>
       new AIError({
-        reason: new InvalidRequestError({
-          message: error instanceof Error ? error.message : String(error),
-          cause: error,
-        }),
+        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>)))
 }

packages/ai/src/llm.ts

@@ -3,7 +3,7 @@ import { LLMClient, Service } from "./route/client.js"
 import {
   GenerationOptions,
   HttpOptions,
-  InvalidProviderOutputError,
+  InvalidProviderOutputReason,
   AIError,
   LLMEvent,
   LLMRequest,
@@ -116,7 +116,9 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (
   )
   if (!call || !LLMEvent.is.toolCall(call))
     return yield* new AIError({
-      reason: new InvalidProviderOutputError({
+      module: "LLM",
+      method: "generateObject",
+      reason: new InvalidProviderOutputReason({
         message: `generateObject: model did not call the forced \`${GENERATE_OBJECT_TOOL_NAME}\` tool`,
       }),
     })
@@ -124,9 +126,10 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (
     Effect.mapError(
       (error) =>
         new AIError({
-          reason: new InvalidProviderOutputError({
+          module: "LLM",
+          method: "generateObject",
+          reason: new InvalidProviderOutputReason({
             message: `generateObject: tool input failed schema decode: ${error.message}`,
-            cause: error,
           }),
         }),
     ),

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

@@ -6,12 +6,8 @@ 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 { Headers } from "effect/unstable/http"
-import { HttpTransport } from "../route/transport/index.js"
 import {
   AIError,
-  HttpOptions,
-  LLMRequest,
   LLMEvent,
   mergeJsonRecords,
   Usage,
@@ -19,6 +15,7 @@ import {
   type FinishReasonDetails,
   type FinishReason,
   type JsonSchema,
+  type LLMRequest,
   type MediaPart,
   type ProviderMetadata,
   type ToolCallPart,
@@ -64,7 +61,6 @@ export type ThinkingInput =
     ))
 
 export interface OptionsInput {
-  readonly contextManagement?: ContextManagement
   readonly [key: string]: unknown
   readonly thinking?: ThinkingInput
   readonly effort?: string
@@ -93,23 +89,6 @@ export interface OptionsInput {
 
 export type ProviderOptionsInput = OptionsInput
 
-export const ContextManagement = Schema.Struct({
-  edits: Schema.Array(
-    Schema.Struct({
-      type: Schema.Literal("compact_20260112"),
-      trigger: Schema.optional(
-        Schema.Struct({
-          type: Schema.Literal("input_tokens"),
-          value: Schema.Int.check(Schema.isGreaterThanOrEqualTo(50000)),
-        }),
-      ),
-      pauseAfterCompaction: Schema.optional(Schema.Boolean),
-      instructions: Schema.optional(Schema.String),
-    }),
-  ),
-})
-export type ContextManagement = typeof ContextManagement.Type
-
 // =============================================================================
 // Request Body Schema
 // =============================================================================
@@ -257,12 +236,7 @@ const AnthropicUserBlock = Schema.Union([
   AnthropicToolResultBlock,
 ])
 type AnthropicUserBlock = Schema.Schema.Type<typeof AnthropicUserBlock>
-const AnthropicCompactionBlock = Schema.Struct({
-  type: Schema.Literal("compaction"),
-  content: Schema.NullOr(Schema.String),
-})
 const AnthropicAssistantBlock = Schema.Union([
-  AnthropicCompactionBlock,
   AnthropicTextBlock,
   AnthropicThinkingBlock,
   AnthropicRedactedThinkingBlock,
@@ -338,18 +312,6 @@ const AnthropicContainer = Schema.Union([
 ])
 
 const AnthropicBodyFields = {
-  context_management: Schema.optional(
-    Schema.Struct({
-      edits: Schema.Array(
-        Schema.Struct({
-          type: Schema.Literal("compact_20260112"),
-          trigger: ContextManagement.fields.edits.value.fields.trigger,
-          pause_after_compaction: Schema.optional(Schema.Boolean),
-          instructions: Schema.optional(Schema.String),
-        }),
-      ),
-    }),
-  ),
   model: Schema.String,
   system: optionalArray(AnthropicTextBlock),
   messages: Schema.Array(AnthropicMessage),
@@ -373,7 +335,7 @@ const AnthropicBodyFields = {
 export const AnthropicMessagesBody = Schema.Struct(AnthropicBodyFields)
 export type AnthropicMessagesBody = Schema.Schema.Type<typeof AnthropicMessagesBody>
 
-const AnthropicIterationUsage = Schema.StructWithRest(
+const AnthropicUsage = Schema.StructWithRest(
   Schema.Struct({
     input_tokens: optionalNull(Schema.Number),
     output_tokens: Schema.optional(Schema.Number),
@@ -392,13 +354,6 @@ const AnthropicIterationUsage = Schema.StructWithRest(
   }),
   [Schema.Record(Schema.String, Schema.Unknown)],
 )
-const AnthropicUsage = Schema.StructWithRest(
-  Schema.Struct({
-    ...AnthropicIterationUsage.schema.fields,
-    iterations: Schema.optional(Schema.Array(AnthropicIterationUsage)),
-  }),
-  [JsonObject],
-)
 type AnthropicUsage = Schema.Schema.Type<typeof AnthropicUsage>
 
 const AnthropicStreamBlock = Schema.Struct({
@@ -422,7 +377,6 @@ type AnthropicStreamBlock = Schema.Schema.Type<typeof AnthropicStreamBlock>
 const decodeAnthropicStreamBlock = Schema.decodeUnknownOption(AnthropicStreamBlock)
 
 const AnthropicStreamDelta = Schema.Struct({
-  content: optionalNull(Schema.String),
   type: Schema.optional(Schema.String),
   text: Schema.optional(Schema.String),
   thinking: Schema.optional(Schema.String),
@@ -452,8 +406,6 @@ const AnthropicEvent = Schema.Struct({
 type AnthropicEvent = Schema.Schema.Type<typeof AnthropicEvent>
 
 interface ParserState {
-  readonly provider: LLMRequest["model"]["provider"]
-  readonly compactions: Readonly<Record<number, string | null>>
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<number>
   readonly reasoningSignatures: Readonly<Record<number, string>>
@@ -879,7 +831,6 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
       const content: AnthropicUserBlock[] = []
       for (const part of message.content) {
         if (part.type === "text") {
-          if (part.text.trim().length === 0) continue
           content.push({ type: "text", text: part.text, cache_control: cacheControl(breakpoints, part.cache) })
           continue
         }
@@ -889,21 +840,14 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
         }
         return yield* ProviderShared.unsupportedContent("Anthropic Messages", "user", ["text", "media"])
       }
-      if (content.length > 0) messages.push({ role: "user", content })
+      messages.push({ role: "user", content })
       continue
     }
 
     if (message.role === "assistant") {
       const content: AnthropicAssistantBlock[] = []
       for (const part of message.content) {
-        if (part.type === "compaction") {
-          if (part.provider !== request.model.provider || part.text === undefined)
-            return yield* invalid("Compaction state must be replayed to its originating provider and API")
-          content.push({ type: "compaction", content: part.text })
-          continue
-        }
         if (part.type === "text") {
-          if (part.text.trim().length === 0) continue
           content.push({ type: "text", text: part.text, cache_control: cacheControl(breakpoints, part.cache) })
           continue
         }
@@ -947,7 +891,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
           `Anthropic Messages assistant messages only support text, reasoning, and tool-call content for now`,
         )
       }
-      if (content.length > 0) messages.push({ role: "assistant", content })
+      messages.push({ role: "assistant", content })
       continue
     }
 
@@ -1057,9 +1001,6 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
 })
 
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) {
-  const management = yield* ProviderShared.validateWith(
-    Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)),
-  )(request.providerOptions?.contextManagement)
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   // Allocate the 4-breakpoint budget in invalidation order: tools → system →
@@ -1078,11 +1019,10 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
         )
   // Anthropic rejects tool_choice when tools are absent; "none" is only meaningful with tools present.
   const toolChoice = tools === undefined || !request.toolChoice ? undefined : yield* lowerToolChoice(request.toolChoice)
-  const systemParts = request.system.filter((part) => part.text.length > 0)
   const system =
-    systemParts.length === 0
+    request.system.length === 0
       ? undefined
-      : systemParts.map((part) => ({
+      : request.system.map((part) => ({
           type: "text" as const,
           text: part.text,
           cache_control: cacheControl(breakpoints, part.cache),
@@ -1094,7 +1034,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     )
   }
   const options = yield* resolveOptions(request)
-  const body = {
+  return {
     model: request.model.id,
     system,
     messages,
@@ -1115,18 +1055,6 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     metadata: options.metadata,
     service_tier: options.service_tier,
   }
-  if (!management) return body
-  return {
-    ...body,
-    context_management: {
-      edits: management.edits.map((edit) => ({
-        type: edit.type,
-        trigger: edit.trigger,
-        pause_after_compaction: edit.pauseAfterCompaction,
-        instructions: edit.instructions,
-      })),
-    },
-  }
 })
 
 // =============================================================================
@@ -1148,31 +1076,18 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 // expose that subset through `output_tokens_details.thinking_tokens`.
 const mapUsage = (usage: AnthropicUsage | undefined, providerMetadataKey: string): Usage | undefined => {
   if (!usage) return undefined
-  const iterations = usage.iterations?.length ? usage.iterations : [usage]
-  const last = usage.iterations?.at(-1)
-  const nonCached = ProviderShared.sumTokens(...iterations.map((item) => item.input_tokens ?? undefined))
-  const cacheRead = ProviderShared.sumTokens(...iterations.map((item) => item.cache_read_input_tokens ?? undefined))
-  const cacheWrite = ProviderShared.sumTokens(
-    ...iterations.map((item) => item.cache_creation_input_tokens ?? undefined),
-  )
+  const nonCached = usage.input_tokens ?? undefined
+  const cacheRead = usage.cache_read_input_tokens ?? undefined
+  const cacheWrite = usage.cache_creation_input_tokens ?? undefined
   const inputTokens = ProviderShared.sumTokens(nonCached, cacheRead, cacheWrite)
-  const outputTokens = ProviderShared.sumTokens(...iterations.map((item) => item.output_tokens))
   return new Usage({
     inputTokens,
-    outputTokens,
-    contextTokens:
-      last?.type === "message"
-        ? ProviderShared.sumTokens(
-            last.input_tokens ?? undefined,
-            last.cache_read_input_tokens ?? undefined,
-            last.cache_creation_input_tokens ?? undefined,
-          )
-        : undefined,
+    outputTokens: usage.output_tokens,
     nonCachedInputTokens: nonCached,
     cacheReadInputTokens: cacheRead,
     cacheWriteInputTokens: cacheWrite,
-    reasoningTokens: ProviderShared.sumTokens(...iterations.map((item) => item.output_tokens_details?.thinking_tokens)),
-    totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
+    reasoningTokens: usage.output_tokens_details?.thinking_tokens,
+    totalTokens: ProviderShared.totalTokens(inputTokens, usage.output_tokens, undefined),
     providerMetadata: { [providerMetadataKey]: usage },
   })
 }
@@ -1194,7 +1109,6 @@ const mergeUsage = (left: Usage | undefined, right: Usage | undefined, providerM
   return new Usage({
     inputTokens,
     outputTokens,
-    contextTokens: right.contextTokens ?? left.contextTokens,
     nonCachedInputTokens,
     cacheReadInputTokens,
     cacheWriteInputTokens,
@@ -1253,6 +1167,7 @@ const onContentBlockStart = (
   event: AnthropicEvent & { readonly content_block: AnthropicStreamBlock },
 ): StepResult => {
   const block = event.content_block
+  if (!block) return [state, NO_EVENTS]
 
   if (block.type === "tool_use" || block.type === "server_tool_use") {
     if (event.index === undefined || !block.id) return [state, NO_EVENTS]
@@ -1347,16 +1262,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
 ) {
   const delta = event.delta
 
-  if (delta.type === "compaction_delta") {
-    if (event.index === undefined || !(event.index in state.compactions) || delta.content === undefined)
-      return yield* ProviderShared.eventError(ADAPTER, "Compaction delta is missing its block or content")
-    return [
-      { ...state, compactions: { ...state.compactions, [event.index]: delta.content } },
-      NO_EVENTS,
-    ] satisfies StepResult
-  }
-
-  if (delta.type === "text_delta" && delta.text) {
+  if (delta?.type === "text_delta" && delta.text) {
     if (!state.lifecycle.text.has(`text-${event.index ?? 0}`)) return [state, NO_EVENTS] satisfies StepResult
     const events: LLMEvent[] = []
     return [
@@ -1365,7 +1271,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     ] satisfies StepResult
   }
 
-  if (delta.type === "thinking_delta" && delta.thinking) {
+  if (delta?.type === "thinking_delta" && delta.thinking) {
     if (!state.lifecycle.reasoning.has(`reasoning-${event.index ?? 0}`)) return [state, NO_EVENTS] satisfies StepResult
     const events: LLMEvent[] = []
     return [
@@ -1377,7 +1283,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     ] satisfies StepResult
   }
 
-  if (delta.type === "signature_delta" && delta.signature) {
+  if (delta?.type === "signature_delta" && delta.signature) {
     const index = event.index ?? 0
     if (!state.lifecycle.reasoning.has(`reasoning-${index}`)) return [state, NO_EVENTS] satisfies StepResult
     return [
@@ -1389,7 +1295,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     ] satisfies StepResult
   }
 
-  if (delta.type === "input_json_delta" && event.index !== undefined) {
+  if (delta?.type === "input_json_delta" && event.index !== undefined) {
     if (!delta.partial_json) return [state, NO_EVENTS] satisfies StepResult
     if (!state.tools[event.index]) return [state, NO_EVENTS] satisfies StepResult
     const result = ToolStream.appendExisting(
@@ -1414,18 +1320,6 @@ const onContentBlockStop = Effect.fn("AnthropicMessages.onContentBlockStop")(fun
   event: AnthropicEvent,
 ) {
   if (event.index === undefined) return [state, NO_EVENTS] satisfies StepResult
-  if (event.index in state.compactions) {
-    const { [event.index]: content, ...compactions } = state.compactions
-    const events: LLMEvent[] = []
-    const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-    events.push(
-      LLMEvent.compaction({
-        provider: state.provider,
-        text: content,
-      }),
-    )
-    return [{ ...state, compactions, lifecycle }, events] satisfies StepResult
-  }
   const result = yield* ToolStream.finish(ADAPTER, state.tools, event.index)
   const events: LLMEvent[] = []
   const resultEvents = result.events ?? []
@@ -1449,51 +1343,31 @@ const onMessageDelta = (
   event: AnthropicEvent & { readonly delta?: AnthropicStreamDelta },
 ): StepResult => {
   const usage = mergeUsage(state.usage, mapUsage(event.usage, state.providerMetadataKey), state.providerMetadataKey)
-  const pendingFinish = (() => {
-    const stopReason = event.delta?.stop_reason
-    if (stopReason === null || stopReason === undefined) return state.pendingFinish
-
-    const stopSequence = event.delta?.stop_sequence
-    const finishMetadata =
-      stopSequence === null || stopSequence === undefined
-        ? state.pendingFinish?.providerMetadata
-        : providerMetadata(state.providerMetadataKey, { stopSequence })
-    return {
-      reason: {
-        normalized: mapFinishReason(stopReason),
-        raw: stopReason,
-      },
-      providerMetadata: finishMetadata,
-    }
-  })()
   return [
     {
       ...state,
       usage,
-      pendingFinish,
+      pendingFinish: {
+        reason: {
+          normalized: mapFinishReason(event.delta?.stop_reason),
+          raw: event.delta?.stop_reason ?? undefined,
+        },
+        providerMetadata:
+          event.delta?.stop_sequence === null || event.delta?.stop_sequence === undefined
+            ? undefined
+            : providerMetadata(state.providerMetadataKey, { stopSequence: event.delta.stop_sequence }),
+      },
     },
     NO_EVENTS,
   ]
 }
 
 const onMessageStop = Effect.fn("AnthropicMessages.onMessageStop")(function* (state: ParserState) {
-  if (Object.keys(state.compactions).length)
-    return yield* ProviderShared.eventError(ADAPTER, "Response ended with an incomplete compaction block")
   const result = yield* ToolStream.finishAll(ADAPTER, state.tools)
   const events: LLMEvent[] = []
   const lifecycle = result.events.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
   events.push(...result.events)
-  const closed = Object.entries(state.reasoningSignatures).reduce(
-    (current, [index, signature]) =>
-      Lifecycle.reasoningEnd(
-        current,
-        events,
-        `reasoning-${index}`,
-        providerMetadata(state.providerMetadataKey, { signature }),
-      ),
-    lifecycle,
-  )
-  const finished = Lifecycle.finish(closed, events, {
+  const finished = Lifecycle.finish(lifecycle, events, {
     reason: state.pendingFinish?.reason ?? {
       normalized: "unknown",
       raw: undefined,
@@ -1513,31 +1387,25 @@ const providerErrorMessage = (event: AnthropicEvent): string => {
   return message || type || "Anthropic Messages stream error"
 }
 
-const onError = (event: AnthropicEvent) => {
-  const message = providerErrorMessage(event)
-  const body = ProviderShared.encodeJson(event)
-  return Effect.fail(
+const onError = (event: AnthropicEvent) =>
+  Effect.fail(
     new AIError({
-      reason: classifyProviderFailure({ message, rawBody: body }),
+      module: ADAPTER,
+      method: "stream",
+      reason: classifyProviderFailure({ message: providerErrorMessage(event), code: event.error?.type }),
     }),
   )
-}
 
-const STREAM_BLOCK_TYPES = new Set([
-  "compaction",
-  "text",
-  "thinking",
-  "redacted_thinking",
-  "tool_use",
-  "server_tool_use",
-])
-const STREAM_DELTA_TYPES = new Set([
-  "compaction_delta",
-  "text_delta",
-  "thinking_delta",
-  "signature_delta",
-  "input_json_delta",
-])
+const isKnownStreamBlockType = (type: string) =>
+  type === "text" ||
+  type === "thinking" ||
+  type === "redacted_thinking" ||
+  type === "tool_use" ||
+  type === "server_tool_use" ||
+  isServerToolResultType(type)
+
+const isKnownStreamDeltaType = (type: string) =>
+  type === "text_delta" || type === "thinking_delta" || type === "signature_delta" || type === "input_json_delta"
 
 const invalidStreamEvent = (event: AnthropicEvent) =>
   Effect.fail(
@@ -1566,16 +1434,7 @@ const step = (state: ParserState, event: AnthropicEvent) => {
   if (event.type === "content_block_start") {
     if (!ProviderShared.isRecord(event.content_block) || typeof event.content_block.type !== "string")
       return invalidStreamEvent(event)
-    if (event.content_block.type === "compaction") {
-      const decoded = Schema.decodeUnknownOption(AnthropicCompactionBlock)(event.content_block)
-      if (event.index === undefined || Option.isNone(decoded)) return invalidStreamEvent(event)
-      return Effect.succeed<StepResult>([
-        { ...state, compactions: { ...state.compactions, [event.index]: decoded.value.content } },
-        NO_EVENTS,
-      ])
-    }
-    if (!STREAM_BLOCK_TYPES.has(event.content_block.type) && !isServerToolResultType(event.content_block.type))
-      return Effect.succeed<StepResult>([state, NO_EVENTS])
+    if (!isKnownStreamBlockType(event.content_block.type)) return Effect.succeed<StepResult>([state, NO_EVENTS])
     const decoded = decodeAnthropicStreamBlock(event.content_block)
     if (Option.isNone(decoded)) return invalidStreamEvent(event)
     const block = decoded.value
@@ -1589,7 +1448,7 @@ const step = (state: ParserState, event: AnthropicEvent) => {
   }
   if (event.type === "content_block_delta") {
     if (!ProviderShared.isRecord(event.delta)) return invalidStreamEvent(event)
-    if (typeof event.delta.type === "string" && !STREAM_DELTA_TYPES.has(event.delta.type))
+    if (typeof event.delta.type === "string" && !isKnownStreamDeltaType(event.delta.type))
       return Effect.succeed<StepResult>([state, NO_EVENTS])
     const decoded = decodeAnthropicStreamDelta(event.delta)
     if (Option.isNone(decoded)) return invalidStreamEvent(event)
@@ -1623,8 +1482,6 @@ export const protocol = Protocol.make({
   stream: {
     event: Protocol.jsonEvent(AnthropicEvent),
     initial: (request) => ({
-      provider: request.model.provider,
-      compactions: {},
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       tools: ToolStream.empty<number>(),
       reasoningSignatures: {},
@@ -1634,37 +1491,6 @@ export const protocol = Protocol.make({
   },
 })
 
-export const transport = <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management">>() => {
-  const http = HttpTransport.httpJson<Body, string>({ framing })
-  return {
-    ...http,
-    prepare: (input: Parameters<typeof http.prepare>[0]) => {
-      if (
-        !input.body.context_management?.edits.length &&
-        !input.body.messages.some((message) => message.content.some((block) => block.type === "compaction"))
-      )
-        return http.prepare(input)
-      const headers = Headers.fromInput(input.request.http?.headers)
-      const betas = new Set(
-        (headers["anthropic-beta"] ?? "")
-          .split(",")
-          .map((item) => item.trim())
-          .filter(Boolean),
-      )
-      betas.add("compact-2026-01-12")
-      return http.prepare({
-        ...input,
-        request: LLMRequest.update(input.request, {
-          http: new HttpOptions({
-            ...input.request.http,
-            headers: { ...headers, "anthropic-beta": [...betas].join(",") },
-          }),
-        }),
-      })
-    },
-  }
-}
-
 export const route = Route.make({
   id: ADAPTER,
   provider: "anthropic",
@@ -1674,7 +1500,7 @@ export const route = Route.make({
     baseURL: DEFAULT_BASE_URL,
   }),
   auth: Auth.none,
-  transport: transport<AnthropicMessagesBody>(),
+  framing,
   headers: () => ({ "anthropic-version": "2023-06-01" }),
 })
 

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

@@ -1,4 +1,4 @@
-import { Effect, Encoding, Schema } from "effect"
+import { Effect, Schema } from "effect"
 import { Route } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
@@ -262,28 +262,24 @@ const providerMetadata = (key: string, metadata: Record<string, unknown>): Provi
 
 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
+  return (
+    part.encrypted ??
+    (ProviderShared.isRecord(metadata) && typeof metadata.signature === "string" ? metadata.signature : undefined)
+  )
 }
 
 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)]])),
-  )
+  return ProviderShared.isRecord(metadata) && typeof metadata.redactedData === "string"
+    ? metadata.redactedData
+    : undefined
 }
 
 const lowerToolCall = (part: ToolCallPart): BedrockToolUseBlock => ({
   toolUse: {
     toolUseId: part.id,
     name: part.name,
-    input: removeEmptyToolInputKeys(part.input),
+    input: part.input,
   },
 })
 
@@ -378,12 +374,6 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
             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
         }
@@ -392,7 +382,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
           continue
         }
       }
-      if (content.length > 0) messages.push({ role: "assistant", content })
+      messages.push({ role: "assistant", content })
       continue
     }
 
@@ -418,12 +408,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
 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
-}
+): BedrockSystemBlock[] => system.flatMap((part) => textWithCache(breakpoints, part.text, part.cache))
 
 const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request: LLMRequest) {
   const toolChoice = request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined
@@ -431,42 +416,38 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request:
   // 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 = (() => {
-    if (request.tools.length === 0) return undefined
-    return {
-      tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, request.tools),
-      // Converse has no native "none". Keep definitions stable for prompt
-      // caching and omit only the unsupported choice.
-      toolChoice,
-    }
-  })()
-  const system = lowerSystem(breakpoints, request.system)
+  const 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)
   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.`,
     )
   }
-  const inferenceConfig = (() => {
-    if (
-      generation?.maxTokens === undefined &&
-      generation?.temperature === undefined &&
-      generation?.topP === undefined &&
-      (generation?.stop === undefined || generation.stop.length === 0)
-    )
-      return undefined
-    return {
-      maxTokens: generation?.maxTokens,
-      temperature: generation?.temperature,
-      topP: generation?.topP,
-      stopSequences: generation?.stop,
-    }
-  })()
   return {
     modelId: request.model.id,
     messages,
     system,
-    inferenceConfig,
+    inferenceConfig:
+      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,
+          },
     toolConfig,
     // Converse's base inferenceConfig has no topK; Anthropic/Nova accept it
     // as a model-specific field, so it goes through additionalModelRequestFields.
@@ -482,6 +463,7 @@ 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"
 }
 
@@ -508,7 +490,6 @@ const mapUsage = (usage: BedrockUsageSchema | undefined, providerMetadataKey: st
 interface ParserState {
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<number>
-  readonly finishedTools: ReadonlySet<number>
   // Bedrock splits the finish into `messageStop` (carries `stopReason`) and
   // `metadata` (carries usage). Hold the terminal event in state so `onHalt`
   // can emit exactly one finish after both chunks have had a chance to arrive.
@@ -516,16 +497,6 @@ interface ParserState {
   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) =>
@@ -573,46 +544,23 @@ const step = (state: ParserState, event: BedrockEvent) =>
       const index = event.contentBlockDelta.contentBlockIndex
       const reasoning = event.contentBlockDelta.delta.reasoningContent
       const events: LLMEvent[] = []
-      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 }
-      })()
+      const redactedData = reasoning.redactedContent ?? reasoning.data
+      const metadata = reasoning.signature
+        ? providerMetadata(state.providerMetadataKey, { signature: reasoning.signature })
+        : redactedData !== undefined
+          ? providerMetadata(state.providerMetadataKey, { redactedData })
+          : undefined
+      const lifecycle =
+        reasoning.text !== undefined || metadata !== undefined
+          ? Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text ?? "", metadata)
+          : state.lifecycle
       return [
         {
           ...state,
           lifecycle,
-          reasoningSignatures,
-          reasoningRedactedContent,
+          reasoningSignatures: reasoning.signature
+            ? { ...state.reasoningSignatures, [index]: reasoning.signature }
+            : state.reasoningSignatures,
         },
         events,
       ] as const
@@ -620,7 +568,6 @@ const step = (state: ParserState, event: BedrockEvent) =>
 
     if (event.contentBlockDelta?.delta?.toolUse) {
       const index = event.contentBlockDelta.contentBlockIndex
-      if (state.finishedTools.has(index)) return [state, []] as const
       const result = ToolStream.appendExisting(
         ADAPTER,
         state.tools,
@@ -640,24 +587,16 @@ const step = (state: ParserState, event: BedrockEvent) =>
       const result = yield* ToolStream.finish(ADAPTER, state.tools, index)
       const events: LLMEvent[] = []
       const resultEvents = result.events ?? []
-      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,
-        )
-      })()
+      const lifecycle = resultEvents.length
+        ? Lifecycle.stepStart(state.lifecycle, events)
+        : Lifecycle.reasoningEnd(
+            Lifecycle.textEnd(state.lifecycle, events, `text-${index}`),
+            events,
+            `reasoning-${index}`,
+            state.reasoningSignatures[index]
+              ? providerMetadata(state.providerMetadataKey, { signature: state.reasoningSignatures[index] })
+              : undefined,
+          )
       events.push(...resultEvents)
       return [
         {
@@ -667,28 +606,15 @@ const step = (state: ParserState, event: BedrockEvent) =>
             state.hasToolCalls,
           lifecycle,
           tools: result.tools,
-          finishedTools: resultEvents.length > 0 ? new Set([...state.finishedTools, index]) : state.finishedTools,
           reasoningSignatures: Object.fromEntries(
             Object.entries(state.reasoningSignatures).filter(([key]) => key !== String(index)),
           ),
-          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,
@@ -719,13 +645,15 @@ const step = (state: ParserState, event: BedrockEvent) =>
     }
 
     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,
-          rawBody: body,
+          message:
+            event.exception.details.message ??
+            event.exception.details.originalMessage ??
+            "Bedrock Converse stream error",
+          code: event.exception.type,
         }),
       })
     }
@@ -735,22 +663,23 @@ const step = (state: ParserState, event: BedrockEvent) =>
 
 const framing = BedrockEventStream.framing(ADAPTER)
 
-const onHalt = (state: ParserState): ReadonlyArray<LLMEvent> => {
-  if (!state.pendingFinish) return []
-  const normalized = (() => {
-    if (state.pendingFinish.reason.normalized === "stop" && state.hasToolCalls) return "tool-calls"
-    return state.pendingFinish.reason.normalized
-  })()
-  const events: LLMEvent[] = []
-  Lifecycle.finish(state.lifecycle, events, {
-    reason: {
-      ...state.pendingFinish.reason,
-      normalized,
-    },
-    usage: state.pendingFinish.usage,
-  })
-  return events
-}
+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
+      })()
+    : []
 
 // =============================================================================
 // Protocol And Bedrock Route
@@ -770,12 +699,10 @@ export const protocol = Protocol.make({
     initial: (request) => ({
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       tools: ToolStream.empty<number>(),
-      finishedTools: new Set<number>(),
       pendingFinish: undefined,
       hasToolCalls: false,
       lifecycle: Lifecycle.initial(),
       reasoningSignatures: {},
-      reasoningRedactedContent: {},
     }),
     step,
     onHalt: (state) => Effect.succeed(onHalt(state)),

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

@@ -1,7 +1,6 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec"
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8"
-import { Effect, Encoding, Stream } from "effect"
-import { AIError, AIErrorReason, InvalidProviderOutputError } from "../schema/index.js"
+import { Effect, Stream } from "effect"
 import { Framing } from "../route/framing.js"
 import { ProviderShared } from "./shared.js"
 
@@ -22,10 +21,6 @@ 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.
@@ -37,23 +32,9 @@ const appendChunk = (state: FrameBufferState, chunk: Uint8Array): FrameBufferSta
   return { buffer: next, offset: 0 }
 }
 
-const consumeFrames = (route: string) => (state: FrameBufferState, input: FrameInput) =>
+const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8Array) =>
   Effect.gen(function* () {
-    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)
+    let cursor = appendChunk(state, chunk)
     const out: object[] = []
     while (cursor.buffer.length - cursor.offset >= 4) {
       const view = cursor.buffer.subarray(cursor.offset)
@@ -68,14 +49,10 @@ const consumeFrames = (route: string) => (state: FrameBufferState, input: FrameI
             `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
@@ -84,7 +61,6 @@ const consumeFrames = (route: string) => (state: FrameBufferState, input: FrameI
           route,
           [code, message].filter((value): value is string => typeof value === "string").join(": ") ||
             "Bedrock Converse event-stream error",
-          body,
         )
       }
       const eventType =
@@ -94,6 +70,7 @@ const consumeFrames = (route: string) => (state: FrameBufferState, input: FrameI
             ? 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
@@ -103,21 +80,11 @@ const consumeFrames = (route: string) => (state: FrameBufferState, input: FrameI
         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({
-        ...(messageType === "exception"
-          ? { exception: { type: eventType, details: parsed } }
-          : { [eventType]: parsed }),
-        rawBody: body,
-      })
+      out.push(
+        messageType === "exception" ? { exception: { type: eventType, details: parsed } } : { [eventType]: parsed },
+      )
     }
     return [cursor, out] as const
   })
@@ -130,13 +97,7 @@ const consumeFrames = (route: string) => (state: FrameBufferState, input: FrameI
  */
 export const framing = (route: string): Framing.Definition<object> => ({
   id: "aws-event-stream",
-  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)),
-    ),
+  frame: (bytes) => bytes.pipe(Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
 })
 
 export * as BedrockEventStream from "./bedrock-event-stream.js"

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

@@ -1,121 +0,0 @@
-import { Effect, Encoding, Schema, Struct } from "effect"
-import { Headers } from "effect/unstable/http"
-import { AIError } from "../schema/index.js"
-import { Route } from "../route/client.js"
-import { Endpoint } from "../route/endpoint.js"
-import { Protocol } from "../route/protocol.js"
-import { classifyProviderFailure } from "../provider-error.js"
-import { AnthropicMessages } from "./anthropic-messages.js"
-import { BedrockEventStream } from "./bedrock-event-stream.js"
-import { BedrockAuth } from "./utils/bedrock-auth.js"
-import { JsonObject, ProviderShared } from "./shared.js"
-
-const ID = "bedrock-messages"
-const VERSION = "bedrock-2023-05-31"
-const Body = Schema.Struct({
-  ...Struct.omit(AnthropicMessages.AnthropicMessagesBody.fields, ["model", "stream"]),
-  anthropic_version: Schema.Literal(VERSION),
-  anthropic_beta: Schema.optional(Schema.Array(Schema.String)),
-}).check(
-  Schema.makeFilter(
-    (body) =>
-      body.messages.flatMap((message) => message.content.map(mediaIssue)).find((issue) => issue !== undefined) ?? true,
-  ),
-)
-const Event = Schema.Struct({
-  chunk: Schema.optional(Schema.Struct({ bytes: Schema.String })),
-  exception: Schema.optional(
-    Schema.Struct({
-      type: Schema.String,
-      details: Schema.StructWithRest(
-        Schema.Struct({ message: Schema.optional(Schema.String), originalMessage: Schema.optional(Schema.String) }),
-        [JsonObject],
-      ),
-    }),
-  ),
-})
-
-export const protocol = Protocol.make({
-  id: ID,
-  body: {
-    schema: Body,
-    from: Effect.fn("BedrockMessages.fromRequest")(function* (request) {
-      const body = yield* AnthropicMessages.protocol.body.from(request)
-      const headers = Headers.fromInput(request.http?.headers)
-      const betas = new Set(
-        (headers["anthropic-beta"] ?? "")
-          .split(",")
-          .map((value) => value.trim())
-          .filter(Boolean),
-      )
-      if (
-        body.context_management?.edits.length ||
-        body.messages.some((message) => message.content.some((block) => block.type === "compaction"))
-      )
-        betas.add("compact-2026-01-12")
-      return {
-        ...Struct.omit(body, ["model", "stream"]),
-        anthropic_version: VERSION,
-        anthropic_beta: betas.size ? [...betas] : undefined,
-      } satisfies typeof Body.Type
-    }),
-  },
-  stream: {
-    event: Event,
-    initial: AnthropicMessages.protocol.stream.initial,
-    step: Effect.fn("BedrockMessages.step")(function* (state, event) {
-      if (event.exception)
-        return yield* new AIError({
-          reason: classifyProviderFailure({
-            message: event.exception.details.message ?? event.exception.details.originalMessage ?? event.exception.type,
-            rawBody: ProviderShared.encodeJson(event),
-          }),
-        })
-      if (!event.chunk) return yield* ProviderShared.eventError(ID, "Bedrock Messages event is missing its chunk")
-      const text = yield* Effect.fromResult(Encoding.decodeBase64String(event.chunk.bytes)).pipe(
-        Effect.mapError((cause) =>
-          ProviderShared.eventError(ID, "Invalid Bedrock Messages chunk encoding", undefined, cause),
-        ),
-      )
-      const decoded = yield* Schema.decodeUnknownEffect(AnthropicMessages.protocol.stream.event)(text).pipe(
-        Effect.mapError((cause) => ProviderShared.eventError(ID, "Invalid Bedrock Messages event", undefined, cause)),
-      )
-      return yield* AnthropicMessages.protocol.stream.step(state, decoded)
-    }),
-  },
-})
-
-function mediaIssue(
-  block: AnthropicMessages.AnthropicMessagesBody["messages"][number]["content"][number],
-): string | undefined {
-  if (block.type === "tool_result")
-    return typeof block.content === "string"
-      ? undefined
-      : block.content.map(mediaIssue).find((issue) => issue !== undefined)
-  if (block.type !== "image" && block.type !== "document") return undefined
-  if (block.source.type === "url" || block.source.type === "file")
-    return "Bedrock Messages does not support URL or file-ID media sources"
-  if (
-    block.type === "image" &&
-    !["image/jpeg", "image/png", "image/webp", "image/gif"].includes(block.source.media_type)
-  )
-    return "Bedrock Messages requires a JPEG, PNG, WebP, or GIF image"
-  if (block.source.type === "base64" && Encoding.decodeBase64(block.source.data)._tag === "Failure")
-    return "Bedrock Messages media data must be valid base64"
-  return undefined
-}
-
-export const route = Route.make({
-  id: ID,
-  provider: "amazon-bedrock",
-  providerMetadataKey: "anthropic",
-  protocol,
-  endpoint: Endpoint.path(
-    ({ request }) => `/model/${encodeURIComponent(request.model.id)}/invoke-with-response-stream`,
-    { baseURL: "https://bedrock-runtime.us-east-1.amazonaws.com" },
-  ),
-  auth: BedrockAuth.auth,
-  framing: BedrockEventStream.framing(ID),
-})
-
-export * as BedrockMessages from "./bedrock-messages.js"

packages/ai/src/protocols/gemini.ts

@@ -6,7 +6,6 @@ import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
 import { Protocol } from "../route/protocol.js"
 import {
-  AIError,
   LLMEvent,
   Usage,
   type FinishReason,
@@ -18,7 +17,6 @@ import {
   type ToolCallPart,
   type ToolDefinition,
 } from "../schema/index.js"
-import { classifyProviderFailure } from "../provider-error.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { GeminiToolSchema } from "./utils/gemini-tool-schema.js"
 import { Lifecycle } from "./utils/lifecycle.js"
@@ -223,7 +221,6 @@ const GeminiPromptFeedback = Schema.StructWithRest(
 type GeminiPromptFeedback = Schema.Schema.Type<typeof GeminiPromptFeedback>
 
 const GeminiEvent = Schema.Struct({
-  error: Schema.optional(Schema.Unknown),
   candidates: optionalNull(Schema.Array(GeminiCandidate)),
   promptFeedback: optionalNull(GeminiPromptFeedback),
   usageMetadata: optionalNull(GeminiUsage),
@@ -240,10 +237,6 @@ 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>
 }
 
@@ -575,23 +568,19 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
 
   const events: LLMEvent[] = []
   let lifecycle = state.lifecycle
-  if (state.reasoningId !== undefined)
+  if (state.reasoningSignature !== undefined)
     lifecycle = Lifecycle.reasoningEnd(
       lifecycle,
       events,
-      state.reasoningId,
-      state.reasoningSignature === undefined
-        ? undefined
-        : providerMetadata(state.providerMetadataKey, { thoughtSignature: state.reasoningSignature }),
+      "reasoning-0",
+      providerMetadata(state.providerMetadataKey, { thoughtSignature: state.reasoningSignature }),
     )
-  if (state.textId !== undefined)
+  if (state.textSignature !== undefined)
     lifecycle = Lifecycle.textEnd(
       lifecycle,
       events,
-      state.textId,
-      state.textSignature === undefined
-        ? undefined
-        : providerMetadata(state.providerMetadataKey, { thoughtSignature: state.textSignature }),
+      "text-0",
+      providerMetadata(state.providerMetadataKey, { thoughtSignature: state.textSignature }),
     )
   Lifecycle.finish(lifecycle, events, {
     reason: {
@@ -609,18 +598,6 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
 }
 
 const step = (state: ParserState, event: GeminiEvent) => {
-  if (ProviderShared.isRecord(event.error) && typeof event.error.message === "string") {
-    const body = ProviderShared.encodeJson(event)
-    return Effect.fail(
-      new AIError({
-        reason: classifyProviderFailure({
-          message: event.error.message,
-          status: typeof event.error.code === "number" ? event.error.code : undefined,
-          rawBody: body,
-        }),
-      }),
-    )
-  }
   const nextState = {
     ...state,
     promptFeedback: event.promptFeedback ?? state.promptFeedback,
@@ -640,10 +617,6 @@ 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)
 
@@ -669,51 +642,27 @@ const step = (state: ParserState, event: GeminiEvent) => {
     else if (signature !== undefined && "text" in part) textSignature = signature
     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,
-          reasoningId,
+          "reasoning-0",
           part.text,
           signature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: signature }) : undefined,
         )
         continue
       }
-      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.reasoningEnd(
+        lifecycle,
+        events,
+        "reasoning-0",
+        reasoningSignature
+          ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
+          : undefined,
+      )
       lifecycle = Lifecycle.textDelta(
         lifecycle,
         events,
-        textId,
+        "text-0",
         part.text,
         textSignature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature }) : undefined,
       )
@@ -731,28 +680,14 @@ const step = (state: ParserState, event: GeminiEvent) => {
       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
+          ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
+          : undefined,
+      )
       lifecycle = Lifecycle.stepStart(lifecycle, events)
       events.push(
         LLMEvent.toolCall({
@@ -775,10 +710,6 @@ const step = (state: ParserState, event: GeminiEvent) => {
       lifecycle,
       reasoningSignature,
       textSignature,
-      reasoningId,
-      textId,
-      nextReasoningId,
-      nextTextId,
       seenCallIds,
       finishReason: candidate.finishReason ?? nextState.finishReason,
     },
@@ -806,8 +737,6 @@ export const protocol = Protocol.make({
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       hasToolCalls: false,
       lifecycle: Lifecycle.initial(),
-      nextReasoningId: 0,
-      nextTextId: 0,
     }),
     step,
     onHalt: (state) => Effect.succeed(finish(state)),

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

@@ -9,7 +9,15 @@ import {
   type ImageRoute,
 } from "../image.js"
 import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
-import { AIError, Usage, mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema/index.js"
+import {
+  InvalidProviderOutputReason,
+  AIError,
+  Usage,
+  mergeHttpOptions,
+  mergeJsonRecords,
+  type HttpOptions,
+  type ProviderMetadata,
+} from "../schema/index.js"
 import { ProviderShared } from "./shared.js"
 import { ImageInputs } from "./utils/image-input.js"
 
@@ -116,6 +124,13 @@ 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)
@@ -154,9 +169,11 @@ export const model = (input: ModelInput) => {
           HttpClientRequest.bodyText(text, "application/json"),
         ),
       )
-      const output = yield* ProviderShared.imageResponse(ADAPTER, "Google Images", response)
-      const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(GoogleImageResponse))(output.body).pipe(
-        Effect.mapError((cause) => output.invalid("Google Images returned an invalid response", cause)),
+      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) => ({
@@ -191,10 +208,9 @@ export const model = (input: ModelInput) => {
       )
       const images = yield* Effect.forEach(encoded, (item) =>
         Effect.fromResult(Encoding.decodeBase64(item.inlineData.data)).pipe(
-          Effect.mapError((cause) =>
-            output.invalid(
+          Effect.mapError(() =>
+            invalidOutput(
               `Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`,
-              cause,
             ),
           ),
           Effect.map(
@@ -221,10 +237,16 @@ export const model = (input: ModelInput) => {
         const finishReasons = candidates.flatMap((candidate) =>
           candidate.finishReason === undefined ? [] : [candidate.finishReason],
         )
-        return yield* output.invalid(
+        return yield* invalidOutput(
           `Google Images returned no final images${
             finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`
-          }; inspect body for prompt feedback and candidate details`,
+          }; inspect reason.providerMetadata.google for prompt feedback and candidate details`,
+          {
+            google: {
+              promptFeedback: decoded.promptFeedback,
+              candidates: candidateMetadata,
+            },
+          },
         )
       }
       const usage = decoded.usageMetadata
@@ -268,11 +290,12 @@ const googleImagePart = (image: ImageInput): Effect.Effect<Record<string, unknow
     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).pipe(
+    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",
             ),
           )
@@ -282,7 +305,7 @@ const googleImagePart = (image: ImageInput): Effect.Effect<Record<string, unknow
       }),
     )
   return Effect.fail(
-    ImageInputs.invalid("Google generateContent requires Gemini file URIs rather than provider file IDs"),
+    ImageInputs.invalid(ADAPTER, "Google generateContent requires Gemini file URIs rather than provider file IDs"),
   )
 }
 

packages/ai/src/protocols/index.ts

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

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

@@ -1,780 +0,0 @@
-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,
-  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 { ToolStream } from "./utils/tool-stream.js"
-
-const ADAPTER = "mistral-chat"
-const DONE = "[DONE]" as const
-const TOOL_ID = /^[A-Za-z0-9]{9}$/
-export const DEFAULT_BASE_URL = "https://api.mistral.ai/v1"
-export const PATH = "/chat/completions"
-
-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 hashID = (value: string) => {
-  const hash = (seed: number) => {
-    let result = seed
-    for (const char of value) result = Math.imul(result ^ char.charCodeAt(0), 16777619)
-    return (result >>> 0).toString(36)
-  }
-  return `${hash(2166136261).padStart(7, "0")}${hash(2246822519).padStart(7, "0")}`.slice(-9)
-}
-
-const toolIDNormalizer = (request: LLMRequest) => {
-  const ids = request.messages.flatMap((message) =>
-    message.content.flatMap((part) => (part.type === "tool-call" || part.type === "tool-result" ? [part.id] : [])),
-  )
-  const used = new Set(ids.filter((id) => TOOL_ID.test(id)))
-  const normalized = new Map<string, string>()
-  return (id: string) => {
-    if (TOOL_ID.test(id)) return id
-    const previous = normalized.get(id)
-    if (previous) return previous
-    let attempt = 0
-    let candidate = hashID(id)
-    while (used.has(candidate)) candidate = hashID(`${id}:${++attempt}`)
-    used.add(candidate)
-    normalized.set(id, candidate)
-    return candidate
-  }
-}
-
-const lowerMedia = Effect.fn("MistralChat.lowerMedia")(function* (part: MediaPart) {
-  const media = ProviderShared.normalizeMedia(part)
-  const url = typeof part.data === "string" && /^(?:https?:|data:)/.test(part.data) ? part.data : media.dataUrl
-  if (media.mime.startsWith("image/")) return { type: "image_url" as const, image_url: url }
-  if (media.mime === "application/pdf") return { type: "document_url" as const, document_url: url }
-  return yield* ProviderShared.invalidRequest(`Mistral Chat does not support media type ${part.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({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name }))
-    }
-    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 = toolIDNormalizer(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
-  return {
-    model: request.model.id,
-    messages: yield* lowerMessages(request),
-    tools: request.tools.length > 0 ? request.tools.map(lowerTool) : undefined,
-    tool_choice: toolChoice,
-    stream: true as const,
-    max_tokens: request.generation?.maxTokens,
-    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 (TOOL_ID.test(source))
-    return { id: source, state: { ...state, usedToolIDs: new Set([...state.usedToolIDs, source]) } }
-  const previous = state.toolIDs.get(source)
-  if (previous) return { id: previous, state }
-  let attempt = 0
-  let id = hashID(source)
-  while (state.usedToolIDs.has(id)) id = hashID(`${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,
-  }
-  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"

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

@@ -1,7 +1,6 @@
 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,
@@ -61,8 +60,8 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
     observe: (_create, frame) =>
       Effect.gen(function* () {
         const event = yield* decodeEvent(frame).pipe(
-          Effect.mapError((cause) =>
-            ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause),
+          Effect.mapError(() =>
+            ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame),
           ),
         )
         if (terminal)
@@ -74,13 +73,13 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
         if (event.type === "error") {
           terminal = true
           yield* OpenResponses.decodeKnownErrorEvent(event).pipe(
-            Effect.mapError((cause) =>
-              ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame, cause),
+            Effect.mapError(() =>
+              ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame),
             ),
           )
           return {
             type: "provider-failure",
-            error: OpenResponses.providerFailure(event, `${options.name} stream error`, frame),
+            error: OpenResponses.providerFailure(options.id, event, `${options.name} stream error`),
           }
         }
         if (event.type === "response.failed") {
@@ -93,7 +92,7 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
             )
           return {
             type: "provider-failure",
-            error: OpenResponses.providerFailure(event, `${options.name} response failed`, frame),
+            error: OpenResponses.providerFailure(options.id, event, `${options.name} response failed`),
           }
         }
         if (event.type === "response.created") {
@@ -176,37 +175,23 @@ export const transport = <Body>(options: Options): Transport<Body, Prepared, str
           channel,
         }
       }),
-    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
-          },
-        }
-      }),
+    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)
+    },
   }
 }
 

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

@@ -1,4 +1,4 @@
-import { AIError, TransportError } from "../schema/index.js"
+import { AIError, TransportReason } from "../schema/index.js"
 import type { ChannelCheckpoint, ChannelObservation, WebSocketChannelDriver } from "../route/transport/index.js"
 import { Effect, Option, Schema } from "effect"
 import * as ProviderShared from "./shared.js"
@@ -99,17 +99,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({
-    reason: new TransportError({
+    module: input.id,
+    method: "stream",
+    reason: new TransportReason({
       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",
@@ -137,16 +137,15 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
     observe: (create, frame) =>
       Effect.gen(function* () {
         const event = yield* decodeEvent(frame).pipe(
-          Effect.mapError((cause) =>
-            ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause),
-          ),
+          Effect.mapError(() => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame)),
         )
         const observation = yield* input.base.observe(create, frame)
         if (event.type === "response.output_item.done" && event.item) output.push(event.item)
         if (observation.type === "provider-failure") {
           const rejection = code(event)
-          if (rejection === "previous_response_not_found") return rejected(observation, "retry-full")
-          if (rejection === "websocket_connection_limit_reached") return rejected(observation, "rotate-and-retry-full")
+          if (rejection === "previous_response_not_found") return rejected(input, observation, "retry-full")
+          if (rejection === "websocket_connection_limit_reached")
+            return rejected(input, observation, "rotate-and-retry-full")
         }
         if (observation.type !== "completed") return observation
         const responseID = event.response?.id

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

@@ -1,11 +1,11 @@
-import { Effect, Option, Schema } from "effect"
+import { Effect, Schema } from "effect"
 import type { Content } from "@opencode-ai/schema/tool"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
 import {
   AIError,
   LLMEvent,
-  ProviderInternalError,
+  ProviderInternalReason,
   Usage,
   type FinishReason,
   type JsonSchema,
@@ -32,19 +32,17 @@ export const PATH = "/responses"
 // =============================================================================
 // Request Body Schema
 // =============================================================================
-export const OpenResponsesInputText = Schema.Struct({
+const OpenResponsesInputText = Schema.Struct({
   type: Schema.tag("input_text"),
   text: Schema.String,
 })
-export const OpenResponsesInputImage = Schema.Struct({
+const OpenResponsesInputImage = Schema.Struct({
   type: Schema.tag("input_image"),
   image_url: Schema.String,
-  detail: Schema.optional(Schema.String),
 })
-export const OpenResponsesInputFile = Schema.Struct({
+const OpenResponsesInputFile = Schema.Struct({
   type: Schema.tag("input_file"),
   filename: Schema.String,
-  detail: Schema.optional(Schema.String),
   file_data: Schema.optional(Schema.String),
   file_url: Schema.optional(Schema.String),
 })
@@ -56,7 +54,7 @@ const MediaInput = Schema.Union([OpenResponsesInputImage, OpenResponsesInputFile
 export type MediaInput = Schema.Schema.Type<typeof MediaInput>
 const OpenResponsesInputContent = Schema.Union([OpenResponsesInputText, MediaInput])
 
-export const OpenResponsesOutputText = Schema.Struct({
+const OpenResponsesOutputText = Schema.Struct({
   type: Schema.tag("output_text"),
   text: Schema.String,
 })
@@ -64,13 +62,6 @@ export const OpenResponsesOutputText = Schema.Struct({
 export const MessagePhase = Schema.NullOr(Schema.Literals(["commentary", "final_answer"]))
 type MessagePhase = Schema.Schema.Type<typeof MessagePhase>
 
-export const MessageMetadata = Schema.Struct({
-  itemId: Schema.optional(Schema.String),
-  type: Schema.optional(Schema.Literal("message")),
-  status: Schema.optional(Schema.String),
-  phase: Schema.optional(MessagePhase),
-})
-
 const messagePhase = (value: unknown): MessagePhase | undefined => {
   if (value === null || value === "commentary" || value === "final_answer") return value
   return undefined
@@ -81,7 +72,7 @@ const OpenResponsesReasoningSummaryText = Schema.Struct({
   text: Schema.String,
 })
 
-export const OpenResponsesReasoningItem = Schema.Struct({
+const OpenResponsesReasoningItem = Schema.Struct({
   type: Schema.tag("reasoning"),
   id: Schema.optionalKey(Schema.String),
   summary: Schema.Array(OpenResponsesReasoningSummaryText),
@@ -158,30 +149,16 @@ const OpenResponsesFunctionCallOutput = Schema.Union([
   Schema.Array(OpenResponsesFunctionCallOutputContent),
 ])
 
-export const CompactionItem = Schema.Struct({
-  type: Schema.Literal("compaction"),
-  id: optionalNull(Schema.String),
-  encrypted_content: Schema.String,
-})
-
 export const InputItem = Schema.Union([
-  CompactionItem,
   Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
   Schema.Struct({ role: Schema.tag("developer"), content: Schema.String }),
-  Schema.Struct({
-    role: Schema.tag("user"),
-    content: Schema.Array(OpenResponsesInputContent),
-    type: Schema.optional(Schema.Literal("message")),
-    id: Schema.optional(Schema.String),
-    status: Schema.optional(Schema.String),
-  }),
+  Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenResponsesInputContent) }),
   Schema.Struct({
     type: Schema.tag("message"),
     id: Schema.optionalKey(Schema.String),
     role: Schema.tag("assistant"),
     content: Schema.Array(OpenResponsesOutputText),
     phase: Schema.optionalKey(MessagePhase),
-    status: Schema.optional(Schema.String),
   }),
   OpenResponsesReasoningItem,
   Schema.Struct({
@@ -290,7 +267,7 @@ const OpenResponsesBody = Schema.Struct({
 })
 export type OpenResponsesBody = Schema.Schema.Type<typeof OpenResponsesBody>
 
-export const OpenResponsesUsage = Schema.Struct({
+const OpenResponsesUsage = Schema.Struct({
   input_tokens: Schema.optional(Schema.Number),
   input_tokens_details: optionalNull(
     Schema.Struct({
@@ -410,25 +387,21 @@ export interface Extension {
 const BASE: Extension = { id: ADAPTER, name: NAME }
 
 export interface ParserState {
-  readonly provider: LLMRequest["model"]["provider"]
-  readonly completedCompactions: ReadonlySet<string>
   readonly id: string
   readonly name: string
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<string>
-  // Call ids stay independent of item ids, which may be omitted or reused.
-  readonly completedTools: ReadonlySet<string>
   readonly hasFunctionCall: boolean
   readonly lifecycle: Lifecycle.State
   readonly outputItems: Readonly<Record<number, string>>
-  readonly message: { readonly id: string; readonly phase: MessagePhase | null | undefined } | undefined
+  readonly messageItems: ReadonlySet<string>
+  readonly messagePhases: Readonly<Record<string, MessagePhase | null>>
   readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>
 }
 
 type ReasoningSummaryStatus = "active" | "can-conclude" | "concluded"
 
 interface ReasoningStreamItem {
-  readonly open: boolean
   readonly encryptedContent: string | null | undefined
   // Keyed by the wire protocol's numeric `summary_index`. JS object keys coerce to
   // strings, but typing the map as `Record<number, ...>` documents intent
@@ -513,9 +486,6 @@ const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
   const media = ProviderShared.normalizeMedia(part)
   const extended = extension.lowerMedia?.({ part, media, request })
   if (extended) return extended
-  const detail = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesInputImage.fields.detail))(
-    part.providerMetadata?.[metadataKey(request.model)]?.detail,
-  )
   const url =
     typeof part.data === "string" && (part.data.startsWith("https://") || part.data.startsWith("http://"))
       ? part.data
@@ -526,15 +496,10 @@ const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
     return {
       type: "input_file" as const,
       filename: part.filename ?? (media.mime === "application/pdf" ? "document.pdf" : "file"),
-      detail,
       ...(url ? { file_url: url } : { file_data: media.dataUrl }),
     }
   }
-  return {
-    type: "input_image" as const,
-    image_url: url ?? media.dataUrl,
-    detail,
-  }
+  return { type: "input_image" as const, image_url: url ?? media.dataUrl }
 })
 
 const lowerUserContent = Effect.fnUntraced(function* (
@@ -598,12 +563,9 @@ const lowerToolResultOutput = Effect.fnUntraced(function* (
 
 const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (request: LLMRequest, extension: Extension) {
   const input: LoweredInputItem[] = []
-  const providerMetadataKey = metadataKey(request.model)
+  const providerMetadataKey = request.model.route.providerMetadataKey ?? "openresponses"
 
   for (const message of request.messages) {
-    const metadata = yield* ProviderShared.validateWith(
-      Schema.decodeUnknownEffect(Schema.UndefinedOr(MessageMetadata)),
-    )(message.providerMetadata?.[providerMetadataKey])
     if (message.role === "system") {
       input.push({
         role: "developer",
@@ -613,9 +575,10 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
     }
 
     if (message.role === "user") {
-      const content = yield* Effect.forEach(message.content, (part) => lowerUserContent(part, request, extension))
-      if (content.length > 0)
-        input.push({ role: "user", content, type: metadata?.type, id: metadata?.itemId, status: metadata?.status })
+      input.push({
+        role: "user",
+        content: yield* Effect.forEach(message.content, (part) => lowerUserContent(part, request, extension)),
+      })
       continue
     }
 
@@ -628,10 +591,9 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
         const groups = content.reduce<
           Array<{ id: string | undefined; phase: MessagePhase | null | undefined; parts: TextPart[] }>
         >((groups, part) => {
-          const partMetadata = part.providerMetadata?.[providerMetadataKey]
-          const id = itemID(part.providerMetadata, providerMetadataKey) ?? metadata?.itemId
-          const partPhase = messagePhase(partMetadata?.phase)
-          const phase = partPhase === undefined ? metadata?.phase : partPhase
+          const metadata = part.providerMetadata?.[providerMetadataKey]
+          const id = itemID(part.providerMetadata, providerMetadataKey)
+          const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase) : undefined
           const group = groups.at(-1)
           if (group && group.id === id && group.phase === phase) group.parts.push(part)
           else groups.push({ id, phase, parts: [part] })
@@ -642,7 +604,6 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
             type: "message" as const,
             ...(group.id === undefined ? {} : { id: group.id }),
             role: "assistant" as const,
-            status: metadata?.status,
             content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
             ...(group.phase === undefined ? {} : { phase: group.phase }),
           })),
@@ -650,15 +611,6 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
         content.splice(0, content.length)
       }
       for (const part of message.content) {
-        if (part.type === "compaction") {
-          flushText()
-          if (part.provider !== request.model.provider || part.encrypted === undefined)
-            return yield* ProviderShared.invalidRequest(
-              "Compaction state must be replayed to its originating provider and API",
-            )
-          input.push({ type: "compaction", id: part.id, encrypted_content: part.encrypted })
-          continue
-        }
         if (part.type === "text") {
           content.push(part)
           continue
@@ -737,30 +689,13 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
   return input
 })
 
-export const lowerConversation = Effect.fn("OpenResponses.lowerConversation")(function* (
-  request: LLMRequest,
-  extension: Extension,
-) {
-  const instructions = ProviderShared.joinText(request.system)
-  return {
-    model: request.model.id,
-    input: yield* lowerMessages(request, extension),
-    ...(instructions ? { instructions } : {}),
-  }
-})
-
-export const lowerGeneration = (request: LLMRequest) => {
+const lowerOptions = (request: LLMRequest) => {
   const options = OpenResponsesOptions.resolve(request)
-  const generation = request.generation
+  const instructions = ProviderShared.joinText(request.system)
   const cacheKey = ProviderShared.promptCacheKey(request)
   const parallelToolCalls = resolveParallelToolCalls(request)
   return {
-    stream: true as const,
-    max_output_tokens: generation?.maxTokens,
-    temperature: generation?.temperature,
-    top_p: generation?.topP,
-    presence_penalty: generation?.presencePenalty,
-    frequency_penalty: generation?.frequencyPenalty,
+    ...(instructions ? { instructions } : {}),
     ...(options.store !== undefined ? { store: options.store } : {}),
     ...(options.metadata ? { metadata: options.metadata } : {}),
     ...(options.safetyIdentifier ? { safety_identifier: options.safetyIdentifier } : {}),
@@ -788,7 +723,7 @@ export const resolveParallelToolCalls = (request: LLMRequest) => {
   return disabled === undefined ? undefined : !disabled
 }
 
-export const allowedToolChoice = (request: LLMRequest) => {
+const allowedToolChoice = (request: LLMRequest) => {
   const allowed = OpenResponsesOptions.resolve(request).allowedTools
   if (!allowed) return undefined
   return {
@@ -802,10 +737,11 @@ export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWith
   request: LLMRequest,
   extension: Extension,
 ) {
+  const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   return {
-    ...(yield* lowerConversation(request, extension)),
-    ...lowerGeneration(request),
+    model: request.model.id,
+    input: yield* lowerMessages(request, extension),
     tools:
       request.tools.length === 0
         ? undefined
@@ -819,6 +755,13 @@ export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWith
     tool_choice:
       allowedToolChoice(request) ??
       (request.toolChoice ? yield* lowerToolChoice(extension.name, request.toolChoice) : undefined),
+    stream: true as const,
+    max_output_tokens: generation?.maxTokens,
+    temperature: generation?.temperature,
+    top_p: generation?.topP,
+    presence_penalty: generation?.presencePenalty,
+    frequency_penalty: generation?.frequencyPenalty,
+    ...lowerOptions(request),
   }
 })
 
@@ -835,7 +778,7 @@ export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (req
 // cached-read and cache-write subsets, and `output_tokens` (inclusive total)
 // with a `reasoning_tokens` subset. Pass the totals through and derive the
 // non-cached breakdown.
-export const mapUsage = (usage: OpenResponsesUsage | null | undefined, providerMetadataKey: string) => {
+const mapUsage = (usage: OpenResponsesUsage | null | undefined, providerMetadataKey: string) => {
   if (!usage) return undefined
   const cached = usage.input_tokens_details?.cached_tokens
   const cacheWrite = usage.input_tokens_details?.cache_write_tokens
@@ -865,8 +808,6 @@ const mapFinishReason = (event: Event, hasFunctionCall: boolean): FinishReason =
   return hasFunctionCall ? "tool-calls" : "unknown"
 }
 
-export const metadataKey = (model: LLMRequest["model"]) => model.route.providerMetadataKey ?? "openresponses"
-
 export const providerMetadata = (state: ParserState, metadata: Record<string, unknown>): ProviderMetadata => ({
   [state.providerMetadataKey]: metadata,
 })
@@ -885,16 +826,16 @@ const TERMINAL_TYPES = new Set(["error", "response.completed", "response.incompl
 export const terminal = (event: Event) => TERMINAL_TYPES.has(event.type)
 
 const onOutputTextDelta = (state: ParserState, event: Event, id: string): StepResult => {
-  if (!event.delta || state.message?.id !== id) return [state, NO_EVENTS]
+  if (!event.delta || !state.messageItems.has(id)) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
-  const phase = state.message.phase
+  const phase = state.messagePhases[id]
   const metadata = providerMetadata(state, { itemId: id, ...(phase === undefined ? {} : { phase }) })
   const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata)
   return [{ ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) }, events]
 }
 
 const onOutputTextDone = (state: ParserState, event: Event, id: string): StepResult => {
-  if (state.message?.id === id) {
+  if (state.messageItems.has(id)) {
     if (state.lifecycle.text.has(id) || event.text === undefined) return [state, NO_EVENTS]
     return onOutputTextDelta(state, { ...event, delta: event.text }, id)
   }
@@ -902,80 +843,21 @@ const onOutputTextDone = (state: ParserState, event: Event, id: string): StepRes
   return [{ ...state, lifecycle: Lifecycle.textEnd(state.lifecycle, events, id) }, events]
 }
 
-const decodeMessagePart = Schema.decodeUnknownOption(
-  Schema.Union([OpenResponsesOutputText, Schema.Struct({ type: Schema.tag("refusal"), refusal: Schema.String })]),
-)
-
-const decodeSummaryPart = Schema.decodeUnknownOption(OpenResponsesReasoningSummaryText)
-
-const decodeReasoningPart = Schema.decodeUnknownOption(
-  Schema.Struct({ type: Schema.tag("reasoning_text"), text: Schema.String }),
-)
-
-const joinReasoningText = (parts: ReadonlyArray<string | undefined>) => {
-  if (!parts.some((part) => part !== undefined && part.length > 0)) return undefined
-  return parts.filter((part) => part !== undefined).join("\n\n")
-}
-
 export const outputItemID = (state: ParserState, event: Event) =>
   event.output_index === undefined ? event.item_id : (state.outputItems[event.output_index] ?? event.item_id)
 
-const startReasoningSummaryPart = (state: ParserState, itemID: string, index: number): StepResult => {
+export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!item?.open || index === 0 || item.summaryParts[index] !== undefined) return [state, NO_EVENTS]
-
+  if (!event.delta || !item) return [state, NO_EVENTS]
+  const index = event.summary_index ?? 0
   const events: LLMEvent[] = []
-  const lifecycle = Object.entries(item.summaryParts)
-    .filter((entry) => entry[1] !== "concluded")
-    .reduce(
-      (lifecycle, entry) =>
-        Lifecycle.reasoningEnd(lifecycle, events, `${itemID}:${entry[0]}`, providerMetadata(state, { itemId: itemID })),
-      state.lifecycle,
-    )
   return [
     {
       ...state,
-      lifecycle: Lifecycle.reasoningStart(
-        lifecycle,
-        events,
-        `${itemID}:${index}`,
-        providerMetadata(state, { itemId: itemID, reasoningEncryptedContent: item.encryptedContent ?? null }),
-      ),
+      lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, `${itemID}:${index}`, event.delta),
       reasoningItems: {
         ...state.reasoningItems,
-        [itemID]: {
-          ...item,
-          summaryParts: {
-            ...Object.fromEntries(
-              Object.entries(item.summaryParts).map((entry) =>
-                entry[1] === "concluded" ? entry : [entry[0], "concluded" as const],
-              ),
-            ),
-            [index]: "active",
-          },
-        },
-      },
-    },
-    events,
-  ]
-}
-
-export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
-  const item = state.reasoningItems[itemID]
-  if (!event.delta || !item?.open) return [state, NO_EVENTS]
-  const index = event.summary_index ?? 0
-  if (item.summaryParts[index] === "concluded") return [state, NO_EVENTS]
-  const [started, emitted] = startReasoningSummaryPart(state, itemID, index)
-  const current = started.reasoningItems[itemID]
-  if (!current) return [started, emitted]
-  const events: LLMEvent[] = [...emitted]
-  return [
-    {
-      ...started,
-      lifecycle: Lifecycle.reasoningDelta(started.lifecycle, events, `${itemID}:${index}`, event.delta),
-      reasoningItems: {
-        ...started.reasoningItems,
-        [itemID]: { ...current, deltaIndexes: new Set([...current.deltaIndexes, index]) },
+        [itemID]: { ...item, deltaIndexes: new Set([...item.deltaIndexes, index]) },
       },
     },
     events,
@@ -987,7 +869,7 @@ export const onReasoningDelta = (state: ParserState, event: Event, itemID: strin
 // as a single delta unless that summary index already streamed one.
 export const onReasoningDone = (state: ParserState, event: Event, itemID: string): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!item?.open || typeof event.text !== "string") return [state, NO_EVENTS]
+  if (!item || typeof event.text !== "string") return [state, NO_EVENTS]
   const index = event.summary_index ?? 0
   if (item.deltaIndexes.has(index)) return [state, NO_EVENTS]
   return onReasoningDelta(state, { ...event, delta: event.text }, itemID)
@@ -996,48 +878,32 @@ export const onReasoningDone = (state: ParserState, event: Event, itemID: string
 const reasoningMetadata = (state: ParserState, item: StreamItem & { id: string }) =>
   providerMetadata(state, { itemId: item.id, reasoningEncryptedContent: item.encrypted_content ?? null })
 
-// Responses APIs normally stream reasoning items in this order:
+// Responses APIs stream reasoning items in a stable order:
 //   `output_item.added` (reasoning) →
 //     `reasoning_summary_part.added` (index=0) →
 //     `reasoning_summary_text.delta` →
 //     `reasoning_summary_part.done` (index=0) →
 //     (repeat for index>0) →
 //   `output_item.done` (reasoning).
-// `onOutputItemAdded` seeds the per-item entry, while each later part start is
-// also an implicit boundary for the previous part. This keeps the common event
-// lifecycle ordered when a compatible provider omits or delays a part-done event.
+// The handlers below rely on this ordering: `onOutputItemAdded` seeds the
+// per-item entry, `onReasoningSummaryPartAdded` for `summary_index === 0`
+// short-circuits when the entry already exists, and higher-index handlers
+// fold against the same entry. Behaviour for out-of-order events is
+// best-effort, not guaranteed.
 const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
   const item = event.item
   if (item?.type === "message" && item.id !== undefined) {
-    const itemID = item.id
     const phase = messagePhase(item.phase)
-    // A new message closes earlier messages, including ones that never streamed.
-    const events: LLMEvent[] = []
-    const lifecycle = [...state.lifecycle.text]
-      .filter((id) => id !== itemID)
-      .reduce((lifecycle, id) => {
-        const openPhase = state.message?.id === id ? state.message.phase : undefined
-        return Lifecycle.textEnd(
-          lifecycle,
-          events,
-          id,
-          providerMetadata(state, { itemId: id, ...(openPhase === undefined ? {} : { phase: openPhase }) }),
-        )
-      }, state.lifecycle)
     return [
       {
         ...state,
-        lifecycle,
-        message: {
-          id: itemID,
-          phase: phase === undefined && state.message?.id === itemID ? state.message.phase : phase,
-        },
+        messageItems: new Set([...state.messageItems, item.id]),
+        messagePhases: phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase },
       },
-      events,
+      NO_EVENTS,
     ]
   }
   if (item && isReasoningItem(item)) {
-    if (state.reasoningItems[item.id] !== undefined) return [state, NO_EVENTS]
     const events: LLMEvent[] = []
     return [
       {
@@ -1046,7 +912,6 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
         reasoningItems: {
           ...state.reasoningItems,
           [item.id]: {
-            open: true,
             encryptedContent: item.encrypted_content,
             summaryParts: { 0: "active" },
             deltaIndexes: new Set(),
@@ -1058,8 +923,6 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
   }
   if (item?.type !== "function_call" || !item.call_id) return [state, NO_EVENTS]
   const id = item.id ?? item.call_id
-  if (Object.values(state.tools).some((tool) => tool?.id === item.call_id) || state.completedTools.has(item.call_id))
-    return [state, NO_EVENTS]
   const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
@@ -1080,14 +943,55 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
 
 const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResult => {
   if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
-  return startReasoningSummaryPart(state, event.item_id, event.summary_index)
+  const item = state.reasoningItems[event.item_id]
+  if (!item) return [state, NO_EVENTS]
+  if (event.summary_index === 0) return [state, NO_EVENTS]
+
+  const events: LLMEvent[] = []
+  const closed = Object.entries(item.summaryParts)
+    .filter((entry) => entry[1] === "can-conclude")
+    .reduce(
+      (lifecycle, entry) =>
+        Lifecycle.reasoningEnd(
+          lifecycle,
+          events,
+          `${event.item_id}:${entry[0]}`,
+          providerMetadata(state, { itemId: event.item_id }),
+        ),
+      state.lifecycle,
+    )
+  return [
+    {
+      ...state,
+      lifecycle: Lifecycle.reasoningStart(
+        closed,
+        events,
+        `${event.item_id}:${event.summary_index}`,
+        providerMetadata(state, { itemId: event.item_id, reasoningEncryptedContent: item.encryptedContent ?? null }),
+      ),
+      reasoningItems: {
+        ...state.reasoningItems,
+        [event.item_id]: {
+          ...item,
+          summaryParts: {
+            ...Object.fromEntries(
+              Object.entries(item.summaryParts).map((entry) =>
+                entry[1] === "can-conclude" ? [entry[0], "concluded" as const] : entry,
+              ),
+            ),
+            [event.summary_index]: "active",
+          },
+        },
+      },
+    },
+    events,
+  ]
 }
 
 const onReasoningSummaryPartDone = (state: ParserState, event: Event): StepResult => {
   if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
   const item = state.reasoningItems[event.item_id]
-  if (!item?.open) return [state, NO_EVENTS]
-  if (item.summaryParts[event.summary_index] !== "active") return [state, NO_EVENTS]
+  if (!item) return [state, NO_EVENTS]
   return [
     {
       ...state,
@@ -1137,52 +1041,28 @@ const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgu
   return [{ ...state, lifecycle, tools: result.tools }, events] satisfies StepResult
 })
 
-const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
-  state: ParserState,
-  item: Event["item"],
-) {
+const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (state: ParserState, event: Event) {
+  const item = event.item
   if (!item) return [state, NO_EVENTS] satisfies StepResult
 
-  if (item.type === "compaction") {
-    if (!item.id || typeof item.encrypted_content !== "string")
-      return yield* ProviderShared.eventError(state.id, "Compaction output is missing its id or encrypted content")
-    if (state.completedCompactions.has(item.id)) return [state, NO_EVENTS] satisfies StepResult
-    const events: LLMEvent[] = []
-    const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-    events.push(
-      LLMEvent.compaction({
-        provider: state.provider,
-        id: item.id,
-        encrypted: item.encrypted_content,
-      }),
-    )
-    return [
-      { ...state, lifecycle, completedCompactions: new Set([...state.completedCompactions, item.id]) },
-      events,
-    ] satisfies StepResult
-  }
-
   if (item.type === "message" && item.id !== undefined) {
-    const message = state.message?.id === item.id ? state.message : undefined
     const itemPhase = messagePhase(item.phase)
-    const phase = itemPhase === undefined ? message?.phase : itemPhase
-    const parts: ReadonlyArray<unknown> = Array.isArray(item.content) ? item.content : []
-    const content: string[] = []
-    for (const part of parts) {
-      const decoded = Option.getOrUndefined(decodeMessagePart(part))
-      if (!decoded) continue
-      content.push(decoded.type === "output_text" ? decoded.text : decoded.refusal)
-    }
-    const text = content.length > 0 ? content.join("") : undefined
-    const metadata = providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) })
+    const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase
     const events: LLMEvent[] = []
-    const lifecycle =
-      message && text ? Lifecycle.textStart(state.lifecycle, events, item.id, metadata) : state.lifecycle
+    const messageItems = new Set(state.messageItems)
+    messageItems.delete(item.id)
+    const { [item.id]: _phase, ...messagePhases } = state.messagePhases
     return [
       {
         ...state,
-        lifecycle: Lifecycle.textEnd(lifecycle, events, item.id, metadata, text),
-        message: message ? undefined : state.message,
+        lifecycle: Lifecycle.textEnd(
+          state.lifecycle,
+          events,
+          item.id,
+          providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) }),
+        ),
+        messageItems,
+        messagePhases,
       },
       events,
     ] satisfies StepResult
@@ -1190,36 +1070,20 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
 
   if (item.type === "function_call") {
     if (!item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
-    const callID = item.call_id
-    if (state.completedTools.has(callID)) return [state, NO_EVENTS] satisfies StepResult
-    const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
-    const fallback = item.id ?? callID
-    // Match the pending tool by call id so item events that disagree on
-    // whether `item.id` is present still resolve the same call.
-    const registered =
-      state.tools[fallback] !== undefined
-        ? fallback
-        : Object.keys(state.tools).find((key) => state.tools[key]?.id === callID)
-    const id = registered ?? fallback
-    const tools =
-      registered !== undefined
-        ? state.tools
-        : ToolStream.start(state.tools, id, {
-            id: callID,
-            name: item.name,
-            providerMetadata: metadata,
-          })
+    const id = item.id ?? item.call_id
+    const tools = state.tools[id]
+      ? state.tools
+      : ToolStream.start(state.tools, id, {
+          id: item.call_id,
+          name: item.name,
+          providerMetadata: item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined,
+        })
     const result =
       item.arguments === undefined
         ? yield* ToolStream.finish(state.id, tools, id)
         : yield* ToolStream.finishWithInput(state.id, tools, id, item.arguments)
     const events: LLMEvent[] = []
-    const finished = result.events ?? []
-    // A done-only call never streamed a start event, so open its lifecycle here.
-    const resultEvents =
-      registered !== undefined || finished.length === 0
-        ? finished
-        : [LLMEvent.toolInputStart({ id: callID, name: item.name, providerMetadata: metadata }), ...finished]
+    const resultEvents = result.events ?? []
     const lifecycle = resultEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
     events.push(...resultEvents)
     return [
@@ -1230,82 +1094,30 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
           resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
           state.hasFunctionCall,
         tools: result.tools,
-        completedTools: new Set([...state.completedTools, callID]),
       },
       events,
     ] satisfies StepResult
   }
 
   if (isReasoningItem(item)) {
-    if (state.reasoningItems[item.id]?.open === false) return [state, NO_EVENTS] satisfies StepResult
-    const metadata = reasoningMetadata(state, item)
-    const summaryParts: ReadonlyArray<unknown> = Array.isArray(item.summary) ? item.summary : []
-    const summary: Array<string | undefined> = []
-    for (const part of summaryParts) {
-      const decoded = Option.getOrUndefined(decodeSummaryPart(part))
-      // Keep missing entries so the array still matches the provider's summary indexes.
-      summary.push(decoded?.text)
-    }
-    const reasoningParts: ReadonlyArray<unknown> = Array.isArray(item.content) ? item.content : []
-    const content: string[] = []
-    for (const part of reasoningParts) {
-      const decoded = Option.getOrUndefined(decodeReasoningPart(part))
-      if (decoded) content.push(decoded.text)
-    }
-    const itemText = joinReasoningText(summary) ?? joinReasoningText(content)
     const events: LLMEvent[] = []
+    const metadata = reasoningMetadata(state, item)
     const reasoningItem = state.reasoningItems[item.id]
     if (reasoningItem) {
-      const fragments = Object.entries(reasoningItem.summaryParts)
-      let lifecycle = state.lifecycle
-      for (const [index, status] of fragments) {
-        if (status === "concluded") continue
-        // Do not repeat earlier summaries that were already emitted as separate fragments.
-        const finalText = fragments.length === 1 ? itemText : summary[Number(index)]
-        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, `${item.id}:${index}`, metadata, finalText || undefined)
-      }
-      return [
-        {
-          ...state,
-          lifecycle,
-          reasoningItems: {
-            ...state.reasoningItems,
-            [item.id]: {
-              ...reasoningItem,
-              open: false,
-              encryptedContent: item.encrypted_content ?? reasoningItem.encryptedContent,
-            },
-          },
-        },
-        events,
-      ] satisfies StepResult
+      const lifecycle = Object.entries(reasoningItem.summaryParts)
+        .filter((entry) => entry[1] === "active" || entry[1] === "can-conclude")
+        .reduce(
+          (lifecycle, entry) => Lifecycle.reasoningEnd(lifecycle, events, `${item.id}:${entry[0]}`, metadata),
+          state.lifecycle,
+        )
+      const { [item.id]: _removed, ...reasoningItems } = state.reasoningItems
+      return [{ ...state, lifecycle, reasoningItems }, events] satisfies StepResult
     }
     if (!state.lifecycle.reasoning.has(item.id)) {
       const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
       events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata: metadata }))
-      events.push(
-        LLMEvent.reasoningEnd({
-          id: item.id,
-          providerMetadata: metadata,
-          text: itemText,
-        }),
-      )
-      return [
-        {
-          ...state,
-          lifecycle,
-          reasoningItems: {
-            ...state.reasoningItems,
-            [item.id]: {
-              open: false,
-              encryptedContent: item.encrypted_content,
-              summaryParts: { 0: "concluded" },
-              deltaIndexes: new Set(),
-            },
-          },
-        },
-        events,
-      ] satisfies StepResult
+      events.push(LLMEvent.reasoningEnd({ id: item.id, providerMetadata: metadata }))
+      return [{ ...state, lifecycle }, events] satisfies StepResult
     }
     return [
       { ...state, lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, item.id, metadata) },
@@ -1317,38 +1129,38 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
 })
 
 const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (state: ParserState, event: Event) {
-  let current = state
-  const events: LLMEvent[] = []
-  if (event.type === "response.completed") {
-    for (const item of event.response?.output ?? []) {
-      if (item.type !== "compaction" && item.type !== "function_call") continue
-      if (item.type === "compaction") {
-        // Terminal recovery cannot insert a checkpoint before already-emitted content.
-        if (state.lifecycle.stepStarted && !state.completedCompactions.has(item.id ?? ""))
-          return yield* ProviderShared.eventError(
-            state.id,
-            "Cannot recover a compaction checkpoint after output has been emitted",
-          )
-      }
-      if (item.type === "function_call" && !current.tools[item.id ?? item.call_id ?? ""]) continue
-      const [next, emitted] = yield* onOutputItemDone(current, item)
-      current = next
-      events.push(...emitted)
-    }
-    // Some compatible providers omit output_item.done even after completing the response.
-    const pending = yield* ToolStream.finishAll(current.id, current.tools)
-    current = {
-      ...current,
-      tools: pending.tools,
-      hasFunctionCall:
-        current.hasFunctionCall ||
-        pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)),
-    }
-    events.push(...pending.events)
-  }
+  const reconciled =
+    event.type === "response.completed"
+      ? yield* Effect.reduce(
+          event.response?.output ?? [],
+          () => [state, NO_EVENTS] satisfies StepResult,
+          ([current, events], item) => {
+            const id = item.id ?? (item.type === "function_call" ? item.call_id : undefined)
+            if (
+              id === undefined ||
+              ((item.type !== "function_call" || !current.tools[id]) &&
+                (item.type !== "reasoning" || !current.reasoningItems[id]))
+            )
+              return Effect.succeed([current, events] satisfies StepResult)
+            return onOutputItemDone(current, { type: "response.output_item.done", item }).pipe(
+              Effect.map(([next, emitted]) => [next, [...events, ...emitted]] satisfies StepResult),
+            )
+          },
+        )
+      : ([state, NO_EVENTS] satisfies StepResult)
+  const current = reconciled[0]
+  // Some compatible providers omit output_item.done even after completing the response.
+  const pending =
+    event.type === "response.completed"
+      ? yield* ToolStream.finishAll(current.id, current.tools)
+      : { tools: current.tools, events: NO_EVENTS }
+  const events: LLMEvent[] = [...reconciled[1], ...pending.events]
+  const hasFunctionCall =
+    pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
+    current.hasFunctionCall
   const lifecycle = Lifecycle.finish(current.lifecycle, events, {
     reason: {
-      normalized: mapFinishReason(event, current.hasFunctionCall),
+      normalized: mapFinishReason(event, hasFunctionCall),
       raw: event.response?.incomplete_details?.reason,
     },
     usage: mapUsage(event.response?.usage, current.providerMetadataKey),
@@ -1360,7 +1172,7 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
           })
         : undefined,
   })
-  return [{ ...current, lifecycle }, events] satisfies StepResult
+  return [{ ...current, lifecycle, hasFunctionCall, tools: pending.tools }, events] satisfies StepResult
 })
 
 // Build the prettiest summary available from whatever the provider supplied.
@@ -1376,8 +1188,11 @@ const providerErrorMessage = (event: Event, nested: OpenResponsesErrorPayload |
   return message || code
 }
 
-export const providerFailure = (event: Event, fallback: string, body = ProviderShared.encodeJson(event)) => {
+export const providerFailure = (id: string, event: Event, fallback: string) => {
   const nested = event.error ?? event.response?.error ?? undefined
+  const code = event.code || nested?.code || undefined
+  // Keep the full raw payload on the error even when the message is a summary.
+  const body = JSON.stringify(nested ?? event) ?? ""
   const summary = providerErrorMessage(event, nested)
   const message = summary ?? (body === "{}" ? fallback : body)
   const status =
@@ -1392,11 +1207,18 @@ export const providerFailure = (event: Event, fallback: string, body = ProviderS
     event.response === undefined &&
     summary === undefined &&
     status === undefined
-      ? new ProviderInternalError({ message, body })
-      : classifyProviderFailure({ message, status, rawBody: body })
-  return new AIError({ reason })
+      ? new ProviderInternalReason({ message })
+      : classifyProviderFailure({ message, code, status, rawBody: body })
+  return new AIError({
+    module: id,
+    method: "stream",
+    body,
+    reason,
+  })
 }
 
+const providerError = (state: ParserState, event: Event, fallback: string) => providerFailure(state.id, event, fallback)
+
 export const step = (state: ParserState, input: Event) => {
   // The OpenAPI requires string IDs but imposes no minLength; empty is not missing.
   const event =
@@ -1444,13 +1266,6 @@ export const step = (state: ParserState, input: Event) => {
   if (event.type === "response.output_item.added") {
     if (event.item?.type === "message" && event.item.id === undefined)
       return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
-    if (
-      event.item &&
-      isReasoningItem(event.item) &&
-      state.reasoningItems[event.item.id] === undefined &&
-      state.lifecycle.reasoning.size > 0
-    )
-      return ProviderShared.eventError(state.id, `${event.type} started reasoning before the previous item ended`)
     const id = event.item?.id ?? (event.item?.type === "function_call" ? event.item.call_id : undefined)
     return Effect.succeed(
       onOutputItemAdded(
@@ -1468,21 +1283,14 @@ export const step = (state: ParserState, input: Event) => {
   if (event.type === "response.output_item.done") {
     if (event.item?.type === "message" && event.item.id === undefined)
       return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
-    return onOutputItemDone(state, event.item)
+    return onOutputItemDone(state, event)
   }
   if (event.type === "response.completed" || event.type === "response.incomplete") return onResponseFinish(state, event)
-  if (event.type === "response.failed") return providerFailure(event, `${state.name} response failed`)
+  if (event.type === "response.failed") return providerError(state, event, `${state.name} response failed`)
   if (event.type === "error")
     return decodeKnownErrorEvent(event).pipe(
-      Effect.mapError((cause) =>
-        ProviderShared.eventError(
-          state.id,
-          `${state.name} returned a malformed error event`,
-          ProviderShared.encodeJson(event),
-          cause,
-        ),
-      ),
-      Effect.flatMap(() => providerFailure(event, `${state.name} stream error`)),
+      Effect.mapError(() => ProviderShared.eventError(state.id, `${state.name} returned a malformed error event`)),
+      Effect.flatMap(() => providerError(state, event, `${state.name} stream error`)),
     )
   return Effect.succeed<StepResult>([state, NO_EVENTS])
 }
@@ -1495,17 +1303,15 @@ export const step = (state: ParserState, input: Event) => {
  * implementations compose this baseline with their own tools and event variants.
  */
 export const initial = (request: LLMRequest, extension: Extension = BASE): ParserState => ({
-  provider: request.model.provider,
-  completedCompactions: new Set<string>(),
   id: extension.id,
   name: extension.name,
-  providerMetadataKey: metadataKey(request.model),
+  providerMetadataKey: request.model.route.providerMetadataKey ?? "openresponses",
   hasFunctionCall: false,
   tools: ToolStream.empty<string>(),
-  completedTools: new Set<string>(),
   lifecycle: Lifecycle.initial(),
   outputItems: {},
-  message: undefined,
+  messageItems: new Set<string>(),
+  messagePhases: {},
   reasoningItems: {},
 })
 

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

@@ -3,16 +3,14 @@ import { Tool } from "@opencode-ai/schema/tool"
 import { Route } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
-import { Framing } from "../route/framing.js"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
 import {
   AIError,
-  AIErrorReason,
-  InvalidProviderOutputError,
+  InvalidProviderOutputReason,
   LLMEvent,
-  ProviderInternalError,
-  UnknownProviderError,
+  ProviderInternalReason,
+  UnknownProviderReason,
   Usage,
   type FinishReason,
   type FinishReasonDetails,
@@ -246,8 +244,6 @@ export const OpenAIChatEvent = Schema.StructWithRest(
   [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 {
@@ -788,22 +784,26 @@ 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 finishReasonError = (event: OpenAIChatEvent, reason: AIError["reason"]) =>
+  new AIError({
+    module: ADAPTER,
+    method: "stream",
+    body: ProviderShared.encodeJson(event),
+    reason,
+  })
+
 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),
-        }),
-      })
+      return yield* finishReasonError(
+        event,
+        new UnknownProviderReason({ message: "Provider reported an error (finish_reason: error)" }),
+      )
     case "network_error":
-      return yield* new AIError({
-        reason: new ProviderInternalError({
-          message: "Provider reported a network error (finish_reason: network_error)",
-          body: ProviderShared.encodeJson(event),
-        }),
-      })
+      return yield* finishReasonError(
+        event,
+        new ProviderInternalReason({ message: "Provider reported a network error (finish_reason: network_error)" }),
+      )
     case "stop":
     case "end":
       return "stop" as const
@@ -815,12 +815,7 @@ const mapFinishReason = Effect.fn("OpenAIChat.mapFinishReason")(function* (event
     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),
-        }),
-      })
+      return "unknown" as const
   }
 })
 
@@ -941,8 +936,12 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     if (event.error) {
       const body = ProviderShared.encodeJson(event)
       return yield* new AIError({
+        module: ADAPTER,
+        method: "stream",
+        body,
         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,
         }),
@@ -1005,12 +1004,33 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
       lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata)
     const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0")
 
-    // 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?.content) {
+      lifecycle = Lifecycle.reasoningEnd(
+        lifecycle,
+        events,
+        "reasoning-0",
+        reasoningMetadata(
+          state.providerMetadataKey,
+          reasoningField,
+          reasoningDetailsObserved ? state.reasoningDetails : undefined,
+        ),
+      )
+      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
+    }
 
-    if (delta?.refusal) lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.refusal)
+    if (delta?.refusal) {
+      lifecycle = Lifecycle.reasoningEnd(
+        lifecycle,
+        events,
+        "reasoning-0",
+        reasoningMetadata(
+          state.providerMetadataKey,
+          reasoningField,
+          reasoningDetailsObserved ? state.reasoningDetails : undefined,
+        ),
+      )
+      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.
@@ -1046,38 +1066,23 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
         "OpenAI Chat tool call delta is missing id or name",
       )
       if (ToolStream.isError(result))
-        return yield* new AIError({
-          reason: AIErrorReason.make({
-            ...result.reason,
-            message: result.message,
-            cause: result.reason.cause,
-            body: ProviderShared.encodeJson(event),
-          }),
-        })
+        return yield* ProviderShared.eventError(ADAPTER, result.reason.message, ProviderShared.encodeJson(event))
       tools = result.tools
       if (result.events.length) lifecycle = Lifecycle.stepStart(lifecycle, events)
       events.push(...result.events)
     }
 
-    const incompleteTools = finishReason?.normalized === "content-filter" || finishReason?.normalized === "length"
-    if (
-      finishReason !== undefined &&
-      !incompleteTools &&
-      state.finishReason === undefined &&
-      Object.keys(pendingTools).length
-    )
+    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",
         ProviderShared.encodeJson(event),
       )
 
-    // Filtering or truncation terminates the response without confirming pending tool calls.
+    // Finalize accumulated tool inputs eagerly when finish_reason arrives so
+    // valid calls and malformed local calls settle independently.
     const finished =
-      finishReason !== undefined &&
-      !incompleteTools &&
-      state.finishReason === undefined &&
-      Object.keys(tools).length > 0
+      finishReason !== undefined && state.finishReason === undefined && Object.keys(tools).length > 0
         ? yield* ToolStream.finishAll(ADAPTER, tools)
         : undefined
 
@@ -1105,9 +1110,11 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
 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",
+      module: ADAPTER,
+      method: "stream",
+      reason: new InvalidProviderOutputReason({
         classification: "incomplete-stream",
+        message: "OpenAI Chat stream ended without finish_reason",
         route: ADAPTER,
       }),
     })
@@ -1124,12 +1131,10 @@ const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state: Pars
           state.finishReason.normalized === "stop" && hasToolCalls ? "tool-calls" : state.finishReason.normalized,
       }
     : { 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
@@ -1163,7 +1168,7 @@ export const protocol = Protocol.make({
     from: fromRequest,
   },
   stream: {
-    event: OpenAIChatStreamEvent,
+    event: Protocol.jsonEvent(OpenAIChatEvent),
     initial: (request) => ({
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       tools: ToolStream.empty<number>(),
@@ -1177,14 +1182,12 @@ export const protocol = Protocol.make({
       nextToolIndex: 0,
       requireFinishReason: request.model.compatibility?.requireFinishReason ?? true,
     }),
-    step: (state: ParserState, event) => (event === DONE ? Effect.succeed([state, []] as const) : step(state, event)),
-    terminal: (event) => event === DONE,
+    step,
     onHalt: finishEvents,
   },
 })
 
-export const framing = Framing.sseWithDone
-export const httpTransport = HttpTransport.sseJson.with<OpenAIChatBody>().with({ framing })
+export const httpTransport = HttpTransport.sseJson.with<OpenAIChatBody>()
 
 export const route = Route.make({
   id: ADAPTER,

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

@@ -1,5 +1,6 @@
 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"
@@ -18,7 +19,7 @@ export const route = Route.make({
   providerMetadataKey: "openai",
   protocol: OpenAIChat.protocol,
   endpoint: Endpoint.path("/chat/completions"),
-  framing: OpenAIChat.framing,
+  framing: Framing.sse,
 })
 
 export * as OpenAICompatibleChat from "./openai-compatible-chat.js"

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

@@ -9,7 +9,14 @@ import {
   type ImageRoute,
 } from "../image.js"
 import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
-import { Usage, mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema/index.js"
+import {
+  InvalidProviderOutputReason,
+  AIError,
+  Usage,
+  mergeHttpOptions,
+  mergeJsonRecords,
+  type HttpOptions,
+} from "../schema/index.js"
 import { ProviderShared } from "./shared.js"
 import { ImageInputs } from "./utils/image-input.js"
 import { OpenAIImage } from "./utils/openai-image.js"
@@ -77,6 +84,13 @@ const nativeOptions = (options: OpenAIImageOptions | undefined) => {
   }
 }
 
+const invalidOutput = (message: string) =>
+  new AIError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+  })
+
 const applyQuery = (url: string, query: Record<string, string> | undefined) => {
   if (!query) return url
   const next = new URL(url)
@@ -90,12 +104,12 @@ export const model = (input: ModelInput) => {
     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("An OpenAI image mask requires at least one input image")
+        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)
+        if (image.type === "url") return ImageInputs.decodeDataUrl(image.url, ADAPTER)
         return Effect.undefined
       })
       const multipartMask =
@@ -104,7 +118,7 @@ export const model = (input: ModelInput) => {
           : mask.type === "bytes"
             ? { data: mask.data, mediaType: mask.mediaType }
             : mask.type === "url"
-              ? yield* ImageInputs.decodeDataUrl(mask.url)
+              ? yield* ImageInputs.decodeDataUrl(mask.url, ADAPTER)
               : undefined
       const useMultipart =
         sourceImages.length > 0 &&
@@ -147,7 +161,7 @@ export const model = (input: ModelInput) => {
         return undefined
       })
       if (references.some((image) => image === undefined))
-        return yield* ImageInputs.invalid("OpenAI Images accepts image URLs, data URLs, bytes, and file IDs")
+        return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts image URLs, data URLs, bytes, and file IDs")
       const maskReference =
         mask === undefined
           ? undefined
@@ -159,7 +173,7 @@ export const model = (input: ModelInput) => {
                 ? { file_id: mask.id }
                 : undefined
       if (mask !== undefined && maskReference === undefined)
-        return yield* ImageInputs.invalid("OpenAI Images accepts masks as URLs, data URLs, bytes, or file IDs")
+        return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts masks as URLs, data URLs, bytes, or file IDs")
       const requestBody = mergeJsonRecords(
         {
           model: request.model.id,
@@ -195,9 +209,11 @@ const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (
   options: OpenAIImageOptions | undefined,
   overlay: Record<string, unknown> | undefined,
 ) {
-  const output = yield* ProviderShared.imageResponse(ADAPTER, "OpenAI Images", response)
-  const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIImageResponse))(output.body).pipe(
-    Effect.mapError((cause) => output.invalid("OpenAI Images returned an invalid response", cause)),
+  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 =
@@ -205,7 +221,7 @@ const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (
   const images = yield* Effect.forEach(decoded.data, (item, index) => {
     if (item.b64_json)
       return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
-        Effect.mapError((cause) => output.invalid(`OpenAI Images result ${index} contains invalid base64 data`, cause)),
+        Effect.mapError(() => invalidOutput(`OpenAI Images result ${index} contains invalid base64 data`)),
         Effect.map(
           (data) =>
             new GeneratedImage({
@@ -225,9 +241,9 @@ const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (
             item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
         }),
       )
-    return Effect.fail(output.invalid(`OpenAI Images result ${index} has neither image data nor a URL`))
+    return Effect.fail(invalidOutput(`OpenAI Images result ${index} has neither image data nor a URL`))
   })
-  if (images.length === 0) return yield* output.invalid("OpenAI Images returned no images")
+  if (images.length === 0) return yield* invalidOutput("OpenAI Images returned no images")
   return new ImageResponse({
     images,
     usage:

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

@@ -5,14 +5,13 @@ 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 type { LLMRequest, JsonSchema, ToolDefinition } from "../schema/index.js"
+import { LLMRequest, type JsonSchema, type ToolDefinition } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { OpenAIImage } from "./utils/openai-image.js"
 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"
 
 const ADAPTER = "openai-responses"
 const NAME = "OpenAI Responses"
@@ -21,14 +20,6 @@ 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"])),
@@ -87,14 +78,6 @@ const OpenAIResponsesCoreFields = {
   input: Schema.Array(Schema.Union([OpenResponses.InputItem, OpenAIResponsesHostedToolItem])),
   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({
@@ -142,14 +125,15 @@ const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tool
 const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIResponsesBody))
 
 const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request: LLMRequest) {
-  const management = yield* ProviderShared.validateWith(
-    Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)),
-  )(request.providerOptions?.contextManagement)
+  const body = yield* OpenResponses.fromRequestWithExtension(
+    LLMRequest.update(request, { tools: [], toolChoice: undefined }),
+    extension,
+  )
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
+  const parallelToolCalls = OpenResponses.resolveParallelToolCalls(request)
   return yield* decodeBody({
-    ...(yield* OpenResponses.lowerConversation(request, extension)),
-    ...OpenResponses.lowerGeneration(request),
-    context_management: management?.map((edit) => ({ type: edit.type, compact_threshold: edit.compactThreshold })),
+    ...body,
+    ...(parallelToolCalls === undefined ? {} : { parallel_tool_calls: parallelToolCalls }),
     tools:
       request.tools.length === 0
         ? undefined
@@ -157,8 +141,7 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
             lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
           ),
     tool_choice:
-      OpenResponses.allowedToolChoice(request) ??
-      (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),
+      body.tool_choice ?? (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),
   })
 })
 
@@ -166,9 +149,7 @@ const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function*
   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((cause) =>
-        ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64", undefined, cause),
-      ),
+      Effect.mapError(() => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64")),
     )
     const format = item.output_format ?? "png"
     return {
@@ -240,7 +221,6 @@ export const transport = channelTransport({
 })
 
 export const route = Route.make({
-  compact: ResponsesCompaction.make(extension),
   id: ADAPTER,
   provider: "openai",
   providerMetadataKey: "openai",

packages/ai/src/protocols/shared.ts

@@ -2,12 +2,11 @@ import { Buffer } from "node:buffer"
 import { Tool } from "@opencode-ai/schema/tool"
 import { Effect, Schema, Stream } from "effect"
 import * as Sse from "effect/unstable/encoding/Sse"
-import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { Headers, HttpClientRequest } from "effect/unstable/http"
 import {
-  InvalidProviderOutputError,
-  InvalidRequestError,
+  InvalidProviderOutputReason,
+  InvalidRequestReason,
   AIError,
-  HttpContext,
   type ContentPart,
   type LLMRequest,
   type MediaPart,
@@ -97,15 +96,17 @@ 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, body?: string, cause?: unknown) =>
+export const eventError = (route: string, message: string, raw?: string) =>
   new AIError({
-    reason: new InvalidProviderOutputError({ route, message, body, cause }),
+    module: "ProviderShared",
+    method: "stream",
+    reason: new InvalidProviderOutputReason({ route, message, raw }),
   })
 
 export const parseJson = (route: string, input: string, message: string) =>
   Effect.try({
     try: () => decodeJson(input),
-    catch: (cause) => eventError(route, message, input, cause),
+    catch: () => eventError(route, message, input),
   })
 
 /**
@@ -207,16 +208,15 @@ 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 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, optionally filters named events, and drops empty / `[DONE]`
+ * keep-alive events so the protocol event schema sees one JSON string per
+ * element. 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(),
@@ -233,7 +233,7 @@ export const sseFraming = (
       (state, chunk) =>
         Effect.gen(function* () {
           const error = state.parser.feed(chunk)
-          if (error) return yield* eventError("sse", error.message, chunk, error)
+          if (error) return yield* eventError("sse", error.message)
           return [state, state.output.splice(0)] as const
         }),
     ),
@@ -241,7 +241,7 @@ export const sseFraming = (
       (event) =>
         (events === undefined || events.has(event.event)) &&
         event.data.length > 0 &&
-        (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message")),
+        (event.data !== "[DONE]" || (events !== undefined && event.event !== "message")),
     ),
     Stream.map((event) => event.data),
   )
@@ -249,39 +249,13 @@ export const sseFraming = (
 /**
  * Canonical invalid-request constructor shared by protocol lowering.
  */
-export const invalidRequest = (message: string, cause?: unknown) =>
+export const invalidRequest = (message: string) =>
   new AIError({
-    reason: new InvalidRequestError({ message, cause }),
+    module: "ProviderShared",
+    method: "request",
+    reason: new InvalidRequestReason({ message }),
   })
 
-export const imageResponse = Effect.fn("ProviderShared.imageResponse")(function* (
-  route: string,
-  name: string,
-  response: HttpClientResponse.HttpClientResponse,
-) {
-  const http = new HttpContext({ url: response.request.url, status: response.status, headers: response.headers })
-  const body = yield* response.text.pipe(
-    Effect.mapError(
-      (cause) =>
-        new AIError({
-          reason: new InvalidProviderOutputError({
-            route,
-            message: `Failed to read the ${name} response`,
-            http,
-            cause,
-          }),
-        }),
-    ),
-  )
-  return {
-    body,
-    invalid: (message: string, cause?: unknown) =>
-      new AIError({
-        reason: new InvalidProviderOutputError({ route, message, body, http, cause }),
-      }),
-  }
-})
-
 export const matchToolChoice = <Auto, None, Required, Tool>(
   route: string,
   toolChoice: NonNullable<LLMRequest["toolChoice"]>,
@@ -328,7 +302,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, error)))
+    decode(payload).pipe(Effect.mapError((error) => invalidRequest(error.message)))
 
 /**
  * Build an HTTP POST with a JSON body. Sets `content-type: application/json`

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

@@ -1,4 +1,4 @@
-import { Effect, Encoding, Schema } from "effect"
+import { Effect, Schema } from "effect"
 import type { MediaPart } from "../../schema/index.js"
 import { ProviderShared } from "../shared.js"
 
@@ -57,16 +57,6 @@ const documentBlock = (name: string, format: DocumentFormat, bytes: string): Doc
   },
 })
 
-const mediaBase64 = Effect.fn("BedrockMedia.mediaBase64")(function* (part: MediaPart) {
-  const media = ProviderShared.normalizeMedia(part)
-  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`)
@@ -76,7 +66,8 @@ export const lower = Effect.fn("BedrockMedia.lower")(function* (part: MediaPart)
   const mime = part.mediaType.toLowerCase()
   const imageFormat = IMAGE_FORMATS[mime as keyof typeof IMAGE_FORMATS]
   if (imageFormat) {
-    return { image: { format: imageFormat, source: { bytes: yield* mediaBase64(part) } } } satisfies ImageBlock
+    const media = ProviderShared.normalizeMedia(part)
+    return { image: { format: imageFormat, source: { bytes: media.base64 } } } satisfies ImageBlock
   }
   if (mime.startsWith("image/"))
     return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support image media type ${part.mediaType}`)
@@ -84,7 +75,8 @@ export const lower = Effect.fn("BedrockMedia.lower")(function* (part: MediaPart)
   if (documentFormat) {
     if (!part.filename)
       return yield* ProviderShared.invalidRequest("Bedrock Converse document media requires a filename")
-    return documentBlock(part.filename, documentFormat, yield* mediaBase64(part))
+    const media = ProviderShared.normalizeMedia(part)
+    return documentBlock(part.filename, documentFormat, media.base64)
   }
   return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.mediaType}`)
 })

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

@@ -1,10 +1,12 @@
 import { Effect, Encoding } from "effect"
 import type { ImageInput } from "../../image.js"
-import { InvalidRequestError, AIError } from "../../schema/index.js"
+import { InvalidRequestReason, AIError } from "../../schema/index.js"
 
-const invalid = (message: string, cause?: unknown) =>
+const invalid = (module: string, message: string) =>
   new AIError({
-    reason: new InvalidRequestError({ message, cause }),
+    module,
+    method: "generate",
+    reason: new InvalidRequestReason({ message }),
   })
 
 export const dataUrl = (input: Extract<ImageInput, { readonly type: "bytes" }>) =>
@@ -12,12 +14,13 @@ export const dataUrl = (input: Extract<ImageInput, { readonly type: "bytes" }>)
 
 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("Image data URLs must contain a MIME type and base64 data"))
+  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((cause) => invalid("Image data URL contains invalid base64 data", cause)),
+    Effect.mapError(() => invalid(module, "Image data URL contains invalid base64 data")),
     Effect.map((data) => ({ mediaType: match[1], data })),
   )
 }

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

@@ -62,31 +62,22 @@ 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, text, providerMetadata }))
+  events.push(LLMEvent.reasoningEnd({ id, providerMetadata }))
   const reasoning = new Set(stepped.reasoning)
   reasoning.delete(id)
   return { ...stepped, reasoning }
 }
 
-export const textEnd = (
-  state: State,
-  events: LLMEvent[],
-  id: string,
-  providerMetadata?: ProviderMetadata,
-  /** Authoritative complete value; replaces accumulated deltas when present. */
-  text?: string,
-): State => {
+export const textEnd = (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata): State => {
   if (!state.text.has(id)) return state
   const stepped = stepStart(state, events)
-  events.push(LLMEvent.textEnd({ id, text, providerMetadata }))
-  const open = new Set(stepped.text)
-  open.delete(id)
-  return { ...stepped, text: open }
+  events.push(LLMEvent.textEnd({ id, providerMetadata }))
+  const text = new Set(stepped.text)
+  text.delete(id)
+  return { ...stepped, text }
 }
 
 const closeOpenBlocks = (state: State, events: LLMEvent[]): State => {

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

@@ -1,174 +0,0 @@
-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 { 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"
-
-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 = (extension: OpenResponses.Extension): CompactOperation =>
-  Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
-    const route = request.model.route
-    const native = yield* OpenResponses.lowerConversation(request, extension)
-    const body = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(
-      mergeJsonRecords(
-        {
-          ...native,
-          service_tier: request.providerOptions?.serviceTier,
-          prompt_cache_key: ProviderShared.promptCacheKey(request),
-        },
-        request.http?.body,
-      ),
-    )
-    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({
-      messages: 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",
-          data: part.image_url,
-          mediaType: /^data:([^;,]+)/.exec(part.image_url)?.[1] ?? "image/*",
-          providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
-        }
-      const data = part.file_url === undefined ? part.file_data : part.file_url
-      return {
-        type: "media",
-        data,
-        filename: part.filename,
-        mediaType: /^data:([^;,]+)/.exec(data)?.[1] ?? "application/octet-stream",
-        providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
-      }
-    }),
-  })
-}
-
-export * as ResponsesCompaction from "./responses-compaction.js"

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

@@ -2,7 +2,14 @@ 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 { Usage, mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema/index.js"
+import {
+  InvalidProviderOutputReason,
+  AIError,
+  Usage,
+  mergeHttpOptions,
+  mergeJsonRecords,
+  type HttpOptions,
+} from "../schema/index.js"
 import { ProviderShared, optionalNull } from "./shared.js"
 import { ImageInputs } from "./utils/image-input.js"
 
@@ -87,6 +94,13 @@ const nativeOptions = (options: XAIImageOptions | undefined) => {
   }
 }
 
+const invalidOutput = (message: string) =>
+  new AIError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+  })
+
 const applyQuery = (url: string, query: Record<string, string> | undefined) => {
   if (!query) return url
   const next = new URL(url)
@@ -106,7 +120,7 @@ export const model = (input: ModelInput) => {
         return undefined
       })
       if (imageReferences.some((image) => image === undefined))
-        return yield* ImageInputs.invalid("xAI Images accepts image URLs, data URLs, bytes, and file IDs")
+        return yield* ImageInputs.invalid(ADAPTER, "xAI Images accepts image URLs, data URLs, bytes, and file IDs")
       const requestBody = mergeJsonRecords(
         {
           model: request.model.id,
@@ -135,17 +149,17 @@ export const model = (input: ModelInput) => {
           HttpClientRequest.bodyText(text, "application/json"),
         ),
       )
-      const output = yield* ProviderShared.imageResponse(ADAPTER, "xAI Images", response)
-      const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(XAIImageResponse))(output.body).pipe(
-        Effect.mapError((cause) => output.invalid("xAI Images returned an invalid response", cause)),
+      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((cause) =>
-              output.invalid(`xAI Images result ${index} contains invalid base64 data`, cause),
-            ),
+            Effect.mapError(() => invalidOutput(`xAI Images result ${index} contains invalid base64 data`)),
             Effect.map(
               (data) =>
                 new GeneratedImage({
@@ -169,9 +183,9 @@ export const model = (input: ModelInput) => {
                   : { xai: { revisedPrompt: item.revised_prompt } },
             }),
           )
-        return Effect.fail(output.invalid(`xAI Images result ${index} has neither image data nor a URL`))
+        return Effect.fail(invalidOutput(`xAI Images result ${index} has neither image data nor a URL`))
       })
-      if (images.length === 0) return yield* output.invalid("xAI Images returned no images")
+      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,

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

@@ -4,7 +4,6 @@ import type { LLMRequest } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { JsonObject, optionalNull, ProviderShared } from "./shared.js"
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
-import { ResponsesCompaction } from "./utils/responses-compaction.js"
 
 const ADAPTER = "xai-responses"
 const NAME = "xAI Responses"
@@ -45,10 +44,6 @@ const extension = {
 
 const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(XAIResponsesBody))
 const fromRequest = Effect.fn("XAIResponses.fromRequest")(function* (request: LLMRequest) {
-  if (request.providerOptions?.contextManagement !== undefined)
-    return yield* ProviderShared.invalidRequest(
-      "xAI requires explicit compaction through LLMClient.compact; automatic context management is not supported",
-    )
   return yield* decodeBody(yield* OpenResponses.fromRequestWithExtension(request, extension))
 })
 
@@ -89,6 +84,4 @@ export const protocol = Protocol.make({
   },
 })
 
-export const compact = ResponsesCompaction.make(extension)
-
 export * as XAIResponses from "./xai-responses.js"

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

@@ -2,7 +2,13 @@ import { Effect, 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 { mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema/index.js"
+import {
+  InvalidProviderOutputReason,
+  AIError,
+  mergeHttpOptions,
+  mergeJsonRecords,
+  type HttpOptions,
+} from "../schema/index.js"
 import { ProviderShared } from "./shared.js"
 import { ImageInputs } from "./utils/image-input.js"
 
@@ -57,6 +63,13 @@ const nativeOptions = (options: ZAIImageOptions | undefined) => {
   }
 }
 
+const invalidOutput = (message: string) =>
+  new AIError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+  })
+
 const applyQuery = (url: string, query: Record<string, string> | undefined) => {
   if (!query) return url
   const next = new URL(url)
@@ -69,7 +82,7 @@ export const model = (input: ModelInput) => {
     id: ADAPTER,
     generate: Effect.fn("ZAIImages.generate")(function* (request: ImageRequestFor<ZAIImageOptions>, execute) {
       if ((request.images?.length ?? 0) > 0)
-        return yield* ImageInputs.invalid("Z.ai hosted image generation does not support image inputs")
+        return yield* ImageInputs.invalid(ADAPTER, "Z.ai hosted image generation does not support image inputs")
       const http = mergeHttpOptions(request.model.http, request.http)
       const requestBody = mergeJsonRecords(
         { model: request.model.id, prompt: request.prompt },
@@ -91,11 +104,13 @@ export const model = (input: ModelInput) => {
           HttpClientRequest.bodyText(text, "application/json"),
         ),
       )
-      const output = yield* ProviderShared.imageResponse(ADAPTER, "Z.ai Images", response)
-      const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(ZAIImageResponse))(output.body).pipe(
-        Effect.mapError((cause) => output.invalid("Z.ai Images returned an invalid response", cause)),
+      const payload = yield* response.json.pipe(
+        Effect.mapError(() => invalidOutput("Failed to read the Z.ai Images response")),
       )
-      if (decoded.data.length === 0) return yield* output.invalid("Z.ai Images returned no images")
+      const decoded = yield* Schema.decodeUnknownEffect(ZAIImageResponse)(payload).pipe(
+        Effect.mapError(() => invalidOutput("Z.ai Images returned an invalid response")),
+      )
+      if (decoded.data.length === 0) return yield* invalidOutput("Z.ai Images returned no images")
       return new ImageResponse({
         images: decoded.data.map(
           (item) =>

packages/ai/src/provider-error.ts

@@ -1,16 +1,17 @@
 import { Option, Schema } from "effect"
 import {
-  AuthenticationError,
-  ContentPolicyError,
-  InvalidRequestError,
+  AuthenticationReason,
+  ContentPolicyReason,
+  InvalidRequestReason,
   AIError,
   ProviderErrorEvent,
-  ProviderInternalError,
-  QuotaExceededError,
-  RateLimitError,
-  UnknownProviderError,
+  ProviderInternalReason,
+  QuotaExceededReason,
+  RateLimitReason,
+  UnknownProviderReason,
   type HttpContext,
   type HttpRateLimitDetails,
+  type ProviderMetadata,
 } from "./schema/index.js"
 
 const patterns = [
@@ -37,7 +38,6 @@ const patterns = [
   /too large for model with \d+ maximum context length/i,
   /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
   /model_context_window_exceeded/i,
-  /range of input length should be/i,
   /too many tokens/i,
   /token limit exceeded/i,
   /request_too_large/i,
@@ -60,7 +60,6 @@ export const isContextOverflowFailure = (failure: unknown) =>
 
 const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown))
 const QUOTA_CODES = new Set(["insufficient_quota", "usage_not_included", "billing_error"])
-const AUTH_CODES = new Set(["authentication_error", "permission_error"])
 const SERVER_CODES = new Set([
   "api_error",
   "internal_error",
@@ -76,38 +75,32 @@ const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error"
 const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i
 const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded/i
 const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i
-const SERVER_ERROR_TEXT =
-  /\b(?:try again|(?:please |you can )?retry (?:the |this |your )?request|try (?:the |this |your )?request again|(?:currently |temporarily )?at capacity|overloaded|temporarily unavailable|service[-_\s]?unavailable|(?:server|internal)[-_\s]?error|server (?:is )?busy|provider returned (?:an )?error|resource[-_\s]?exhausted|upstream (?:connect|connection|request)|request buffer limit while retrying upstream)\b/i
+const NETWORK_ERROR_TEXT = /network[-_\s]error/i
 
 export interface ProviderFailure {
   readonly message: string
   readonly status?: number | undefined
+  readonly code?: string | undefined
   // Raw wire payload, scanned for failure signals (codes, overflow phrases)
   // that the summary message does not carry. Not shown to users.
   readonly rawBody?: string | undefined
-  // Some SDKs supply parsed error data separately from the original response text.
-  readonly data?: unknown
-  readonly http?: HttpContext | undefined
-  readonly cause?: unknown
   readonly retryAfterMs?: number | undefined
   readonly rateLimit?: HttpRateLimitDetails | undefined
+  readonly http?: HttpContext | undefined
+  readonly providerMetadata?: ProviderMetadata | undefined
 }
 
-// Classification records affirmative evidence about a failure. Deterministic
-// failures need positive identification (a 4xx status, quota/auth/policy
-// signals); anything unrecognized stays UnknownProvider, which the session
-// retry policy treats as retry-eligible because transient failures arrive in
-// unpredictable shapes while deterministic rejections almost always carry a
-// status or known code.
+// Keep HTTP failures and provider-reported stream failures on one typed path so
+// session retry policy never needs provider-specific string matching.
 export function classifyProviderFailure(input: ProviderFailure): AIError["reason"] {
-  const details = { message: input.message, body: input.rawBody, http: input.http, cause: input.cause }
-  const body = input.rawBody ?? ""
-  const codes = [...providerCodes(input.data), ...providerCodes(body), ...providerCodes(input.message)].map((code) =>
-    code.toLowerCase(),
-  )
+  const body = input.http?.body ?? input.rawBody ?? ""
+  const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message)]
+    .filter((code): code is string => code !== undefined)
+    .map((code) => code.toLowerCase())
   // Scan the raw payload too so signals missing from the summary message
   // (e.g. overflow phrases nested in a JSON error body) still classify.
   const text = [input.message, body].filter((value) => value.length > 0).join("\n")
+  const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http }
   const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500)
 
   if (
@@ -117,55 +110,62 @@ export function classifyProviderFailure(input: ProviderFailure): AIError["reason
       codes.includes("request_too_large") ||
       isContextOverflow(text))
   )
-    return new InvalidRequestError({ ...details, classification: "context-overflow" })
+    return new InvalidRequestReason({ ...common, classification: "context-overflow" })
   if (input.status === 413 || isPayloadTooLarge(text))
-    return new InvalidRequestError({ ...details, classification: "payload-too-large" })
-  if (CONTENT_POLICY_TEXT.test(text)) return new ContentPolicyError(details)
+    return new InvalidRequestReason({ ...common, classification: "payload-too-large" })
+  if (CONTENT_POLICY_TEXT.test(text)) return new ContentPolicyReason(common)
   if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
-    return new QuotaExceededError(details)
-  if (input.status === 401 || input.status === 403 || codes.some((code) => AUTH_CODES.has(code)))
-    return new AuthenticationError(details)
+    return new QuotaExceededReason(common)
+  if (input.status === 401) return new AuthenticationReason({ ...common, kind: "invalid" })
+  if (input.status === 403) return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
+  if (codes.includes("authentication_error")) return new AuthenticationReason({ ...common, kind: "invalid" })
+  if (codes.includes("permission_error"))
+    return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
   if (
-    input.status === 429 ||
-    codes.some(
-      (code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception",
-    ) ||
-    RATE_LIMIT_TEXT.test(text)
+    codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception")
   )
-    return new RateLimitError({
-      ...details,
+    return new RateLimitReason({
+      ...common,
       retryAfterMs: input.retryAfterMs,
       rateLimit: input.rateLimit,
     })
-  if (
-    input.status === 408 ||
-    input.status === 409 ||
-    (input.status !== undefined && input.status >= 500) ||
-    ((input.status === undefined || input.status < 400) &&
-      !codes.some((code) => INVALID_REQUEST_CODES.has(code)) &&
-      SERVER_ERROR_TEXT.test(text)) ||
-    codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable"))
-  )
-    return new ProviderInternalError({
-      ...details,
+  if (RATE_LIMIT_TEXT.test(text))
+    return new RateLimitReason({
+      ...common,
+      retryAfterMs: input.retryAfterMs,
+      rateLimit: input.rateLimit,
+    })
+  if (NETWORK_ERROR_TEXT.test(text)) return new ProviderInternalReason({ ...common, status: input.status })
+  if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
+    return new ProviderInternalReason({
+      ...common,
+      status: input.status,
       retryAfterMs: input.retryAfterMs,
     })
-  if (codes.some((code) => INVALID_REQUEST_CODES.has(code))) return new InvalidRequestError(details)
-  // Any remaining 4xx is a deterministic rejection of this request.
-  if (input.status !== undefined && input.status >= 400 && input.status < 500) return new InvalidRequestError(details)
-  return new UnknownProviderError(details)
+  if (input.status === 429) {
+    return new RateLimitReason({
+      ...common,
+      retryAfterMs: input.retryAfterMs,
+      rateLimit: input.rateLimit,
+    })
+  }
+  if (input.status === 408 || input.status === 409 || (input.status !== undefined && input.status >= 500))
+    return new ProviderInternalReason({
+      ...common,
+      status: input.status,
+      retryAfterMs: input.retryAfterMs,
+    })
+  if (codes.some((code) => INVALID_REQUEST_CODES.has(code))) return new InvalidRequestReason(common)
+  if (input.status === 400 || input.status === 404 || input.status === 413 || input.status === 422)
+    return new InvalidRequestReason(common)
+  return new UnknownProviderReason({ ...common, status: input.status })
 }
 
-function providerCodes(value: unknown) {
-  const decoded = typeof value === "string" ? Option.getOrUndefined(decodeJson(value)) : value
+function providerCodes(value: string) {
+  const decoded = Option.getOrUndefined(decodeJson(value))
   if (!isRecord(decoded)) return []
   const error = isRecord(decoded.error) ? decoded.error : undefined
-  const response = isRecord(decoded.response) ? decoded.response : undefined
-  const responseError = response && isRecord(response.error) ? response.error : undefined
-  const exception = isRecord(decoded.exception) ? decoded.exception : undefined
-  return [decoded.code, error?.code, error?.type, error?.status, responseError?.code, exception?.type].filter(
-    (value): value is string => typeof value === "string",
-  )
+  return [decoded.code, error?.code, error?.type].filter((value): value is string => typeof value === "string")
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {

packages/ai/src/provider-package.ts

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

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

@@ -1,11 +1,9 @@
-import type { Route, RouteDefaultsInput } from "../route/client.js"
+import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import * as BedrockConverse from "../protocols/bedrock-converse.js"
 import type { BedrockCredentials } from "../protocols/bedrock-converse.js"
-import { BedrockMessages } from "../protocols/bedrock-messages.js"
-import type { AnthropicMessages } from "../protocols/anthropic-messages.js"
 
 export const id = ProviderID.make("amazon-bedrock")
 
@@ -27,40 +25,38 @@ export interface Settings extends ProviderPackage.Settings {
   readonly region?: string
   readonly topP?: number
 }
-export const routes = [BedrockConverse.route, BedrockMessages.route]
+export const routes = [BedrockConverse.route]
 
 const bedrockBaseURL = (region: string) => `https://bedrock-runtime.${region}.amazonaws.com`
 
-const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Config) => {
+const configuredRoute = (input: Config) => {
   const { apiKey, credentials, region, baseURL, ...rest } = input
   const resolvedRegion = region ?? credentials?.region ?? "us-east-1"
-  return route.with({
+  return BedrockConverse.route.with({
     ...rest,
     provider: id,
-    providerMetadataKey: route.providerMetadataKey,
+    providerMetadataKey: "bedrock",
     endpoint: { baseURL: baseURL ?? bedrockBaseURL(resolvedRegion) },
     auth: apiKey === undefined ? BedrockConverse.sigV4Auth(credentials) : Auth.bearer(apiKey),
   })
 }
 
 export const configure = (input: Config = {}) => {
-  const route = configuredRoute(BedrockConverse.route, input)
-  const messages = configuredRoute(BedrockMessages.route, input)
+  const route = configuredRoute(input)
   return {
     id,
     model: (modelID: string | ModelID) => route.model({ id: modelID }),
-    messages: (modelID: string | ModelID) => messages.model<AnthropicMessages.ProviderOptionsInput>({ id: modelID }),
     configure,
   }
 }
 
 export const provider = configure()
-const config = (settings: Settings): Config => {
+export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
   if (settings.auth === "bearer" && settings.apiKey === undefined)
     throw new Error("Amazon Bedrock bearer auth requires apiKey")
   if (settings.auth === "sigv4" && settings.apiKey !== undefined)
     throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey")
-  return {
+  return configure({
     apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
     baseURL: settings.baseURL,
     credentials: settings.credentials,
@@ -68,13 +64,5 @@ const config = (settings: Settings): Config => {
     headers: settings.headers === undefined ? undefined : { ...settings.headers },
     http: settings.body === undefined ? undefined : { body: { ...settings.body } },
     region: settings.region,
-  }
+  }).model(modelID)
 }
-
-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
-  configure(config(settings)).model(modelID)
-export const messagesModel: ProviderPackage.Definition<
-  Settings & { readonly providerOptions?: AnthropicMessages.ProviderOptionsInput },
-  AnthropicMessages.ProviderOptionsInput
->["model"] = (modelID, settings) =>
-  configure({ ...config(settings), providerOptions: settings.providerOptions }).messages(modelID)

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

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

packages/ai/src/providers/azure.ts

@@ -1,7 +1,7 @@
 import { Headers } from "effect/unstable/http"
 import { Auth } from "../route/auth.js"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
-import type { Route, RouteDefaultsInput, CompactOperation } from "../route/client.js"
+import type { Route as RouteDef, RouteDefaultsInput } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
@@ -102,11 +102,7 @@ const auth = (input: Config) => {
   )
 }
 
-const configuredRoute = <Body, Prepared, Compact extends CompactOperation | undefined>(
-  route: Route<Body, Prepared, Compact>,
-  input: Config,
-  modelID: string | ModelID,
-) =>
+const configuredRoute = <Body, Prepared>(route: RouteDef<Body, Prepared>, input: Config, modelID: string | ModelID) =>
   route.with({
     auth: auth(input),
     endpoint: endpoint(input, modelID),
@@ -165,11 +161,10 @@ const config = (settings: Settings): Config => {
   throw new Error("Azure requires resourceName or baseURL")
 }
 
-export const responsesModel: ProviderPackage.Definition<
-  Settings,
-  OpenAIProviderOptionsInput,
-  CompactOperation
->["model"] = (modelID, settings) => configure(config(settings)).responses(modelID)
+export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => configure(config(settings)).responses(modelID)
 export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
   modelID,
   settings,

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

@@ -57,9 +57,7 @@ const route = Route.make({
   }),
   endpoint: Endpoint.path(({ request }) => `/${request.model.id}:streamRawPredict`),
   auth: Auth.none,
-  transport: AnthropicMessages.transport<
-    Omit<AnthropicMessages.AnthropicMessagesBody, "model"> & { readonly anthropic_version: typeof VERSION }
-  >(),
+  framing: AnthropicMessages.framing,
   headers: () => ({ "anthropic-version": HEADER_VERSION }),
 })
 

packages/ai/src/providers/groq.ts

@@ -5,6 +5,7 @@ import { ProviderShared } from "../protocols/shared.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
 import { Protocol } from "../route/protocol.js"
 import { ProviderID, type ModelID, type LLMRequest } from "../schema/index.js"
 import { profiles } from "./openai-compatible-profile.js"
@@ -74,7 +75,7 @@ export const route = Route.make({
   providerMetadataKey: "openai",
   protocol,
   endpoint: Endpoint.path("/chat/completions", { baseURL: profiles.groq.baseURL }),
-  framing: OpenAIChat.framing,
+  framing: Framing.sse,
 })
 
 export const configure = (input: LanguageModelOptions = {}) => {

packages/ai/src/providers/index.ts

@@ -13,7 +13,6 @@ export * as GoogleVertexChat from "./google-vertex-chat.js"
 export * as GoogleVertexMessages from "./google-vertex-messages.js"
 export * as GoogleVertexResponses from "./google-vertex-responses.js"
 export * as Groq from "./groq.js"
-export * as Mistral from "./mistral.js"
 export * as OpenAI from "./openai.js"
 export * as OpenAICompatible from "./openai-compatible.js"
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js"

packages/ai/src/providers/mistral.ts

@@ -1,51 +0,0 @@
-import type { ProviderPackage } from "../provider-package.js"
-import { MistralChat } from "../protocols/mistral-chat.js"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import type { RouteDefaultsInput } from "../route/client.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
-
-export const id = ProviderID.make("mistral")
-
-export type ProviderOptions = MistralChat.ProviderOptionsInput
-
-export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: ProviderOptions
-  }
-
-export interface Settings extends ProviderPackage.Settings {
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly providerOptions?: ProviderOptions
-}
-
-export const route = MistralChat.route
-export const routes = [route]
-
-export const configure = (input: LanguageModelOptions = {}) => {
-  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
-  const configured = route.with({
-    ...defaults,
-    endpoint: { baseURL: baseURL ?? MistralChat.DEFAULT_BASE_URL },
-    auth: AuthOptions.bearer(input, "MISTRAL_API_KEY"),
-  })
-  return {
-    id,
-    model: (modelID: string | ModelID) => configured.model<ProviderOptions>({ id: modelID }),
-    configure,
-  }
-}
-
-export const provider = configure()
-
-export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (modelID, settings) =>
-  configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
-
-export * as Mistral from "./mistral.js"

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

@@ -1,12 +1,10 @@
 import { mergeProviderOptions, type ProviderOptions } from "../schema/index.js"
 import type { OpenAIServiceTier } from "../protocols/utils/openai-options.js"
 import type { Options } from "../protocols/utils/open-responses-options.js"
-import type { ContextManagement } from "../protocols/openai-responses.js"
 
 export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options.js"
 
 export type OpenAIOptionsInput = Omit<Options, "serviceTier"> & {
-  readonly contextManagement?: ContextManagement
   readonly serviceTier?: OpenAIServiceTier
   readonly [key: string]: unknown
 }

packages/ai/src/providers/openai.ts

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

packages/ai/src/providers/openrouter.ts

@@ -1,6 +1,7 @@
 import { Effect, Schema } from "effect"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
 import { Protocol } from "../route/protocol.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { ProviderID, type CacheHint, type ModelID } from "../schema/index.js"
@@ -166,7 +167,7 @@ export const route = Route.make({
   providerMetadataKey: "openrouter",
   protocol,
   endpoint: Endpoint.path("/chat/completions", { baseURL: profile.baseURL }),
-  framing: OpenAIChat.framing,
+  framing: Framing.sse,
 })
 
 export const routes = [route]

packages/ai/src/providers/xai.ts

@@ -1,5 +1,5 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput, type CompactOperation } from "../route/client.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
@@ -13,7 +13,7 @@ import type { ProviderPackage } from "../provider-package.js"
 
 export const id = ProviderID.make("xai")
 
-export type XAIProviderOptionsInput = OpenAIOptionsInput & { readonly contextManagement?: never }
+export type XAIProviderOptionsInput = OpenAIOptionsInput
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -32,7 +32,6 @@ export type { XAIImageOptions } from "../protocols/xai-images.js"
 const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000
 
 const responsesRoute = Route.make({
-  compact: XAIResponses.compact,
   id: "openai-responses",
   provider: id,
   providerMetadataKey: "xai",
@@ -103,10 +102,7 @@ export const configure = (input: LanguageModelOptions = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput, CompactOperation>["model"] = (
-  modelID,
-  settings,
-) =>
+export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
     apiKey: settings.apiKey,
     baseURL: settings.baseURL,

packages/ai/src/route/auth.ts

@@ -1,6 +1,6 @@
 import { Config, Effect, Redacted } from "effect"
 import { Headers } from "effect/unstable/http"
-import { AuthenticationError, InvalidRequestError, AIError, type HttpOptions } from "../schema/index.js"
+import { AuthenticationReason, InvalidRequestReason, AIError, type HttpOptions } from "../schema/index.js"
 
 export class MissingCredentialError extends Error {
   readonly _tag = "MissingCredentialError"
@@ -137,10 +137,12 @@ export function bearerHeader(name: string, source?: Secret | Credential) {
 const toAIError = (error: AuthError): AIError => {
   if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
     return new AIError({
+      module: "Auth",
+      method: "apply",
       reason:
         error instanceof MissingCredentialError
-          ? new AuthenticationError({ message: error.message, cause: error })
-          : new InvalidRequestError({ message: `Failed to resolve auth config: ${error.message}`, cause: error }),
+          ? new AuthenticationReason({ message: error.message, kind: "missing" })
+          : new InvalidRequestReason({ message: `Failed to resolve auth config: ${error.message}` }),
     })
   }
   return error

packages/ai/src/route/client.ts

@@ -7,21 +7,18 @@ import { HttpTransport } from "./transport/index.js"
 import type { HttpMiddleware, Transport, TransportRuntime, WebSocketChannelExecutor } from "./transport/index.js"
 import type { Protocol } from "./protocol.js"
 import { applyCachePolicy } from "../cache-policy.js"
-import { normalizeToolHistory } from "../tool-history.js"
 import { sanitizeSurrogates } from "../utils/sanitize.js"
 import * as ProviderShared from "../protocols/shared.js"
 import type { ProtocolID, ProviderOptions } from "../schema/index.js"
 import {
   AIError,
-  CompactionResponse,
-  AIErrorReason,
   GenerationOptions,
   HttpOptions,
   LLMRequest,
   LLMResponse,
   LanguageModel,
   LLMEvent,
-  InvalidProviderOutputError,
+  InvalidProviderOutputReason,
   ProviderID,
   mergeGenerationOptions,
   mergeHttpOptions,
@@ -35,12 +32,7 @@ export interface RouteBody<Body> {
   readonly from: (request: LLMRequest) => Effect.Effect<Body, AIError>
 }
 
-export interface Route<
-  Body,
-  Prepared = unknown,
-  Compact extends CompactOperation | undefined = CompactOperation | undefined,
-> {
-  readonly compact: Compact
+export interface Route<Body, Prepared = unknown> {
   readonly id: string
   readonly provider?: ProviderID
   /** ProviderMetadata namespace emitted and consumed by this route. */
@@ -48,15 +40,13 @@ export interface Route<
   readonly protocol: ProtocolID
   readonly endpoint: Endpoint.Definition<Body>
   readonly auth: Auth.Definition
-  /** Deployment headers resolved once for every operation, before transport authentication. */
-  readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
   readonly transport: Transport<Body, Prepared, unknown>
   readonly defaults: RouteDefaults
   readonly body: RouteBody<Body>
-  readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared, Compact>
+  readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared>
   readonly model: <Options extends ProviderOptions = ProviderOptions>(
     input: RouteMappedLanguageModelInput,
-  ) => LanguageModel<Options, Compact>
+  ) => LanguageModel<Options>
   readonly prepareTransport: (
     body: Body,
     request: LLMRequest,
@@ -74,11 +64,7 @@ export interface Route<
 // Normal call sites use `OpenAIChat.route`; callers only need body types
 // when preparing a request with a protocol-specific type assertion.
 // oxlint-disable-next-line typescript-eslint/no-explicit-any
-export type AnyRoute<Compact extends CompactOperation | undefined = CompactOperation | undefined> = Route<
-  any,
-  any,
-  Compact
->
+export type AnyRoute = Route<any, any>
 
 export type HttpOptionsInput = HttpOptions.Input
 
@@ -111,15 +97,15 @@ export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
 
 type RouteMappedLanguageModelInput = RouteLanguageModelInput | RouteRoutedLanguageModelInput
 
-const makeRouteLanguageModel = <Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
-  route: AnyRoute<Compact>,
+const makeRouteLanguageModel = <Options extends ProviderOptions = ProviderOptions>(
+  route: AnyRoute,
   mapped: RouteMappedLanguageModelInput,
 ) => {
   const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
   if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
   if (!endpointBaseURL(route.endpoint))
     throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`)
-  return LanguageModel.make<Options, Compact>({
+  return LanguageModel.make<Options>({
     ...mapped,
     provider,
     route,
@@ -162,10 +148,6 @@ export const httpOptions = (input: HttpOptionsInput | undefined) => {
 }
 
 export interface Interface {
-  readonly compact: (
-    request: CompactionRequest,
-    options?: Pick<StreamOptions, "http">,
-  ) => Effect.Effect<CompactionResponse, AIError>
   readonly stream: StreamMethod
   readonly generate: GenerateMethod
 }
@@ -183,38 +165,24 @@ export interface GenerateMethod {
   (request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError>
 }
 
-export type CompactOperation = (
-  request: LLMRequest,
-  executor: RequestExecutor.Interface,
-  options?: Pick<StreamOptions, "http">,
-) => Effect.Effect<CompactionResponse, AIError>
-
-export type CompactionRequest = LLMRequest<LanguageModel<ProviderOptions, CompactOperation>>
-
-export const canCompact = (request: LLMRequest): request is CompactionRequest =>
-  request.model.route.compact !== undefined
-
 export class Service extends Context.Service<Service, Interface>()("@opencode/LLMClient") {}
 
 const resolveRequestOptions = (request: LLMRequest) => {
-  const messages = normalizeToolHistory(request.messages)
-  const normalized = messages === request.messages ? request : LLMRequest.update(request, { messages })
-  const routeDefaults = normalized.model.route.defaults
-  const modelDefaults = normalized.model.defaults
-  const generation = mergeGenerationOptions(routeDefaults.generation, modelDefaults?.generation, normalized.generation)
-  return LLMRequest.update(normalized, {
+  const routeDefaults = request.model.route.defaults
+  const modelDefaults = request.model.defaults
+  const generation = mergeGenerationOptions(routeDefaults.generation, modelDefaults?.generation, request.generation)
+  return LLMRequest.update(request, {
     generation: generation ?? new GenerationOptions({}),
     providerOptions: mergeProviderOptions(
       routeDefaults.providerOptions,
       modelDefaults?.providerOptions,
-      normalized.providerOptions,
+      request.providerOptions,
     ),
-    http: mergeHttpOptions(routeDefaults.http, modelDefaults?.http, normalized.http),
+    http: mergeHttpOptions(routeDefaults.http, modelDefaults?.http, request.http),
   })
 }
 
 export interface MakeInput<Body, Frame, Event, State> {
-  readonly compact?: CompactOperation
   /** Route id used in diagnostics and prepared request metadata. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
@@ -236,7 +204,6 @@ export interface MakeInput<Body, Frame, Event, State> {
 }
 
 export interface MakeTransportInput<Body, Prepared, Frame, Event, State> {
-  readonly compact?: CompactOperation
   /** Route id used in diagnostics and prepared request metadata. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
@@ -260,14 +227,16 @@ export interface MakeTransportInput<Body, Prepared, Frame, Event, State> {
 const streamError = (route: string, message: string, cause: Cause.Cause<unknown>) => {
   const failed = cause.reasons.find(Cause.isFailReason)?.error
   if (failed instanceof AIError) return failed
-  return ProviderShared.eventError(route, message, undefined, cause)
+  return ProviderShared.eventError(route, message, Cause.pretty(cause))
 }
 
 const incompleteStreamError = (route: string) =>
   new AIError({
-    reason: new InvalidProviderOutputError({
-      message: "The provider response ended unexpectedly.",
+    module: "LLMClient",
+    method: "stream",
+    reason: new InvalidProviderOutputReason({
       classification: "incomplete-stream",
+      message: "The provider response ended unexpectedly.",
       route,
     }),
   })
@@ -296,12 +265,11 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
   const decodeEventEffect = Schema.decodeUnknownEffect(protocol.stream.event)
   const decodeEvent = (route: string) => (frame: Frame) =>
     decodeEventEffect(frame).pipe(
-      Effect.mapError((cause) =>
+      Effect.mapError(() =>
         ProviderShared.eventError(
           input.id,
           `Invalid ${route} stream event`,
           typeof frame === "string" ? frame : ProviderShared.encodeJson(frame),
-          cause,
         ),
       ),
     )
@@ -312,14 +280,12 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
 
   const build = (routeInput: BuiltRouteInput): Route<Body, Prepared> => {
     const route: Route<Body, Prepared> = {
-      compact: routeInput.compact,
       id: routeInput.id,
       provider: routeInput.provider === undefined ? undefined : ProviderID.make(routeInput.provider),
       providerMetadataKey: routeInput.providerMetadataKey,
       protocol: protocol.id,
       endpoint: routeInput.endpoint,
       auth: routeInput.auth ?? Auth.none,
-      headers: routeInput.headers,
       transport: routeInput.transport,
       defaults: routeInput.defaults ?? {},
       body: protocol.body,
@@ -341,7 +307,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
         })
       },
       model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedLanguageModelInput) =>
-        makeRouteLanguageModel<Options, CompactOperation | undefined>(route, input),
+        makeRouteLanguageModel<Options>(route, input),
       prepareTransport: (body, request, options) =>
         routeInput.transport.prepare({
           body,
@@ -349,6 +315,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
           endpoint: routeInput.endpoint,
           auth: routeInput.auth ?? Auth.none,
           encodeBody,
+          headers: routeInput.headers,
           middleware: options?.http,
           webSocket: options?.webSocket,
         }),
@@ -357,48 +324,19 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
         return Stream.unwrap(
           routeInput.transport.execute(prepared, request, runtime, options).pipe(
             Effect.map((execution) => {
-              const terminal = protocol.stream.terminal
-              // Preserve assembled inputs; replace only serialized event fallbacks with their original wire data.
-              const frameError =
-                (frame: Frame, event: Frame | Event = frame) =>
-                (error: AIError) =>
-                  new AIError({
-                    reason: AIErrorReason.make({
-                      ...error.reason,
-                      message: error.reason.message,
-                      cause: error.reason.cause,
-                      body:
-                        error.reason.body !== undefined && error.reason.body !== ProviderShared.encodeJson(event)
-                          ? error.reason.body
-                          : (execution.body?.(frame) ??
-                            (typeof frame === "string" ? frame : ProviderShared.encodeJson(frame))),
-                    }),
-                  })
               const events = execution.frames.pipe(
-                Stream.mapEffect((frame) =>
-                  decodeEvent(route)(frame).pipe(
-                    Effect.catchCause((cause) =>
-                      Effect.fail(streamError(route, `Failed to decode ${route} event`, cause)),
-                    ),
-                    Effect.map((event) => ({ event, frame })),
-                    Effect.mapError(frameError(frame)),
-                  ),
-                ),
-                terminal ? Stream.takeUntil(({ event }) => terminal(event)) : (stream) => stream,
+                Stream.mapEffect(decodeEvent(route)),
+                protocol.stream.terminal ? Stream.takeUntil(protocol.stream.terminal) : (stream) => stream,
               )
               const stream = Stream.suspend(() => {
                 let state = protocol.stream.initial(request)
                 const parsed = events.pipe(
-                  Stream.mapEffect(({ event, frame }) =>
+                  Stream.mapEffect((event) =>
                     protocol.stream.step(state, event).pipe(
-                      Effect.catchCause((cause) =>
-                        Effect.fail(streamError(route, `Failed to parse ${route} event`, cause)),
-                      ),
                       Effect.map(([next, output]) => {
                         state = next
                         return output
                       }),
-                      Effect.mapError(frameError(frame, event)),
                     ),
                   ),
                   Stream.flatMap(Stream.fromIterable),
@@ -414,17 +352,6 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
               }).pipe(
                 Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))),
                 requireTerminalEvent(route),
-                Stream.mapError(
-                  (error) =>
-                    new AIError({
-                      reason: AIErrorReason.make({
-                        ...error.reason,
-                        message: error.reason.message,
-                        cause: error.reason.cause,
-                        http: error.reason.http ?? execution.http,
-                      }),
-                    }),
-                ),
               )
               return execution.complete ? stream.pipe(Stream.onEnd(execution.complete)) : stream
             }),
@@ -438,12 +365,6 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
   return build({ ...input, defaults: mergeRouteDefaults(undefined, input.defaults ?? {}) })
 }
 
-export function make<Body, Prepared, Frame, Event, State>(
-  input: MakeTransportInput<Body, Prepared, Frame, Event, State> & { readonly compact: CompactOperation },
-): Route<Body, Prepared, CompactOperation>
-export function make<Body, Frame, Event, State>(
-  input: MakeInput<Body, Frame, Event, State> & { readonly compact: CompactOperation },
-): Route<Body, HttpTransport.HttpPrepared<Frame>, CompactOperation>
 export function make<Body, Prepared, Frame, Event, State>(
   input: MakeTransportInput<Body, Prepared, Frame, Event, State>,
 ): Route<Body, Prepared>
@@ -471,7 +392,6 @@ export function make<Body, Prepared, Frame, Event, State>(
   if ("transport" in input) return makeFromTransport(input)
   const protocol = input.protocol
   return makeFromTransport({
-    compact: input.compact,
     id: input.id,
     provider: input.provider,
     providerMetadataKey: input.providerMetadataKey,
@@ -484,19 +404,9 @@ export function make<Body, Prepared, Frame, Event, State>(
   })
 }
 
-const prepareRequest = (request: LLMRequest) => {
-  const original = applyCachePolicy(resolveRequestOptions(request))
-  const sanitized = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }))
-  const tools = [...new Map(sanitized.tools.map((tool) => [tool.name, tool])).values()]
-  const resolved = tools.length === sanitized.tools.length ? sanitized : LLMRequest.update(sanitized, { tools })
-  const headers = resolved.model.route.headers?.({ request: resolved })
-  return headers === undefined
-    ? resolved
-    : LLMRequest.update(resolved, { http: mergeHttpOptions(new HttpOptions({ headers }), resolved.http) })
-}
-
 const compile = Effect.fn("LLM.compile")(function* (request: LLMRequest, options?: StreamOptions) {
-  const resolved = prepareRequest(request)
+  const original = applyCachePolicy(resolveRequestOptions(request))
+  const resolved = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }))
   const route = resolved.model.route
 
   const body = yield* route.body
@@ -555,15 +465,6 @@ export function generate(request: LLMRequest, options?: StreamOptions): Effect.E
   })
 }
 
-export const compact = (
-  request: CompactionRequest,
-  options?: Pick<StreamOptions, "http">,
-): Effect.Effect<CompactionResponse, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.compact(request, options)
-  })
-
 export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>
   Stream.unwrap(
     Effect.gen(function* () {
@@ -574,29 +475,16 @@ export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>
 export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service
-    const stream = streamRequestWith({ http: executor })
-    return Service.of({
-      stream,
-      generate: generateWith(stream),
-      compact: (request, options) =>
-        Effect.suspend(() => {
-          const operation = request.model.route.compact
-          if (!operation)
-            return ProviderShared.invalidRequest(
-              `${request.model.provider}/${request.model.route.id} does not support explicit compaction`,
-            )
-          return operation(prepareRequest(request), executor, options)
-        }),
+    const stream = streamRequestWith({
+      http: yield* RequestExecutor.Service,
     })
+    return Service.of({ stream, generate: generateWith(stream) })
   }),
 )
 
 export const Route = { make } as const
 
 export const LLMClient = {
-  canCompact,
-  compact,
   Service,
   layer,
   stream,

packages/ai/src/route/executor.ts

@@ -7,7 +7,14 @@ import {
   HttpClientRequest,
   HttpClientResponse,
 } from "effect/unstable/http"
-import { HttpContext, HttpRateLimitDetails, AIError, TransportError } from "../schema/index.js"
+import {
+  HttpContext,
+  HttpRateLimitDetails,
+  HttpRequestDetails,
+  HttpResponseDetails,
+  AIError,
+  TransportReason,
+} from "../schema/index.js"
 import { classifyProviderFailure } from "../provider-error.js"
 
 export interface Interface {
@@ -90,13 +97,24 @@ const rateLimitDetails = (headers: Record<string, string>, retryAfter: number |
   })
 }
 
-export const responseHttp = (response: HttpClientResponse.HttpClientResponse) =>
-  new HttpContext({
-    url: response.request.url,
+const requestDetails = (request: HttpClientRequest.HttpClientRequest) =>
+  new HttpRequestDetails({
+    method: request.method,
+    url: request.url,
+    headers: headerDetails(request.headers),
+  })
+
+const responseDetails = (response: HttpClientResponse.HttpClientResponse) =>
+  new HttpResponseDetails({
     status: response.status,
     headers: headerDetails(response.headers),
   })
 
+const responseBody = (body: string | void) => {
+  if (body === undefined) return {}
+  return { body }
+}
+
 const decodeProviderBody = Schema.decodeUnknownOption(
   Schema.fromJsonString(
     Schema.Struct({
@@ -114,46 +132,77 @@ const providerMessage = (status: number, body: string | void) => {
   )
 }
 
-const statusError = (response: HttpClientResponse.HttpClientResponse) =>
-  Effect.gen(function* () {
-    if (response.status < 400) return response
-    const result = yield* response.text.pipe(Effect.result)
-    return yield* httpFailure({
-      message: providerMessage(response.status, result._tag === "Success" ? result.success : undefined),
-      url: response.request.url,
-      status: response.status,
-      responseHeaders: headerDetails(response.headers),
-      responseBody: result._tag === "Success" ? result.success : undefined,
-      cause: result._tag === "Failure" ? (result.failure.cause ?? result.failure) : undefined,
-    })
+const responseHttp = (input: {
+  readonly request: HttpClientRequest.HttpClientRequest
+  readonly response: HttpClientResponse.HttpClientResponse
+  readonly body: ReturnType<typeof responseBody>
+  readonly rateLimit?: HttpRateLimitDetails | undefined
+}) =>
+  new HttpContext({
+    request: requestDetails(input.request),
+    response: responseDetails(input.response),
+    ...input.body,
+    rateLimit: input.rateLimit,
   })
 
-/** Preserve HTTP diagnostics for executor and externally captured failures alike. */
-export const httpFailure = (input: {
+const statusError =
+  (request: HttpClientRequest.HttpClientRequest) => (response: HttpClientResponse.HttpClientResponse) =>
+    Effect.gen(function* () {
+      if (response.status < 400) return response
+      const body = yield* response.text.pipe(Effect.catch(() => Effect.void))
+      const headers = normalizedHeaders(response.headers)
+      const retryAfter = retryAfterMs(headers)
+      const rateLimit = rateLimitDetails(headers, retryAfter)
+      const details = responseBody(body)
+      return yield* new AIError({
+        module: "RequestExecutor",
+        method: "execute",
+        reason: classifyProviderFailure({
+          status: response.status,
+          message: providerMessage(response.status, body),
+          retryAfterMs: retryAfter,
+          rateLimit,
+          http: responseHttp({
+            request,
+            response,
+            body: details,
+            rateLimit,
+          }),
+        }),
+      })
+    })
+
+// Classifies an HTTP failure captured outside the executor (for example by the
+// AI SDK's own fetch) onto the same reason types and HttpContext that
+// executor-driven requests produce. The originating request is not available on
+// that path, so the method is assumed (language model calls are always POST),
+// request headers are empty.
+export const classifyHttpFailure = (input: {
   readonly message: string
-  readonly url?: string | undefined
+  readonly url: string
   readonly status?: number | undefined
-  readonly data?: unknown
+  readonly code?: string | undefined
   readonly responseHeaders?: Record<string, string> | undefined
   readonly responseBody?: string | undefined
-  readonly cause?: unknown
 }) => {
   const headers = normalizedHeaders(Headers.fromInput(input.responseHeaders))
   const retryAfter = retryAfterMs(headers)
   const rateLimit = rateLimitDetails(headers, retryAfter)
-  return new AIError({
-    reason: classifyProviderFailure({
-      message: input.message,
-      status: input.status,
-      data: input.data,
-      rawBody: input.responseBody,
-      retryAfterMs: retryAfter,
-      rateLimit,
-      cause: input.cause,
-      http:
-        input.status === undefined || input.url === undefined
+  const details = responseBody(input.responseBody)
+  return classifyProviderFailure({
+    message: input.message,
+    status: input.status,
+    code: input.code,
+    retryAfterMs: retryAfter,
+    rateLimit,
+    http: new HttpContext({
+      request: new HttpRequestDetails({ method: "POST", url: input.url, headers: {} }),
+      response:
+        input.status === undefined
           ? undefined
-          : new HttpContext({ url: input.url, status: input.status, headers }),
+          : new HttpResponseDetails({ status: input.status, headers: headerDetails(Headers.fromInput(headers)) }),
+      ...details,
+      rateLimit,
     }),
   })
 }
@@ -180,25 +229,25 @@ const httpError = (input: {
   readonly error: unknown
   readonly request: HttpClientRequest.HttpClientRequest
   readonly operation: HttpOperation
-  readonly http?: HttpContext
 }) => {
   const request = HttpClientError.isHttpClientError(input.error) ? input.error.request : input.request
   const transportError = (failure: { readonly message: string; readonly code?: string | undefined }) =>
     new AIError({
-      reason: new TransportError({
+      module: "RequestExecutor",
+      method: input.operation,
+      reason: new TransportReason({
         message: failure.message,
-        cause: source,
-        http: input.http,
         transport: "http",
         operation: input.operation,
         code: failure.code,
         url: request.url,
+        http: new HttpContext({ request: requestDetails(request) }),
       }),
     })
 
   const source =
     HttpClientError.isHttpClientError(input.error) && "cause" in input.error.reason
-      ? (input.error.reason.cause ?? input.error)
+      ? input.error.reason.cause
       : input.error
   const native = nativeTransportFailure(source)
   const code = native?.code
@@ -222,13 +271,6 @@ const httpError = (input: {
   })
 }
 
-export const responseStream = (response: HttpClientResponse.HttpClientResponse): Stream.Stream<Uint8Array, AIError> =>
-  response.stream.pipe(
-    Stream.mapError((error) =>
-      httpError({ error, request: response.request, operation: "read", http: responseHttp(response) }),
-    ),
-  )
-
 export const stream = (
   executor: Interface,
   request: HttpClientRequest.HttpClientRequest,
@@ -237,7 +279,9 @@ export const stream = (
   Stream.unwrap(
     Effect.gen(function* () {
       const response = yield* executor.execute(request, middleware)
-      return responseStream(response)
+      return response.stream.pipe(
+        Stream.mapError((error) => httpError({ error, request: response.request, operation: "read" })),
+      )
     }),
   )
 
@@ -250,7 +294,7 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
         if (!middleware)
           return yield* http.execute(request).pipe(
             Effect.mapError((error) => httpError({ error, request, operation: "request" })),
-            Effect.flatMap(statusError),
+            Effect.flatMap(statusError(request)),
           )
 
         const response = yield* middleware(request, (input) =>
@@ -258,7 +302,7 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
             .execute(input)
             .pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause))))),
         ).pipe(Effect.mapError((error) => httpError({ error, request, operation: "request" })))
-        return yield* statusError(response)
+        return yield* statusError(response.request)(response)
       })
     return Service.of({
       execute: executeOnce,

packages/ai/src/route/framing.ts

@@ -8,8 +8,8 @@ import type { AIError } from "../schema/index.js"
  * `Framing` is the byte-stream-shaped seam between transport and protocol:
  *
  * - SSE (`Framing.sse`) — UTF-8 decode the body, run the SSE channel decoder,
- *   and emit the `data:` payload of each non-empty event. The default drops
- *   `[DONE]`; protocols that use it as a terminal select `sseWithDone`.
+ *   drop empty / `[DONE]` keep-alives. Each emitted frame is the JSON `data:`
+ *   payload of one event.
  * - AWS event stream — length-prefixed binary frames with CRC checksums.
  *   Each emitted frame is one parsed binary event record.
  *
@@ -19,19 +19,11 @@ import type { AIError } from "../schema/index.js"
 export interface Definition<Frame> {
   readonly id: string
   readonly frame: (bytes: Stream.Stream<Uint8Array, AIError>) => Stream.Stream<Frame, AIError>
-  /** Original wire representation when framing transforms the provider payload. */
-  readonly body?: (frame: Frame) => string | undefined
 }
 
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export const sse: Definition<string> = { id: "sse", frame: ProviderShared.sseFraming }
 
-/** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */
-export const sseWithDone: Definition<string> = {
-  id: "sse",
-  frame: (bytes) => ProviderShared.sseFraming(bytes, undefined, true),
-}
-
 /** SSE framing restricted to protocol-recognized event names. */
 export const sseEvents = (events: ReadonlySet<string>): Definition<string> => ({
   id: "sse",

packages/ai/src/route/transport/http.ts

@@ -88,13 +88,8 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
       }
     }),
   execute: (prepared, _request, runtime) =>
-    Effect.gen(function* () {
-      const response = yield* runtime.http.execute(prepared.request, prepared.middleware)
-      return {
-        frames: prepared.framing.frame(RequestExecutor.responseStream(response)),
-        http: RequestExecutor.responseHttp(response),
-        body: prepared.framing.body,
-      }
+    Effect.succeed({
+      frames: prepared.framing.frame(RequestExecutor.stream(runtime.http, prepared.request, prepared.middleware)),
     }),
 })
 

packages/ai/src/route/transport/index.ts

@@ -3,7 +3,7 @@ import { Endpoint } from "../endpoint.js"
 import { Auth } from "../auth.js"
 import type { HttpMiddleware, Interface as RequestExecutorInterface } from "../executor.js"
 import type { WebSocketChannelExecutor } from "./websocket-channel.js"
-import type { AIError, HttpContext, LLMRequest } from "../../schema/index.js"
+import type { AIError, LLMRequest } from "../../schema/index.js"
 
 export interface TransportRuntime {
   readonly http: RequestExecutorInterface
@@ -11,8 +11,6 @@ export interface TransportRuntime {
 
 export interface TransportExecution<Frame> {
   readonly frames: Stream.Stream<Frame, AIError>
-  readonly http?: HttpContext
-  body?(frame: Frame): string | undefined
   /** Optional successful-consumption acknowledgement. HTTP leaves this absent. */
   readonly complete?: Effect.Effect<void>
 }

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

@@ -1,6 +1,6 @@
 import type { Effect, Scope, Stream } from "effect"
 import type { Headers } from "effect/unstable/http"
-import type { AIError, HttpContext } from "../../schema/index.js"
+import type { AIError } from "../../schema/index.js"
 
 export interface WebSocketChannelExecutor {
   readonly execute: (
@@ -10,7 +10,6 @@ export interface WebSocketChannelExecutor {
 
 export interface WebSocketChannelExecution {
   readonly frames: Stream.Stream<string, AIError>
-  readonly http?: HttpContext
   /** Commits staged state after the decoded Route stream ends successfully. */
   readonly complete: Effect.Effect<void>
 }

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

@@ -1,13 +1,7 @@
 import { Cause, Effect, Queue, Stream } from "effect"
 import { Headers } from "effect/unstable/http"
 import { Socket } from "effect/unstable/socket"
-import {
-  AIError,
-  AIErrorReason,
-  TransportError,
-  type HttpContext,
-  type TransportOperation,
-} from "../../schema/index.js"
+import { AIError, TransportReason, type TransportOperation } from "../../schema/index.js"
 import * as HttpTransport from "./http.js"
 import type { Transport } from "./index.js"
 import type {
@@ -23,7 +17,6 @@ export interface WebSocketRequest {
 }
 
 export interface WebSocketConnection {
-  readonly http?: HttpContext
   readonly sendText: (message: string) => Effect.Effect<void, AIError>
   readonly messages: Stream.Stream<string | Uint8Array, AIError>
   readonly close: Effect.Effect<void, never>
@@ -40,22 +33,21 @@ type WebSocketConstructorWithHeaders = (
 
 const MAX_FRAME_BYTES = 16 * 1024 * 1024
 const transportError = (
+  method: string,
   message: string,
   input: {
     readonly operation: TransportOperation
     readonly url?: string
     readonly code?: string
-    readonly phase?: TransportError["phase"]
-    readonly delivery?: TransportError["delivery"]
-    readonly body?: string
-    readonly cause?: unknown
+    readonly phase?: TransportReason["phase"]
+    readonly delivery?: TransportReason["delivery"]
   },
 ) =>
   new AIError({
-    reason: new TransportError({
+    module: "WebSocketConnector",
+    method,
+    reason: new TransportReason({
       message,
-      body: input.body,
-      cause: input.cause,
       transport: "websocket",
       operation: input.operation,
       url: input.url,
@@ -67,16 +59,22 @@ const transportError = (
 
 const annotateTransportError = (
   error: AIError,
-  input: { readonly phase: TransportError["phase"]; readonly delivery: TransportError["delivery"] },
+  input: { readonly phase: TransportReason["phase"]; readonly delivery: TransportReason["delivery"] },
 ) =>
   error.reason._tag === "Transport"
     ? new AIError({
-        reason: new TransportError({
-          ...error.reason,
+        module: error.module,
+        method: error.method,
+        reason: new TransportReason({
           message: error.reason.message,
-          cause: error.reason.cause,
+          transport: error.reason.transport,
+          operation: error.reason.operation,
+          code: error.reason.code,
+          url: error.reason.url,
+          http: error.reason.http,
           phase: input.phase,
           delivery: input.delivery,
+          recovery: error.reason.recovery,
         }),
       })
     : error
@@ -97,7 +95,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
   if (ws.readyState === globalThis.WebSocket.OPEN) return Effect.void
   if (ws.readyState === globalThis.WebSocket.CLOSING || ws.readyState === globalThis.WebSocket.CLOSED) {
     return Effect.fail(
-      transportError(`WebSocket closed before opening (state ${ws.readyState})`, {
+      transportError("open", `WebSocket closed before opening (state ${ws.readyState})`, {
         url: input.url,
         operation: "request",
         code: "closed",
@@ -126,8 +124,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
       cleanup()
       resume(
         Effect.fail(
-          transportError(`Failed to open WebSocket: ${eventMessage(event)}`, {
-            cause: "error" in event ? (event.error ?? event) : event,
+          transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, {
             url: input.url,
             operation: "request",
             phase: "connect",
@@ -140,9 +137,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
       cleanup()
       resume(
         Effect.fail(
-          transportError(`WebSocket closed before opening with code ${event.code}`, {
-            body: event.reason,
-            cause: event,
+          transportError("open", `WebSocket closed before opening with code ${event.code}`, {
             url: input.url,
             operation: "request",
             code: String(event.code),
@@ -174,8 +169,7 @@ export const toWebSocketUrl = (value: string) =>
       throw new Error(`Unsupported WebSocket URL protocol ${url.protocol}`)
     },
     catch: (error) =>
-      transportError(error instanceof Error ? error.message : "Invalid WebSocket URL", {
-        cause: error,
+      transportError("prepare", error instanceof Error ? error.message : "Invalid WebSocket URL", {
         url: value,
         operation: "request",
         code: "invalid-url",
@@ -195,8 +189,7 @@ export const open = (input: WebSocketRequest) =>
           headers: input.headers,
         }),
       catch: (error) =>
-        transportError(error instanceof Error ? error.message : "Failed to construct WebSocket", {
-          cause: error,
+        transportError("open", error instanceof Error ? error.message : "Failed to construct WebSocket", {
           url: input.url,
           operation: "request",
           phase: "connect",
@@ -221,8 +214,7 @@ export const fromWebSocket = (
       Queue.failCauseUnsafe(
         messages,
         Cause.fail(
-          transportError("WebSocket message exceeds the 16 MiB limit", {
-            body: typeof message === "string" ? message : new TextDecoder().decode(message),
+          transportError("message", "WebSocket message exceeds the 16 MiB limit", {
             url: input.url,
             operation: "read",
             code: "message-too-large",
@@ -239,8 +231,7 @@ export const fromWebSocket = (
       Queue.failCauseUnsafe(
         messages,
         Cause.fail(
-          transportError("WebSocket inbound queue overflow", {
-            body: typeof message === "string" ? message : new TextDecoder().decode(message),
+          transportError("message", "WebSocket inbound queue overflow", {
             url: input.url,
             operation: "read",
             code: "queue-overflow",
@@ -257,8 +248,7 @@ export const fromWebSocket = (
       Queue.failCauseUnsafe(
         messages,
         Cause.fail(
-          transportError("Unsupported WebSocket message payload", {
-            cause: event,
+          transportError("message", "Unsupported WebSocket message payload", {
             url: input.url,
             operation: "read",
             code: "message",
@@ -271,8 +261,7 @@ export const fromWebSocket = (
       Queue.failCauseUnsafe(
         messages,
         Cause.fail(
-          transportError(`WebSocket error: ${eventMessage(event)}`, {
-            cause: "error" in event ? (event.error ?? event) : event,
+          transportError("message", `WebSocket error: ${eventMessage(event)}`, {
             url: input.url,
             operation: "read",
             code: "message",
@@ -285,9 +274,7 @@ export const fromWebSocket = (
       Queue.failCauseUnsafe(
         messages,
         Cause.fail(
-          transportError(`WebSocket closed with code ${event.code}`, {
-            body: event.reason,
-            cause: event,
+          transportError("message", `WebSocket closed with code ${event.code}`, {
             url: input.url,
             operation: "read",
             code: String(event.code),
@@ -311,7 +298,7 @@ export const fromWebSocket = (
         Effect.suspend(() => {
           if (ws.readyState !== globalThis.WebSocket.OPEN)
             return Effect.fail(
-              transportError(`WebSocket is not open (state ${ws.readyState})`, {
+              transportError("sendText", `WebSocket is not open (state ${ws.readyState})`, {
                 url: input.url,
                 operation: "write",
                 phase: "send",
@@ -321,8 +308,7 @@ export const fromWebSocket = (
           return Effect.try({
             try: () => ws.send(message),
             catch: (error) =>
-              transportError(error instanceof Error ? error.message : "Failed to send WebSocket message", {
-                cause: error,
+              transportError("sendText", error instanceof Error ? error.message : "Failed to send WebSocket message", {
                 url: input.url,
                 operation: "write",
                 phase: "send",
@@ -363,23 +349,10 @@ export const makeDirect = (connector: WebSocketConnector): WebSocketChannelExecu
         (connection) => connection.close,
       )
       const create = yield* exchange.driver.create(undefined)
-      yield* connection.sendText(create.message).pipe(
-        Effect.mapError(
-          (error) =>
-            new AIError({
-              reason: AIErrorReason.make({
-                ...error.reason,
-                message: error.reason.message,
-                cause: error.reason.cause,
-                http: error.reason.http ?? connection.http,
-              }),
-            }),
-        ),
-      )
+      yield* connection.sendText(create.message)
       const decoder = new TextDecoder()
       let observed = false
       return {
-        http: connection.http,
         frames: connection.messages.pipe(
           Stream.map((message) => {
             observed = true
@@ -391,49 +364,9 @@ export const makeDirect = (connector: WebSocketConnector): WebSocketChannelExecu
               delivery: observed ? "accepted" : "ambiguous",
             }),
           ),
-          Stream.mapEffect((frame) =>
-            exchange.driver.observe(create, frame).pipe(
-              Effect.mapError(
-                (error) =>
-                  new AIError({
-                    reason: AIErrorReason.make({
-                      ...error.reason,
-                      message: error.reason.message,
-                      cause: error.reason.cause,
-                      body: frame,
-                    }),
-                  }),
-              ),
-              Effect.map((observation) =>
-                "error" in observation
-                  ? {
-                      ...observation,
-                      error: new AIError({
-                        reason: AIErrorReason.make({
-                          ...observation.error.reason,
-                          message: observation.error.reason.message,
-                          cause: observation.error.reason.cause,
-                          body: frame,
-                        }),
-                      }),
-                    }
-                  : observation,
-              ),
-            ),
-          ),
+          Stream.mapEffect((frame) => exchange.driver.observe(create, frame)),
           Stream.takeUntil(observationTerminal),
           Stream.mapEffect(observationFrame),
-          Stream.mapError(
-            (error) =>
-              new AIError({
-                reason: AIErrorReason.make({
-                  ...error.reason,
-                  message: error.reason.message,
-                  cause: error.reason.cause,
-                  http: error.reason.http ?? connection.http,
-                }),
-              }),
-          ),
         ),
         complete: Effect.void,
       }
@@ -484,7 +417,7 @@ export const json = <Body, Message>(input: JsonInput<Body, Message>): JsonTransp
     const webSocket = options?.webSocket
     if (!webSocket) {
       return Effect.fail(
-        transportError("WebSocket JSON transport requires StreamOptions.webSocket", {
+        transportError("json", "WebSocket JSON transport requires StreamOptions.webSocket", {
           url: prepared.url,
           operation: "request",
           code: "unavailable",
@@ -502,7 +435,7 @@ export const json = <Body, Message>(input: JsonInput<Body, Message>): JsonTransp
       connect: { url: prepared.url, headers: prepared.headers },
       fallback: () =>
         Stream.fail(
-          transportError("WebSocket JSON transport does not provide HTTP fallback", {
+          transportError("fallback", "WebSocket JSON transport does not provide HTTP fallback", {
             url: prepared.url,
             operation: "request",
             code: "websocket",

packages/ai/src/schema/errors.ts

@@ -1,13 +1,19 @@
 import { Schema } from "effect"
 import { Tool } from "@opencode-ai/schema/tool"
 import { ModelID, ProviderID, RouteID } from "./ids.js"
+import { ProviderMetadata } from "./messages.js"
 
 export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"])
 export type ProviderFailureClassification = typeof ProviderFailureClassification.Type
 
-export class HttpContext extends Schema.Class<HttpContext>("AI.HttpContext")({
+export class HttpRequestDetails extends Schema.Class<HttpRequestDetails>("AI.HttpRequestDetails")({
+  method: Schema.String,
   url: Schema.String,
-  status: Schema.Int.check(Schema.isBetween({ minimum: 100, maximum: 599 })),
+  headers: Schema.Record(Schema.String, Schema.String),
+}) {}
+
+export class HttpResponseDetails extends Schema.Class<HttpResponseDetails>("AI.HttpResponseDetails")({
+  status: Schema.Number,
   headers: Schema.Record(Schema.String, Schema.String),
 }) {}
 
@@ -18,58 +24,73 @@ export class HttpRateLimitDetails extends Schema.Class<HttpRateLimitDetails>("AI
   reset: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 }) {}
 
-const ReasonFields = {
-  message: Schema.String,
-  // Preserve the complete original response or triggering event before decoding narrows it.
+export class HttpContext extends Schema.Class<HttpContext>("AI.HttpContext")({
+  request: HttpRequestDetails,
+  response: Schema.optional(HttpResponseDetails),
   body: Schema.optional(Schema.String),
-  http: Schema.optional(HttpContext),
-  cause: Schema.optional(Schema.Defect({ includeStack: true })),
-}
-
-export class InvalidRequestError extends Schema.TaggedError<InvalidRequestError>("AI.Error.InvalidRequest")(
-  "InvalidRequest",
-  {
-    ...ReasonFields,
-    parameter: Schema.optional(Schema.String),
-    classification: Schema.optional(ProviderFailureClassification),
-  },
-) {}
-
-export class NoRouteError extends Schema.TaggedError<NoRouteError>("AI.Error.NoRoute")("NoRoute", {
-  ...ReasonFields,
-  route: RouteID,
-  provider: ProviderID,
-  model: ModelID,
-}) {}
-
-export class AuthenticationError extends Schema.TaggedError<AuthenticationError>("AI.Error.Authentication")(
-  "Authentication",
-  ReasonFields,
-) {}
-
-export class RateLimitError extends Schema.TaggedError<RateLimitError>("AI.Error.RateLimit")("RateLimit", {
-  ...ReasonFields,
-  retryAfterMs: Schema.optional(Schema.Number),
+  bodyTruncated: Schema.optional(Schema.Boolean),
   rateLimit: Schema.optional(HttpRateLimitDetails),
 }) {}
 
-export class QuotaExceededError extends Schema.TaggedError<QuotaExceededError>("AI.Error.QuotaExceeded")(
-  "QuotaExceeded",
-  ReasonFields,
-) {}
+export class InvalidRequestReason extends Schema.Class<InvalidRequestReason>("AI.Error.InvalidRequest")({
+  _tag: Schema.tag("InvalidRequest"),
+  message: Schema.String,
+  parameter: Schema.optional(Schema.String),
+  classification: Schema.optional(ProviderFailureClassification),
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}
 
-export class ContentPolicyError extends Schema.TaggedError<ContentPolicyError>("AI.Error.ContentPolicy")(
-  "ContentPolicy",
-  ReasonFields,
-) {}
+export class NoRouteReason extends Schema.Class<NoRouteReason>("AI.Error.NoRoute")({
+  _tag: Schema.tag("NoRoute"),
+  route: RouteID,
+  provider: ProviderID,
+  model: ModelID,
+}) {
+  get message() {
+    return `No AI route for ${this.provider}/${this.model} using ${this.route}`
+  }
+}
 
-export class ProviderInternalError extends Schema.TaggedError<ProviderInternalError>("AI.Error.ProviderInternal")(
-  "ProviderInternal",
-  {
-    ...ReasonFields,
-    retryAfterMs: Schema.optional(Schema.Number),
-  },
-) {}
+export class AuthenticationReason extends Schema.Class<AuthenticationReason>("AI.Error.Authentication")({
+  _tag: Schema.tag("Authentication"),
+  message: Schema.String,
+  kind: Schema.Literals(["missing", "invalid", "expired", "insufficient-permissions", "unknown"]),
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}
+
+export class RateLimitReason extends Schema.Class<RateLimitReason>("AI.Error.RateLimit")({
+  _tag: Schema.tag("RateLimit"),
+  message: Schema.String,
+  retryAfterMs: Schema.optional(Schema.Number),
+  rateLimit: Schema.optional(HttpRateLimitDetails),
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}
+
+export class QuotaExceededReason extends Schema.Class<QuotaExceededReason>("AI.Error.QuotaExceeded")({
+  _tag: Schema.tag("QuotaExceeded"),
+  message: Schema.String,
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}
+
+export class ContentPolicyReason extends Schema.Class<ContentPolicyReason>("AI.Error.ContentPolicy")({
+  _tag: Schema.tag("ContentPolicy"),
+  message: Schema.String,
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}
+
+export class ProviderInternalReason extends Schema.Class<ProviderInternalReason>("AI.Error.ProviderInternal")({
+  _tag: Schema.tag("ProviderInternal"),
+  message: Schema.String,
+  status: Schema.optional(Schema.Number),
+  retryAfterMs: Schema.optional(Schema.Number),
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}
 
 export const TransportType = Schema.Literals(["http", "websocket"])
 export type TransportType = typeof TransportType.Type
@@ -77,12 +98,14 @@ export type TransportType = typeof TransportType.Type
 export const TransportOperation = Schema.Literals(["request", "read", "write"])
 export type TransportOperation = typeof TransportOperation.Type
 
-export class TransportError extends Schema.TaggedError<TransportError>("AI.Error.Transport")("Transport", {
-  ...ReasonFields,
+export class TransportReason extends Schema.Class<TransportReason>("AI.Error.Transport")({
+  _tag: Schema.tag("Transport"),
+  message: Schema.String,
   transport: TransportType,
   operation: TransportOperation,
   code: Schema.optional(Schema.String),
   url: Schema.optional(Schema.String),
+  http: Schema.optional(HttpContext),
   phase: Schema.optional(
     Schema.Literals(["prepare", "queue", "connect", "send", "receive", "decode", "complete", "fallback", "close"]),
   ),
@@ -92,40 +115,51 @@ export class TransportError extends Schema.TaggedError<TransportError>("AI.Error
   ),
 }) {}
 
-export class InvalidProviderOutputError extends Schema.TaggedError<InvalidProviderOutputError>(
+export class InvalidProviderOutputReason extends Schema.Class<InvalidProviderOutputReason>(
   "AI.Error.InvalidProviderOutput",
-)("InvalidProviderOutput", {
-  ...ReasonFields,
+)({
+  _tag: Schema.tag("InvalidProviderOutput"),
+  message: Schema.String,
   classification: Schema.optional(Schema.Literals(["incomplete-stream"])),
   route: Schema.optional(Schema.String),
+  raw: Schema.optional(Schema.String),
+  providerMetadata: Schema.optional(ProviderMetadata),
 }) {}
 
-export class UnknownProviderError extends Schema.TaggedError<UnknownProviderError>("AI.Error.UnknownProvider")(
-  "UnknownProvider",
-  ReasonFields,
-) {}
+export class UnknownProviderReason extends Schema.Class<UnknownProviderReason>("AI.Error.UnknownProvider")({
+  _tag: Schema.tag("UnknownProvider"),
+  message: Schema.String,
+  status: Schema.optional(Schema.Number),
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}
 
 export const AIErrorReason = Schema.Union([
-  InvalidRequestError,
-  NoRouteError,
-  AuthenticationError,
-  RateLimitError,
-  QuotaExceededError,
-  ContentPolicyError,
-  ProviderInternalError,
-  TransportError,
-  InvalidProviderOutputError,
-  UnknownProviderError,
+  InvalidRequestReason,
+  NoRouteReason,
+  AuthenticationReason,
+  RateLimitReason,
+  QuotaExceededReason,
+  ContentPolicyReason,
+  ProviderInternalReason,
+  TransportReason,
+  InvalidProviderOutputReason,
+  UnknownProviderReason,
 ]).pipe(Schema.toTaggedUnion("_tag"))
 export type AIErrorReason = Schema.Schema.Type<typeof AIErrorReason>
 
 export class AIError extends Schema.TaggedError<AIError>()("AI.Error", {
+  module: Schema.String,
+  method: Schema.String,
   reason: AIErrorReason,
+  // Raw provider payload as a string, so classified failures never lose the
+  // original error detail even when the pretty message is a summary.
+  body: Schema.optional(Schema.String),
 }) {
   override readonly cause = this.reason
 
-  override get message(): string {
-    return this.reason.message
+  override get message() {
+    return `${this.module}.${this.method}: ${this.reason.message}`
   }
 }
 

packages/ai/src/schema/events.ts

@@ -3,7 +3,6 @@ import { LLM } from "@opencode-ai/schema/llm"
 import { ContentBlockID, ToolCallID } from "./ids.js"
 import {
   Message,
-  CompactionPart,
   ProviderMetadata,
   ToolCallPart,
   ToolOutput,
@@ -63,8 +62,6 @@ export { ProviderMetadata } from "./messages.js"
  * Matches the same escape-hatch field on `LLMEvent`.
  */
 export class Usage extends Schema.Class<Usage>("AI.Usage")({
-  /** Effective input size of the final message iteration, when reported; not billed totals. */
-  contextTokens: Schema.optional(Schema.Number),
   inputTokens: Schema.optional(Schema.Number),
   outputTokens: Schema.optional(Schema.Number),
   nonCachedInputTokens: Schema.optional(Schema.Number),
@@ -75,7 +72,7 @@ export class Usage extends Schema.Class<Usage>("AI.Usage")({
   providerMetadata: Schema.optional(ProviderMetadata),
 }) {
   /**
-   * Non-reasoning output tokens (including compaction summaries) — `outputTokens` minus `reasoningTokens`, clamped
+   * Visible output tokens — `outputTokens` minus `reasoningTokens`, clamped
    * to zero. The one place subtraction happens in this contract; the clamp
    * means a provider reporting `reasoningTokens > outputTokens` produces a
    * harmless zero rather than a negative that crashes downstream schemas.
@@ -91,12 +88,6 @@ export class Usage extends Schema.Class<Usage>("AI.Usage")({
 
 export type UsageInput = Usage | ConstructorParameters<typeof Usage>[0]
 
-/** A replacement context window. Replace prior history with these messages. */
-export class CompactionResponse extends Schema.Class<CompactionResponse>("LLM.CompactionResponse")({
-  messages: Schema.Array(Message),
-  usage: Schema.optional(Usage),
-}) {}
-
 export const StepStart = Schema.Struct({
   type: Schema.tag("step-start"),
   index: Schema.Number,
@@ -121,8 +112,6 @@ export type TextDelta = Schema.Schema.Type<typeof TextDelta>
 export const TextEnd = Schema.Struct({
   type: Schema.tag("text-end"),
   id: ContentBlockID,
-  /** Authoritative complete value; replaces accumulated deltas when present. */
-  text: Schema.optional(Schema.String),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.TextEnd" })
 export type TextEnd = Schema.Schema.Type<typeof TextEnd>
@@ -145,8 +134,6 @@ export type ReasoningDelta = Schema.Schema.Type<typeof ReasoningDelta>
 export const ReasoningEnd = Schema.Struct({
   type: Schema.tag("reasoning-end"),
   id: ContentBlockID,
-  /** Authoritative complete value; replaces accumulated deltas when present. */
-  text: Schema.optional(Schema.String),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ReasoningEnd" })
 export type ReasoningEnd = Schema.Schema.Type<typeof ReasoningEnd>
@@ -250,7 +237,6 @@ export const ProviderErrorEvent = Schema.Struct({
 export type ProviderErrorEvent = Schema.Schema.Type<typeof ProviderErrorEvent>
 
 const llmEventTagged = Schema.Union([
-  CompactionPart,
   StepStart,
   TextStart,
   TextDelta,
@@ -284,7 +270,6 @@ const toolCallID = (value: ToolCallID | string) => ToolCallID.make(value)
  * `events.filter(LLMEvent.guards["tool-call"])`.
  */
 export const LLMEvent = Object.assign(llmEventTagged, {
-  compaction: CompactionPart.make,
   stepStart: StepStart.make,
   textStart: (input: WithID<TextStart, ContentBlockID>) => TextStart.make({ ...input, id: contentBlockID(input.id) }),
   textDelta: (input: WithID<TextDelta, ContentBlockID>) => TextDelta.make({ ...input, id: contentBlockID(input.id) }),
@@ -322,7 +307,6 @@ export const LLMEvent = Object.assign(llmEventTagged, {
     }),
   providerError: ProviderErrorEvent.make,
   is: {
-    compaction: llmEventTagged.guards.compaction,
     stepStart: llmEventTagged.guards["step-start"],
     textStart: llmEventTagged.guards["text-start"],
     textDelta: llmEventTagged.guards["text-delta"],
@@ -344,32 +328,17 @@ export const LLMEvent = Object.assign(llmEventTagged, {
 })
 export type LLMEvent = Schema.Schema.Type<typeof llmEventTagged>
 
-/** Joins deltas per fragment, letting an authoritative end value replace that fragment's accumulated deltas. */
-const joinFragments = (
-  events: ReadonlyArray<LLMEvent>,
-  isDelta: (event: LLMEvent) => event is LLMEvent & { id: string; text: string },
-  isEnd: (event: LLMEvent) => event is LLMEvent & { id: string; text?: string },
-) => {
-  const order: string[] = []
-  const parts = new Map<string, string>()
-  for (const event of events) {
-    if (isDelta(event)) {
-      if (!parts.has(event.id)) order.push(event.id)
-      parts.set(event.id, (parts.get(event.id) ?? "") + event.text)
-    }
-    if (isEnd(event) && event.text !== undefined) {
-      if (!parts.has(event.id)) order.push(event.id)
-      parts.set(event.id, event.text)
-    }
-  }
-  return order.map((id) => parts.get(id)).join("")
-}
-
 const responseText = (events: ReadonlyArray<LLMEvent>) =>
-  joinFragments(events, LLMEvent.is.textDelta, LLMEvent.is.textEnd)
+  events
+    .filter(LLMEvent.is.textDelta)
+    .map((event) => event.text)
+    .join("")
 
 const responseReasoning = (events: ReadonlyArray<LLMEvent>) =>
-  joinFragments(events, LLMEvent.is.reasoningDelta, LLMEvent.is.reasoningEnd)
+  events
+    .filter(LLMEvent.is.reasoningDelta)
+    .map((event) => event.text)
+    .join("")
 
 const responseUsage = (events: ReadonlyArray<LLMEvent>) =>
   events.reduce<Usage | undefined>(
@@ -476,11 +445,10 @@ const reduceTextDelta = (state: ResponseState, event: TextDelta): ResponseState
 const reduceTextEnd = (state: ResponseState, event: TextEnd): ResponseState => {
   const current = state.textParts[event.id]
   if (!current) return state
-  const text = event.text ?? current.text
   const providerMetadata = event.providerMetadata ?? current.providerMetadata
   return {
-    ...replaceContent(state, current.contentIndex, textContent(text, providerMetadata)),
-    textParts: { ...state.textParts, [event.id]: { ...current, text, providerMetadata } },
+    ...replaceContent(state, current.contentIndex, textContent(current.text, providerMetadata)),
+    textParts: { ...state.textParts, [event.id]: { ...current, providerMetadata } },
   }
 }
 
@@ -510,11 +478,10 @@ const reduceReasoningDelta = (state: ResponseState, event: ReasoningDelta): Resp
 const reduceReasoningEnd = (state: ResponseState, event: ReasoningEnd): ResponseState => {
   const current = state.reasoningParts[event.id]
   if (!current) return state
-  const text = event.text ?? current.text
   const providerMetadata = event.providerMetadata ?? current.providerMetadata
   return {
-    ...replaceContent(state, current.contentIndex, reasoningContent(text, providerMetadata)),
-    reasoningParts: { ...state.reasoningParts, [event.id]: { ...current, text, providerMetadata } },
+    ...replaceContent(state, current.contentIndex, reasoningContent(current.text, providerMetadata)),
+    reasoningParts: { ...state.reasoningParts, [event.id]: { ...current, providerMetadata } },
   }
 }
 
@@ -575,8 +542,6 @@ const reduceToolCall = (state: ResponseState, event: ToolCall): ResponseState =>
 const reduceResponseState = (state: ResponseState, event: LLMEvent): ResponseState => {
   const next = appendEvent(state, event)
   switch (event.type) {
-    case "compaction":
-      return appendContent(next, event)
     case "text-start":
       return ensureText(next, event.id, event.providerMetadata)
     case "text-delta":
@@ -614,12 +579,12 @@ export class LLMResponse extends Schema.Class<LLMResponse>("LLM.Response")({
   usage: Schema.optional(Usage),
   finishReason: FinishReasonDetails,
 }) {
-  /** Concatenated assistant text; each fragment's `text-end` value replaces its accumulated deltas when present. */
+  /** Concatenated assistant text assembled from streamed `text-delta` events. */
   get text() {
     return responseText(this.events)
   }
 
-  /** Concatenated reasoning text; each fragment's `reasoning-end` value replaces its accumulated deltas when present. */
+  /** Concatenated reasoning text assembled from streamed `reasoning-delta` events. */
   get reasoning() {
     return responseReasoning(this.events)
   }

packages/ai/src/schema/messages.ts

@@ -7,10 +7,9 @@ import {
   HttpOptions,
   JsonSchema,
   LanguageModelSchema,
-  type LanguageModel,
   ProviderOptions,
 } from "./options.js"
-import { ProviderID } from "./ids.js"
+import { isRecord } from "../utils/record.js"
 
 export const MessageRole = Schema.Literals(["system", "user", "assistant", "tool"])
 export type MessageRole = Schema.Schema.Type<typeof MessageRole>
@@ -54,10 +53,14 @@ export const MediaPart = Schema.Struct({
   filename: Schema.optional(Schema.String),
   cache: Schema.optional(CacheHint),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Content.Media" })
 export type MediaPart = Schema.Schema.Type<typeof MediaPart>
 
+const isToolResultValue = (value: unknown): value is ToolResultValue =>
+  isRecord(value) &&
+  (value.type === "text" || value.type === "json" || value.type === "error" || value.type === "content") &&
+  "value" in value
+
 const toolResultValueSchema = Schema.Union([
   Schema.Struct({
     type: Schema.Literal("json"),
@@ -77,7 +80,6 @@ const toolResultValueSchema = Schema.Union([
   }),
 ]).annotate({ identifier: "LLM.ToolResult" })
 export type ToolResultValue = Schema.Schema.Type<typeof toolResultValueSchema>
-const isToolResultValue = Schema.is(toolResultValueSchema)
 
 export const ToolResultValue = Object.assign(toolResultValueSchema, {
   is: isToolResultValue,
@@ -188,40 +190,9 @@ export const ReasoningPart = Schema.Struct({
 }).annotate({ identifier: "LLM.Content.Reasoning" })
 export type ReasoningPart = Schema.Schema.Type<typeof ReasoningPart>
 
-/** A provider-generated context checkpoint, distinct from visible assistant text. */
-type CompactionContent =
-  | { readonly encrypted: string; readonly text?: never }
-  | { readonly text: string | null; readonly encrypted?: never }
-
-const compactionPartSchema = Schema.Struct({
-  type: Schema.Literal("compaction"),
-  provider: ProviderID,
-  id: Schema.optional(Schema.String),
-  encrypted: Schema.optional(Schema.String),
-  /** Null means the provider failed to produce a summary; prior history must be retained. */
-  text: Schema.optional(Schema.NullOr(Schema.String)),
-})
-  .pipe(
-    Schema.refine(
-      (part): part is typeof part & CompactionContent => (part.encrypted !== undefined) !== (part.text !== undefined),
-      { message: "Compaction requires either encrypted content or a summary" },
-    ),
-  )
-  .annotate({ identifier: "LLM.Content.Compaction" })
-export type CompactionPart = typeof compactionPartSchema.Type
-export const CompactionPart = Object.assign(compactionPartSchema, {
-  make: (input: Omit<CompactionPart, "type" | "encrypted" | "text"> & CompactionContent): CompactionPart =>
-    Schema.decodeUnknownSync(compactionPartSchema)({ type: "compaction", ...input }),
-})
-
-export const ContentPart = Schema.Union([
-  TextPart,
-  MediaPart,
-  ToolCallPart,
-  ToolResultPart,
-  ReasoningPart,
-  CompactionPart,
-]).pipe(Schema.toTaggedUnion("type"))
+export const ContentPart = Schema.Union([TextPart, MediaPart, ToolCallPart, ToolResultPart, ReasoningPart]).pipe(
+  Schema.toTaggedUnion("type"),
+)
 export type ContentPart = Schema.Schema.Type<typeof ContentPart>
 
 export class Message extends Schema.Class<Message>("LLM.Message")({
@@ -229,7 +200,6 @@ export class Message extends Schema.Class<Message>("LLM.Message")({
   role: MessageRole,
   content: Schema.Array(ContentPart),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  providerMetadata: Schema.optional(ProviderMetadata),
   native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 }) {}
 
@@ -307,7 +277,7 @@ export namespace ToolChoice {
   }
 }
 
-const requestSchema = Schema.Struct({
+export class LLMRequest extends Schema.Class<LLMRequest>("LLM.Request")({
   id: Schema.optional(Schema.String),
   model: LanguageModelSchema,
   system: Schema.Array(SystemPart),
@@ -321,26 +291,12 @@ const requestSchema = Schema.Struct({
   // Stable cache affinity for protocols that support provider-managed prompt caching.
   promptCacheKey: Schema.optional(Schema.String),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-})
-
-export class LLMRequest<Model extends LanguageModel = LanguageModel> extends Schema.Class<LLMRequest>("LLM.Request")(
-  requestSchema.fields,
-) {
-  declare readonly model: Model
-
-  // Preserve model inference instead of inheriting the schema's erased constructor signature.
-  // oxlint-disable-next-line no-useless-constructor
-  constructor(input: LLMRequest.Input<Model>) {
-    super(input)
-  }
-}
+}) {}
 
 export namespace LLMRequest {
-  export type Input<Model extends LanguageModel = LanguageModel> = Omit<typeof requestSchema.Type, "model"> & {
-    readonly model: Model
-  }
+  export type Input = ConstructorParameters<typeof LLMRequest>[0]
 
-  export const input = <Model extends LanguageModel>(request: LLMRequest<Model>): Input<Model> => ({
+  export const input = (request: LLMRequest): Input => ({
     id: request.id,
     model: request.model,
     system: request.system,
@@ -355,16 +311,7 @@ export namespace LLMRequest {
     metadata: request.metadata,
   })
 
-  export function update<Model extends LanguageModel>(
-    request: LLMRequest,
-    patch: Partial<Input<Model>> & { readonly model: Model },
-  ): LLMRequest<Model>
-  export function update<Model extends LanguageModel>(
-    request: LLMRequest<Model>,
-    patch: Partial<Omit<Input, "model">> & { readonly model?: undefined },
-  ): LLMRequest<Model>
-  export function update(request: LLMRequest, patch: Partial<Input>): LLMRequest
-  export function update(request: LLMRequest, patch: Partial<Input>) {
+  export const update = (request: LLMRequest, patch: Partial<Input>) => {
     if (Object.keys(patch).length === 0) return request
     return new LLMRequest({
       ...input(request),

packages/ai/src/schema/options.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect"
 import { ModelID, ProviderID } from "./ids.js"
-import type { AnyRoute, CompactOperation } from "../route/client.js"
+import type { AnyRoute } from "../route/client.js"
 import { isRecord } from "../utils/record.js"
 
 export const JsonSchema = Schema.Record(Schema.String, Schema.Unknown)
@@ -173,18 +173,15 @@ export namespace LanguageModelCompatibility {
     input instanceof LanguageModelCompatibility ? input : new LanguageModelCompatibility(input)
 }
 
-export class LanguageModel<
-  Options extends ProviderOptions = ProviderOptions,
-  Compact extends CompactOperation | undefined = CompactOperation | undefined,
-> {
+export class LanguageModel<Options extends ProviderOptions = ProviderOptions> {
   declare protected readonly _ProviderOptions: Options
   readonly id: ModelID
   readonly provider: ProviderID
-  readonly route: AnyRoute<Compact>
+  readonly route: AnyRoute
   readonly defaults?: LanguageModelDefaults
   readonly compatibility?: LanguageModelCompatibility
 
-  constructor(input: LanguageModel.ConstructorInput<Compact>) {
+  constructor(input: LanguageModel.ConstructorInput) {
     this.id = input.id
     this.provider = input.provider
     this.route = input.route
@@ -192,11 +189,8 @@ export class LanguageModel<
     this.compatibility = input.compatibility
   }
 
-  static make<
-    Options extends ProviderOptions = ProviderOptions,
-    Compact extends CompactOperation | undefined = CompactOperation | undefined,
-  >(input: LanguageModel.Input<Compact>) {
-    return new LanguageModel<Options, Compact>({
+  static make<Options extends ProviderOptions = ProviderOptions>(input: LanguageModel.Input) {
+    return new LanguageModel<Options>({
       id: ModelID.make(input.id),
       provider: ProviderID.make(input.provider),
       route: input.route,
@@ -206,9 +200,7 @@ export class LanguageModel<
     })
   }
 
-  static input<Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
-    model: LanguageModel<Options, Compact>,
-  ): LanguageModel.ConstructorInput<Compact> {
+  static input<Options extends ProviderOptions>(model: LanguageModel<Options>): LanguageModel.ConstructorInput {
     return {
       id: model.id,
       provider: model.provider,
@@ -218,41 +210,25 @@ export class LanguageModel<
     }
   }
 
-  static update<Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
-    model: LanguageModel<Options>,
-    patch: Partial<LanguageModel.Input<Compact>> & { readonly route: AnyRoute<Compact> },
-  ): LanguageModel<Options, Compact>
-  static update<Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
-    model: LanguageModel<Options, Compact>,
-    patch: Partial<Omit<LanguageModel.Input, "route">> & { readonly route?: undefined },
-  ): LanguageModel<Options, Compact>
-  static update<Options extends ProviderOptions>(
-    model: LanguageModel<Options>,
-    patch: Partial<LanguageModel.Input>,
-  ): LanguageModel<Options>
   static update<Options extends ProviderOptions>(model: LanguageModel<Options>, patch: Partial<LanguageModel.Input>) {
     if (Object.keys(patch).length === 0) return model
     return LanguageModel.make<Options>({
       ...LanguageModel.input(model),
       ...patch,
-      route: patch.route ?? model.route,
     })
   }
 }
 
 export namespace LanguageModel {
-  export type ConstructorInput<Compact extends CompactOperation | undefined = CompactOperation | undefined> = {
+  export type ConstructorInput = {
     readonly id: ModelID
     readonly provider: ProviderID
-    readonly route: AnyRoute<Compact>
+    readonly route: AnyRoute
     readonly defaults?: LanguageModelDefaults
     readonly compatibility?: LanguageModelCompatibility
   }
 
-  export type Input<Compact extends CompactOperation | undefined = CompactOperation | undefined> = Omit<
-    ConstructorInput<Compact>,
-    "id" | "provider" | "defaults" | "compatibility"
-  > & {
+  export type Input = Omit<ConstructorInput, "id" | "provider" | "defaults" | "compatibility"> & {
     readonly id: string | ModelID
     readonly provider: string | ProviderID
     readonly defaults?: LanguageModelDefaults.Input
@@ -291,7 +267,7 @@ export const CachePolicyObject = Schema.Struct({
     Schema.Union([
       Schema.Literal("latest-user-message"),
       Schema.Literal("latest-assistant"),
-      Schema.Struct({ tail: Schema.Natural }),
+      Schema.Struct({ tail: Schema.Number }),
     ]),
   ),
   ttlSeconds: Schema.optional(Schema.Number),

packages/ai/src/testing.ts

@@ -1,10 +1,9 @@
 export * as TestLLM from "./testing.js"
 
-import { LLMClient } from "./route/client.js"
+import { LLMClient, type Interface as LLMClientShape } from "./route/client.js"
 import {
   LLMEvent,
   LLMResponse,
-  CompactionResponse,
   type FinishReasonDetails,
   type AIError,
   type LLMRequest,
@@ -13,37 +12,17 @@ import {
 } from "./schema/index.js"
 import { Context, Deferred, Effect, Latch, Layer, Queue, Scope, Stream } from "effect"
 
-export type Response = readonly LLMEvent[] | Stream.Stream<LLMEvent, AIError> | CompactionResponse
+export type Response = readonly LLMEvent[] | Stream.Stream<LLMEvent, AIError>
 
 export type Gate = Readonly<{ started: Effect.Effect<void>; release: Effect.Effect<void> }>
 
-type ClientInterface = Context.Service.Shape<typeof LLMClient.Service>
-
-export type Responder = (request: LLMRequest) => Response
-
-export interface TestInterface extends ClientInterface {
-  /** Returns a snapshot of requests observed at execution time. */
-  readonly requests: () => Effect.Effect<readonly LLMRequest[]>
-  readonly push: (...responses: readonly Response[]) => Effect.Effect<void>
-  /** Replaces the fallback without changing queued responses. */
-  readonly always: (response: Response) => Effect.Effect<void>
-  /** Answers requests after the one-shot queue is exhausted; receives the original request. */
-  readonly serve: (responder: Responder) => Effect.Effect<void>
-  /** Waits for request arrivals, not output or completion. */
-  readonly wait: (count: number) => Effect.Effect<void>
-  readonly gate: () => Effect.Effect<Gate, never, Scope.Scope>
-}
-
-export class Test extends Context.Service<Test, TestInterface>()("@opencode/ai/TestLLM/Test") {}
-
-/** @deprecated Use TestInterface through Test and testLayer. */
 export interface Interface {
   readonly requests: LLMRequest[]
   readonly push: (...responses: readonly Response[]) => Effect.Effect<void>
   readonly always: (response: Response) => Effect.Effect<void>
   readonly wait: (count: number) => Effect.Effect<void>
   readonly gate: Effect.Effect<Gate, never, Scope.Scope>
-  readonly client: ClientInterface
+  readonly client: LLMClientShape
 }
 
 export interface LayerOptions {
@@ -52,7 +31,6 @@ export interface LayerOptions {
   readonly fallback?: Response
 }
 
-/** @deprecated Use Test and testLayer for normal client methods and test controls. */
 export class Service extends Context.Service<Service, Interface>()("@opencode/ai/TestLLM") {}
 
 export const complete = (
@@ -100,79 +78,61 @@ export const failAfter = (error: AIError, ...events: readonly LLMEvent[]) =>
 
 export const hangAfter = (...events: readonly LLMEvent[]) => Stream.concat(Stream.fromIterable(events), Stream.never)
 
-const make = (options: LayerOptions) =>
-  Effect.sync(() => {
-    const requests: LLMRequest[] = []
-    const responses: Response[] = []
-    let started = Deferred.makeUnsafe<void>()
-    let fallback: Response | Responder | undefined = options.fallback
-    let activeGate: { readonly started: Queue.Queue<void>; readonly release: Latch.Latch } | undefined
-    const wait = (count: number): Effect.Effect<void> =>
-      Effect.suspend(() =>
-        requests.length >= count ? Effect.void : Deferred.await(started).pipe(Effect.andThen(wait(count))),
-      )
+const toStream = (response: Response) => (Stream.isStream(response) ? response : Stream.fromIterable(response))
 
-    const take = (request: LLMRequest) =>
-      Effect.suspend(() => {
-        const count = requests.push(options.transformRequest?.(request) ?? request)
+export const layer = (options: LayerOptions = {}) =>
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const requests: LLMRequest[] = []
+      const responses: Response[] = []
+      let started = Deferred.makeUnsafe<void>()
+      let fallback = options.fallback
+      let activeGate: { readonly started: Queue.Queue<void>; readonly release: Latch.Latch } | undefined
+      const wait = (count: number): Effect.Effect<void> =>
+        Effect.suspend(() =>
+          requests.length >= count ? Effect.void : Deferred.await(started).pipe(Effect.andThen(wait(count))),
+        )
+
+      const stream = ((request: LLMRequest) => {
+        requests.push(options.transformRequest?.(request) ?? request)
         const waiting = started
         started = Deferred.makeUnsafe()
+        Deferred.doneUnsafe(waiting, Effect.void)
+        const response = responses.shift() ?? fallback
+        if (!response) return Stream.die(new Error(`TestLLM has no response for request ${requests.length}`))
+        const streamed = toStream(response)
         const gate = activeGate
-        try {
-          const response = responses.shift() ?? (typeof fallback === "function" ? fallback(request) : fallback)
-          if (!response) return Effect.die(new Error(`TestLLM has no response for request ${count}`))
-          if (!gate) return Effect.succeed(response)
-          return Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(response))
-        } finally {
-          // Waiters can resume synchronously; assign the reply and gate before notifying them.
-          Deferred.doneUnsafe(waiting, Effect.void)
-        }
-      })
-    const stream: ClientInterface["stream"] = (request) =>
-      Stream.unwrap(
-        take(request).pipe(
-          Effect.map((response) => {
-            if (response instanceof CompactionResponse)
-              return Stream.die("TestLLM generation requires an event response")
-            return Stream.isStream(response) ? response : Stream.fromIterable(response)
-          }),
-        ),
-      )
-    const test = Test.of({
-      compact: (request) =>
-        take(request).pipe(
-          Effect.flatMap((response) =>
-            response instanceof CompactionResponse
-              ? Effect.succeed(response)
-              : Effect.die("TestLLM compaction requires a CompactionResponse"),
+        if (!gate) return streamed
+        return Stream.unwrap(
+          Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(streamed)),
+        )
+      }) as LLMClientShape["stream"]
+      const client = LLMClient.Service.of({
+        stream,
+        generate: (request) =>
+          stream(request).pipe(
+            Stream.runFold(LLMResponse.empty, LLMResponse.reduce),
+            Effect.flatMap((state) => {
+              const response = LLMResponse.complete(state)
+              if (response) return Effect.succeed(response)
+              return Effect.die("TestLLM response ended without a terminal finish event")
+            }),
           ),
-        ),
-      stream,
-      generate: (request) =>
-        stream(request).pipe(
-          Stream.runFold(LLMResponse.empty, LLMResponse.reduce),
-          Effect.flatMap((state) => {
-            const response = LLMResponse.complete(state)
-            if (response) return Effect.succeed(response)
-            return Effect.die("TestLLM response ended without a terminal finish event")
+      })
+
+      return Service.of({
+        requests,
+        push: (...input) =>
+          Effect.sync(() => {
+            responses.push(...input)
           }),
-        ),
-      requests: () => Effect.sync(() => [...requests]),
-      push: (...input) =>
-        Effect.sync(() => {
-          responses.push(...input)
-        }),
-      always: (response) =>
-        Effect.sync(() => {
-          fallback = response
-        }),
-      serve: (responder) =>
-        Effect.sync(() => {
-          fallback = responder
-        }),
-      wait,
-      gate: () =>
-        Effect.gen(function* () {
+        always: (response) =>
+          Effect.sync(() => {
+            fallback = response
+          }),
+        wait,
+        gate: Effect.gen(function* () {
           const gate = {
             started: yield* Effect.acquireRelease(Queue.unbounded<void>(), Queue.shutdown),
             release: yield* Latch.make(),
@@ -187,36 +147,11 @@ const make = (options: LayerOptions) =>
             release,
           }
         }),
-    })
-
-    return { test, requests }
-  })
-
-/** Provides one shared implementation under the normal client and test-control tags. */
-export const testLayer = (options: LayerOptions = {}) =>
-  Layer.effectContext(
-    Effect.map(make(options), (implementation) =>
-      Context.make(LLMClient.Service, implementation.test).pipe(Context.add(Test, implementation.test)),
-    ),
+        client,
+      })
+    }),
   )
 
-/** @deprecated Use testLayer; retained for published callers of the legacy control interface. */
-export const layer = (options: LayerOptions = {}) =>
-  Layer.effect(
-    Service,
-    Effect.map(make(options), (implementation) =>
-      Service.of({
-        requests: implementation.requests,
-        push: implementation.test.push,
-        always: implementation.test.always,
-        wait: implementation.test.wait,
-        gate: implementation.test.gate(),
-        client: implementation.test,
-      }),
-    ),
-  )
-
-/** @deprecated testLayer provides LLMClient.Service directly. */
 export const clientLayer = Layer.effect(
   LLMClient.Service,
   Effect.map(Service, (service) => service.client),

packages/ai/src/tool-history.ts

@@ -1,75 +0,0 @@
-import { Message, ToolResultPart, type ToolCallPart } from "./schema/messages.js"
-
-const EMPTY_TOOL_OUTPUT = "(no tool output)"
-const MISSING_TOOL_RESULT = "Tool result missing"
-
-export function normalizeToolHistory(messages: ReadonlyArray<Message>) {
-  const normalized: Message[] = []
-  const pending = new Map<string, ToolCallPart>()
-  const appendMissingResults = () => {
-    if (pending.size === 0) return
-    normalized.push(missingToolResults(pending.values()))
-    pending.clear()
-  }
-
-  for (const message of messages) {
-    if (message.role === "user" || message.role === "assistant") appendMissingResults()
-
-    if (message.role === "tool") {
-      const tool = normalizeToolMessage(message, pending)
-      if (tool) normalized.push(tool)
-      continue
-    }
-
-    normalized.push(message)
-    if (message.role !== "assistant") continue
-    for (const part of message.content) {
-      if (part.type === "tool-call" && part.providerExecuted !== true) pending.set(part.id, part)
-    }
-  }
-
-  return normalized.length === messages.length && normalized.every((message, index) => message === messages[index])
-    ? messages
-    : normalized
-}
-
-function missingToolResults(calls: Iterable<ToolCallPart>) {
-  return new Message({
-    role: "tool",
-    content: [...calls].map((call) =>
-      ToolResultPart.make({ id: call.id, name: call.name, result: MISSING_TOOL_RESULT, resultType: "error" }),
-    ),
-  })
-}
-
-function normalizeToolMessage(message: Message, pending: Map<string, ToolCallPart>): Message | undefined {
-  const content = message.content.map((part) => {
-    if (part.type !== "tool-result" || part.providerExecuted === true) return part
-    const call = pending.get(part.id)
-    if (call) pending.delete(part.id)
-    return normalizeToolResult(part, call?.name ?? part.name)
-  })
-  if (content.length === 0) return undefined
-  if (content.every((part, index) => part === message.content[index])) return message
-  return new Message({
-    id: message.id,
-    role: message.role,
-    content,
-    metadata: message.metadata,
-    providerMetadata: message.providerMetadata,
-    native: message.native,
-  })
-}
-
-function normalizeToolResult(part: ToolResultPart, name: string): ToolResultPart {
-  const named = part.name === name ? part : { ...part, name }
-  if (named.result.type === "text" && named.result.value === "")
-    return { ...named, result: { type: "text", value: EMPTY_TOOL_OUTPUT } }
-  if (named.result.type === "error" && named.result.value === "")
-    return { ...named, result: { type: "error", value: EMPTY_TOOL_OUTPUT } }
-  if (named.result.type !== "content") return named
-  const value = named.result.value.filter((item) => item.type !== "text" || item.text !== "")
-  if (value.length === 0) return { ...named, result: { type: "text", value: EMPTY_TOOL_OUTPUT } }
-  if (value.length === named.result.value.length) return named
-  return { ...named, result: { type: "content", value } }
-}

packages/ai/test/adapter.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Effect, Schema, Stream } from "effect"
 import { LLM, LLMRequest, LLMResponse } from "../src/index.js"
 import { Route, Endpoint, LLMClient, Protocol, type FramingDef } from "../src/route.js"
@@ -148,13 +148,15 @@ describe("llm route", () => {
     }),
   )
 
-  test("builds models from configured routes", () => {
-    const configured = fake.with({ provider: "fake-provider", endpoint: { baseURL: "https://fake.local" } })
+  it.effect("builds models from configured routes", () =>
+    Effect.gen(function* () {
+      const configured = fake.with({ provider: "fake-provider", endpoint: { baseURL: "https://fake.local" } })
 
-    expect(configured.model({ id: "fake-model" })).toMatchObject({
-      provider: "fake-provider",
-    })
-  })
+      expect(configured.model({ id: "fake-model" })).toMatchObject({
+        provider: "fake-provider",
+      })
+    }),
+  )
 
   it.effect("does not register duplicate route ids globally", () =>
     Effect.gen(function* () {

packages/ai/test/cache-policy.test.ts

@@ -126,38 +126,6 @@ describe("applyCachePolicy", () => {
     }),
   )
 
-  for (const fixture of [
-    { name: "default", cache: undefined, control: { type: "ephemeral" } },
-    { name: "auto", cache: "auto", control: { type: "ephemeral" } },
-    {
-      name: "explicit one-hour",
-      cache: { tools: true, system: true, messages: { tail: 1 }, ttlSeconds: 3600 },
-      control: { type: "ephemeral", ttl: "1h" },
-    },
-    { name: "disabled", cache: "none", control: undefined },
-  ] as const) {
-    it.effect(`Bedrock Messages respects ${fixture.name} caching`, () =>
-      Effect.gen(function* () {
-        const prepared = yield* compileRequest(
-          LLM.request({
-            model: AmazonBedrock.configure({ apiKey: "test" }).messages("anthropic.claude-opus-4-6-v1"),
-            system: "Stable instructions",
-            tools: [
-              { name: "lookup", description: "Look up a value", inputSchema: { type: "object", properties: {} } },
-            ],
-            prompt: "hello",
-            cache: fixture.cache,
-          }),
-        )
-        expect(prepared.body).toMatchObject({
-          tools: [{ name: "lookup", cache_control: fixture.control }],
-          system: [{ type: "text", text: "Stable instructions", cache_control: fixture.control }],
-          messages: [{ role: "user", content: [{ type: "text", text: "hello", cache_control: fixture.control }] }],
-        })
-      }),
-    )
-  }
-
   it.effect("'auto' is a no-op on Gemini (out-of-band caching protocol)", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(

packages/ai/test/compaction-http.test.ts

@@ -1,97 +0,0 @@
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { LLM, LLMRequest, Message } from "../src/index.js"
-import { LLMClient } from "../src/route/client.js"
-import { OpenAI } from "../src/providers.js"
-import { testEffect } from "./lib/effect.js"
-import { runtimeLayer } from "./lib/http.js"
-import { sseEvents } from "./lib/sse.js"
-
-testEffect(runtimeLayer(FetchHttpClient.layer)).live("compaction and a tool loop work end to end over HTTP", () =>
-  Effect.gen(function* () {
-    const checkpoint = { type: "compaction", id: "cmp_local", encrypted_content: "opaque-local-state" }
-    const calls: string[] = []
-    const server = yield* Effect.acquireRelease(
-      Effect.sync(() =>
-        Bun.serve({
-          hostname: "127.0.0.1",
-          port: 0,
-          async fetch(request) {
-            const path = new URL(request.url).pathname
-            calls.push(path)
-            const body = await request.json()
-            expect(request.headers.get("authorization")).toBe("Bearer fixture")
-            if (path === "/v1/responses/compact") {
-              expect(body.stream).toBeUndefined()
-              return Response.json({
-                object: "response.compaction",
-                output: [checkpoint],
-                usage: { input_tokens: 100, output_tokens: 10, total_tokens: 110 },
-              })
-            }
-            expect(body.input[0]).toEqual(checkpoint)
-            expect(body.stream).toBe(true)
-            if (calls.length === 2)
-              return new Response(
-                sseEvents(
-                  {
-                    type: "response.output_item.done",
-                    item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "{}" },
-                  },
-                  { type: "response.completed", response: { id: "resp_1" } },
-                ),
-                { headers: { "content-type": "text/event-stream" } },
-              )
-            expect(body.input.at(-2)).toMatchObject({ type: "function_call", call_id: "call_1" })
-            expect(body.input.at(-1)).toEqual({ type: "function_call_output", call_id: "call_1", output: "42" })
-            const output = sseEvents(
-              { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
-              { type: "response.output_text.delta", item_id: "msg_1", delta: "The answer is 42." },
-              {
-                type: "response.output_item.done",
-                item: { type: "message", id: "msg_1", content: [{ type: "output_text", text: "The answer is 42." }] },
-              },
-              { type: "response.completed", response: { id: "resp_2" } },
-            )
-            return new Response(
-              new ReadableStream({
-                start(controller) {
-                  controller.enqueue(new TextEncoder().encode(output.slice(0, 37)))
-                  controller.enqueue(new TextEncoder().encode(output.slice(37)))
-                  controller.close()
-                },
-              }),
-              { headers: { "content-type": "text/event-stream" } },
-            )
-          },
-        }),
-      ),
-      (server) => Effect.sync(() => server.stop(true)),
-    )
-    const model = OpenAI.configure({ apiKey: "fixture", baseURL: `http://127.0.0.1:${server.port}/v1` }).responses(
-      "fixture",
-    )
-    const request = LLM.request({
-      model,
-      prompt: "original",
-      tools: [{ name: "lookup", description: "Lookup a number", inputSchema: { type: "object", properties: {} } }],
-    })
-    const compacted = yield* LLMClient.compact(request)
-    const messages = [...compacted.messages, Message.user("Look up the answer")]
-    const first = yield* LLMClient.generate(LLMRequest.update(request, { messages }))
-    expect(first.toolCalls).toHaveLength(1)
-    const call = first.toolCalls[0]!
-    const last = yield* LLMClient.generate(
-      LLMRequest.update(request, {
-        messages: [
-          ...messages,
-          first.message,
-          Message.tool({ id: call.id, name: call.name, result: "42", resultType: "text" }),
-        ],
-      }),
-    )
-    expect(last.text).toBe("The answer is 42.")
-    expect(calls).toEqual(["/v1/responses/compact", "/v1/responses", "/v1/responses"])
-  }),
-)

packages/ai/test/compaction.test.ts

@@ -1,64 +0,0 @@
-import { expect, test } from "bun:test"
-import { Schema } from "effect"
-import { CompactionPart, LLMEvent, LLMResponse, Message, ProviderID } from "../src/schema/index.js"
-import { LLM, LLMClient, LLMRequest, LanguageModel } from "../src/index.js"
-import { OpenAI, Anthropic } from "../src/providers.js"
-
-test("runtime capability checks follow model and route updates", () => {
-  const supported = OpenAI.configure({ apiKey: "test" }).responses("fixture")
-  const unsupported = Anthropic.configure({ apiKey: "test" }).model("fixture")
-  const request = LLM.request({ model: supported, prompt: "hello" })
-  expect(LLMClient.canCompact(request)).toBe(true)
-  expect(LLMClient.canCompact(LLMRequest.update(request, { messages: [] }))).toBe(true)
-  expect(LLMClient.canCompact(LLMRequest.update(request, { model: unsupported }))).toBe(false)
-  expect(
-    LLMClient.canCompact(LLM.request({ model: LanguageModel.update(supported, { route: unsupported.route }) })),
-  ).toBe(false)
-  expect(LLMClient.canCompact(LLM.request({ model: LanguageModel.update(supported, { route: undefined }) }))).toBe(true)
-})
-
-test("compaction survives event assembly and message serialization without becoming text", () => {
-  const part = CompactionPart.make({
-    provider: ProviderID.make("openai"),
-    id: "cmp_1",
-    encrypted: "opaque",
-  })
-  const response = LLMResponse.fromEvents([
-    LLMEvent.textStart({ id: "before" }),
-    LLMEvent.textDelta({ id: "before", text: "Before" }),
-    LLMEvent.textEnd({ id: "before" }),
-    part,
-    LLMEvent.textStart({ id: "after" }),
-    LLMEvent.textDelta({ id: "after", text: "After" }),
-    LLMEvent.textEnd({ id: "after" }),
-    LLMEvent.finish({ reason: { normalized: "stop" } }),
-  ])!
-  expect(response.message.content.map((part) => part.type)).toEqual(["text", "compaction", "text"])
-  expect(response.text).toBe("BeforeAfter")
-  expect(response.reasoning).toBe("")
-  expect(response.events.filter(LLMEvent.is.compaction)).toEqual([part])
-  const codec = Schema.fromJsonString(Message)
-  expect(Schema.decodeSync(codec)(Schema.encodeSync(codec)(response.message))).toEqual(response.message)
-})
-
-test("compaction requires exactly one typed representation", () => {
-  const provider = ProviderID.make("anthropic")
-  expect(CompactionPart.make({ provider, text: null })).toEqual({ type: "compaction", provider, text: null })
-  const decode = Schema.decodeUnknownSync(CompactionPart)
-  expect(() => decode({ type: "compaction", provider })).toThrow()
-  expect(() => decode({ type: "compaction", provider, text: "summary", encrypted: "opaque" })).toThrow()
-})
-
-test("tagged content and event guards accept both checkpoint representations", () => {
-  for (const part of [
-    CompactionPart.make({ provider: ProviderID.make("openai"), encrypted: "opaque" }),
-    CompactionPart.make({ provider: ProviderID.make("anthropic"), text: "summary" }),
-    CompactionPart.make({ provider: ProviderID.make("anthropic"), text: null }),
-  ]) {
-    expect(LLMEvent.is.compaction(part)).toBe(true)
-    expect(LLMEvent.guards.compaction(part)).toBe(true)
-    const codec = Schema.fromJsonString(Message)
-    const message = Message.assistant(part)
-    expect(Schema.decodeSync(codec)(Schema.encodeSync(codec)(message))).toEqual(message)
-  }
-})

packages/ai/test/compile.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import { Effect, Ref, Schema } from "effect"
 import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { LLM, LLMRequest, Message, ToolCallPart, ToolDefinition, mergeProviderOptions } from "../src/index.js"
+import { LLM, Message, ToolCallPart, mergeProviderOptions } from "../src/index.js"
 import { AnthropicMessages, OpenAIChat } from "../src/protocols.js"
 import { Auth, LLMClient } from "../src/route.js"
 import { compileRequest } from "../src/route/client.js"
@@ -77,55 +77,6 @@ describe("request option precedence", () => {
     }),
   )
 
-  it.effect("keeps the last tool definition for duplicate names", () =>
-    Effect.gen(function* () {
-      const request = LLM.request({
-        model: OpenAIChat.route.model({ id: "gpt-4o-mini" }),
-        prompt: "Use a tool.",
-      })
-      const prepared = yield* compileRequest(
-        LLMRequest.update(request, {
-          tools: [
-            ToolDefinition.make({ name: "lookup", description: "old", inputSchema: { type: "object" } }),
-            ToolDefinition.make({ name: "search", description: "search", inputSchema: { type: "object" } }),
-            ToolDefinition.make({ name: "lookup", description: "new", inputSchema: { type: "object" } }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        {
-          type: "function",
-          function: { name: "lookup", description: "new", parameters: { type: "object" }, strict: false },
-        },
-        {
-          type: "function",
-          function: { name: "search", description: "search", parameters: { type: "object" }, strict: false },
-        },
-      ])
-    }),
-  )
-
-  it.effect("normalizes tool history before protocol lowering", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: OpenAIChat.route.model({ id: "gpt-4o-mini" }),
-          messages: [
-            Message.assistant(ToolCallPart.make({ id: "call_1", name: "lookup", input: {} })),
-            Message.user("Continue."),
-          ],
-        }),
-      )
-
-      expect(prepared.body.messages).toMatchObject([
-        { role: "assistant", tool_calls: [{ id: "call_1", function: { name: "lookup" } }] },
-        { role: "tool", tool_call_id: "call_1", content: "Tool result missing" },
-        { role: "user", content: "Continue." },
-      ])
-    }),
-  )
-
   it.effect("applies model HTTP defaults before request HTTP overlays", () =>
     LLMClient.generate(
       LLM.request({

packages/ai/test/executor.test.ts

@@ -1,10 +1,10 @@
 import { describe, expect } from "bun:test"
-import { Deferred, Effect, Fiber, Ref, Stream } from "effect"
-import { Headers, HttpClientError, HttpClientRequest } from "effect/unstable/http"
-import { LLM, AIError, HttpContext, InvalidProviderOutputError, TransportError } from "../src/index.js"
+import { Deferred, Effect, Fiber, Layer, Ref, Stream } from "effect"
+import { Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { LLM, AIError } from "../src/index.js"
 import { LLMClient, RequestExecutor, WebSocketTransport, type WebSocketChannelExecutor } from "../src/route.js"
-import { route } from "../src/protocols/openai-chat.js"
-import { configure } from "../src/providers/openai.js"
+import * as OpenAIChat from "../src/protocols/openai-chat.js"
+import * as OpenAI from "../src/providers/openai.js"
 import { dynamicResponse, fixedResponse, systemError } from "./lib/http.js"
 import { deltaChunk } from "./lib/openai-chunks.js"
 import { sseEvents, sseRaw } from "./lib/sse.js"
@@ -18,86 +18,66 @@ const secretRequest = HttpClientRequest.post("https://provider.test/v1/chat?api_
   HttpClientRequest.setHeaders(Headers.fromInput({ authorization: "Bearer header-secret-456" })),
 )
 
+const responsesLayer = (responses: ReadonlyArray<Response>) =>
+  RequestExecutor.layer.pipe(
+    Layer.provide(
+      Layer.unwrap(
+        Effect.gen(function* () {
+          const cursor = yield* Ref.make(0)
+          return Layer.succeed(
+            HttpClient.HttpClient,
+            HttpClient.make((request) =>
+              Effect.gen(function* () {
+                const index = yield* Ref.getAndUpdate(cursor, (value) => value + 1)
+                return HttpClientResponse.fromWeb(request, responses[index] ?? responses[responses.length - 1])
+              }),
+            ),
+          )
+        }),
+      ),
+    ),
+  )
+
+const countedResponsesLayer = (attempts: Ref.Ref<number>, responses: ReadonlyArray<Response>) =>
+  RequestExecutor.layer.pipe(
+    Layer.provide(
+      Layer.unwrap(
+        Effect.gen(function* () {
+          const cursor = yield* Ref.make(0)
+          return Layer.succeed(
+            HttpClient.HttpClient,
+            HttpClient.make((request) =>
+              Effect.gen(function* () {
+                yield* Ref.update(attempts, (value) => value + 1)
+                const index = yield* Ref.getAndUpdate(cursor, (value) => value + 1)
+                return HttpClientResponse.fromWeb(request, responses[index] ?? responses[responses.length - 1])
+              }),
+            ),
+          )
+        }),
+      ),
+    ),
+  )
+
 const expectAIError = (error: unknown) => {
   expect(error).toBeInstanceOf(AIError)
   if (!(error instanceof AIError)) throw new Error("expected AIError")
-  expect(error.reason).toBeInstanceOf(Error)
-  expect(error.cause).toBe(error.reason)
   return error
 }
 
+const errorHttp = (error: AIError) => ("http" in error.reason ? error.reason.http : undefined)
 const largeProviderMessage = `Upstream request failed: ${"validation failed; ".repeat(1_000)}`
 
 describe("RequestExecutor", () => {
-  it.effect("preserves externally captured HTTP errors without inventing response context", () =>
-    Effect.sync(() => {
-      const cause = new Error("upstream request failed")
-      const body = '{"error":{"message":"Rate limited","trace":"original"}}'
-      const error = RequestExecutor.httpFailure({
-        message: "Rate limited",
-        url: request.url,
-        status: 429,
-        responseHeaders: { "Retry-After": "2", "X-Request-ID": "req_external" },
-        responseBody: body,
-        cause,
-      })
-
-      expect(error.message).toBe("Rate limited")
-      expect(error.reason).toMatchObject({ _tag: "RateLimit", retryAfterMs: 2000 })
-      expect(error.reason.body).toBe(body)
-      expect(error.reason.cause).toBe(cause)
-      expect(error.reason.http).toEqual(
-        new HttpContext({
-          url: request.url,
-          status: 429,
-          headers: { "retry-after": "2", "x-request-id": "req_external" },
-        }),
-      )
-      expect(RequestExecutor.httpFailure({ message: "No response", url: request.url }).reason.http).toBeUndefined()
-      expect(RequestExecutor.httpFailure({ message: "No URL", status: 500 }).reason.http).toBeUndefined()
-    }),
-  )
-
-  it.effect("retains the original body-read failure on an HTTP status error", () =>
-    Effect.gen(function* () {
-      const cause = new Error("response body disconnected")
-      const error = yield* Effect.gen(function* () {
-        const executor = yield* RequestExecutor.Service
-        return yield* executor.execute(request).pipe(Effect.flip)
-      }).pipe(
-        Effect.provide(
-          fixedResponse(
-            new ReadableStream({
-              start(controller) {
-                controller.error(cause)
-              },
-            }),
-            {
-              status: 503,
-              headers: { "x-request-id": "req_failed_body" },
-            },
-          ),
-        ),
-      )
-
-      expect(error.reason._tag).toBe("ProviderInternal")
-      expect(error.reason.cause).toBe(cause)
-      expect(error.reason.body).toBeUndefined()
-      expect(error.reason.http).toMatchObject({ status: 503, headers: { "x-request-id": "req_failed_body" } })
-    }),
-  )
-
   it.effect("parses response body failures at the executor seam", () =>
     Effect.gen(function* () {
       const executor = yield* RequestExecutor.Service
       const error = yield* RequestExecutor.stream(executor, secretRequest).pipe(Stream.runDrain, Effect.flip)
 
       expectAIError(error)
-      expect(error.message).toBe("ECONNRESET: disconnected query-secret-123 header-secret-456")
-      expect(error.reason.http).toMatchObject({ status: 200, url: secretRequest.url })
-      expect(error.reason.cause).toMatchObject({ code: "ECONNRESET" })
       expect(error.reason).toMatchObject({
         _tag: "Transport",
+        message: "ECONNRESET: disconnected query-secret-123 header-secret-456",
         transport: "http",
         operation: "read",
         code: "ECONNRESET",
@@ -105,14 +85,15 @@ describe("RequestExecutor", () => {
       })
     }).pipe(
       Effect.provide(
-        fixedResponse(
-          new ReadableStream({
-            start(controller) {
-              controller.error(systemError("ECONNRESET", "disconnected query-secret-123 header-secret-456"))
-            },
-          }),
-          {},
-        ),
+        responsesLayer([
+          new Response(
+            new ReadableStream({
+              start(controller) {
+                controller.error(systemError("ECONNRESET", "disconnected query-secret-123 header-secret-456"))
+              },
+            }),
+          ),
+        ]),
       ),
     ),
   )
@@ -123,23 +104,23 @@ describe("RequestExecutor", () => {
       const error = yield* RequestExecutor.stream(executor, secretRequest).pipe(Stream.runDrain, Effect.flip)
 
       expectAIError(error)
-      expect(error.message).toBe("ECONNRESET: socket closed")
-      expect(error.reason.cause).toBeInstanceOf(TypeError)
       expect(error.reason).toMatchObject({
         _tag: "Transport",
+        message: "ECONNRESET: socket closed",
         operation: "read",
         code: "ECONNRESET",
       })
     }).pipe(
       Effect.provide(
-        fixedResponse(
-          new ReadableStream({
-            pull(controller) {
-              controller.error(new TypeError("fetch failed", { cause: systemError("ECONNRESET", "socket closed") }))
-            },
-          }),
-          {},
-        ),
+        responsesLayer([
+          new Response(
+            new ReadableStream({
+              pull(controller) {
+                controller.error(new TypeError("fetch failed", { cause: systemError("ECONNRESET", "socket closed") }))
+              },
+            }),
+          ),
+        ]),
       ),
     ),
   )
@@ -152,10 +133,8 @@ describe("RequestExecutor", () => {
         .pipe(Effect.flip)
 
       expectAIError(error)
-      expect(error.message).toBe("plugin rejected request")
-      expect(error.reason.cause).toBeInstanceOf(Error)
-      expect(error.reason.http).toBeUndefined()
-    }).pipe(Effect.provide(dynamicResponse(() => Effect.die(new Error("unexpected HTTP request"))))),
+      expect(error.reason.message).toBe("plugin rejected request")
+    }).pipe(Effect.provide(responsesLayer([]))),
   )
 
   it.effect("reports the request sent by middleware", () =>
@@ -173,11 +152,16 @@ describe("RequestExecutor", () => {
         .pipe(Effect.flip)
 
       expectAIError(error)
-      expect(error.message).toBe("ECONNRESET: proxy disconnected proxy-secret")
-      expect(error.reason.http).toBeUndefined()
       expect(error.reason).toMatchObject({
         _tag: "Transport",
+        message: "ECONNRESET: proxy disconnected proxy-secret",
         url: "https://proxy.test/v1/chat?api_key=proxy-secret",
+        http: {
+          request: {
+            url: "https://proxy.test/v1/chat?api_key=proxy-secret",
+            headers: { authorization: "Bearer proxy-secret" },
+          },
+        },
       })
     }).pipe(
       Effect.provide(
@@ -204,9 +188,11 @@ describe("RequestExecutor", () => {
       expect(error.reason).toMatchObject({ _tag: "InvalidRequest", classification: "context-overflow" })
     }).pipe(
       Effect.provide(
-        fixedResponse('{"error":{"code":"context_length_exceeded","message":"prompt too long"}}', {
-          status: 400,
-        }),
+        responsesLayer([
+          new Response('{"error":{"code":"context_length_exceeded","message":"prompt too long"}}', {
+            status: 400,
+          }),
+        ]),
       ),
     ),
   )
@@ -220,9 +206,9 @@ describe("RequestExecutor", () => {
       expect(error.reason).toMatchObject({
         _tag: "InvalidRequest",
         classification: "payload-too-large",
+        http: { response: { status: 413 } },
       })
-      expect(error.reason.http?.status).toBe(413)
-    }).pipe(Effect.provide(fixedResponse("request too large", { status: 413 }))),
+    }).pipe(Effect.provide(responsesLayer([new Response("request too large", { status: 413 })]))),
   )
 
   it.effect("classifies Anthropic request_too_large as context overflow", () =>
@@ -234,13 +220,15 @@ describe("RequestExecutor", () => {
       expect(error.reason).toMatchObject({
         _tag: "InvalidRequest",
         classification: "context-overflow",
+        http: { response: { status: 413 } },
       })
-      expect(error.reason.http?.status).toBe(413)
     }).pipe(
       Effect.provide(
-        fixedResponse('{"error":{"type":"request_too_large","message":"Request exceeds the maximum size"}}', {
-          status: 413,
-        }),
+        responsesLayer([
+          new Response('{"error":{"type":"request_too_large","message":"Request exceeds the maximum size"}}', {
+            status: 413,
+          }),
+        ]),
       ),
     ),
   )
@@ -253,8 +241,8 @@ describe("RequestExecutor", () => {
       expectAIError(error)
       expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
       expect("classification" in error.reason ? error.reason.classification : undefined).toBeUndefined()
-      expect(error.message).toBe("Provider request failed with HTTP 400")
-    }).pipe(Effect.provide(fixedResponse("invalid parameter", { status: 400 }))),
+      expect(error.reason.message).toBe("Provider request failed with HTTP 400")
+    }).pipe(Effect.provide(responsesLayer([new Response("invalid parameter", { status: 400 })]))),
   )
 
   it.effect("preserves structured provider messages from large error bodies", () =>
@@ -263,18 +251,20 @@ describe("RequestExecutor", () => {
       const error = yield* executor.execute(request).pipe(Effect.flip)
 
       expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
-      expect(error.message).toBe(largeProviderMessage)
-      expect(error.reason.body).toContain(largeProviderMessage)
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: largeProviderMessage })
+      expect(errorHttp(error)?.body).toContain(largeProviderMessage)
+      expect(errorHttp(error)?.bodyTruncated).toBeUndefined()
     }).pipe(
       Effect.provide(
-        fixedResponse(
-          JSON.stringify({
-            model: "test-model",
-            error: { type: "invalid_request", message: largeProviderMessage },
-          }),
-          { status: 400 },
-        ),
+        responsesLayer([
+          new Response(
+            JSON.stringify({
+              model: "gpt-5.6-sol",
+              error: { type: "invalid_request", message: largeProviderMessage },
+            }),
+            { status: 400 },
+          ),
+        ]),
       ),
     ),
   )
@@ -287,9 +277,9 @@ describe("RequestExecutor", () => {
       expectAIError(error)
       expect(error.reason).toMatchObject({
         _tag: "InvalidRequest",
+        message: "Provider request failed with HTTP 400",
       })
-      expect(error.message).toBe("Provider request failed with HTTP 400")
-    }).pipe(Effect.provide(fixedResponse('{"error":{"message":"  "}}', { status: 400 }))),
+    }).pipe(Effect.provide(responsesLayer([new Response('{"error":{"message":"  "}}', { status: 400 })]))),
   )
 
   it.effect("classifies provider rate limits hidden behind HTTP 400", () =>
@@ -301,7 +291,7 @@ describe("RequestExecutor", () => {
 
           expectAIError(error)
           expect(error.reason).toMatchObject({ _tag: "RateLimit" })
-        }).pipe(Effect.provide(fixedResponse(body, { status: 400 })))
+        }).pipe(Effect.provide(responsesLayer([new Response(body, { status: 400 })])))
 
       yield* classify("Request rate increased too quickly")
       yield* classify('{"type":"error","error":{"type":"too_many_requests"}}')
@@ -318,7 +308,7 @@ describe("RequestExecutor", () => {
 
           expectAIError(error)
           expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
-        }).pipe(Effect.provide(fixedResponse(body, { status: 400 })))
+        }).pipe(Effect.provide(responsesLayer([new Response(body, { status: 400 })])))
 
       yield* classify('{"code":"resource_exhausted"}')
       yield* classify('{"code":"service_unavailable"}')
@@ -331,27 +321,37 @@ describe("RequestExecutor", () => {
       const error = yield* executor.execute(request).pipe(Effect.flip)
 
       expectAIError(error)
-      expect(error.reason).toMatchObject({
-        _tag: "RateLimit",
-        retryAfterMs: 0,
-        rateLimit: { retryAfterMs: 0 },
-        http: {
-          url: "https://provider.test/v1/chat?api_key=secret&key=secret&debug=1",
-          status: 429,
-          headers: {
-            "retry-after-ms": "0",
-            "x-request-id": "req_123",
-            "x-api-key": "secret",
+      expect(error).toMatchObject({
+        reason: {
+          _tag: "RateLimit",
+          retryAfterMs: 0,
+          rateLimit: { retryAfterMs: 0 },
+          http: {
+            request: {
+              method: "POST",
+              url: "https://provider.test/v1/chat?api_key=secret&key=secret&debug=1",
+              headers: { authorization: "Bearer secret", "x-safe": "visible" },
+            },
+            response: {
+              status: 429,
+              headers: {
+                "retry-after-ms": "0",
+                "x-request-id": "req_123",
+                "x-api-key": "secret",
+              },
+            },
           },
         },
       })
-      expect(error.reason.body).toBe("rate limited")
+      expect(errorHttp(error)?.body).toBe("rate limited")
     }).pipe(
       Effect.provide(
-        fixedResponse("rate limited", {
-          status: 429,
-          headers: { "retry-after-ms": "0", "x-request-id": "req_123", "x-api-key": "secret" },
-        }),
+        responsesLayer([
+          new Response("rate limited", {
+            status: 429,
+            headers: { "retry-after-ms": "0", "x-request-id": "req_123", "x-api-key": "secret" },
+          }),
+        ]),
       ),
     ),
   )
@@ -362,9 +362,10 @@ describe("RequestExecutor", () => {
       const error = yield* executor.execute(request).pipe(Effect.flip)
 
       expectAIError(error)
-      expect(error.reason.http?.headers["x-safe"]).toBe("response-secret")
+      expect(errorHttp(error)?.request.headers["x-safe"]).toBe("visible")
+      expect(errorHttp(error)?.response?.headers["x-safe"]).toBe("response-secret")
     }).pipe(
-      Effect.provide(fixedResponse("bad", { status: 400, headers: { "x-safe": "response-secret" } })),
+      Effect.provide(responsesLayer([new Response("bad", { status: 400, headers: { "x-safe": "response-secret" } })])),
       Effect.provideService(Headers.CurrentRedactedNames, ["x-safe"]),
     ),
   )
@@ -384,18 +385,20 @@ describe("RequestExecutor", () => {
       })
     }).pipe(
       Effect.provide(
-        fixedResponse("rate limited", {
-          status: 429,
-          headers: {
-            "retry-after-ms": "0",
-            "x-ratelimit-limit-requests": "500",
-            "x-ratelimit-limit-tokens": "30000",
-            "x-ratelimit-remaining-requests": "499",
-            "x-ratelimit-remaining-tokens": "29900",
-            "x-ratelimit-reset-requests": "1s",
-            "x-ratelimit-reset-tokens": "10s",
-          },
-        }),
+        responsesLayer([
+          new Response("rate limited", {
+            status: 429,
+            headers: {
+              "retry-after-ms": "0",
+              "x-ratelimit-limit-requests": "500",
+              "x-ratelimit-limit-tokens": "30000",
+              "x-ratelimit-remaining-requests": "499",
+              "x-ratelimit-remaining-tokens": "29900",
+              "x-ratelimit-reset-requests": "1s",
+              "x-ratelimit-reset-tokens": "10s",
+            },
+          }),
+        ]),
       ),
     ),
   )
@@ -406,8 +409,8 @@ describe("RequestExecutor", () => {
       const error = yield* executor.execute(request).pipe(Effect.flip)
 
       expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "RateLimit" })
-      expect(error.reason._tag === "RateLimit" ? error.reason.rateLimit : undefined).toEqual({
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
+      expect(errorHttp(error)?.rateLimit).toEqual({
         retryAfterMs: 0,
         limit: { requests: "100", "input-tokens": "10000" },
         remaining: { requests: "12", "input-tokens": "9000" },
@@ -415,18 +418,20 @@ describe("RequestExecutor", () => {
       })
     }).pipe(
       Effect.provide(
-        fixedResponse("rate limited", {
-          status: 429,
-          headers: {
-            "retry-after-ms": "0",
-            "anthropic-ratelimit-requests-limit": "100",
-            "anthropic-ratelimit-requests-remaining": "12",
-            "anthropic-ratelimit-requests-reset": "2026-05-06T12:00:00Z",
-            "anthropic-ratelimit-input-tokens-limit": "10000",
-            "anthropic-ratelimit-input-tokens-remaining": "9000",
-            "anthropic-ratelimit-input-tokens-reset": "2026-05-06T12:00:10Z",
-          },
-        }),
+        responsesLayer([
+          new Response("overloaded", {
+            status: 529,
+            headers: {
+              "retry-after-ms": "0",
+              "anthropic-ratelimit-requests-limit": "100",
+              "anthropic-ratelimit-requests-remaining": "12",
+              "anthropic-ratelimit-requests-reset": "2026-05-06T12:00:00Z",
+              "anthropic-ratelimit-input-tokens-limit": "10000",
+              "anthropic-ratelimit-input-tokens-remaining": "9000",
+              "anthropic-ratelimit-input-tokens-reset": "2026-05-06T12:00:10Z",
+            },
+          }),
+        ]),
       ),
     ),
   )
@@ -439,20 +444,15 @@ describe("RequestExecutor", () => {
         return yield* executor.execute(request).pipe(Effect.flip)
       }).pipe(
         Effect.provide(
-          dynamicResponse((input) =>
-            Effect.gen(function* () {
-              const attempt = yield* Ref.getAndUpdate(attempts, (value) => value + 1)
-              return attempt === 0
-                ? input.respond("busy", { status: 503, headers: { "retry-after-ms": "0" } })
-                : input.respond("ok", { status: 200 })
-            }),
-          ),
+          countedResponsesLayer(attempts, [
+            new Response("busy", { status: 503, headers: { "retry-after-ms": "0" } }),
+            new Response("ok", { status: 200 }),
+          ]),
         ),
       )
 
       expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
-      expect(error.reason.http?.status).toBe(503)
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", status: 503 })
       expect(yield* Ref.get(attempts)).toBe(1)
     }),
   )
@@ -465,14 +465,15 @@ describe("RequestExecutor", () => {
           const error = yield* executor.execute(request).pipe(Effect.flip)
 
           expectAIError(error)
-          expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
-          expect(error.reason.http?.status).toBe(status)
+          expect(error.reason).toMatchObject({ _tag: "ProviderInternal", status })
         }).pipe(
           Effect.provide(
-            fixedResponse("provider failure", {
-              status,
-              headers: { "retry-after-ms": "0" },
-            }),
+            responsesLayer([
+              new Response("provider failure", {
+                status,
+                headers: { "retry-after-ms": "0" },
+              }),
+            ]),
           ),
         )
 
@@ -483,28 +484,21 @@ describe("RequestExecutor", () => {
 
   it.effect("preserves large authentication error bodies", () =>
     Effect.gen(function* () {
-      const attempts = yield* Ref.make(0)
-      const error = yield* Effect.gen(function* () {
-        const executor = yield* RequestExecutor.Service
-        return yield* executor.execute(request).pipe(Effect.flip)
-      }).pipe(
-        Effect.provide(
-          dynamicResponse((input) =>
-            Effect.gen(function* () {
-              const attempt = yield* Ref.getAndUpdate(attempts, (value) => value + 1)
-              return attempt === 0
-                ? input.respond("x".repeat(20_000), { status: 401 })
-                : input.respond("should not retry", { status: 200 })
-            }),
-          ),
-        ),
-      )
+      const executor = yield* RequestExecutor.Service
+      const error = yield* executor.execute(request).pipe(Effect.flip)
 
       expectAIError(error)
       expect(error.reason).toMatchObject({ _tag: "Authentication" })
-      expect(error.reason.body).toHaveLength(20_000)
-      expect(yield* Ref.get(attempts)).toBe(1)
-    }),
+      expect(errorHttp(error)?.bodyTruncated).toBeUndefined()
+      expect(errorHttp(error)?.body).toHaveLength(20_000)
+    }).pipe(
+      Effect.provide(
+        responsesLayer([
+          new Response("x".repeat(20_000), { status: 401 }),
+          new Response("should not retry", { status: 200 }),
+        ]),
+      ),
+    ),
   )
 
   it.effect("preserves response body fields", () =>
@@ -513,12 +507,16 @@ describe("RequestExecutor", () => {
       const error = yield* executor.execute(request).pipe(Effect.flip)
 
       expectAIError(error)
-      expect(error.reason.body).toBe('{"error":{"message":"bad","key":"body-secret","detail":"api_key=query-secret"}}')
+      expect(errorHttp(error)?.body).toBe(
+        '{"error":{"message":"bad","key":"body-secret","detail":"api_key=query-secret"}}',
+      )
     }).pipe(
       Effect.provide(
-        fixedResponse('{"error":{"message":"bad","key":"body-secret","detail":"api_key=query-secret"}}', {
-          status: 400,
-        }),
+        responsesLayer([
+          new Response('{"error":{"message":"bad","key":"body-secret","detail":"api_key=query-secret"}}', {
+            status: 400,
+          }),
+        ]),
       ),
     ),
   )
@@ -529,10 +527,12 @@ describe("RequestExecutor", () => {
       const error = yield* executor.execute(secretRequest).pipe(Effect.flip)
 
       expectAIError(error)
-      expect(error.reason.body).toBe("provider echoed query-secret-123 and authorization header-secret-456")
+      expect(errorHttp(error)?.body).toBe("provider echoed query-secret-123 and authorization header-secret-456")
     }).pipe(
       Effect.provide(
-        fixedResponse("provider echoed query-secret-123 and authorization header-secret-456", { status: 400 }),
+        responsesLayer([
+          new Response("provider echoed query-secret-123 and authorization header-secret-456", { status: 400 }),
+        ]),
       ),
     ),
   )
@@ -540,7 +540,9 @@ describe("RequestExecutor", () => {
   it.effect("does not re-execute after a successful response reaches stream parsing", () =>
     Effect.gen(function* () {
       const attempts = yield* Ref.make(0)
-      const model = route.with({ endpoint: { baseURL: "https://api.openai.test/v1" } }).model({ id: "gpt-4o-mini" })
+      const model = OpenAIChat.route
+        .with({ endpoint: { baseURL: "https://api.openai.test/v1" } })
+        .model({ id: "gpt-4o-mini" })
       const error = yield* LLMClient.generate(LLM.request({ model, prompt: "Say hello." })).pipe(
         Effect.provide(
           dynamicResponse((input) =>
@@ -562,171 +564,19 @@ describe("RequestExecutor", () => {
 
       expectAIError(error)
       expect(error.reason).toMatchObject({ _tag: "InvalidProviderOutput" })
-      expect(error.reason.body).toBe("not-json")
-      expect(error.reason.cause).toBeDefined()
-      expect(error.reason.http).toMatchObject({ status: 200, headers: { "content-type": "text/event-stream" } })
       expect(yield* Ref.get(attempts)).toBe(1)
     }),
   )
 })
 
 describe("WebSocket channel execution", () => {
-  const model = configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses("gpt-4.1-mini")
+  const model = OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses("gpt-4.1-mini")
   const request = LLM.request({ model, prompt: "Say hello." })
   const frames = [
-    JSON.stringify({ type: "response.output_item.added", item: { type: "message", id: "msg_1" } }),
     JSON.stringify({ type: "response.output_text.delta", item_id: "msg_1", delta: "Hi" }),
     JSON.stringify({ type: "response.completed", response: { id: "resp_1" } }),
   ]
 
-  it.effect("preserves close reasons and native event causes without fabricated HTTP metadata", () =>
-    Effect.gen(function* () {
-      class TestSocket extends EventTarget {
-        readyState = globalThis.WebSocket.OPEN
-        send() {}
-        close() {}
-      }
-      const socket = new TestSocket()
-      const connection = yield* WebSocketTransport.fromWebSocket(
-        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-        socket as unknown as globalThis.WebSocket,
-        { url: "wss://provider.test/responses", headers: Headers.empty },
-      )
-      const event = new CloseEvent("close", { code: 1011, reason: "upstream trace: req_close" })
-      socket.dispatchEvent(event)
-      const error = yield* connection.messages.pipe(Stream.runDrain, Effect.flip)
-
-      expect(error.reason).toMatchObject({ _tag: "Transport", code: "1011", phase: "close" })
-      expect(error.message).toBe("WebSocket closed with code 1011")
-      expect(error.reason.body).toBe(event.reason)
-      expect(error.reason.cause).toBe(event)
-      expect(error.reason.http).toBeUndefined()
-      yield* connection.close
-    }),
-  )
-
-  it.effect("preserves opening event errors and native send exceptions", () =>
-    Effect.gen(function* () {
-      const cause = new Error("native send failed")
-      class TestSocket extends EventTarget {
-        readyState = globalThis.WebSocket.CONNECTING
-        send() {
-          throw cause
-        }
-        close() {}
-      }
-      const socket = new TestSocket()
-      const open = WebSocketTransport.fromWebSocket(
-        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-        socket as unknown as globalThis.WebSocket,
-        { url: "wss://provider.test/responses", headers: Headers.empty },
-      )
-      const fiber = yield* open.pipe(Effect.flip, Effect.forkChild({ startImmediately: true }))
-      const event = new ErrorEvent("error", { message: "handshake rejected", error: cause })
-      socket.dispatchEvent(event)
-      const error = yield* Fiber.join(fiber)
-      expect(error.reason.cause).toBe(cause)
-      expect(error.message).toContain("handshake rejected")
-      expect(error.reason.http).toBeUndefined()
-
-      socket.readyState = globalThis.WebSocket.OPEN
-      const connection = yield* open
-      const sent = yield* connection.sendText("create").pipe(Effect.flip)
-      expect(sent.reason.cause).toBe(cause)
-      expect(sent.message).toBe(cause.message)
-      yield* connection.close
-    }),
-  )
-
-  it.effect("preserves raw driver failures and known upgrade metadata", () =>
-    Effect.gen(function* () {
-      const cause = new Error("driver validation failed")
-      const frame = '{ "error": "failed", "trace": "original" }'
-      const http = new HttpContext({
-        url: "https://provider.test/responses",
-        status: 101,
-        headers: { upgrade: "websocket" },
-      })
-      const executor = WebSocketTransport.makeDirect({
-        open: () =>
-          Effect.succeed({
-            http,
-            sendText: () => Effect.void,
-            messages: Stream.make(frame),
-            close: Effect.void,
-          }),
-      })
-      const execution = yield* executor.execute({
-        id: "exchange_error",
-        connect: { url: "wss://provider.test/responses", headers: Headers.empty },
-        fallback: () => Stream.empty,
-        driver: {
-          create: () => Effect.succeed({ message: "create", mode: "full" }),
-          observe: () =>
-            Effect.succeed({
-              type: "provider-failure",
-              error: new AIError({
-                reason: new InvalidProviderOutputError({
-                  message: "Driver failed",
-                  cause,
-                  body: "narrowed",
-                }),
-              }),
-            }),
-        },
-      })
-      const error = yield* execution.frames.pipe(Stream.runDrain, Effect.flip)
-
-      expect(error.message).toBe("Driver failed")
-      expect(error.reason.body).toBe(frame)
-      expect(error.reason.cause).toBe(cause)
-      expect(error.reason.http).toBe(http)
-      expect(execution.http).toBe(http)
-    }),
-  )
-
-  it.effect("retains diagnostic fields when annotating transport delivery", () =>
-    Effect.gen(function* () {
-      const cause = new Error("connection closed")
-      const executor = WebSocketTransport.makeDirect({
-        open: () =>
-          Effect.succeed({
-            sendText: () => Effect.void,
-            messages: Stream.fail(
-              new AIError({
-                reason: new TransportError({
-                  message: "Socket closed",
-                  transport: "websocket",
-                  operation: "read",
-                  phase: "close",
-                  recovery: "retry-full",
-                  body: "server close detail",
-                  cause,
-                }),
-              }),
-            ),
-            close: Effect.void,
-          }),
-      })
-      const execution = yield* executor.execute({
-        id: "exchange_closed",
-        connect: { url: "wss://provider.test/responses", headers: Headers.empty },
-        fallback: () => Stream.empty,
-        driver: {
-          create: () => Effect.succeed({ message: "create", mode: "full" }),
-          observe: (_create, frame) => Effect.succeed({ type: "frame", frame }),
-        },
-      })
-      const error = yield* execution.frames.pipe(Stream.runDrain, Effect.flip)
-
-      expect(error.message).toBe("Socket closed")
-      expect(error.reason.body).toBe("server close detail")
-      expect(error.reason.cause).toBe(cause)
-      expect(error.reason).toMatchObject({ phase: "close", delivery: "ambiguous", recovery: "retry-full" })
-      expect(error.reason.http).toBeUndefined()
-    }),
-  )
-
   it.effect("runs a channel driver through the direct executor", () =>
     Effect.gen(function* () {
       const sent = yield* Ref.make("")

packages/ai/test/exports.test.ts

@@ -32,8 +32,6 @@ describe("public exports", () => {
     expect(Provider.make).toBeFunction()
     expect(ProviderSubpath.make).toBe(Provider.make)
     expect(TestLLM.layer).toBeFunction()
-    expect(TestLLM.testLayer).toBeFunction()
-    expect(TestLLM.Test.of).toBeFunction()
   })
 
   test("route barrel exposes route-authoring APIs", () => {

packages/ai/test/fixtures/recordings/anthropic-messages-cache/keeps-a-long-tool-turn-inside-the-cache-lookback.json

@@ -10,7 +10,7 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages?beta=true",
+        "url": "https://api.anthropic.com/v1/messages",
         "headers": {
           "anthropic-version": "2023-06-01",
           "content-type": "application/json"
@@ -29,7 +29,7 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages?beta=true",
+        "url": "https://api.anthropic.com/v1/messages",
         "headers": {
           "anthropic-version": "2023-06-01",
           "content-type": "application/json"

packages/ai/test/fixtures/recordings/anthropic-messages-cache/writes-then-reads-cache-control-on-identical-second-call.json

@@ -10,7 +10,7 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages?beta=true",
+        "url": "https://api.anthropic.com/v1/messages",
         "headers": {
           "anthropic-version": "2023-06-01",
           "content-type": "application/json"
@@ -29,7 +29,7 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages?beta=true",
+        "url": "https://api.anthropic.com/v1/messages",
         "headers": {
           "anthropic-version": "2023-06-01",
           "content-type": "application/json"

packages/ai/test/fixtures/recordings/anthropic-messages/anthropic-opus-4-7-image-tool-result.json

@@ -24,7 +24,7 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages?beta=true",
+        "url": "https://api.anthropic.com/v1/messages",
         "headers": {
           "anthropic-version": "2023-06-01",
           "content-type": "application/json"

packages/ai/test/fixtures/recordings/mistral-chat-glm/streams-an-indexed-tool-call.json

@@ -1,36 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "zai-glm-5-2",
-    "tags": [
-      "prefix:mistral-chat-glm",
-      "provider:mistral",
-      "protocol:mistral-chat",
-      "hosted-model",
-      "tool",
-      "tool-call"
-    ],
-    "name": "mistral-chat-glm/streams-an-indexed-tool-call",
-    "recordedAt": "2026-08-30T17:38:02.921Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.mistral.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"zai-glm-5-2\",\"messages\":[{\"role\":\"system\",\"content\":\"Call lookup_weather exactly once with Paris.\"},{\"role\":\"user\",\"content\":\"What is the weather?\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"description\":\"Look up the current weather for a city\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\",\"enum\":[\"Paris\"]}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}}],\"tool_choice\":{\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\"}},\"stream\":true,\"max_tokens\":256,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "data: {\"id\":\"f139bf0e4b984e51aabf6a83c237674d\",\"object\":\"chat.completion.chunk\",\"created\":1788111482,\"model\":\"zai-glm-5-2\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\"},\"finish_reason\":null}]}\n\ndata: {\"id\":\"f139bf0e4b984e51aabf6a83c237674d\",\"object\":\"chat.completion.chunk\",\"created\":1788111482,\"model\":\"zai-glm-5-2\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"index\":0,\"content\":\"\"},\"finish_reason\":null,\"logprobs\":null}]}\n\ndata: {\"id\":\"f139bf0e4b984e51aabf6a83c237674d\",\"object\":\"chat.completion.chunk\",\"created\":1788111482,\"model\":\"zai-glm-5-2\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"id\":\"chatcmpl-tool-8cc4d8f9f07b298a\",\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"arguments\":\"{\\\"city\\\": \\\"\"},\"index\":0}],\"index\":0,\"content\":\"\"},\"finish_reason\":null,\"logprobs\":null}]}\n\ndata: {\"id\":\"f139bf0e4b984e51aabf6a83c237674d\",\"object\":\"chat.completion.chunk\",\"created\":1788111482,\"model\":\"zai-glm-5-2\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"type\":\"function\",\"function\":{\"name\":\"\",\"arguments\":\"Paris\\\"}\"},\"index\":0}],\"index\":0,\"content\":\"\"},\"finish_reason\":null,\"logprobs\":null}]}\n\ndata: {\"id\":\"f139bf0e4b984e51aabf6a83c237674d\",\"object\":\"chat.completion.chunk\",\"created\":1788111482,\"model\":\"zai-glm-5-2\",\"choices\":[{\"index\":0,\"delta\":{\"index\":0,\"content\":\"\"},\"finish_reason\":\"stop\",\"logprobs\":null}],\"usage\":{\"prompt_tokens\":171,\"total_tokens\":182,\"completion_tokens\":11,\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/mistral-chat/drives-a-tool-loop.json

@@ -1,47 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "mistral-small-latest",
-    "tags": ["prefix:mistral-chat", "provider:mistral", "protocol:mistral-chat", "tool", "tool-loop", "usage"],
-    "name": "mistral-chat/drives-a-tool-loop",
-    "recordedAt": "2026-08-30T17:18:49.552Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.mistral.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"mistral-small-latest\",\"messages\":[{\"role\":\"system\",\"content\":\"Call lookup_weather exactly once with Paris.\"},{\"role\":\"user\",\"content\":\"What is the weather?\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"description\":\"Look up the current weather for a city\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\",\"enum\":[\"Paris\"]}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}}],\"tool_choice\":{\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\"}},\"stream\":true,\"max_tokens\":160,\"temperature\":0,\"reasoning_effort\":\"none\"}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "data: {\"id\":\"07491e37a5ed48f9987f1583753a466b\",\"object\":\"chat.completion.chunk\",\"created\":1788110328,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\"},\"finish_reason\":null}]}\n\ndata: {\"id\":\"07491e37a5ed48f9987f1583753a466b\",\"object\":\"chat.completion.chunk\",\"created\":1788110328,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"id\":\"ffJovBNqY\",\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"arguments\":\"{\\\"city\\\": \\\"Paris\\\"}\"},\"index\":0}]},\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":110,\"total_tokens\":122,\"completion_tokens\":12,\"prompt_tokens_details\":{\"cached_tokens\":0},\"service_tier\":\"standard\"},\"p\":\"abcdefghijklm\"}\n\ndata: [DONE]\n\n"
-      }
-    },
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.mistral.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"mistral-small-latest\",\"messages\":[{\"role\":\"system\",\"content\":\"Call lookup_weather exactly once with Paris.\"},{\"role\":\"user\",\"content\":\"What is the weather?\"},{\"role\":\"assistant\",\"content\":\"\",\"tool_calls\":[{\"id\":\"ffJovBNqY\",\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}]},{\"role\":\"tool\",\"tool_call_id\":\"ffJovBNqY\",\"name\":\"lookup_weather\",\"content\":\"{\\\"condition\\\":\\\"sunny\\\",\\\"temperature\\\":\\\"18C\\\"}\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"description\":\"Look up the current weather for a city\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\",\"enum\":[\"Paris\"]}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}}],\"tool_choice\":\"none\",\"stream\":true,\"max_tokens\":160,\"temperature\":0,\"reasoning_effort\":\"none\"}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "data: {\"id\":\"8fcd293093b849139fc0893a48bbc7ce\",\"object\":\"chat.completion.chunk\",\"created\":1788110328,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\"},\"finish_reason\":null}]}\n\ndata: {\"id\":\"8fcd293093b849139fc0893a48bbc7ce\",\"object\":\"chat.completion.chunk\",\"created\":1788110328,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"The\"},\"finish_reason\":null}],\"p\":\"abcdefghijklmn\"}\n\ndata: {\"id\":\"8fcd293093b849139fc0893a48bbc7ce\",\"object\":\"chat.completion.chunk\",\"created\":1788110328,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" weather in Paris is\"},\"finish_reason\":null}],\"p\":\"abcdefghijklmn\"}\n\ndata: {\"id\":\"8fcd293093b849139fc0893a48bbc7ce\",\"object\":\"chat.completion.chunk\",\"created\":1788110328,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" currently sunny with\"},\"finish_reason\":null}],\"p\":\"abcdefghijklmnopqrstu\"}\n\ndata: {\"id\":\"8fcd293093b849139fc0893a48bbc7ce\",\"object\":\"chat.completion.chunk\",\"created\":1788110328,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\" a temperature of \"},\"finish_reason\":null}],\"p\":\"abcdef\"}\n\ndata: {\"id\":\"8fcd293093b849139fc0893a48bbc7ce\",\"object\":\"chat.completion.chunk\",\"created\":1788110328,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"18°C\"},\"finish_reason\":null}],\"p\":\"abcdefghijklmnopqr\"}\n\ndata: {\"id\":\"8fcd293093b849139fc0893a48bbc7ce\",\"object\":\"chat.completion.chunk\",\"created\":1788110328,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\".\"},\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":57,\"total_tokens\":74,\"completion_tokens\":17,\"prompt_tokens_details\":{\"cached_tokens\":0},\"service_tier\":\"standard\"},\"p\":\"abcdefghijklmnopqrstuvwxyz\"}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/mistral-chat/streams-text-with-usage.json

@@ -1,29 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "mistral-small-latest",
-    "tags": ["prefix:mistral-chat", "provider:mistral", "protocol:mistral-chat", "text", "usage"],
-    "name": "mistral-chat/streams-text-with-usage",
-    "recordedAt": "2026-08-30T17:18:45.432Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.mistral.ai/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"mistral-small-latest\",\"messages\":[{\"role\":\"user\",\"content\":\"Reply with exactly one word: hello\"}],\"stream\":true,\"max_tokens\":40,\"temperature\":0,\"reasoning_effort\":\"none\"}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "data: {\"id\":\"9a4d16bdddb74e5e89c2cf9e9b91e065\",\"object\":\"chat.completion.chunk\",\"created\":1788110325,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\"},\"finish_reason\":null}]}\n\ndata: {\"id\":\"9a4d16bdddb74e5e89c2cf9e9b91e065\",\"object\":\"chat.completion.chunk\",\"created\":1788110325,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hi\"},\"finish_reason\":null}],\"p\":\"abcdefghijklmnopqrs\"}\n\ndata: {\"id\":\"9a4d16bdddb74e5e89c2cf9e9b91e065\",\"object\":\"chat.completion.chunk\",\"created\":1788110325,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\"},\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":22,\"total_tokens\":24,\"completion_tokens\":2,\"prompt_tokens_details\":{\"cached_tokens\":0},\"service_tier\":\"standard\"},\"p\":\"abcdefghijklmnopqrstuvwxyz0\"}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/openrouter-reasoning-tool-loop.json

@@ -23,7 +23,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"},{\"role\":\"user\",\"content\":\"What is the weather in Paris?\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning\":{\"max_tokens\":1024},\"max_completion_tokens\":1536,\"store\":false,\"usage\":{\"include\":true}}"
+        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"},{\"role\":\"user\",\"content\":\"What is the weather in Paris?\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"max_tokens\":1536,\"reasoning\":{\"max_tokens\":1024}}"
       },
       "response": {
         "status": 200,
@@ -41,7 +41,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"},{\"role\":\"user\",\"content\":\"What is the weather in Paris?\"},{\"role\":\"assistant\",\"content\":\"Sure! Let me check the weather in Paris for you right now!\",\"tool_calls\":[{\"id\":\"toolu_01PaChhcyw3yu2P2bDS2bgAA\",\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}],\"reasoning\":\"The user wants to know the weather in Paris. I'll use the get_weather tool.\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\"The user wants to know the weather in Paris. I'll use the get_weather tool.\",\"format\":\"anthropic-claude-v1\",\"index\":0,\"signature\":\"ErkCCosBCA8YAipAjKnRKpxkZ4eHrMPJ63IWEOYPSzb+XSHyG+vLK+2ks2O9T4N9M37Xn2kausQSH1rfsrdmKxgUlBg6yUFRgMVR7DIRY2xhdWRlLXNvbm5ldC00LTY4AEIIdGhpbmtpbmdaJDRjMGYwNDZmLTI1ZmQtNDVmYi1iZmIzLWEwOGE4ZTI0OWNhNxIMNFb5O6pb4nX0HojdGgyL5h+CAIpsxpdM1QgiMGm/i3ST6F5mAhxB+Uez0Cm95ra9yvQkrzHaA/AmWoXpdmPlczSn1S1RDk2IqeA57Spbf7JT44jygtLQt6yZmGzoTBHn3VkwaNZsuuAtbdo4B5QJXooa/AoKKs54QZ2kfS640vsv5flQVCg7CoQCFuLKjIeLMO7MnxVyuskXJr1DgesTa7I0ScF53U9JGhgB\"}]},{\"role\":\"tool\",\"tool_call_id\":\"toolu_01PaChhcyw3yu2P2bDS2bgAA\",\"content\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning\":{\"max_tokens\":1024},\"max_completion_tokens\":1536,\"store\":false,\"usage\":{\"include\":true}}"
+        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"},{\"role\":\"user\",\"content\":\"What is the weather in Paris?\"},{\"role\":\"assistant\",\"content\":\"Sure! Let me check the weather in Paris for you right now!\",\"tool_calls\":[{\"id\":\"toolu_01PaChhcyw3yu2P2bDS2bgAA\",\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}],\"reasoning\":\"The user wants to know the weather in Paris. I'll use the get_weather tool.\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\"The user wants to know the weather in Paris. I'll use the get_weather tool.\",\"format\":\"anthropic-claude-v1\",\"index\":0,\"signature\":\"ErkCCosBCA8YAipAjKnRKpxkZ4eHrMPJ63IWEOYPSzb+XSHyG+vLK+2ks2O9T4N9M37Xn2kausQSH1rfsrdmKxgUlBg6yUFRgMVR7DIRY2xhdWRlLXNvbm5ldC00LTY4AEIIdGhpbmtpbmdaJDRjMGYwNDZmLTI1ZmQtNDVmYi1iZmIzLWEwOGE4ZTI0OWNhNxIMNFb5O6pb4nX0HojdGgyL5h+CAIpsxpdM1QgiMGm/i3ST6F5mAhxB+Uez0Cm95ra9yvQkrzHaA/AmWoXpdmPlczSn1S1RDk2IqeA57Spbf7JT44jygtLQt6yZmGzoTBHn3VkwaNZsuuAtbdo4B5QJXooa/AoKKs54QZ2kfS640vsv5flQVCg7CoQCFuLKjIeLMO7MnxVyuskXJr1DgesTa7I0ScF53U9JGhgB\"}]},{\"role\":\"tool\",\"tool_call_id\":\"toolu_01PaChhcyw3yu2P2bDS2bgAA\",\"content\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"max_tokens\":1536,\"reasoning\":{\"max_tokens\":1024}}"
       },
       "response": {
         "status": 200,

packages/ai/test/fixtures/recordings/openrouter-reasoning.json

@@ -15,7 +15,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Think through the arithmetic, then reply with only the final integer.\"},{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219?\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"temperature\":0,\"reasoning\":{\"max_tokens\":1024},\"max_completion_tokens\":1536,\"store\":false,\"usage\":{\"include\":true}}"
+        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Think through the arithmetic, then reply with only the final integer.\"},{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219?\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"max_tokens\":1536,\"temperature\":0,\"reasoning\":{\"max_tokens\":1024}}"
       },
       "response": {
         "status": 200,

packages/ai/test/fixtures/recordings/pdf/anthropic-tool-result.json

@@ -10,11 +10,11 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages?beta=true",
+        "url": "https://api.anthropic.com/v1/messages",
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"system\":[{\"type\":\"text\",\"text\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"role\":\"assistant\",\"content\":[{\"type\":\"tool_use\",\"id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"input\":{}}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"call_pdf_1\",\"content\":[{\"type\":\"text\",\"text\":\"PDF read successfully\"},{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"},\"title\":\"verification.pdf\"}]}]}],\"tools\":[{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"input_schema\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
+        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"system\":[{\"type\":\"text\",\"text\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"role\":\"assistant\",\"content\":[{\"type\":\"tool_use\",\"id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"input\":{}}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"call_pdf_1\",\"content\":[{\"type\":\"text\",\"text\":\"PDF read successfully\"},{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}}]}]}],\"tools\":[{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"input_schema\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
       },
       "response": {
         "status": 200,

packages/ai/test/fixtures/recordings/pdf/anthropic-user-input.json

@@ -10,11 +10,11 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages?beta=true",
+        "url": "https://api.anthropic.com/v1/messages",
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"},\"title\":\"verification.pdf\"},{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
+        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}},{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
       },
       "response": {
         "status": 200,