fix(core): refresh git references on daily activity

2026-08-28 12:36:15 +00:00 · 2026-08-27 20:32:59 +05:30
442 changed files with 13756 additions and 21062 deletions
@@ -0,0 +1,5 @@
+---
+"@opencode-ai/core": patch
+---
+
+Preserve prompt cache prefixes when sessions move between locations with unchanged instructions.
@@ -0,0 +1,5 @@
+---
+"@opencode-ai/core": patch
+---
+
+Fix OpenCode Console device authorization URLs when the server returns an origin-rooted verification path.
@@ -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.
@@ -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.
@@ -0,0 +1,5 @@
+---
+"@opencode-ai/plugin": patch
+---
+
+Derive Promise plugin API request and response conversion from the canonical protocol schemas.
@@ -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.
@@ -0,0 +1,5 @@
+---
+"@opencode-ai/core": patch
+---
+
+Include both paths of renamed files in new snapshot change lists so undo restores the original file instead of only deleting the renamed file.
@@ -0,0 +1,5 @@
+---
+"@opencode-ai/core": patch
+---
+
+Apply shared Session model-request preparation to transient generation.
@@ -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.
@@ -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.
@@ -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.
@@ -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.
@@ -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.
@@ -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.
@@ -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"]
 }
@@ -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"
@@ -63,8 +63,7 @@ new sst.cloudflare.StaticSite("WebApp", {
  domain: "app." + domain,
  path: "packages/app",
  build: {
-    // Preserve Sentry credentials and run source-map uploads on every deployment.
-    command: "bun run build",
+    command: "bun turbo build",
    output: "./dist",
  },
 })
@@ -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 = ''
@@ -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=";
-}
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-EtUp4pHl9TyPtRrLGvk/X7kd2LuIxNxCpUwF5aLtzN4=",
-    "aarch64-linux": "sha256-m0j/pMZCguclR3/T9JmzCfi11YzmIvBFyR2bVhIO37Y=",
-    "aarch64-darwin": "sha256-nqefk68ZTUfNU15q1WkXaGsFzPNwOjCtMHpp6WrpNqM=",
-    "x86_64-darwin": "sha256-syD7hX62E4yCDV/wux1QKw4q/zZr24f99Y2mmzMJo6o="
+    "x86_64-linux": "sha256-iYdVrLtyKmjlyypisF9SqzgyriWT90kSCh3crxw9AKU=",
+    "aarch64-linux": "sha256-BV2t4w5ujArbtSC/Qfm3gLzevQW9A6hMgOyPVp94g/o=",
+    "aarch64-darwin": "sha256-EwMq7zaxzzcsmH0Pjqu4ftGdcM8Lna8mvHgKzRcVI8g=",
+    "x86_64-darwin": "sha256-PokzxlkQy6JvHADF2ZMIIDI1u9ZjSNNedpmR9gvHS5c="
  }
 }
@@ -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",
@@ -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.
@@ -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>)))
 }
@@ -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,
          }),
        }),
    ),
@@ -1387,15 +1387,14 @@ 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 isKnownStreamBlockType = (type: string) =>
  type === "text" ||
@@ -374,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
        }
@@ -388,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
    }

@@ -496,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.
@@ -575,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,
@@ -614,7 +606,6 @@ 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)),
          ),
@@ -654,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,
        }),
      })
    }
@@ -706,7 +699,6 @@ 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(),
@@ -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 } from "../schema/index.js"
+import { Effect, Stream } from "effect"
 import { Framing } from "../route/framing.js"
 import { ProviderShared } from "./shared.js"

@@ -50,14 +49,10 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
            `Failed to decode Bedrock Converse event-stream frame: ${
              error instanceof Error ? error.message : String(error)
            }`,
-            Encoding.encodeBase64(view.subarray(0, totalLength)),
-            error,
          ),
      })
      cursor = { buffer: cursor.buffer, offset: cursor.offset + totalLength }

-      const payload = utf8.decode(decoded.body)
-      const body = ProviderShared.encodeJson({ headers: decoded.headers, body: payload })
      const messageType = decoded.headers[":message-type"]?.value
      if (messageType === "error") {
        const code = decoded.headers[":error-code"]?.value
@@ -66,7 +61,6 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
          route,
          [code, message].filter((value): value is string => typeof value === "string").join(": ") ||
            "Bedrock Converse event-stream error",
-          body,
        )
      }
      const eventType =
@@ -76,6 +70,7 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
            ? decoded.headers[":exception-type"]?.value
            : undefined
      if (typeof eventType !== "string") continue
+      const payload = utf8.decode(decoded.body)
      if (!payload) continue
      // The AWS event stream pads short payloads with a `p` field. Drop it
      // before handing the object to the chunk schema. JSON decode goes
@@ -85,21 +80,11 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
        route,
        payload,
        "Failed to parse Bedrock Converse event-stream payload",
-      ).pipe(
-        Effect.mapError(
-          (error) =>
-            new AIError({
-              reason: AIErrorReason.make({ ...error.reason, message: error.message, cause: error.reason.cause, body }),
-            }),
-        ),
      )) as Record<string, unknown>
      delete parsed.p
-      out.push({
-        ...(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
  })
@@ -112,7 +97,6 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
 */
 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.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
 })

@@ -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),
@@ -601,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,
@@ -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"),
  )
 }

@@ -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)
+    },
  }
 }

@@ -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
@@ -5,7 +5,7 @@ import { Protocol } from "../route/protocol.js"
 import {
  AIError,
  LLMEvent,
-  ProviderInternalError,
+  ProviderInternalReason,
  Usage,
  type FinishReason,
  type JsonSchema,
@@ -391,19 +391,17 @@ export interface ParserState {
  readonly name: string
  readonly providerMetadataKey: string
  readonly tools: ToolStream.State<string>
-  // Call ids stay independent of item ids, which may be omitted or reused.
-  readonly completedTools: ReadonlySet<string>
  readonly hasFunctionCall: boolean
  readonly lifecycle: Lifecycle.State
  readonly outputItems: Readonly<Record<number, string>>
-  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
@@ -828,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)
  }
@@ -848,62 +846,18 @@ const onOutputTextDone = (state: ParserState, event: Event, id: string): StepRes
 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,
@@ -915,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)
@@ -924,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 [
      {
@@ -974,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(),
@@ -986,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)
@@ -1008,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,
@@ -1071,8 +1047,11 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (

  if (item.type === "message" && item.id !== undefined) {
    const itemPhase = messagePhase(item.phase)
-    const phase = itemPhase === undefined && state.message?.id === item.id ? state.message.phase : itemPhase
+    const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase
    const events: LLMEvent[] = []
+    const messageItems = new Set(state.messageItems)
+    messageItems.delete(item.id)
+    const { [item.id]: _phase, ...messagePhases } = state.messagePhases
    return [
      {
        ...state,
@@ -1082,7 +1061,8 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
          item.id,
          providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) }),
        ),
-        message: state.message?.id === item.id ? undefined : state.message,
+        messageItems,
+        messagePhases,
      },
      events,
    ] satisfies StepResult
@@ -1090,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 [
@@ -1130,7 +1094,6 @@ 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
@@ -1141,49 +1104,20 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
    const metadata = reasoningMetadata(state, item)
    const reasoningItem = state.reasoningItems[item.id]
    if (reasoningItem) {
-      if (!reasoningItem.open) return [state, NO_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,
        )
-      return [
-        {
-          ...state,
-          lifecycle,
-          reasoningItems: {
-            ...state.reasoningItems,
-            [item.id]: {
-              ...reasoningItem,
-              open: false,
-              encryptedContent: item.encrypted_content ?? reasoningItem.encryptedContent,
-            },
-          },
-        },
-        events,
-      ] satisfies StepResult
+      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 }))
-      return [
-        {
-          ...state,
-          lifecycle,
-          reasoningItems: {
-            ...state.reasoningItems,
-            [item.id]: {
-              open: false,
-              encryptedContent: item.encrypted_content,
-              summaryParts: { 0: "concluded" },
-              deltaIndexes: new Set(),
-            },
-          },
-        },
-        events,
-      ] satisfies StepResult
+      return [{ ...state, lifecycle }, events] satisfies StepResult
    }
    return [
      { ...state, lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, item.id, metadata) },
@@ -1205,7 +1139,7 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
            if (
              id === undefined ||
              ((item.type !== "function_call" || !current.tools[id]) &&
-                (item.type !== "reasoning" || !current.reasoningItems[id]?.open))
+                (item.type !== "reasoning" || !current.reasoningItems[id]))
            )
              return Effect.succeed([current, events] satisfies StepResult)
            return onOutputItemDone(current, { type: "response.output_item.done", item }).pipe(
@@ -1254,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 =
@@ -1270,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 =
@@ -1322,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(
@@ -1349,18 +1286,11 @@ export const step = (state: ParserState, input: Event) => {
    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])
 }
@@ -1378,10 +1308,10 @@ export const initial = (request: LLMRequest, extension: Extension = BASE): Parse
  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: {},
 })

@@ -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
@@ -936,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,
        }),
@@ -1062,14 +1066,7 @@ 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)
@@ -1113,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,
      }),
    })
@@ -1169,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>(),
@@ -1183,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,
@@ -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"
@@ -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:
@@ -149,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 {
@@ -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`
@@ -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 })),
  )
 }
@@ -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 => {
@@ -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,
@@ -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) =>
@@ -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,36 +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 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 (
@@ -115,52 +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) ||
-    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> {
@@ -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 = {}) => {
@@ -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]
@@ -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
@@ -12,14 +12,13 @@ import * as ProviderShared from "../protocols/shared.js"
 import type { ProtocolID, ProviderOptions } from "../schema/index.js"
 import {
  AIError,
-  AIErrorReason,
  GenerationOptions,
  HttpOptions,
  LLMRequest,
  LLMResponse,
  LanguageModel,
  LLMEvent,
-  InvalidProviderOutputError,
+  InvalidProviderOutputReason,
  ProviderID,
  mergeGenerationOptions,
  mergeHttpOptions,
@@ -228,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,
    }),
  })
@@ -264,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,
        ),
      ),
    )
@@ -324,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),
@@ -381,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
            }),
@@ -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,
@@ -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",
@@ -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)),
    }),
 })

@@ -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>
 }
@@ -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>
 }
@@ -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",
@@ -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}`
  }
 }

@@ -112,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>
@@ -136,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>
@@ -332,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 = <Delta extends { id: string; text: string }, End extends { id: string; text?: string }>(
-  events: ReadonlyArray<LLMEvent>,
-  isDelta: (event: LLMEvent) => event is Extract<LLMEvent, Delta>,
-  isEnd: (event: LLMEvent) => event is Extract<LLMEvent, End>,
-) => {
-  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>(
@@ -464,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 } },
  }
 }

@@ -498,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 } },
  }
 }

@@ -600,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)
  }
@@ -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* () {
@@ -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,170 +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_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("")
@@ -44,23 +44,21 @@ describe("Tool.make (dynamic JSON Schema)", () => {
    expect(definition?.inputSchema).toEqual(jsonSchema)
  })

-  it.effect("execute receives the raw input untouched", () =>
-    Effect.gen(function* () {
-      const seen: unknown[] = []
-      const tool = Tool.make({
-        description: "echo",
-        jsonSchema: { type: "object" },
-        execute: (params) =>
-          Effect.sync(() => {
-            seen.push(params)
-            return { ok: true }
-          }),
-      })
-      const result = yield* tool.execute({ hello: "world" })
-      expect(seen).toEqual([{ hello: "world" }])
-      expect(result).toEqual({ ok: true })
-    }),
-  )
+  test("execute receives the raw input untouched", async () => {
+    const seen: unknown[] = []
+    const tool = Tool.make({
+      description: "echo",
+      jsonSchema: { type: "object" },
+      execute: (params) =>
+        Effect.sync(() => {
+          seen.push(params)
+          return { ok: true }
+        }),
+    })
+    const result = await Effect.runPromise(tool.execute({ hello: "world" }))
+    expect(seen).toEqual([{ hello: "world" }])
+    expect(result).toEqual({ ok: true })
+  })
 })

 describe("LLM.generateObject", () => {
@@ -7,37 +7,6 @@ import { it } from "./lib/effect.js"
 import { dynamicResponse } from "./lib/http.js"

 describe("Image", () => {
-  for (const provider of [OpenAI, Google, XAI, ZAI]) {
-    const model = provider.configure({ apiKey: "test", baseURL: "https://image.test" }).image("image-model")
-    for (const body of ['{"data":42,"candidates":42,"opaque":{"nested":[1,2]},"trace":"outer"}', '{"invalid":']) {
-      it.effect(`retains ${model.provider} image response body and decode cause: ${body}`, () =>
-        Effect.gen(function* () {
-          const error = yield* Image.generate({ model, prompt: "hello" }).pipe(Effect.flip)
-          expect(error.reason._tag).toBe("InvalidProviderOutput")
-          expect(error.message).toContain("invalid response")
-          expect(error.reason.body).toBe(body)
-          expect(error.reason.http).toMatchObject({ status: 200, headers: { "x-image-trace": "trace-1" } })
-          expect(error.reason.http?.url).toStartWith("https://image.test/")
-          expect(error.reason.cause).toBeInstanceOf(Error)
-        }).pipe(
-          Effect.provide(
-            ImageClient.layer.pipe(
-              Layer.provide(
-                dynamicResponse((input) =>
-                  Effect.succeed(
-                    input.respond(body, {
-                      headers: { "content-type": "application/json", "x-image-trace": "trace-1" },
-                    }),
-                  ),
-                ),
-              ),
-            ),
-          ),
-        ),
-      )
-    }
-  }
-
  it.effect("generates images through the OpenAI Images API", () =>
    Effect.gen(function* () {
      const response = yield* Image.generate({
@@ -561,17 +530,22 @@ describe("Image", () => {
        Effect.sync(() => {
          expect(error.reason._tag).toBe("InvalidProviderOutput")
          if (error.reason._tag !== "InvalidProviderOutput") return
-          expect(error.message).toContain("finish reasons: IMAGE_SAFETY")
-          expect(JSON.parse(error.reason.body ?? "")).toEqual({
-            promptFeedback: { blockReason: "SAFETY" },
-            candidates: [
-              {
-                finishReason: "IMAGE_SAFETY",
-                finishMessage: "The generated image was blocked by safety filters.",
-                safetyRatings: [{ category: "HARM_CATEGORY_DANGEROUS_CONTENT", blocked: true }],
-                content: { parts: [{ text: "blocked", thought: false }] },
-              },
-            ],
+          expect(error.reason.message).toContain("finish reasons: IMAGE_SAFETY")
+          expect(error.reason.providerMetadata).toEqual({
+            google: {
+              promptFeedback: { blockReason: "SAFETY" },
+              candidates: [
+                {
+                  index: 0,
+                  finishReason: "IMAGE_SAFETY",
+                  finishMessage: "The generated image was blocked by safety filters.",
+                  safetyRatings: [{ category: "HARM_CATEGORY_DANGEROUS_CONTENT", blocked: true }],
+                  citationMetadata: undefined,
+                  groundingMetadata: undefined,
+                  parts: [{ type: "text", text: "blocked", thought: false, thoughtSignature: undefined }],
+                },
+              ],
+            },
          })
        }),
      ),
@@ -11,7 +11,6 @@ describe("provider error classification", () => {
      "Input length 131393 exceeds the maximum allowed input length of 131040 tokens.",
      "The input (516368 tokens) is longer than the model's context length (262144 tokens).",
      "Prompt has 5,958,968 tokens, but the configured context size is 256,000 tokens",
-      "Range of input length should be [1, 129024]",
      "Too many tokens",
      "Token limit exceeded",
    ]
@@ -88,12 +87,10 @@ describe("provider error classification", () => {
    ])
  })

-  test("classifies any remaining 4xx status as an invalid request", () => {
+  test("classifies network error text as provider internal", () => {
    expect(
-      [400, 402, 404, 418, 422, 451].map(
-        (status) => classifyProviderFailure({ message: `HTTP ${status}`, status })._tag,
-      ),
-    ).toEqual(Array(6).fill("InvalidRequest"))
+      ["network error", "network-error", "network_error"].map((message) => classifyProviderFailure({ message })._tag),
+    ).toEqual(["ProviderInternal", "ProviderInternal", "ProviderInternal"])
  })

  test("classifies nested provider codes when a top-level code is also present", () => {
@@ -106,49 +103,14 @@ describe("provider error classification", () => {
    ).toEqual(["QuotaExceeded", "ProviderInternal", "InvalidRequest"])
  })

-  test("leaves unrecognized failures unclassified for the retry default", () => {
+  test("keeps unknown and malformed provider payloads non-retryable", () => {
    expect(classifyProviderFailure({ message: '{"error":{"message":"no_kv_space"}}' })._tag).toBe("UnknownProvider")
    expect(classifyProviderFailure({ message: '{"type":"error","error":{"code":123}}' })._tag).toBe("UnknownProvider")
    expect(classifyProviderFailure({ message: "not-json" })._tag).toBe("UnknownProvider")
-    expect(classifyProviderFailure({ message: "network error" })._tag).toBe("UnknownProvider")
-    expect(classifyProviderFailure({ message: "Provider returned error" })._tag).toBe("UnknownProvider")
  })
 })

 describe("provider error rawBody classification", () => {
-  test("classifies provider envelopes without separate code inputs", () => {
-    const cases = [
-      ['{"type":"error","error":{"type":"overloaded_error","message":"Try again"}}', "ProviderInternal"],
-      ['{"error":{"code":"insufficient_quota","message":"Request failed"}}', "QuotaExceeded"],
-      [
-        '{"type":"response.failed","response":{"error":{"code":"authentication_error","message":"Denied"}}}',
-        "Authentication",
-      ],
-      ['{"error":{"code":429,"status":"RESOURCE_EXHAUSTED","message":"Try again"}}', "ProviderInternal"],
-      ['{"exception":{"type":"throttlingException","details":{"message":"Try again"}}}', "RateLimit"],
-    ] as const
-    for (const [rawBody, expected] of cases) {
-      const reason = classifyProviderFailure({ message: "Request failed", rawBody })
-      expect(reason._tag).toBe(expected)
-      expect(reason.body).toBe(rawBody)
-      expect(reason).not.toHaveProperty("code")
-    }
-  })
-
-  test("classifies separately supplied SDK data without replacing the response body", () => {
-    const data = { error: { code: "authentication_error" } }
-    for (const value of [data, JSON.stringify(data)]) {
-      const reason = classifyProviderFailure({
-        message: "Request failed",
-        status: 400,
-        rawBody: '{"message":"Request failed"}',
-        data: value,
-      })
-      expect(reason._tag).toBe("Authentication")
-      expect(reason.body).toBe('{"message":"Request failed"}')
-    }
-  })
-
  test("classifies overflow signals buried in the raw payload when the summary is vague", () => {
    const reason = classifyProviderFailure({
      message: "Request failed",
@@ -39,7 +39,7 @@ describe("Anthropic Messages sad-path recorded", () => {

      expect(error).toBeInstanceOf(AIError)
      expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
-      expect(error.message).toContain("`tool_use` ids were found without `tool_result` blocks")
+      expect(error.reason.message).toContain("`tool_use` ids were found without `tool_result` blocks")
    }),
  )
 })
@@ -966,8 +966,9 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput", classification: "incomplete-stream" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
+        classification: "incomplete-stream",
        message: "The provider response ended unexpectedly.",
      })
    }),
@@ -1056,8 +1057,8 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
        message: "Invalid anthropic/anthropic-messages stream event",
      })
    }),
@@ -1078,8 +1079,8 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
        message: "Invalid anthropic/anthropic-messages stream event",
      })
    }),
@@ -1105,8 +1106,8 @@ describe("Anthropic Messages route", () => {
            Effect.flip,
          )

-          expect(error).toMatchObject({
-            reason: { _tag: "InvalidProviderOutput" },
+          expect(error.reason).toMatchObject({
+            _tag: "InvalidProviderOutput",
            message: "Invalid anthropic/anthropic-messages stream event",
          })
        }),
@@ -1121,8 +1122,8 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
        message: "Invalid anthropic/anthropic-messages stream event",
      })
    }),
@@ -1644,7 +1645,7 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "overloaded_error: Overloaded" })
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "overloaded_error: Overloaded" })
    }),
  )

@@ -1662,9 +1663,10 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidRequest", classification: "context-overflow" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidRequest",
        message: "invalid_request_error: prompt is too long: 210000 tokens",
+        classification: "context-overflow",
      })
    }),
  )
@@ -1676,7 +1678,7 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "overloaded_error" })
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "overloaded_error" })
    }),
  )

@@ -1687,7 +1689,7 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "UnknownProvider" }, message: "Anthropic Messages stream error" })
+      expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "Anthropic Messages stream error" })
    }),
  )

@@ -1704,7 +1706,7 @@ describe("Anthropic Messages route", () => {
      )

      expect(error).toBeInstanceOf(AIError)
-      expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" }, message: "Bad request" })
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "Bad request" })
    }),
  )

@@ -491,59 +491,6 @@ describe("Bedrock Converse route", () => {
    }),
  )

-  it.effect("ignores late tool deltas after contentBlockStop", () =>
-    Effect.gen(function* () {
-      const body = eventStreamBody(
-        [
-          "contentBlockStart",
-          {
-            contentBlockIndex: 0,
-            start: { toolUse: { toolUseId: "tool_1", name: "lookup" } },
-          },
-        ],
-        ["contentBlockDelta", { contentBlockIndex: 0, delta: { toolUse: { input: '{"query":"weather"}' } } }],
-        ["contentBlockStop", { contentBlockIndex: 0 }],
-        ["contentBlockDelta", { contentBlockIndex: 0, delta: { toolUse: { input: '{"late":true}' } } }],
-        ["messageStop", { stopReason: "tool_use" }],
-      )
-      const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
-
-      expect(response.toolCalls).toEqual([
-        { type: "tool-call", id: "tool_1", name: "lookup", input: { query: "weather" } },
-      ])
-      expect(response.events.filter((event) => event.type === "tool-input-delta")).toEqual([
-        {
-          type: "tool-input-delta",
-          id: "tool_1",
-          name: "lookup",
-          text: '{"query":"weather"}',
-          input: { query: "weather" },
-        },
-      ])
-    }),
-  )
-
-  it.effect("rejects tool deltas without contentBlockStart", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(baseRequest).pipe(
-        Effect.provide(
-          fixedBytes(
-            eventStreamBody(
-              ["contentBlockDelta", { contentBlockIndex: 0, delta: { toolUse: { input: "{}" } } }],
-              ["messageStop", { stopReason: "tool_use" }],
-            ),
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput" },
-        message: "Bedrock Converse tool delta is missing its tool call",
-      })
-    }),
-  )
-
  it.effect("recovers incomplete tool input at finalization", () =>
    Effect.gen(function* () {
      const body = eventStreamBody(
@@ -584,104 +531,6 @@ describe("Bedrock Converse route", () => {
    }),
  )

-  for (const signature of [undefined, "", "   "]) {
-    for (const cache of ["none", "auto"] as const) {
-      it.effect(`demotes unsigned reasoning to text (${JSON.stringify(signature)}, cache: ${cache})`, () =>
-        Effect.gen(function* () {
-          const prepared = yield* compileRequest(
-            LLM.request({
-              model,
-              messages: [
-                Message.user("Think"),
-                Message.assistant([
-                  {
-                    type: "reasoning",
-                    text: "Partial thought",
-                    providerMetadata: signature === undefined ? undefined : { bedrock: { signature } },
-                    cache: new CacheHint({ type: "ephemeral" }),
-                  },
-                ]),
-                Message.user("Continue"),
-              ],
-              cache,
-            }),
-          )
-          expect(prepared.body.messages[1]).toEqual({
-            role: "assistant",
-            content: [{ text: "Partial thought" }, { cachePoint: { type: "default" } }],
-          })
-        }),
-      )
-    }
-  }
-
-  it.effect("omits empty unsigned reasoning without leaving an empty or cache-only assistant", () =>
-    Effect.gen(function* () {
-      const cache = new CacheHint({ type: "ephemeral" })
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.user("Think"),
-            Message.assistant([
-              { type: "reasoning", text: "", cache },
-              { type: "reasoning", text: "  ", providerMetadata: { bedrock: { signature: "" } }, cache },
-            ]),
-            Message.user([{ type: "text", text: "Continue", cache }]),
-          ],
-          cache: "none",
-        }),
-      )
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "user",
-          content: [{ text: "Think" }, { text: "Continue" }, { cachePoint: { type: "default" } }],
-        },
-      ])
-    }),
-  )
-
-  it.effect("demotes foreign reasoning while preserving signed, redacted, text, and tool blocks", () =>
-    Effect.gen(function* () {
-      const cache = new CacheHint({ type: "ephemeral" })
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([
-              { type: "reasoning", text: "Foreign thought", providerMetadata: { anthropic: { signature: "old" } } },
-              {
-                type: "reasoning",
-                text: "Signed thought",
-                providerMetadata: { bedrock: { signature: "sig_1" } },
-                cache,
-              },
-              { type: "reasoning", text: "", encrypted: "sig_2", cache },
-              { type: "reasoning", text: "", providerMetadata: { bedrock: { redactedData: "cmVkYWN0ZWQ=" } }, cache },
-              { type: "text", text: "Checking" },
-              ToolCallPart.make({ id: "call_1", name: "lookup", input: {} }),
-            ]),
-          ],
-          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
-          cache: "none",
-        }),
-      )
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "assistant",
-          content: [
-            { text: "Foreign thought" },
-            { reasoningContent: { reasoningText: { text: "Signed thought", signature: "sig_1" } } },
-            { reasoningContent: { reasoningText: { text: "", signature: "sig_2" } } },
-            { reasoningContent: { redactedContent: "cmVkYWN0ZWQ=" } },
-            { text: "Checking" },
-            { toolUse: { toolUseId: "call_1", name: "lookup", input: {} } },
-          ],
-        },
-      ])
-    }),
-  )
-
  it.effect("preserves streamed reasoning signatures for continuation lowering", () =>
    Effect.gen(function* () {
      const body = eventStreamBody(
@@ -940,32 +789,19 @@ describe("Bedrock Converse route", () => {
      ])
      const error = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)), Effect.flip)

-      expect(error).toMatchObject({ reason: { _tag: "UnknownProvider" }, message: "A future provider failure" })
+      expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "A future provider failure" })
    }),
  )

  it.effect("classifies throttlingException as a rate limit", () =>
    Effect.gen(function* () {
-      const payload = { message: "Slow down", details: { opaque: [1, 2] }, trace: "outer", p: "padding" }
      const body = concat([
        eventFrame("messageStart", { role: "assistant" }),
-        exceptionFrame("throttlingException", payload),
+        exceptionFrame("throttlingException", { message: "Slow down" }),
      ])
      const error = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)), Effect.flip)

-      expect(error).toMatchObject({ reason: { _tag: "RateLimit" }, message: "Slow down" })
-      expect(JSON.parse(error.reason.body ?? "")).toEqual({
-        headers: {
-          ":message-type": { type: "string", value: "exception" },
-          ":exception-type": { type: "string", value: "throttlingException" },
-          ":content-type": { type: "string", value: "application/json" },
-        },
-        body: JSON.stringify(payload),
-      })
-      expect(error.reason.http).toMatchObject({
-        status: 200,
-        headers: { "content-type": "application/vnd.amazon.eventstream" },
-      })
+      expect(error.reason).toMatchObject({ _tag: "RateLimit", message: "Slow down" })
    }),
  )

@@ -978,9 +814,10 @@ describe("Bedrock Converse route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidRequest", classification: "context-overflow" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidRequest",
        message: "Input is too long for requested model",
+        classification: "context-overflow",
      })
    }),
  )
@@ -999,7 +836,7 @@ describe("Bedrock Converse route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "Upstream model failed" })
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "Upstream model failed" })
    }),
  )

@@ -1010,32 +847,10 @@ describe("Bedrock Converse route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
        message: "BadStream: Stream failed",
      })
-      expect(JSON.parse(error.reason.body ?? "")).toMatchObject({
-        headers: { ":error-code": { value: "BadStream" } },
-        body: "",
-      })
-    }),
-  )
-
-  it.effect("retains malformed AWS payloads with headers and decode cause", () =>
-    Effect.gen(function* () {
-      const headers = {
-        ":message-type": { type: "string" as const, value: "event" },
-        ":event-type": { type: "string" as const, value: "messageStart" },
-      }
-      const body = '{"malformed":'
-      const error = yield* LLMClient.generate(baseRequest).pipe(
-        Effect.provide(fixedBytes(codec.encode({ headers, body: utf8Encoder.encode(body) }))),
-        Effect.flip,
-      )
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(JSON.parse(error.reason.body ?? "")).toEqual({ headers, body })
-      expect(error.reason.cause).toBeInstanceOf(Error)
-      expect(error.reason.http?.status).toBe(200)
    }),
  )

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { ConfigProvider, Effect, Schema } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, LLMEvent } from "../../src/index.js"
@@ -136,15 +136,17 @@ describe("Cloudflare", () => {
    }),
  )

-  test("defaults AI Gateway id to default when omitted or blank", () => {
-    expect(
-      CloudflareAIGateway.configure({
-        accountId: "test-account",
-        gatewayId: "",
-        gatewayApiKey: "test-token",
-      }).model("workers-ai/@cf/meta/llama-3.3-70b-instruct").route.endpoint.baseURL,
-    ).toBe("https://gateway.ai.cloudflare.com/v1/test-account/default/compat")
-  })
+  it.effect("defaults AI Gateway id to default when omitted or blank", () =>
+    Effect.gen(function* () {
+      expect(
+        CloudflareAIGateway.configure({
+          accountId: "test-account",
+          gatewayId: "",
+          gatewayApiKey: "test-token",
+        }).model("workers-ai/@cf/meta/llama-3.3-70b-instruct").route.endpoint.baseURL,
+      ).toBe("https://gateway.ai.cloudflare.com/v1/test-account/default/compat")
+    }),
+  )

  it.effect("supports authenticated AI Gateway plus upstream provider auth", () =>
    Effect.gen(function* () {
@@ -1,102 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM } from "../../src/index.js"
-import { Anthropic, Google, OpenAI } from "../../src/providers.js"
-import { LLMClient } from "../../src/route.js"
-import { it } from "../lib/effect.js"
-import { fixedResponse } from "../lib/http.js"
-import { sseEvents } from "../lib/sse.js"
-
-describe("provider error retention", () => {
-  const options = { apiKey: "test", baseURL: "https://provider.test" }
-  const cases = [
-    {
-      name: "Anthropic",
-      model: Anthropic.configure(options).model("claude"),
-      event: { type: "error", error: { type: "rate_limit_error", message: "Slow down", details: { opaque: [1, 2] } } },
-    },
-    {
-      name: "OpenAI Chat",
-      model: OpenAI.configure(options).chat("gpt"),
-      event: { error: { code: "rate_limit_exceeded", message: "Slow down", details: { opaque: [1, 2] } } },
-    },
-    {
-      name: "OpenAI Responses",
-      model: OpenAI.configure(options).responses("gpt"),
-      event: {
-        type: "response.failed",
-        response: {
-          id: "resp_error",
-          error: { code: "rate_limit_exceeded", message: "Slow down", details: { opaque: [1, 2] } },
-          opaque: { upstream: true },
-        },
-      },
-    },
-    {
-      name: "Gemini",
-      model: Google.configure(options).model("gemini"),
-      event: { error: { code: 429, status: "RESOURCE_EXHAUSTED", message: "Slow down", details: { opaque: [1, 2] } } },
-    },
-  ]
-
-  for (const entry of cases) {
-    it.effect(`retains the complete ${entry.name} event and HTTP context`, () =>
-      Effect.gen(function* () {
-        const body = JSON.stringify({ ...entry.event, trace: { opaque: "outer" } })
-        const error = yield* LLMClient.generate(LLM.request({ model: entry.model, prompt: "hello" })).pipe(
-          Effect.provide(
-            fixedResponse(sseEvents(body), {
-              headers: { "content-type": "text/event-stream", "x-provider-trace": "trace-1" },
-            }),
-          ),
-          Effect.flip,
-        )
-        expect(error.message).toContain("Slow down")
-        expect(error.reason._tag).toBe("RateLimit")
-        expect(error.reason.body).toBe(body)
-        expect(error.reason.http).toMatchObject({ status: 200, headers: { "x-provider-trace": "trace-1" } })
-        expect(error.reason.http?.url).toStartWith("https://provider.test/")
-        expect(error.reason.cause).toBeUndefined()
-        expect(error.cause).toBe(error.reason)
-      }),
-    )
-  }
-
-  it.effect("retains malformed provider frames and the original decode cause", () =>
-    Effect.gen(function* () {
-      const body = '{"type":"error","error":{"message":42,"opaque":{"nested":true}},"trace":"outer"}'
-      const error = yield* LLMClient.generate(
-        LLM.request({ model: Anthropic.configure(options).model("claude"), prompt: "hello" }),
-      ).pipe(Effect.provide(fixedResponse(sseEvents(body))), Effect.flip)
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.reason.body).toBe(body)
-      expect(error.reason.cause).toBeInstanceOf(Error)
-      expect(error.reason.http?.status).toBe(200)
-    }),
-  )
-
-  it.effect("retains the HTTP response context when a channel falls back", () =>
-    Effect.gen(function* () {
-      const body = '{"type":"error","error":{"code":"rate_limit_exceeded","message":"Slow down","extra":42}}'
-      const error = yield* LLMClient.generate(
-        LLM.request({ model: OpenAI.configure(options).responses("gpt"), prompt: "hello" }),
-        {
-          webSocket: {
-            execute: (exchange) => Effect.succeed({ frames: exchange.fallback(), complete: Effect.void }),
-          },
-        },
-      ).pipe(
-        Effect.provide(fixedResponse(sseEvents(body), { headers: { "x-provider-trace": "fallback-1" } })),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("RateLimit")
-      expect(error.reason.body).toBe(body)
-      expect(error.reason.http).toMatchObject({
-        url: "https://provider.test/responses",
-        status: 200,
-        headers: { "x-provider-trace": "fallback-1" },
-      })
-    }),
-  )
-})
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, Message, ToolCallPart } from "../../src/index.js"
@@ -376,9 +376,11 @@ describe("Google Vertex providers", () => {
    }),
  )

-  test("rejects tuned Gemini models in express mode", () => {
-    expect(() => GoogleVertex.configure({ apiKey: "fixture" }).model("endpoints/1234567890")).toThrow(
-      "Google Vertex tuned models do not support Express Mode API keys",
-    )
-  })
+  it.effect("rejects tuned Gemini models in express mode", () =>
+    Effect.sync(() => {
+      expect(() => GoogleVertex.configure({ apiKey: "fixture" }).model("endpoints/1234567890")).toThrow(
+        "Google Vertex tuned models do not support Express Mode API keys",
+      )
+    }),
+  )
 })
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { ConfigProvider, Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, Message, ToolDefinition } from "../../src/index.js"
@@ -31,71 +31,82 @@ import { dynamicResponse } from "../lib/http.js"
 import { sseEvents } from "../lib/sse.js"

 describe("native OpenAI-compatible providers", () => {
-  test("assigns provider-owned metadata namespaces across native routes", () => {
-    const vertex = { project: "project", accessToken: "token" }
-    const providers = [
-      [OpenAI.configure({ apiKey: "test" }).chat("model"), "openai"],
-      [OpenAI.configure({ apiKey: "test" }).responses("model"), "openai"],
-      [Azure.configure({ resourceName: "resource", apiKey: "test" }).chat("model"), "azure"],
-      [Azure.configure({ resourceName: "resource", apiKey: "test" }).responses("model"), "azure"],
-      [AmazonBedrock.configure({ apiKey: "test" }).model("model"), "bedrock"],
-      [AmazonBedrockMantle.configure({ apiKey: "test" }).chat("model"), "mantle"],
-      [AmazonBedrockMantle.configure({ apiKey: "test" }).responses("model"), "mantle"],
-      [Google.configure({ apiKey: "test" }).model("model"), "google"],
-      [GoogleVertex.configure(vertex).model("model"), "vertex"],
-      [GoogleVertexChat.configure(vertex).model("model"), "vertex"],
-      [GoogleVertexResponses.configure(vertex).model("model"), "vertex"],
-      [GoogleVertexMessages.configure(vertex).model("model"), "anthropic"],
-      [Anthropic.configure({ apiKey: "test" }).model("model"), "anthropic"],
-      [
-        AnthropicCompatible.configure({ baseURL: "https://example.test/v1", provider: "minimax" }).model("model"),
-        "minimax",
-      ],
-      [OpenAICompatible.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model("model"), "custom"],
-      [
-        OpenAICompatibleResponses.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model("model"),
-        "custom",
-      ],
-      [Cerebras.configure({ apiKey: "test" }).model("model"), "cerebras"],
-      [DeepInfra.configure({ apiKey: "test" }).model("model"), "deepinfra"],
-      [TogetherAI.configure({ apiKey: "test" }).model("model"), "togetherai"],
-      [CloudflareAIGateway.configure({ accountId: "account" }).model("model"), "cloudflare-ai-gateway"],
-      [CloudflareWorkersAI.configure({ accountId: "account" }).model("model"), "cloudflare-workers-ai"],
-      [OpenRouter.configure({ apiKey: "test" }).model("model"), "openrouter"],
-      [XAI.configure({ apiKey: "test" }).chat("model"), "xai"],
-      [XAI.configure({ apiKey: "test" }).responses("model"), "xai"],
-    ] as const
+  it.effect("assigns provider-owned metadata namespaces across native routes", () =>
+    Effect.gen(function* () {
+      const vertex = { project: "project", accessToken: "token" }
+      const providers = [
+        [OpenAI.configure({ apiKey: "test" }).chat("model"), "openai"],
+        [OpenAI.configure({ apiKey: "test" }).responses("model"), "openai"],
+        [Azure.configure({ resourceName: "resource", apiKey: "test" }).chat("model"), "azure"],
+        [Azure.configure({ resourceName: "resource", apiKey: "test" }).responses("model"), "azure"],
+        [AmazonBedrock.configure({ apiKey: "test" }).model("model"), "bedrock"],
+        [AmazonBedrockMantle.configure({ apiKey: "test" }).chat("model"), "mantle"],
+        [AmazonBedrockMantle.configure({ apiKey: "test" }).responses("model"), "mantle"],
+        [Google.configure({ apiKey: "test" }).model("model"), "google"],
+        [GoogleVertex.configure(vertex).model("model"), "vertex"],
+        [GoogleVertexChat.configure(vertex).model("model"), "vertex"],
+        [GoogleVertexResponses.configure(vertex).model("model"), "vertex"],
+        [GoogleVertexMessages.configure(vertex).model("model"), "anthropic"],
+        [Anthropic.configure({ apiKey: "test" }).model("model"), "anthropic"],
+        [
+          AnthropicCompatible.configure({ baseURL: "https://example.test/v1", provider: "minimax" }).model("model"),
+          "minimax",
+        ],
+        [
+          OpenAICompatible.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model("model"),
+          "custom",
+        ],
+        [
+          OpenAICompatibleResponses.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model(
+            "model",
+          ),
+          "custom",
+        ],
+        [Cerebras.configure({ apiKey: "test" }).model("model"), "cerebras"],
+        [DeepInfra.configure({ apiKey: "test" }).model("model"), "deepinfra"],
+        [TogetherAI.configure({ apiKey: "test" }).model("model"), "togetherai"],
+        [CloudflareAIGateway.configure({ accountId: "account" }).model("model"), "cloudflare-ai-gateway"],
+        [CloudflareWorkersAI.configure({ accountId: "account" }).model("model"), "cloudflare-workers-ai"],
+        [OpenRouter.configure({ apiKey: "test" }).model("model"), "openrouter"],
+        [XAI.configure({ apiKey: "test" }).chat("model"), "xai"],
+        [XAI.configure({ apiKey: "test" }).responses("model"), "xai"],
+      ] as const

-    for (const [model, key] of providers) expect(model.route.providerMetadataKey).toBe(key)
-  })
+      for (const [model, key] of providers) expect(model.route.providerMetadataKey).toBe(key)
+    }),
+  )

-  test("preserves native Together AI and Cerebras provider and route identities", () => {
-    const together = TogetherAI.configure({ apiKey: "fixture" }).model("meta-llama/Llama-3.3-70B")
-    const cerebras = Cerebras.configure({ apiKey: "fixture" }).model("qwen-3-235b-a22b")
+  it.effect("preserves native Together AI and Cerebras provider and route identities", () =>
+    Effect.gen(function* () {
+      const together = TogetherAI.configure({ apiKey: "fixture" }).model("meta-llama/Llama-3.3-70B")
+      const cerebras = Cerebras.configure({ apiKey: "fixture" }).model("qwen-3-235b-a22b")

-    expect(together).toMatchObject({
-      provider: "togetherai",
-      compatibility: { maxTokensField: "max_tokens", supportsStore: false, supportsStrictMode: false },
-      route: { id: "togetherai-chat", protocol: "openai-chat" },
-    })
-    expect(together.route.endpoint.baseURL).toBe("https://api.together.xyz/v1")
-    expect(cerebras).toMatchObject({
-      provider: "cerebras",
-      compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning", supportsStore: false },
-      route: { id: "cerebras-chat", protocol: "openai-chat" },
-    })
-    expect(cerebras.route.endpoint.baseURL).toBe("https://api.cerebras.ai/v1")
-  })
+      expect(together).toMatchObject({
+        provider: "togetherai",
+        compatibility: { maxTokensField: "max_tokens", supportsStore: false, supportsStrictMode: false },
+        route: { id: "togetherai-chat", protocol: "openai-chat" },
+      })
+      expect(together.route.endpoint.baseURL).toBe("https://api.together.xyz/v1")
+      expect(cerebras).toMatchObject({
+        provider: "cerebras",
+        compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning", supportsStore: false },
+        route: { id: "cerebras-chat", protocol: "openai-chat" },
+      })
+      expect(cerebras.route.endpoint.baseURL).toBe("https://api.cerebras.ai/v1")
+    }),
+  )

-  test("preserves native DeepInfra provider and route identity", () => {
-    const deepinfra = DeepInfra.configure({ apiKey: "fixture" }).model("google/gemma-3-27b-it")
-    expect(deepinfra).toMatchObject({
-      provider: "deepinfra",
-      compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning_content", supportsStore: false },
-      route: { id: "deepinfra-chat", protocol: "openai-chat" },
-    })
-    expect(deepinfra.route.endpoint.baseURL).toBe("https://api.deepinfra.com/v1/openai")
-  })
+  it.effect("preserves native DeepInfra provider and route identity", () =>
+    Effect.gen(function* () {
+      const deepinfra = DeepInfra.configure({ apiKey: "fixture" }).model("google/gemma-3-27b-it")
+      expect(deepinfra).toMatchObject({
+        provider: "deepinfra",
+        compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning_content", supportsStore: false },
+        route: { id: "deepinfra-chat", protocol: "openai-chat" },
+      })
+      expect(deepinfra.route.endpoint.baseURL).toBe("https://api.deepinfra.com/v1/openai")
+    }),
+  )

  it.effect("applies native provider request defaults even with a custom gateway URL", () =>
    Effect.gen(function* () {
@@ -150,35 +161,39 @@ describe("native OpenAI-compatible providers", () => {
    }),
  )

-  test("normalizes DeepInfra API roots without duplicating the OpenAI path", () => {
-    for (const baseURL of [
-      "https://gateway.example/v1",
-      "https://gateway.example/v1/",
-      "https://gateway.example/v1/openai",
-      "https://gateway.example/v1/openai/",
-    ]) {
-      expect(DeepInfra.configure({ apiKey: "fixture", baseURL }).model("gemma").route.endpoint.baseURL).toBe(
+  it.effect("normalizes DeepInfra API roots without duplicating the OpenAI path", () =>
+    Effect.gen(function* () {
+      for (const baseURL of [
+        "https://gateway.example/v1",
+        "https://gateway.example/v1/",
        "https://gateway.example/v1/openai",
-      )
-    }
-  })
+        "https://gateway.example/v1/openai/",
+      ]) {
+        expect(DeepInfra.configure({ apiKey: "fixture", baseURL }).model("gemma").route.endpoint.baseURL).toBe(
+          "https://gateway.example/v1/openai",
+        )
+      }
+    }),
+  )

-  test("maps package settings onto native executable models", () => {
-    for (const native of [TogetherAI, Cerebras]) {
-      const selected = native.model("provider-model", {
-        apiKey: "fixture",
-        baseURL: "https://gateway.example/v1",
-        headers: { "x-application": "opencode" },
-        body: { service_tier: "priority" },
-        providerOptions: { reasoningEffort: "high" },
-      })
+  it.effect("maps package settings onto native executable models", () =>
+    Effect.gen(function* () {
+      for (const native of [TogetherAI, Cerebras]) {
+        const selected = native.model("provider-model", {
+          apiKey: "fixture",
+          baseURL: "https://gateway.example/v1",
+          headers: { "x-application": "opencode" },
+          body: { service_tier: "priority" },
+          providerOptions: { reasoningEffort: "high" },
+        })

-      expect(selected.route.endpoint.baseURL).toBe("https://gateway.example/v1")
-      expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
-      expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" })
-      expect(selected.route.defaults.providerOptions).toEqual({ reasoningEffort: "high" })
-    }
-  })
+        expect(selected.route.endpoint.baseURL).toBe("https://gateway.example/v1")
+        expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
+        expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" })
+        expect(selected.route.defaults.providerOptions).toEqual({ reasoningEffort: "high" })
+      }
+    }),
+  )

  it.effect("resolves provider environment credentials and preserves deprecated Together credentials", () =>
    Effect.gen(function* () {
@@ -1,467 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Stream } from "effect"
-import { LLM, LLMEvent } from "../../src/index.js"
-import { OpenResponses } from "../../src/protocols/open-responses.js"
-import { configure } from "../../src/providers/openai-compatible-responses.js"
-import { LLMClient } from "../../src/route.js"
-import { it } from "../lib/effect.js"
-import { fixedResponse } from "../lib/http.js"
-import { sseEvents } from "../lib/sse.js"
-
-const request = LLM.request({
-  model: configure({ apiKey: "test-key", baseURL: "https://responses.example.test/v1" }).model("example-model"),
-  prompt: "Respond.",
-})
-const completed = { type: "response.completed", response: { id: "resp_1" } }
-
-const collect = (...input: OpenResponses.Event[]) =>
-  Effect.gen(function* () {
-    const events = yield* LLMClient.stream(request).pipe(
-      Stream.runCollect,
-      Effect.provide(fixedResponse(sseEvents(...input))),
-    )
-    expectLifecycle(
-      events,
-      input.some((event) => event.type === "response.completed"),
-    )
-    return events
-  })
-
-// Deliberately local to these basic-item fixtures, not a general stream validator.
-function expectLifecycle(events: ReadonlyArray<LLMEvent>, completed: boolean) {
-  const active = { text: new Set<string>(), reasoning: new Set<string>() }
-  const tools = new Map<string, "started" | "ended" | "called">()
-  events.forEach((event) => {
-    if (event.type === "text-start" || event.type === "reasoning-start") {
-      const blocks = event.type === "text-start" ? active.text : active.reasoning
-      expect(blocks.size).toBe(0)
-      blocks.add(event.id)
-    }
-    if (event.type === "text-delta" || event.type === "reasoning-delta") {
-      expect((event.type === "text-delta" ? active.text : active.reasoning).has(event.id)).toBe(true)
-    }
-    if (event.type === "text-end" || event.type === "reasoning-end") {
-      expect((event.type === "text-end" ? active.text : active.reasoning).delete(event.id)).toBe(true)
-    }
-    if (event.type === "tool-input-start") {
-      expect(tools.has(event.id)).toBe(false)
-      tools.set(event.id, "started")
-    }
-    if (event.type === "tool-input-delta") expect(tools.get(event.id)).toBe("started")
-    if (event.type === "tool-input-end") {
-      expect(tools.get(event.id)).toBe("started")
-      tools.set(event.id, "ended")
-    }
-    if (event.type === "tool-call") {
-      expect(tools.get(event.id)).toBe("ended")
-      tools.set(event.id, "called")
-    }
-    // Incomplete responses may leave pending tool inputs without a call.
-    if (event.type === "finish" && completed) {
-      expect(active.text.size).toBe(0)
-      expect(active.reasoning.size).toBe(0)
-      expect([...tools.values()].every((status) => status === "called")).toBe(true)
-    }
-  })
-  expect(events.filter(LLMEvent.is.stepStart)).toHaveLength(1)
-  expect(events[0]?.type).toBe("step-start")
-  expect(events.filter(LLMEvent.is.stepFinish)).toHaveLength(1)
-  expect(events.filter(LLMEvent.is.finish)).toHaveLength(1)
-  expect(events.slice(-2).map((event) => event.type)).toEqual(["step-finish", "finish"])
-}
-
-describe("Open Responses basic-item lifecycles", () => {
-  it.effect("closes implicit summary boundaries and ignores late events for completed reasoning", () =>
-    Effect.gen(function* () {
-      const item = { type: "reasoning", id: "rs_1", encrypted_content: "encrypted-state" }
-      const events = yield* collect(
-        { type: "response.output_item.added", output_index: 0, item: { ...item, encrypted_content: null } },
-        { type: "response.output_item.added", item: { ...item, encrypted_content: null } },
-        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 0, delta: "First" },
-        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 1 },
-        { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 0 },
-        { type: "response.reasoning_summary_text.done", item_id: "rs_1", summary_index: 1, text: "Second" },
-        // The third part omits both explicit summary boundaries.
-        {
-          type: "response.reasoning_summary_text.delta",
-          output_index: 0,
-          item_id: "wrong",
-          summary_index: 2,
-          delta: "Third",
-        },
-        { type: "response.output_item.done", item },
-        { type: "response.output_item.done", item },
-        { type: "response.output_item.added", item },
-        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 3 },
-        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 3, delta: "late" },
-        { type: "response.reasoning_summary_text.done", item_id: "rs_1", summary_index: 2, text: "late final" },
-        { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 3 },
-        completed,
-      )
-
-      expect(events.filter((event) => event.type.startsWith("reasoning-"))).toEqual([
-        {
-          type: "reasoning-start",
-          id: "rs_1:0",
-          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: null } },
-        },
-        { type: "reasoning-delta", id: "rs_1:0", text: "First" },
-        { type: "reasoning-end", id: "rs_1:0", providerMetadata: { "openai-compatible": { itemId: "rs_1" } } },
-        {
-          type: "reasoning-start",
-          id: "rs_1:1",
-          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: null } },
-        },
-        { type: "reasoning-delta", id: "rs_1:1", text: "Second" },
-        { type: "reasoning-end", id: "rs_1:1", providerMetadata: { "openai-compatible": { itemId: "rs_1" } } },
-        {
-          type: "reasoning-start",
-          id: "rs_1:2",
-          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: null } },
-        },
-        { type: "reasoning-delta", id: "rs_1:2", text: "Third" },
-        {
-          type: "reasoning-end",
-          id: "rs_1:2",
-          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
-        },
-      ])
-    }),
-  )
-
-  it.effect("preserves done-only encrypted reasoning without replaying its summary or late events", () =>
-    Effect.gen(function* () {
-      const item = {
-        type: "reasoning",
-        id: "rs_1",
-        encrypted_content: "encrypted-state",
-        summary: [{ type: "summary_text", text: "Not streamed" }],
-      }
-      const events = yield* collect(
-        { type: "response.output_item.done", item },
-        { type: "response.output_item.done", item },
-        { type: "response.output_item.added", item },
-        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", delta: "late" },
-        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 1 },
-        { type: "response.reasoning_summary_text.done", item_id: "rs_1", summary_index: 1, text: "late final" },
-        completed,
-        // Route termination must also prevent events after response completion.
-        { type: "response.output_item.added", item: { type: "reasoning", id: "rs_after" } },
-      )
-      expect(events.filter((event) => event.type.startsWith("reasoning-"))).toEqual([
-        {
-          type: "reasoning-start",
-          id: "rs_1",
-          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
-        },
-        {
-          type: "reasoning-end",
-          id: "rs_1",
-          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
-        },
-      ])
-    }),
-  )
-
-  it.effect("forgets never-streamed messages at implicit boundaries and preserves refusal phases", () =>
-    Effect.gen(function* () {
-      const events = yield* collect(
-        { type: "response.output_item.added", item: { type: "message", id: "msg_empty" } },
-        { type: "response.output_item.added", item: { type: "message", id: "msg_1", phase: "commentary" } },
-        { type: "response.output_text.done", item_id: "msg_1", text: "Checking" },
-        { type: "response.output_text.done", item_id: "msg_1", text: "Duplicate" },
-        { type: "response.output_item.added", item: { type: "message", id: "msg_2", phase: null } },
-        { type: "response.output_text.delta", item_id: "msg_empty", delta: "stale" },
-        { type: "response.output_text.done", item_id: "msg_empty", text: "stale final" },
-        { type: "response.output_text.delta", item_id: "msg_1", delta: "late" },
-        { type: "response.refusal.delta", item_id: "msg_2", delta: "Cannot help." },
-        { type: "response.refusal.done", item_id: "msg_2", refusal: "Cannot help." },
-        { type: "response.output_item.done", item: { type: "message", id: "msg_2", phase: "final_answer" } },
-        { type: "response.output_item.added", item: { type: "message", id: "msg_3", phase: null } },
-        { type: "response.refusal.done", item_id: "msg_3", refusal: "Done-only refusal." },
-        { type: "response.output_item.done", item: { type: "message", id: "msg_3" } },
-        completed,
-      )
-      expect(events.filter((event) => event.type.startsWith("text-"))).toEqual([
-        {
-          type: "text-start",
-          id: "msg_1",
-          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
-        },
-        { type: "text-delta", id: "msg_1", text: "Checking" },
-        {
-          type: "text-end",
-          id: "msg_1",
-          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
-        },
-        {
-          type: "text-start",
-          id: "msg_2",
-          providerMetadata: { "openai-compatible": { itemId: "msg_2", phase: null } },
-        },
-        { type: "text-delta", id: "msg_2", text: "Cannot help." },
-        {
-          type: "text-end",
-          id: "msg_2",
-          providerMetadata: { "openai-compatible": { itemId: "msg_2", phase: "final_answer" } },
-        },
-        {
-          type: "text-start",
-          id: "msg_3",
-          providerMetadata: { "openai-compatible": { itemId: "msg_3", phase: null } },
-        },
-        { type: "text-delta", id: "msg_3", text: "Done-only refusal." },
-        { type: "text-end", id: "msg_3", providerMetadata: { "openai-compatible": { itemId: "msg_3", phase: null } } },
-      ])
-    }),
-  )
-  it.effect("allows a message to be registered again without inheriting its previous phase", () =>
-    Effect.gen(function* () {
-      const events = yield* collect(
-        { type: "response.output_item.added", item: { type: "message", id: "msg_1", phase: "commentary" } },
-        { type: "response.output_text.delta", item_id: "msg_1", delta: "First" },
-        { type: "response.output_item.done", item: { type: "message", id: "msg_1" } },
-        { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
-        { type: "response.output_text.delta", item_id: "msg_1", delta: "Second" },
-        { type: "response.output_item.done", item: { type: "message", id: "msg_1" } },
-        completed,
-      )
-      expect(events.filter(LLMEvent.is.textEnd)).toEqual([
-        {
-          type: "text-end",
-          id: "msg_1",
-          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
-        },
-        { type: "text-end", id: "msg_1", providerMetadata: { "openai-compatible": { itemId: "msg_1" } } },
-      ])
-      expect(events.filter(LLMEvent.is.textDelta).map((event) => event.text)).toEqual(["First", "Second"])
-    }),
-  )
-  ;[undefined, "fc_1"].forEach((id) => {
-    it.effect(`opens and closes a done-only tool ${id === undefined ? "without" : "with"} an item id`, () =>
-      Effect.gen(function* () {
-        const item = {
-          type: "function_call",
-          ...(id === undefined ? {} : { id }),
-          call_id: "call_1",
-          name: "lookup",
-          arguments: '{"query":"weather"}',
-        }
-        const events = yield* collect(
-          { type: "response.output_item.done", item },
-          { type: "response.output_item.done", item: { ...item, id: "fc_1" } },
-          { type: "response.output_item.added", item },
-          completed,
-        )
-        const providerMetadata = id === undefined ? undefined : { "openai-compatible": { itemId: id } }
-        expect(events.filter((event) => event.type.startsWith("tool-"))).toEqual([
-          { type: "tool-input-start", id: "call_1", name: "lookup", providerMetadata },
-          { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata },
-          { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" }, providerMetadata },
-        ])
-        expect(events.filter(LLMEvent.is.finish)).toEqual([
-          {
-            type: "finish",
-            reason: { normalized: "tool-calls", raw: undefined },
-            providerMetadata: { "openai-compatible": { responseId: "resp_1", serviceTier: undefined } },
-          },
-        ])
-      }),
-    )
-
-    it.effect(`deduplicates a pending call whose item id is ${id === undefined ? "introduced" : "omitted"} later`, () =>
-      Effect.gen(function* () {
-        const item = { type: "function_call", call_id: "call_1", name: "lookup" }
-        const first = { ...item, ...(id === undefined ? {} : { id }) }
-        const duplicate = { ...item, ...(id === undefined ? { id: "fc_1" } : {}) }
-        const events = yield* collect(
-          { type: "response.output_item.added", item: first },
-          { type: "response.function_call_arguments.delta", item_id: id ?? "call_1", delta: '{"query":"weather"}' },
-          { type: "response.output_item.added", item: duplicate },
-          { type: "response.output_item.done", item: duplicate },
-          { type: "response.output_item.done", item: first },
-          { type: "response.output_item.added", item: duplicate },
-          completed,
-        )
-        // Identity metadata comes from the first admission, not the duplicate.
-        const providerMetadata = id === undefined ? undefined : { "openai-compatible": { itemId: id } }
-        expect(events.filter((event) => event.type.startsWith("tool-"))).toEqual([
-          { type: "tool-input-start", id: "call_1", name: "lookup", providerMetadata },
-          {
-            type: "tool-input-delta",
-            id: "call_1",
-            name: "lookup",
-            text: '{"query":"weather"}',
-            input: { query: "weather" },
-          },
-          { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata },
-          { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" }, providerMetadata },
-        ])
-      }),
-    )
-  })
-
-  it.effect("recovers pending items in completed output order with terminal encrypted metadata", () =>
-    Effect.gen(function* () {
-      const events = yield* collect(
-        {
-          type: "response.output_item.added",
-          item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup" },
-        },
-        { type: "response.function_call_arguments.delta", item_id: "fc_1", delta: '{"query":"draft"}' },
-        { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1", encrypted_content: null } },
-        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", delta: "Thinking" },
-        { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 0 },
-        {
-          type: "response.completed",
-          response: {
-            id: "resp_1",
-            output: [
-              { type: "reasoning", id: "rs_1", encrypted_content: "terminal-state" },
-              { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: '{"query":"final"}' },
-              { type: "function_call", id: "fc_unseen", call_id: "call_unseen", name: "lookup", arguments: "{}" },
-            ],
-          },
-        },
-      )
-      expect(events.slice(5, -2)).toEqual([
-        {
-          type: "reasoning-end",
-          id: "rs_1:0",
-          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: "terminal-state" } },
-        },
-        {
-          type: "tool-input-end",
-          id: "call_1",
-          name: "lookup",
-          providerMetadata: { "openai-compatible": { itemId: "fc_1" } },
-        },
-        {
-          type: "tool-call",
-          id: "call_1",
-          name: "lookup",
-          input: { query: "final" },
-          providerMetadata: { "openai-compatible": { itemId: "fc_1" } },
-        },
-      ])
-    }),
-  )
-
-  it.effect("preserves call identity and pending order when an item id is reused", () =>
-    Effect.gen(function* () {
-      const first = { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "{}" }
-      const events = yield* collect(
-        { type: "response.output_item.added", item: first },
-        { type: "response.output_item.added", item: { ...first, id: "fc_2", call_id: "call_2" } },
-        { type: "response.output_item.done", item: first },
-        { type: "response.output_item.added", item: { ...first, call_id: "call_3" } },
-        { type: "response.output_item.done", item: first },
-        completed,
-      )
-      expect(events.filter(LLMEvent.is.toolCall).map((event) => event.id)).toEqual(["call_1", "call_2", "call_3"])
-    }),
-  )
-
-  it.effect("keeps text and reasoning identities separate even with empty item ids", () =>
-    Effect.gen(function* () {
-      const events = yield* collect(
-        { type: "response.output_item.added", item: { type: "reasoning", id: "" } },
-        { type: "response.output_item.added", item: { type: "message", id: "" } },
-        { type: "response.output_item.added", item: { type: "reasoning", id: "" } },
-        { type: "response.reasoning_summary_text.delta", item_id: "", delta: "Thinking" },
-        { type: "response.output_text.delta", item_id: "", delta: "Answer" },
-        { type: "response.output_item.done", item: { type: "reasoning", id: "", encrypted_content: "state" } },
-        { type: "response.output_item.done", item: { type: "message", id: "" } },
-        completed,
-      )
-      expect(events.filter(LLMEvent.is.reasoningDelta).map((event) => event.text)).toEqual(["Thinking"])
-      expect(events.filter(LLMEvent.is.textDelta).map((event) => event.text)).toEqual(["Answer"])
-      expect(events.filter(LLMEvent.is.reasoningEnd)).toEqual([
-        {
-          type: "reasoning-end",
-          id: ":0",
-          providerMetadata: { "openai-compatible": { itemId: "", reasoningEncryptedContent: "state" } },
-        },
-      ])
-    }),
-  )
-
-  it.effect("does not recover a completed tool from a tracked message with the same id", () =>
-    Effect.gen(function* () {
-      const events = yield* collect(
-        { type: "response.output_item.added", item: { type: "message", id: "item_1" } },
-        { type: "response.output_text.delta", item_id: "item_1", delta: "Answer" },
-        {
-          type: "response.completed",
-          response: {
-            id: "resp_1",
-            output: [{ type: "function_call", id: "item_1", call_id: "call_1", name: "lookup", arguments: "{}" }],
-          },
-        },
-      )
-      expect(events.filter(LLMEvent.is.toolCall)).toEqual([])
-      expect(events.filter(LLMEvent.is.finish).map((event) => event.reason.normalized)).toEqual(["stop"])
-    }),
-  )
-
-  it.effect("flushes pending calls and open text when completed output is absent", () =>
-    Effect.gen(function* () {
-      const events = yield* collect(
-        { type: "response.output_item.added", item: { type: "message", id: "msg_1", phase: "final_answer" } },
-        { type: "response.output_text.delta", item_id: "msg_1", delta: "Answer" },
-        {
-          type: "response.output_item.added",
-          item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: "{}" },
-        },
-        completed,
-      )
-      // Generic terminal closure does not repeat the message's phase metadata.
-      expect(events.slice(4, -2)).toEqual([
-        { type: "tool-input-end", id: "call_1", name: "lookup" },
-        { type: "tool-call", id: "call_1", name: "lookup", input: {} },
-        { type: "text-end", id: "msg_1" },
-      ])
-    }),
-  )
-
-  it.effect("does not reconcile pending calls or terminal reasoning metadata on incomplete responses", () =>
-    Effect.gen(function* () {
-      const events = yield* collect(
-        { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1", encrypted_content: null } },
-        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", delta: "Partial" },
-        {
-          type: "response.output_item.added",
-          item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup" },
-        },
-        { type: "response.function_call_arguments.delta", item_id: "fc_1", delta: '{"query":' },
-        {
-          type: "response.incomplete",
-          response: {
-            id: "resp_1",
-            incomplete_details: { reason: "max_output_tokens" },
-            output: [
-              { type: "reasoning", id: "rs_1", encrypted_content: "not-reconciled" },
-              {
-                type: "function_call",
-                id: "fc_1",
-                call_id: "call_1",
-                name: "lookup",
-                arguments: '{"query":"not-reconciled"}',
-              },
-            ],
-          },
-        },
-      )
-      expect(events.filter(LLMEvent.is.toolInputEnd)).toEqual([])
-      expect(events.filter(LLMEvent.is.toolCall)).toEqual([])
-      expect(events.filter(LLMEvent.is.reasoningEnd)).toEqual([{ type: "reasoning-end", id: "rs_1:0" }])
-      expect(events.filter(LLMEvent.is.finish)).toEqual([
-        {
-          type: "finish",
-          reason: { normalized: "length", raw: "max_output_tokens" },
-          providerMetadata: { "openai-compatible": { responseId: "resp_1", serviceTier: undefined } },
-        },
-      ])
-    }),
-  )
-})
@@ -807,28 +807,6 @@ describe("OpenAI Chat route", () => {
    }),
  )

-  it.effect("finishes at the done sentinel without waiting for response EOF", () =>
-    Effect.gen(function* () {
-      const stream = new ReadableStream<Uint8Array>({
-        start(controller) {
-          controller.enqueue(
-            new TextEncoder().encode(sseEvents(deltaChunk({ content: "Hello" }), deltaChunk({}, "stop"))),
-          )
-        },
-      })
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(stream, {
-            headers: { "content-type": "text/event-stream" },
-          }),
-        ),
-      )
-
-      expect(response.text).toBe("Hello")
-      expect(response.events.at(-1)?.type).toBe("finish")
-    }),
-  )
-
  it.effect("preserves streamed refusals as ordinary assistant text", () =>
    Effect.gen(function* () {
      const response = yield* LLMClient.generate(request).pipe(
@@ -1479,7 +1457,7 @@ describe("OpenAI Chat route", () => {
      expect(error.message).toContain("OpenAI Chat tool call delta is missing id or name")
      expect(error.reason._tag).toBe("InvalidProviderOutput")
      if (error.reason._tag !== "InvalidProviderOutput") return
-      expect(decodeJson(error.reason.body ?? "")).toMatchObject({
+      expect(decodeJson(error.reason.raw ?? "")).toMatchObject({
        choices: [{ finish_reason: "tool_calls" }],
      })
    }),
@@ -1556,9 +1534,9 @@ describe("OpenAI Chat route", () => {
      )

      expect((yield* Ref.get(events)).some((event) => event.type === "text-delta")).toBeTrue()
-      expect(error.message).toBe("ECONNRESET: socket closed unexpectedly")
      expect(error.reason).toMatchObject({
        _tag: "Transport",
+        message: "ECONNRESET: socket closed unexpectedly",
        transport: "http",
        operation: "read",
        code: "ECONNRESET",
@@ -1574,9 +1552,9 @@ describe("OpenAI Chat route", () => {
        Effect.flip,
      )

-      expect(error.message).toBe("ECONNRESET: socket closed before output")
      expect(error.reason).toMatchObject({
        _tag: "Transport",
+        message: "ECONNRESET: socket closed before output",
        transport: "http",
        operation: "read",
        code: "ECONNRESET",
@@ -1597,7 +1575,7 @@ describe("OpenAI Chat route", () => {
      )

      expect(error).toBeInstanceOf(AIError)
-      expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" }, message: "Bad request" })
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "Bad request" })
    }),
  )

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Effect, Schema } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, LLMRequest, Message, ToolCallPart, ToolChoice, ToolDefinition } from "../../src/index.js"
@@ -91,38 +91,40 @@ describe("OpenAI-compatible Chat route", () => {
    }),
  )

-  test("provides model helpers for compatible provider families", () => {
-    expect(
-      providerFamilies.map(([provider, family]) => {
-        const model = family.configure({ apiKey: "test-key" }).model(`${provider}-model`)
-        return {
-          id: String(model.id),
-          provider: String(model.provider),
-          route: model.route.id,
-          baseURL: model.route.endpoint.baseURL,
-        }
-      }),
-    ).toEqual(
-      providerFamilies.map(([provider, _, baseURL]) => ({
-        id: `${provider}-model`,
-        provider,
-        route: "openai-compatible-chat",
-        baseURL,
-      })),
-    )
+  it.effect("provides model helpers for compatible provider families", () =>
+    Effect.gen(function* () {
+      expect(
+        providerFamilies.map(([provider, family]) => {
+          const model = family.configure({ apiKey: "test-key" }).model(`${provider}-model`)
+          return {
+            id: String(model.id),
+            provider: String(model.provider),
+            route: model.route.id,
+            baseURL: model.route.endpoint.baseURL,
+          }
+        }),
+      ).toEqual(
+        providerFamilies.map(([provider, _, baseURL]) => ({
+          id: `${provider}-model`,
+          provider,
+          route: "openai-compatible-chat",
+          baseURL,
+        })),
+      )

-    const custom = OpenAICompatible.deepseek
-      .configure({
-        apiKey: "test-key",
-        baseURL: "https://custom.deepseek.test/v1",
+      const custom = OpenAICompatible.deepseek
+        .configure({
+          apiKey: "test-key",
+          baseURL: "https://custom.deepseek.test/v1",
+        })
+        .model("deepseek-chat")
+      expect(custom).toMatchObject({
+        provider: "deepseek",
+        route: { id: "openai-compatible-chat" },
      })
-      .model("deepseek-chat")
-    expect(custom).toMatchObject({
-      provider: "deepseek",
-      route: { id: "openai-compatible-chat" },
-    })
-    expect(custom.route.endpoint.baseURL).toBe("https://custom.deepseek.test/v1")
-  })
+      expect(custom.route.endpoint.baseURL).toBe("https://custom.deepseek.test/v1")
+    }),
+  )

  it.effect("matches AI SDK compatible basic request body fixture", () =>
    Effect.gen(function* () {
@@ -405,19 +407,6 @@ describe("OpenAI-compatible Chat route", () => {
    }),
  )

-  it.effect("ignores events after the done sentinel", () =>
-    Effect.gen(function* () {
-      const body = `${sseEvents(
-        deltaChunk({ content: "Hello" }),
-        deltaChunk({}, "stop"),
-      )}data: ${JSON.stringify(deltaChunk({ content: " late" }))}\n\n`
-      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.text).toBe("Hello")
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: "stop" })
-    }),
-  )
-
  it.effect("accepts nullable usage and preserves provider fields", () =>
    Effect.gen(function* () {
      const response = yield* LLMClient.generate(request).pipe(
@@ -500,8 +489,9 @@ describe("OpenAI-compatible Chat route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput", classification: "incomplete-stream" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
+        classification: "incomplete-stream",
        message: "OpenAI Chat stream ended without finish_reason",
      })
    }),
@@ -537,11 +527,11 @@ describe("OpenAI-compatible Chat route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "ProviderInternal" },
+      expect(error.reason).toMatchObject({
+        _tag: "ProviderInternal",
        message: "Provider reported a network error (finish_reason: network_error)",
      })
-      expect(decodeJson(error.reason.body ?? "")).toMatchObject({
+      expect(decodeJson(error.body ?? "")).toMatchObject({
        id: "chatcmpl_fixture",
        choices: [{ finish_reason: "network_error" }],
      })
@@ -550,8 +540,8 @@ describe("OpenAI-compatible Chat route", () => {
        Effect.provide(fixedResponse(sseEvents(deltaChunk({}, "error")))),
        Effect.flip,
      )
-      expect(generic).toMatchObject({
-        reason: { _tag: "UnknownProvider" },
+      expect(generic.reason).toMatchObject({
+        _tag: "UnknownProvider",
        message: "Provider reported an error (finish_reason: error)",
      })
    }),
@@ -572,8 +562,8 @@ describe("OpenAI-compatible Chat route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "Provider disconnected" })
-      expect(decodeJson(error.reason.body ?? "")).toMatchObject({
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "Provider disconnected", status: 502 })
+      expect(decodeJson(error.body ?? "")).toMatchObject({
        id: "chatcmpl_error",
        error: { code: 502, message: "Provider disconnected", details: { upstream: "vendor" } },
        trace_id: "trace_1",
@@ -613,7 +603,7 @@ describe("OpenAI-compatible Chat route", () => {
      expect(error.message).toContain("OpenAI Chat received content after the finish reason")
      expect(error.reason._tag).toBe("InvalidProviderOutput")
      if (error.reason._tag !== "InvalidProviderOutput") return
-      expect(decodeJson(error.reason.body ?? "")).toMatchObject({
+      expect(decodeJson(error.reason.raw ?? "")).toMatchObject({
        choices: [{ delta: { tool_calls: [{ id: "call_1" }] } }],
      })
    }),
@@ -4,7 +4,6 @@ import { Headers, HttpClientRequest } from "effect/unstable/http"
 import {
  LLM,
  AIError,
-  HttpContext,
  HttpOptions,
  LLMEvent,
  LLMRequest,
@@ -13,7 +12,7 @@ import {
  ToolCallPart,
  ToolDefinition,
  ToolResultPart,
-  TransportError,
+  TransportReason,
  Usage,
 } from "../../src/index.js"
 import {
@@ -53,11 +52,10 @@ const baseChannelDriver = (message: string): WebSocketChannelDriver => ({
      return Effect.succeed({
        type: "provider-failure",
        error: new AIError({
-          reason: new TransportError({
+          module: "test",
+          method: "stream",
+          reason: new TransportReason({
            message: "provider rejected request",
-            body: frame,
-            cause: new Error("provider cause"),
-            http: new HttpContext({ url: "https://provider.test", status: 200, headers: { "x-trace": "trace-1" } }),
            transport: "websocket",
            operation: "read",
            phase: "receive",
@@ -746,18 +744,6 @@ describe("OpenAI Responses route", () => {
          reason: { _tag: "Transport", delivery: "rejected", recovery: "rotate-and-retry-full" },
        },
      })
-      for (const observation of [missing, limit]) {
-        expect(observation.type).toBe("rejected")
-        if (observation.type !== "rejected") continue
-        expect(observation.error.message).toBe("provider rejected request")
-        expect(observation.error.reason.cause).toBeInstanceOf(Error)
-        expect(observation.error.reason.cause).toMatchObject({ message: "provider cause" })
-        expect(observation.error.reason.http).toMatchObject({ status: 200, headers: { "x-trace": "trace-1" } })
-        expect(ProviderShared.decodeJson(observation.error.reason.body ?? "")).toMatchObject({
-          type: "error",
-          error: { code: expect.any(String) },
-        })
-      }
    }),
  )

@@ -1124,7 +1110,9 @@ describe("OpenAI Responses route", () => {
  it.effect("marks post-send WebSocket failures with delivery state", () =>
    Effect.gen(function* () {
      const failure = new AIError({
-        reason: new TransportError({
+        module: "test",
+        method: "receive",
+        reason: new TransportReason({
          message: "socket closed",
          transport: "websocket",
          operation: "read",
@@ -2750,227 +2738,6 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("concludes reasoning at implicit summary boundaries", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLMRequest.update(request, { providerOptions: { store: false } }),
-      ).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.added",
-                item: { type: "reasoning", id: "rs_1", encrypted_content: null },
-              },
-              { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 0 },
-              { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 0, delta: "First" },
-              // The next part is enough to conclude the previous one even when
-              // its done event is delayed.
-              { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 1 },
-              { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 0 },
-              { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 1, delta: "Second" },
-              { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 1 },
-              // Some compatible providers begin the next part with its first delta.
-              { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 2, delta: "Third" },
-              {
-                type: "response.output_item.done",
-                item: { type: "reasoning", id: "rs_1", encrypted_content: "encrypted-state" },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("FirstSecondThird")
-      expect(response.events.filter((event) => event.type.startsWith("reasoning-"))).toEqual([
-        {
-          type: "reasoning-start",
-          id: "rs_1:0",
-          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: null } },
-        },
-        { type: "reasoning-delta", id: "rs_1:0", text: "First", providerMetadata: undefined },
-        { type: "reasoning-end", id: "rs_1:0", providerMetadata: { openai: { itemId: "rs_1" } } },
-        {
-          type: "reasoning-start",
-          id: "rs_1:1",
-          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: null } },
-        },
-        { type: "reasoning-delta", id: "rs_1:1", text: "Second", providerMetadata: undefined },
-        {
-          type: "reasoning-end",
-          id: "rs_1:1",
-          providerMetadata: { openai: { itemId: "rs_1" } },
-        },
-        {
-          type: "reasoning-start",
-          id: "rs_1:2",
-          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: null } },
-        },
-        { type: "reasoning-delta", id: "rs_1:2", text: "Third", providerMetadata: undefined },
-        {
-          type: "reasoning-end",
-          id: "rs_1:2",
-          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
-        },
-      ])
-    }),
-  )
-
-  it.effect("rejects a reasoning item that starts before the previous item ends", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1" } },
-              { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 0, delta: "First" },
-              { type: "response.output_item.added", item: { type: "reasoning", id: "rs_2" } },
-            ),
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.message).toContain("started reasoning before the previous item ended")
-    }),
-  )
-
-  it.effect("concludes text at implicit message boundaries", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              // An item that never streams text is untracked at the boundary too.
-              { type: "response.output_item.added", item: { type: "message", id: "msg_0" } },
-              { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
-              { type: "response.output_text.delta", item_id: "msg_1", delta: "First" },
-              // The previous message's done event is missing; the next message
-              // item is the boundary for its open text.
-              { type: "response.output_item.added", item: { type: "message", id: "msg_2" } },
-              // Late deltas for concluded or untracked messages must stay no-ops.
-              { type: "response.output_text.delta", item_id: "msg_1", delta: " late" },
-              { type: "response.output_text.delta", item_id: "msg_0", delta: " stale" },
-              { type: "response.output_text.delta", item_id: "msg_2", delta: "Second" },
-              { type: "response.output_item.done", item: { type: "message", id: "msg_2" } },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("FirstSecond")
-      expect(response.events.filter((event) => event.type.startsWith("text-"))).toMatchObject([
-        { type: "text-start", id: "msg_1" },
-        { type: "text-delta", id: "msg_1", text: "First" },
-        { type: "text-end", id: "msg_1" },
-        { type: "text-start", id: "msg_2" },
-        { type: "text-delta", id: "msg_2", text: "Second" },
-        { type: "text-end", id: "msg_2" },
-      ])
-    }),
-  )
-
-  it.effect("opens the tool lifecycle for a done-only function call", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              // No output_item.added: the call arrives only as a completed item.
-              {
-                type: "response.output_item.done",
-                item: {
-                  type: "function_call",
-                  id: "fc_1",
-                  call_id: "call_1",
-                  name: "lookup",
-                  arguments: '{"query":"weather"}',
-                },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.events.filter((event) => event.type.startsWith("tool-"))).toMatchObject([
-        { type: "tool-input-start", id: "call_1", name: "lookup" },
-        { type: "tool-input-end", id: "call_1", name: "lookup" },
-        { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" } },
-      ])
-      expect(response.finishReason.normalized).toBe("tool-calls")
-    }),
-  )
-
-  it.effect("ignores duplicate item boundary events", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1" } },
-              // Duplicate added for a known item is not overlap and must no-op.
-              { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1" } },
-              { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 0, delta: "Think" },
-              { type: "response.output_item.done", item: { type: "reasoning", id: "rs_1" } },
-              { type: "response.output_item.done", item: { type: "reasoning", id: "rs_1" } },
-              {
-                type: "response.output_item.added",
-                item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "" },
-              },
-              {
-                type: "response.output_item.added",
-                item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "" },
-              },
-              { type: "response.function_call_arguments.delta", item_id: "fc_1", delta: '{"query":"weather"}' },
-              {
-                type: "response.output_item.done",
-                item: {
-                  type: "function_call",
-                  id: "fc_1",
-                  call_id: "call_1",
-                  name: "lookup",
-                  arguments: '{"query":"weather"}',
-                },
-              },
-              {
-                type: "response.output_item.done",
-                item: {
-                  type: "function_call",
-                  id: "fc_1",
-                  call_id: "call_1",
-                  name: "lookup",
-                  arguments: '{"query":"weather"}',
-                },
-              },
-              // Duplicates that drop the item id still resolve the same call.
-              {
-                type: "response.output_item.done",
-                item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: '{"query":"weather"}' },
-              },
-              {
-                type: "response.output_item.added",
-                item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: "" },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("Think")
-      expect(response.events.filter((event) => event.type === "reasoning-start")).toHaveLength(1)
-      expect(response.events.filter((event) => event.type === "reasoning-end")).toHaveLength(1)
-      expect(response.events.filter((event) => event.type === "tool-input-start")).toHaveLength(1)
-      expect(response.events.filter(LLMEvent.is.toolCall)).toEqual([
-        expect.objectContaining({ id: "call_1", input: { query: "weather" } }),
-      ])
-    }),
-  )
-
  it.effect("reconciles reasoning summaries that arrive only as finals", () =>
    Effect.gen(function* () {
      const response = yield* LLMClient.generate(
@@ -4668,7 +4435,7 @@ describe("OpenAI Responses route", () => {
      )

      expect(error).toBeInstanceOf(AIError)
-      expect(error).toMatchObject({ reason: { _tag: "RateLimit" }, message: "rate_limit_exceeded: Slow down" })
+      expect(error.reason).toMatchObject({ _tag: "RateLimit", message: "rate_limit_exceeded: Slow down" })
    }),
  )

@@ -4679,7 +4446,7 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "internal_error" })
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "internal_error" })
    }),
  )

@@ -4690,7 +4457,7 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "internal_error" })
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "internal_error" })
    }),
  )

@@ -4715,8 +4482,8 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "ProviderInternal" },
+      expect(error.reason).toMatchObject({
+        _tag: "ProviderInternal",
        message: "server_error: Upstream model unavailable",
      })
    }),
@@ -4736,7 +4503,7 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" }, message: "invalid_prompt" })
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "invalid_prompt" })
    }),
  )

@@ -4759,9 +4526,10 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidRequest", classification: "context-overflow" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidRequest",
        message: "context_length_exceeded: prompt too long",
+        classification: "context-overflow",
      })
    }),
  )
@@ -4786,9 +4554,10 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidRequest", classification: "context-overflow" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidRequest",
        message: "context_length_exceeded: prompt too long",
+        classification: "context-overflow",
      })
    }),
  )
@@ -4810,7 +4579,7 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "UnknownProvider" }, message: "Something went wrong" })
+      expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "Something went wrong" })
    }),
  )

@@ -4822,8 +4591,8 @@ describe("OpenAI Responses route", () => {
      )

      expect(error.reason).toMatchObject({ _tag: "UnknownProvider" })
-      expect(error.message).toContain('"error":null')
-      expect(error.reason.body).toBe(error.message)
+      expect(error.reason.message).toContain('"error":null')
+      expect(error.body).toBe(error.reason.message)
    }),
  )

@@ -4835,8 +4604,8 @@ describe("OpenAI Responses route", () => {
      )

      expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
-      expect(error.message).toContain('"type":"error"')
-      expect(error.reason.body).toBe(error.message)
+      expect(error.reason.message).toContain('"type":"error"')
+      expect(error.body).toBe(error.reason.message)
    }),
  )

@@ -4848,8 +4617,8 @@ describe("OpenAI Responses route", () => {
      )

      expect(error.reason).toMatchObject({ _tag: "UnknownProvider" })
-      expect(error.message).toContain('"resp_failed_3"')
-      expect(error.reason.body).toBe(error.message)
+      expect(error.reason.message).toContain('"resp_failed_3"')
+      expect(error.body).toBe(error.reason.message)
    }),
  )

@@ -4866,7 +4635,7 @@ describe("OpenAI Responses route", () => {
      )

      expect(error).toBeInstanceOf(AIError)
-      expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" }, message: "Bad request" })
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "Bad request" })
    }),
  )
 })
@@ -104,60 +104,6 @@ describe("LLMResponse reducer", () => {
    ])
  })

-  test("authoritative text-end value replaces accumulated deltas", () => {
-    const response = LLMResponse.fromEvents([
-      LLMEvent.textStart({ id: "t1" }),
-      LLMEvent.textDelta({ id: "t1", text: "Hel" }),
-      LLMEvent.textEnd({ id: "t1", text: "Hello!" }),
-      LLMEvent.finish({ reason: { normalized: "stop" } }),
-    ])
-
-    expect(response?.message.content).toEqual([{ type: "text", text: "Hello!" }])
-    expect(response?.text).toBe("Hello!")
-  })
-
-  test("text-end without value keeps joined deltas", () => {
-    const response = LLMResponse.fromEvents([
-      LLMEvent.textStart({ id: "t1" }),
-      LLMEvent.textDelta({ id: "t1", text: "Hel" }),
-      LLMEvent.textDelta({ id: "t1", text: "lo" }),
-      LLMEvent.textEnd({ id: "t1" }),
-      LLMEvent.finish({ reason: { normalized: "stop" } }),
-    ])
-
-    expect(response?.message.content).toEqual([{ type: "text", text: "Hello" }])
-    expect(response?.text).toBe("Hello")
-  })
-
-  test("authoritative reasoning-end value replaces only its own fragment", () => {
-    const response = LLMResponse.fromEvents([
-      LLMEvent.reasoningStart({ id: "r1:0" }),
-      LLMEvent.reasoningDelta({ id: "r1:0", text: "First summ" }),
-      LLMEvent.reasoningEnd({ id: "r1:0", text: "First summary." }),
-      LLMEvent.reasoningStart({ id: "r1:1" }),
-      LLMEvent.reasoningDelta({ id: "r1:1", text: "Second summary." }),
-      LLMEvent.reasoningEnd({ id: "r1:1" }),
-      LLMEvent.finish({ reason: { normalized: "stop" } }),
-    ])
-
-    expect(response?.message.content).toEqual([
-      { type: "reasoning", text: "First summary." },
-      { type: "reasoning", text: "Second summary." },
-    ])
-    expect(response?.reasoning).toBe("First summary.Second summary.")
-  })
-
-  test("end value recovers a fragment that streamed no deltas", () => {
-    const response = LLMResponse.fromEvents([
-      LLMEvent.textStart({ id: "t1" }),
-      LLMEvent.textEnd({ id: "t1", text: "Hello!" }),
-      LLMEvent.finish({ reason: { normalized: "stop" } }),
-    ])
-
-    expect(response?.message.content).toEqual([{ type: "text", text: "Hello!" }])
-    expect(response?.text).toBe("Hello!")
-  })
-
  test("clears malformed tool input without appending an executable call", () => {
    const state = reduce([
      LLMEvent.toolInputStart({ id: "call_1", name: "lookup" }),
@@ -1,12 +1,6 @@
 import { describe, expect, test } from "bun:test"
-import { Effect, Schema, Stream } from "effect"
 import * as OpenAIChat from "../src/protocols/openai-chat.js"
-import { AIError, HttpContext, InvalidProviderOutputError, LLM } from "../src/index.js"
-import { Anthropic } from "../src/providers.js"
-import { Auth, Framing, HttpTransport, LLMClient, Route } from "../src/route.js"
-import { fixedResponse, truncatedStream } from "./lib/http.js"
-import { sseEvents } from "./lib/sse.js"
-import { it } from "./lib/effect.js"
+import { Auth } from "../src/route.js"

 describe("Route.with", () => {
  test("merges endpoint query and header defaults while replacing auth and id", () => {
@@ -56,175 +50,3 @@ describe("Route.with", () => {
    expect(overridden.defaults).not.toHaveProperty("providerMetadataKey")
  })
 })
-
-describe("Route diagnostics", () => {
-  const route = OpenAIChat.route.with({ endpoint: { baseURL: "https://provider.test/v1" } })
-  const request = LLM.request({ model: route.model({ id: "test" }), prompt: "Hello" })
-  const headers = { "content-type": "text/event-stream", "x-request-id": "req_stream" }
-
-  it.effect("retains an entire invalid event and its validation cause", () =>
-    Effect.gen(function* () {
-      const frame = '{ "choices": "invalid", "diagnostic": { "detail": "original" } }'
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(fixedResponse(sseEvents(frame), { headers })),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.reason.body).toBe(frame)
-      expect(error.reason.cause).toMatchObject({ _tag: "SchemaError" })
-      expect(error.reason.http).toEqual(
-        new HttpContext({ url: "https://provider.test/v1/chat/completions", status: 200, headers }),
-      )
-    }),
-  )
-
-  it.effect("retains original provider error fields discarded by the event schema", () =>
-    Effect.gen(function* () {
-      const frame =
-        '{ "error": { "message": "Rate limit exceeded", "code": "rate_limit_exceeded", "debug": { "trace": "original" } }, "request_id": "req_original" }'
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(fixedResponse(sseEvents(frame), { headers })),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("RateLimit")
-      expect(error.message).toBe("Rate limit exceeded")
-      expect(error.reason.body).toBe(frame)
-      expect(error.reason.http?.headers["x-request-id"]).toBe("req_stream")
-    }),
-  )
-
-  it.effect("preserves semantic parser bodies while replacing serialized event fallbacks", () =>
-    Effect.forEach([undefined, '{"query": BROKEN}', ""], (body) =>
-      Effect.gen(function* () {
-        const cause = new Error("parser failure")
-        const http = new HttpContext({
-          url: "https://upstream.test/v1",
-          status: 202,
-          headers: { "x-trace": "precise" },
-        })
-        const frame = '{ "type": "failure", "debug": "not in schema" }'
-        const failing = Route.make({
-          id: "diagnostics",
-          provider: "test",
-          endpoint: route.endpoint,
-          framing: Framing.sse,
-          protocol: {
-            ...OpenAIChat.protocol,
-            stream: {
-              event: Schema.fromJsonString(Schema.Struct({ type: Schema.String })),
-              initial: () => undefined,
-              step: (_state, event) =>
-                Effect.fail(
-                  new AIError({
-                    reason: new InvalidProviderOutputError({
-                      message: "Parser failed",
-                      body: body ?? JSON.stringify(event),
-                      http,
-                      cause,
-                    }),
-                  }),
-                ),
-            },
-          },
-        })
-        const error = yield* LLMClient.generate(
-          LLM.request({ model: failing.model({ id: "test" }), prompt: "Hello" }),
-        ).pipe(Effect.provide(fixedResponse(sseEvents(frame), { headers })), Effect.flip)
-
-        expect(error.message).toBe("Parser failed")
-        expect(error.reason.body).toBe(body ?? frame)
-        expect(error.reason.cause).toBe(cause)
-        expect(error.reason.http).toBe(http)
-      }),
-    ),
-  )
-
-  it.effect("retains malformed assembled Anthropic hosted-tool arguments", () =>
-    Effect.gen(function* () {
-      const body = '{"query": BROKEN}'
-      const error = yield* LLMClient.generate(
-        LLM.request({
-          model: Anthropic.configure({ apiKey: "test", baseURL: "https://provider.test" }).model("claude"),
-          prompt: "Hello",
-        }),
-      ).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              {
-                type: "content_block_start",
-                index: 0,
-                content_block: { type: "server_tool_use", id: "srv1", name: "web_search" },
-              },
-              {
-                type: "content_block_delta",
-                index: 0,
-                delta: { type: "input_json_delta", partial_json: '{"query": ' },
-              },
-              { type: "content_block_delta", index: 0, delta: { type: "input_json_delta", partial_json: "BROKEN}" } },
-              { type: "content_block_stop", index: 0 },
-            ),
-            { headers },
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.message).toContain("Invalid JSON input for anthropic-messages tool call web_search")
-      expect(error.reason.body).toBe(body)
-      expect(error.reason.cause).toBeInstanceOf(Error)
-      expect(error.reason.http).toMatchObject({ status: 200, headers })
-    }),
-  )
-
-  it.effect("adds successful HTTP metadata without replacing framing diagnostics", () =>
-    Effect.gen(function* () {
-      const cause = new Error("frame checksum mismatch")
-      const failure = new AIError({
-        reason: new InvalidProviderOutputError({
-          message: "Invalid frame",
-          body: "original frame representation",
-          cause,
-        }),
-      })
-      const failing = route.with({
-        transport: HttpTransport.httpJson({ framing: { id: "failure", frame: () => Stream.fail(failure) } }),
-      })
-      const error = yield* LLMClient.generate(
-        LLM.request({ model: failing.model({ id: "test" }), prompt: "Hello" }),
-      ).pipe(Effect.provide(fixedResponse("wire bytes", { headers })), Effect.flip)
-
-      expect(error.reason.body).toBe(failure.reason.body)
-      expect(error.reason.cause).toBe(cause)
-      expect(error.message).toBe(failure.message)
-      expect(error.reason.http?.status).toBe(200)
-      expect(error.reason.http?.headers).toEqual(headers)
-    }),
-  )
-
-  it.effect("retains the original read error after successful response headers", () =>
-    Effect.gen(function* () {
-      const cause = new Error("socket disconnected")
-      const error = yield* LLMClient.generate(request).pipe(Effect.provide(truncatedStream([], cause)), Effect.flip)
-
-      expect(error.reason).toMatchObject({ _tag: "Transport", operation: "read" })
-      expect(error.reason.cause).toBe(cause)
-      expect(error.reason.http?.status).toBe(200)
-      expect(error.reason.body).toBeUndefined()
-    }),
-  )
-
-  it.effect("retains successful response headers on an incomplete stream", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse("", { headers })), Effect.flip)
-
-      expect(error.reason).toMatchObject({ _tag: "InvalidProviderOutput", classification: "incomplete-stream" })
-      expect(error.reason.http?.headers).toEqual(headers)
-      expect(error.reason.body).toBeUndefined()
-    }),
-  )
-})
@@ -4,29 +4,17 @@ import * as OpenAIChat from "../src/protocols/openai-chat.js"
 import * as OpenAIResponses from "../src/protocols/openai-responses.js"
 import {
  AIError,
-  AIErrorReason,
-  AuthenticationError,
  ContentPart,
-  ContentPolicyError,
-  HttpContext,
-  InvalidProviderOutputError,
-  InvalidRequestError,
+  InvalidRequestReason,
  LLMEvent,
  LLMRequest,
  LanguageModel,
  ModelID,
-  NoRouteError,
  ProviderID,
-  ProviderInternalError,
-  QuotaExceededError,
-  RateLimitError,
-  RouteID,
-  TransportError,
-  UnknownProviderError,
+  TransportReason,
  Usage,
 } from "../src/schema/index.js"
 import { ProviderShared } from "../src/protocols/shared.js"
-import { it } from "./lib/effect.js"

 const model = new LanguageModel({
  id: ModelID.make("fake-model"),
@@ -102,48 +90,49 @@ describe("AI.Usage", () => {
    expect(ProviderShared.sumTokens()).toBeUndefined()
  })

-  it.effect("sseFraming maps decoder failures to AI errors", () =>
-    Effect.gen(function* () {
-      const error = yield* ProviderShared.sseFraming(
-        Stream.make(new TextEncoder().encode(`data: ${"x".repeat(10 * 1024 * 1024)}`)),
-      ).pipe(Stream.runCollect, Effect.flip)
+  test("sseFraming maps decoder failures to AI errors", async () => {
+    const error = await Effect.runPromise(
+      ProviderShared.sseFraming(Stream.make(new TextEncoder().encode(`data: ${"x".repeat(10 * 1024 * 1024)}`))).pipe(
+        Stream.runCollect,
+        Effect.flip,
+      ),
+    )

-      expect(error).toBeInstanceOf(AIError)
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-    }),
-  )
+    expect(error).toBeInstanceOf(AIError)
+    expect(error.reason._tag).toBe("InvalidProviderOutput")
+  })

-  it.effect("sseFraming ignores retry directives without ending the stream", () =>
-    Effect.gen(function* () {
-      const encoder = new TextEncoder()
-      const frames = yield* ProviderShared.sseFraming(
+  test("sseFraming ignores retry directives without ending the stream", async () => {
+    const encoder = new TextEncoder()
+    const frames = await Effect.runPromise(
+      ProviderShared.sseFraming(
        Stream.make(
          encoder.encode("retry: 1000\n\n"),
          encoder.encode('data: {"first":true}\n\n'),
          encoder.encode("retry: 2000\n\n"),
          encoder.encode('data: {"second":true}\n\n'),
        ).pipe(Stream.rechunk(1)),
-      ).pipe(Stream.runCollect)
+      ).pipe(Stream.runCollect),
+    )

-      expect(Array.from(frames)).toEqual(['{"first":true}', '{"second":true}'])
-    }),
-  )
+    expect(Array.from(frames)).toEqual(['{"first":true}', '{"second":true}'])
+  })

-  it.effect("sseFraming preserves event data around retry directives", () =>
-    Effect.gen(function* () {
-      const encoder = new TextEncoder()
-      const frames = yield* ProviderShared.sseFraming(
+  test("sseFraming preserves event data around retry directives", async () => {
+    const encoder = new TextEncoder()
+    const frames = await Effect.runPromise(
+      ProviderShared.sseFraming(
        Stream.make(
          encoder.encode("event: update\ndata: first\n"),
          encoder.encode("retry: 1000\n"),
          encoder.encode("data: second\n\n"),
        ).pipe(Stream.rechunk(1)),
        new Set(["update"]),
-      ).pipe(Stream.runCollect)
+      ).pipe(Stream.runCollect),
+    )

-      expect(Array.from(frames)).toEqual(["first\nsecond"])
-    }),
-  )
+    expect(Array.from(frames)).toEqual(["first\nsecond"])
+  })

  test("visibleOutputTokens clamps reasoning > output to zero", () => {
    expect(new Usage({ outputTokens: 10, reasoningTokens: 4 }).visibleOutputTokens).toBe(6)
@@ -153,22 +142,21 @@ describe("AI.Usage", () => {
  })
 })

-it.effect("AI errors expose the shared runtime tag", () =>
-  Effect.gen(function* () {
-    const error = new AIError({
-      reason: new InvalidRequestError({ message: "invalid" }),
-    })
-    expect(error._tag).toBe("AI.Error")
-    expect(error.message).toBe("invalid")
-    expect(error.cause).toBe(error.reason)
-    expect(error.reason.cause).toBeUndefined()
-    expect(yield* Effect.fail(error).pipe(Effect.catchTag("AI.Error", () => Effect.succeed("caught")))).toBe("caught")
-  }),
-)
+test("AI errors expose the shared runtime tag", async () => {
+  const error = new AIError({
+    module: "test",
+    method: "call",
+    reason: new InvalidRequestReason({ message: "invalid" }),
+  })
+  expect(error._tag).toBe("AI.Error")
+  expect(
+    await Effect.runPromise(Effect.fail(error).pipe(Effect.catchTag("AI.Error", () => Effect.succeed("caught")))),
+  ).toBe("caught")
+})

 test("transport errors serialize execution facts", () => {
-  const reason = new TransportError({
-    message: "Connection closed",
+  const reason = new TransportReason({
+    message: "connection closed",
    transport: "websocket",
    operation: "read",
    phase: "receive",
@@ -176,176 +164,14 @@ test("transport errors serialize execution facts", () => {
    recovery: "fail",
  })

-  expect(Schema.encodeSync(TransportError)(reason)).toEqual({
+  expect(Schema.encodeSync(TransportReason)(reason)).toEqual({
    _tag: "Transport",
-    message: "Connection closed",
+    message: "connection closed",
    transport: "websocket",
    operation: "read",
    phase: "receive",
    delivery: "ambiguous",
    recovery: "fail",
  })
-  expect(Schema.decodeUnknownSync(TransportError)(Schema.encodeSync(TransportError)(reason))).toEqual(reason)
-})
-
-test("AI errors serialize diagnostics only on their typed reason", () => {
-  const cause = new SyntaxError("Unexpected end of JSON input")
-  const error = new AIError({
-    reason: new InvalidRequestError({
-      message: "Invalid provider response",
-      body: '{"error":',
-      http: new HttpContext({
-        url: "https://provider.test/v1/messages",
-        status: 400,
-        headers: { "request-id": "req_123" },
-      }),
-      cause,
-      parameter: "messages",
-      classification: "context-overflow",
-    }),
-  })
-  const encoded = Schema.encodeSync(AIError)(error)
-  expect(encoded).toEqual({
-    _tag: "AI.Error",
-    reason: {
-      _tag: "InvalidRequest",
-      message: "Invalid provider response",
-      body: '{"error":',
-      http: {
-        url: "https://provider.test/v1/messages",
-        status: 400,
-        headers: { "request-id": "req_123" },
-      },
-      cause: { name: "SyntaxError", message: cause.message, stack: cause.stack },
-      parameter: "messages",
-      classification: "context-overflow",
-    },
-  })
-  const decoded = Schema.decodeUnknownSync(Schema.fromJsonString(AIError))(
-    Schema.encodeSync(Schema.fromJsonString(AIError))(error),
-  )
-
-  expect(error).not.toHaveProperty("body")
-  expect(error).not.toHaveProperty("http")
-  expect(error.cause).toBe(error.reason)
-  expect(error.reason.cause).toBe(cause)
-  expect(decoded).toBeInstanceOf(AIError)
-  expect(decoded.reason).toBeInstanceOf(InvalidRequestError)
-  expect(decoded.message).toBe("Invalid provider response")
-  expect(decoded.reason.message).toBe(decoded.message)
-  expect(decoded.reason.body).toBe('{"error":')
-  expect(decoded.reason.http).toEqual(error.reason.http)
-  expect(decoded.cause).toBe(decoded.reason)
-  expect(decoded.reason.cause).toBeInstanceOf(Error)
-  expect(decoded.reason.cause).toMatchObject({ name: "SyntaxError", message: cause.message, stack: cause.stack })
-  expect(decoded.reason).toMatchObject({ parameter: "messages", classification: "context-overflow" })
-})
-
-test("AI error reasons are tagged Errors with required messages", () => {
-  const reasons = [
-    new InvalidRequestError({ message: "Invalid request" }),
-    new NoRouteError({
-      message: "No route",
-      route: RouteID.make("missing"),
-      provider: model.provider,
-      model: model.id,
-    }),
-    new AuthenticationError({ message: "Missing credentials" }),
-    new RateLimitError({ message: "Rate limited" }),
-    new QuotaExceededError({ message: "Quota exceeded" }),
-    new ContentPolicyError({ message: "Content blocked" }),
-    new ProviderInternalError({ message: "Provider failed" }),
-    new TransportError({ message: "Connection failed", transport: "http", operation: "request" }),
-    new InvalidProviderOutputError({ message: "Invalid output" }),
-    new UnknownProviderError({ message: "Unknown failure" }),
-  ]
-  expect(reasons.map((reason) => reason._tag)).toEqual([
-    "InvalidRequest",
-    "NoRoute",
-    "Authentication",
-    "RateLimit",
-    "QuotaExceeded",
-    "ContentPolicy",
-    "ProviderInternal",
-    "Transport",
-    "InvalidProviderOutput",
-    "UnknownProvider",
-  ])
-  reasons.forEach((reason) => {
-    expect(reason).toBeInstanceOf(Error)
-    const encoded = Schema.encodeSync(AIErrorReason)(reason)
-    const decoded = Schema.decodeUnknownSync(AIErrorReason)(encoded)
-    expect(decoded).toBeInstanceOf(reason.constructor)
-    expect(decoded.message).toBe(reason.message)
-    expect(Schema.decodeUnknownOption(AIErrorReason)({ ...encoded, message: undefined })._tag).toBe("None")
-  })
-})
-
-test("AI error reason enrichment preserves non-enumerable diagnostics", () => {
-  const cause = new Error("socket disconnected")
-  const reason = new TransportError({
-    message: "Connection closed",
-    body: "close frame detail",
-    http: new HttpContext({ url: "https://provider.test/responses", status: 101, headers: { upgrade: "websocket" } }),
-    cause,
-    transport: "websocket",
-    operation: "read",
-    phase: "close",
-  })
-  expect(Object.prototype.propertyIsEnumerable.call(reason, "message")).toBe(false)
-  expect(Object.prototype.propertyIsEnumerable.call(reason, "cause")).toBe(false)
-  const enriched = AIErrorReason.make({
-    // oxlint-disable-next-line typescript-eslint/no-misused-spread -- Copy fields rather than iterating the yieldable error.
-    ...reason,
-    message: reason.message,
-    cause: reason.cause,
-    delivery: "ambiguous",
-    recovery: "retry-full",
-  })
-  const error = new AIError({ reason: enriched })
-
-  expect(enriched).toBeInstanceOf(TransportError)
-  expect(error.message).toBe(reason.message)
-  expect(error.cause).toBe(enriched)
-  expect(enriched.cause).toBe(cause)
-  expect(enriched.body).toBe(reason.body)
-  expect(enriched.http).toBe(reason.http)
-  expect(enriched).toMatchObject({ phase: "close", delivery: "ambiguous", recovery: "retry-full" })
-})
-
-test("AI errors support reason-specific handlers", async () => {
-  const limited = new AIError({ reason: new RateLimitError({ message: "Slow down", retryAfterMs: 2000 }) })
-  const invalid = new AIError({ reason: new InvalidRequestError({ message: "Invalid request", parameter: "model" }) })
-  expect(
-    await Effect.runPromise(
-      Effect.fail(limited).pipe(
-        Effect.catchReason("AI.Error", "RateLimit", (reason) => {
-          expect(reason).toBe(limited.reason)
-          expect(reason).toBeInstanceOf(RateLimitError)
-          return Effect.succeed(reason.retryAfterMs)
-        }),
-      ),
-    ),
-  ).toBe(2000)
-  expect(
-    await Effect.runPromise(
-      Effect.forEach([limited, invalid], (error) =>
-        Effect.fail(error).pipe(
-          Effect.catchReasons("AI.Error", {
-            RateLimit: (reason) => Effect.succeed(reason.message),
-            InvalidRequest: (reason) => Effect.succeed(reason.parameter),
-          }),
-        ),
-      ),
-    ),
-  ).toEqual(["Slow down", "model"])
-})
-
-test("HTTP error context requires an observed response", () => {
-  const decode = Schema.decodeUnknownOption(HttpContext)
-  expect(decode({ status: 400, headers: {} })._tag).toBe("None")
-  expect(decode({ url: "https://provider.test", headers: {} })._tag).toBe("None")
-  expect(decode({ url: "https://provider.test", status: 400 })._tag).toBe("None")
-  expect(decode({ url: "https://provider.test", status: 0, headers: {} })._tag).toBe("None")
-  expect(decode({ url: "https://provider.test", status: Number.NaN, headers: {} })._tag).toBe("None")
+  expect(Schema.decodeUnknownSync(TransportReason)(Schema.encodeSync(TransportReason)(reason))).toEqual(reason)
 })
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Content } from "@opencode-ai/schema/tool"
 import { Effect, Schema, Stream } from "effect"
 import {
@@ -277,61 +277,65 @@ describe("LLMClient tools", () => {
    }),
  )

-  test("models canonical tool files with URIs", () => {
-    const decode = Schema.decodeUnknownSync(Content)
+  it.effect("models canonical tool files with URIs", () =>
+    Effect.sync(() => {
+      const decode = Schema.decodeUnknownSync(Content)

-    expect(decode({ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" })).toEqual({
-      type: "file",
-      uri: "data:image/png;base64,AAAA",
-      mime: "image/png",
-    })
-    expect(decode({ type: "file", uri: "https://example.test/image.png", mime: "image/png" })).toEqual({
-      type: "file",
-      uri: "https://example.test/image.png",
-      mime: "image/png",
-    })
-    expect(decode({ type: "file", uri: "file:///tmp/image.png", mime: "image/png" })).toEqual({
-      type: "file",
-      uri: "file:///tmp/image.png",
-      mime: "image/png",
-    })
-  })
+      expect(decode({ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" })).toEqual({
+        type: "file",
+        uri: "data:image/png;base64,AAAA",
+        mime: "image/png",
+      })
+      expect(decode({ type: "file", uri: "https://example.test/image.png", mime: "image/png" })).toEqual({
+        type: "file",
+        uri: "https://example.test/image.png",
+        mime: "image/png",
+      })
+      expect(decode({ type: "file", uri: "file:///tmp/image.png", mime: "image/png" })).toEqual({
+        type: "file",
+        uri: "file:///tmp/image.png",
+        mime: "image/png",
+      })
+    }),
+  )

-  test("preserves canonical tool file URIs", () => {
-    expect(
-      ToolOutput.toResultValue(
-        ToolOutput.make({}, [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }]),
-      ),
-    ).toEqual({
-      type: "content",
-      value: [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }],
-    })
-    expect(
-      ToolOutput.toResultValue(
-        ToolOutput.make({}, [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }]),
-      ),
-    ).toEqual({
-      type: "content",
-      value: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }],
-    })
-    expect(
-      ToolOutput.toResultValue(
-        ToolOutput.make({}, [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }]),
-      ),
-    ).toEqual({
-      type: "content",
-      value: [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }],
-    })
-    expect(
-      ToolOutput.fromResultValue({
+  it.effect("preserves canonical tool file URIs", () =>
+    Effect.sync(() => {
+      expect(
+        ToolOutput.toResultValue(
+          ToolOutput.make({}, [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }]),
+        ),
+      ).toEqual({
+        type: "content",
+        value: [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }],
+      })
+      expect(
+        ToolOutput.toResultValue(
+          ToolOutput.make({}, [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }]),
+        ),
+      ).toEqual({
        type: "content",
        value: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }],
-      }),
-    ).toEqual({
-      structured: {},
-      content: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }],
-    })
-  })
+      })
+      expect(
+        ToolOutput.toResultValue(
+          ToolOutput.make({}, [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }]),
+        ),
+      ).toEqual({
+        type: "content",
+        value: [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }],
+      })
+      expect(
+        ToolOutput.fromResultValue({
+          type: "content",
+          value: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }],
+        }),
+      ).toEqual({
+        structured: {},
+        content: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }],
+      })
+    }),
+  )

  it.effect("settles projected URL files as canonical tool results", () =>
    Effect.gen(function* () {
@@ -360,22 +364,24 @@ describe("LLMClient tools", () => {
    }),
  )

-  test("derives typed output schemas and preserves dynamic output schemas", () => {
-    const [typed] = toDefinitions({ get_weather })
-    const schema = { type: "object", properties: { result: { type: "string" } } } as const
-    const [dynamic] = toDefinitions({
-      dynamic: Tool.make({ description: "Dynamic tool.", jsonSchema: { type: "object" }, outputSchema: schema }),
-    })
+  it.effect("derives typed output schemas and preserves dynamic output schemas", () =>
+    Effect.sync(() => {
+      const [typed] = toDefinitions({ get_weather })
+      const schema = { type: "object", properties: { result: { type: "string" } } } as const
+      const [dynamic] = toDefinitions({
+        dynamic: Tool.make({ description: "Dynamic tool.", jsonSchema: { type: "object" }, outputSchema: schema }),
+      })

-    expect(typed?.outputSchema).toMatchObject({
-      type: "object",
-      properties: { condition: { type: "string" } },
-      required: ["temperature", "condition"],
-      additionalProperties: false,
-    })
-    expect(Reflect.get(Reflect.get(typed?.outputSchema ?? {}, "properties") as object, "temperature")).toBeDefined()
-    expect(dynamic?.outputSchema).toEqual(schema)
-  })
+      expect(typed?.outputSchema).toMatchObject({
+        type: "object",
+        properties: { condition: { type: "string" } },
+        required: ["temperature", "condition"],
+        additionalProperties: false,
+      })
+      expect(Reflect.get(Reflect.get(typed?.outputSchema ?? {}, "properties") as object, "temperature")).toBeDefined()
+      expect(dynamic?.outputSchema).toEqual(schema)
+    }),
+  )

  it.effect("preserves content tool results from dynamic tools", () =>
    Effect.gen(function* () {
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { AIError } from "../src/schema/index.js"
 import { ToolStream } from "../src/protocols/utils/tool-stream.js"
@@ -38,40 +38,44 @@ describe("ToolStream", () => {
    }),
  )

-  test("exposes cumulative partial string values", () => {
-    const result = ToolStream.appendOrStart(
-      ADAPTER,
-      ToolStream.empty<number>(),
-      0,
-      { id: "call_1", name: "lookup", text: '{"query":"wea' },
-      "missing tool",
-    )
-    if (ToolStream.isError(result)) throw result
+  it.effect("exposes cumulative partial string values", () =>
+    Effect.gen(function* () {
+      const result = ToolStream.appendOrStart(
+        ADAPTER,
+        ToolStream.empty<number>(),
+        0,
+        { id: "call_1", name: "lookup", text: '{"query":"wea' },
+        "missing tool",
+      )
+      if (ToolStream.isError(result)) return yield* result

-    expect(result.events.at(-1)).toEqual({
-      type: "tool-input-delta",
-      id: "call_1",
-      name: "lookup",
-      text: '{"query":"wea',
-      input: { query: "wea" },
-    })
-  })
+      expect(result.events.at(-1)).toEqual({
+        type: "tool-input-delta",
+        id: "call_1",
+        name: "lookup",
+        text: '{"query":"wea',
+        input: { query: "wea" },
+      })
+    }),
+  )

-  test("defaults partial input to an empty object when the accumulated value cannot be parsed", () => {
-    const result = ToolStream.appendOrStart(
-      ADAPTER,
-      ToolStream.empty<number>(),
-      0,
-      { id: "call_1", name: "lookup", text: "x" },
-      "missing tool",
-    )
-    if (ToolStream.isError(result)) throw result
+  it.effect("defaults partial input to an empty object when the accumulated value cannot be parsed", () =>
+    Effect.gen(function* () {
+      const result = ToolStream.appendOrStart(
+        ADAPTER,
+        ToolStream.empty<number>(),
+        0,
+        { id: "call_1", name: "lookup", text: "x" },
+        "missing tool",
+      )
+      if (ToolStream.isError(result)) return yield* result

-    expect(result.events).toEqual([
-      { type: "tool-input-start", id: "call_1", name: "lookup" },
-      { type: "tool-input-delta", id: "call_1", name: "lookup", text: "x", input: {} },
-    ])
-  })
+      expect(result.events).toEqual([
+        { type: "tool-input-start", id: "call_1", name: "lookup" },
+        { type: "tool-input-delta", id: "call_1", name: "lookup", text: "x", input: {} },
+      ])
+    }),
+  )

  it.effect("keeps accumulated identity when later deltas contain empty strings", () =>
    Effect.gen(function* () {
@@ -100,12 +104,14 @@ describe("ToolStream", () => {
    }),
  )

-  test("fails appendExisting when the provider skipped the tool start", () => {
-    const error = ToolStream.appendExisting(ADAPTER, ToolStream.empty<number>(), 0, "{}", "missing tool")
+  it.effect("fails appendExisting when the provider skipped the tool start", () =>
+    Effect.gen(function* () {
+      const error = ToolStream.appendExisting(ADAPTER, ToolStream.empty<number>(), 0, "{}", "missing tool")

-    expect(error).toBeInstanceOf(AIError)
-    if (ToolStream.isError(error)) expect(error.message).toBe("missing tool")
-  })
+      expect(error).toBeInstanceOf(AIError)
+      if (ToolStream.isError(error)) expect(error.reason.message).toBe("missing tool")
+    }),
+  )

  it.effect("uses final input override without losing accumulated deltas", () =>
    Effect.gen(function* () {
@@ -25,7 +25,6 @@ for (const viewport of [
    const mock = await openDraft(page)
    const pending = await submitPending(page, mock)

-    expect(mock.worktreeRequests).toEqual([expect.objectContaining({ from: directory })])
    await expect(pending.message).toBeInViewport()
    await expect(pending.shimmer).toBeInViewport()
    await testInfo.attach("creating-worktree", {
@@ -185,7 +184,6 @@ test("restores the draft after closing and revisiting a pending session that fai
 async function openDraft(page: Page, options?: { failSessionCreate?: boolean }) {
  const worktree = Promise.withResolvers<{ status: number; json: { directory?: string; message?: string } }>()
  const calls: string[] = []
-  const worktreeRequests: Record<string, unknown>[] = []
  const creates: Record<string, unknown>[] = []
  const prompts: { sessionID: string; body: Record<string, unknown> }[] = []
  const project = {
@@ -218,10 +216,7 @@ async function openDraft(page: Page, options?: { failSessionCreate?: boolean })
  page.on("request", (request) => {
    if (request.method() !== "POST") return
    const path = new URL(request.url()).pathname
-    if (path === `/api/worktree/${projectID}`) {
-      calls.push("worktree")
-      worktreeRequests.push(request.postDataJSON())
-    }
+    if (path === `/api/worktree/${projectID}`) calls.push("worktree")
    if (path === "/api/session") calls.push("session")
    if (/^\/api\/session\/[^/]+\/prompt$/.test(path)) calls.push("prompt")
  })
@@ -279,7 +274,7 @@ async function openDraft(page: Page, options?: { failSessionCreate?: boolean })
  await page.getByRole("menuitem", { name: "New workspace", exact: true }).click()
  await expect(page.getByRole("button", { name: "New workspace", exact: true })).toBeVisible()
  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  return { worktree, worktreeRequests, calls, creates, prompts }
+  return { worktree, calls, creates, prompts }
 }

 async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDraft>>) {
@@ -308,8 +308,8 @@ for (const delivery of ["steer", "queue"] as const) {
    })
    const tools = page.locator('[data-timeline-part-ids="tool_queue_read,tool_queue_grep"]')
    await expect(tools).toBeVisible()
-    await expect(tools).toHaveText(/^Used\s*2 Read, Grep$/)
-    await expect(tools.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("2 Read, Grep")
+    await expect(tools).toContainText(/Used\s*Read, Grep/)
+    await expect(tools.locator('[data-component="tag"]')).toHaveText("2")
    await expect(thinking).toHaveCount(0)
    await expect(pending).toBeVisible()
    expect(mock.rows.map((row) => ({ id: row.id, delivery: row.delivery }))).toEqual([
@@ -318,7 +318,7 @@ for (const delivery of ["steer", "queue"] as const) {
    await transcript.screenshot({ path: testInfo.outputPath("pending-steer.png") })

    // Soft assertions let delivery run too, even when the pending ordering regresses.
-    await expect.soft(tools.or(pending)).toHaveText([/^Used\s*2 Read, Grep$/, /U2: Also check the retry path\./])
+    await expect.soft(tools.or(pending)).toHaveText([/Used\s*Read, Grep/, /U2: Also check the retry path\./])
    await expect
      .soft(transcript.locator('[data-timeline-row="AssistantPart"]').filter({ has: tools }))
      .toHaveAttribute("data-message-id", userID)
@@ -350,7 +350,7 @@ for (const delivery of ["steer", "queue"] as const) {
    await expect(response).toHaveAttribute("data-message-id", inboxID)
    await expect(thinking).toHaveCount(0)
    await expect(tools.or(pending).or(response)).toHaveText([
-      /^Used\s*2 Read, Grep$/,
+      /Used\s*Read, Grep/,
      /U2: Also check the retry path\./,
      /A3: Now checking the retry path for U2\./,
    ])
@@ -25,7 +25,7 @@ test("space activates a focused timeline button instead of scrolling", async ({
    seedHistory: true,
  })
  const scroller = page.locator(".scroll-view__viewport", { has: page.locator("[data-timeline-row]") })
-  const trigger = page.getByRole("button", { name: "Used 1 Shell", exact: true })
+  const trigger = page.getByRole("button", { name: "Used Shell" })
  await expect
    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight))
    .toBeGreaterThan(300)
@@ -93,8 +93,7 @@ test.describe("regression: session timeline local row state", () => {
    await expectSessionTitle(page, title)

    const group = page.locator('[data-component="collapsed-tool-group"]')
-    const summary = group.getByRole("button", { name: /^Used \d+ Patch$/ })
-    await expect(summary).toHaveAccessibleName("Used 1 Patch")
+    const summary = group.getByRole("button", { name: "Used Patch", exact: true })
    await summary.click()
    await group.locator(`[data-timeline-part-id="${editPartID}"]`).evaluate((element) => {
      element.setAttribute("data-disclosure-probe", "existing")
@@ -110,8 +109,7 @@ test.describe("regression: session timeline local row state", () => {
      if (count === 3) await trigger.click()
      const id = `prt_patch_${count}`
      events.push(...toolEvents({ ...part, id, callID: id }))
-      await expect(summary).toHaveAccessibleName(`Used ${count} Patch`)
-      await expect(summary.locator('[data-slot="basic-tool-tool-title"]')).toHaveText(`${count} Patch`)
+      await expect(group.locator('[data-component="tag"]')).toHaveText(String(count))
      await expect(group).toHaveAttribute("data-timeline-part-ids", new RegExp(`${id}$`))
      await expect(trigger).toHaveAttribute("aria-expanded", String(count === 2))
      await expect(summary).toHaveAttribute("aria-expanded", "true")
@@ -55,7 +55,7 @@ test.describe("regression: session timeline context group resize", () => {
    await devtools.send("Emulation.setCPUThrottlingRate", { rate: 4 })
    const context = page.locator(`[data-timeline-part-ids="${contextIDs.join(",")}"]`).first()
    await expectAppVisible(context)
-    await expect(context.getByRole("button")).toHaveAccessibleName("Used 4 Read, Glob, Grep, List")
+    await expect(context.getByRole("button")).toHaveAccessibleName("Used Read, Glob, Grep, List")

    const contextSelector = `[data-timeline-part-ids="${contextIDs.join(",")}"]`
    const regions = defineVisualRegions({
@@ -88,7 +88,7 @@ test.describe("regression: session timeline context group resize", () => {
      await page.waitForTimeout(delay)
    }

-    await expect(context.getByRole("button")).toHaveAccessibleName("Used 4 Read, Glob, Grep, List")
+    await expect(context.getByRole("button")).toHaveAccessibleName("Used Read, Glob, Grep, List")
    await page.waitForTimeout(700)
    const trace = await stopVisualProbe<keyof typeof regions>(page)
    const labels = trace.samples
@@ -107,7 +107,7 @@ test.describe("regression: session timeline context group resize", () => {
      ]),
    )

-    expect(labels).toEqual(["Used 4 Read, Glob, Grep, List"])
+    expect(labels).toEqual(["Used Read, Glob, Grep, List"])
    expect(issues, JSON.stringify(trace.samples, null, 2)).toEqual([])
  })
 })
@@ -28,7 +28,7 @@ for (const expanded of [false, true]) {
    })
    const trigger = expanded
      ? page.locator(`[data-timeline-part-id="${id}"] [data-slot="collapsible-trigger"]`)
-      : page.getByRole("button", { name: "Used 1 Shell", exact: true })
+      : page.getByRole("button", { name: "Used Shell" })
    await expect(trigger).toHaveAttribute("aria-expanded", String(expanded))
    await trigger.click()
    await expect(trigger).toHaveAttribute("aria-expanded", String(!expanded))
@@ -141,7 +141,7 @@ for (const open of [false, true]) {
    await timeline.send(partUpdated(shell(shellID, "completed", "done")))
    await timeline.send(messageUpdated(completedAssistantInfo(assistant)))
    await timeline.send(status("idle"))
-    const used = group.getByRole("button", { name: "Used 1 Shell", exact: true })
+    const used = group.getByRole("button", { name: "Used Shell", exact: true })
    await expect(used).toHaveAttribute("aria-expanded", "false")
    await used.click()
    await expect(used).toHaveAttribute("aria-expanded", "true")
@@ -150,7 +150,7 @@ for (const open of [false, true]) {
      "aria-expanded",
      String(open),
    )
-    await expect(used.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("1 Shell")
+    await expect(group.locator('[data-component="tag"]')).toHaveText("1")
    await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
    await expect(used).toHaveAttribute("aria-expanded", "true")
    if (!open) await thought.click()
@@ -16,9 +16,8 @@ for (const locale of ["de", "ar"] as const) {
    })

    const group = page.locator(`[data-timeline-part-ids="${ids.join(",")}"]`)
-    const names = locale === "de" ? "Lesen, Glob" : "\u0642\u0631\u0627\u0621\u0629, Glob"
-    await expect(group.getByRole("button")).toHaveAccessibleName(`Used 2 ${names}`)
-    await expect(group.locator('[data-slot="basic-tool-tool-title"]')).toHaveText(`2 ${names}`)
+    await expect(group.getByRole("button")).toHaveAccessibleName(/^Used /)
+    await expect(group.locator('[data-component="tag"]')).toHaveText("2")
    await expect(page.locator("html")).toHaveAttribute("lang", locale)
  })
 }
@@ -105,10 +105,10 @@ for (const summaries of [false, true]) {
      if (profile === "tool") {
        const group = page.locator('[data-component="collapsed-tool-group"]')
        const used = group.locator(':scope > [data-component="collapsible"] > [data-slot="collapsible-trigger"]')
-        await expect(used).toHaveText(/^Used\s*1 Skill$/)
+        await expect(used).toContainText("UsedSkill")
        await expect(used).toHaveAttribute("aria-expanded", "false")
        await expect(page.getByText("Inspecting stability", { exact: true })).toBeHidden()
-        await expect(used.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("1 Skill")
+        await expect(group.locator('[data-component="tag"]')).toHaveText("1")
        await used.click()
        await expect(used).toHaveAttribute("aria-expanded", "true")
        await expect(group.locator(`[data-timeline-part-id="prt_reasoning_tool_${summaries}"]`)).toBeVisible()
@@ -45,11 +45,10 @@ test("expands a mixed collapsed tool stack without expanding its individual call
  const group = page.locator(
    '[data-timeline-part-ids="prt_stack_shell_1,prt_stack_explore,prt_stack_patch,prt_stack_shell_2"]',
  )
-  const summary = group.getByRole("button", { name: "Used 4 Shell, Agent, Patch", exact: true })
+  const summary = group.getByRole("button", { name: "Used Shell, Agent, Patch" })
  await expect(summary).toHaveAttribute("aria-expanded", "false")
  await expect(summary).toHaveCSS("height", "28px")
-  await expect(summary.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("4 Shell, Agent, Patch")
-  await expect(summary.locator('[data-component="tag"]')).toHaveCount(0)
+  await expect(group.locator('[data-component="tag"]')).toHaveText("4")
  await summary.click()
  await expect(summary).toHaveAttribute("aria-expanded", "true")
  await expect(group.locator('[data-slot="context-tool-group-item"]')).toHaveCount(4)
@@ -75,8 +74,8 @@ test("leaves tools expanded by settings outside the collapsed stack", async ({ p

  await expect(page.locator('[data-timeline-part-id="prt_expanded_shell"]')).toBeVisible()
  const group = page.locator('[data-timeline-part-ids="prt_collapsed_patch,prt_collapsed_read"]')
-  await expect(group.getByRole("button", { name: "Used 2 Patch, Read", exact: true })).toBeVisible()
-  await expect(group.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("2 Patch, Read")
+  await expect(group.getByRole("button", { name: "Used Patch, Read" })).toBeVisible()
+  await expect(group.locator('[data-component="tag"]')).toHaveText("2")
  await expect(page.locator('[data-timeline-spacing="tool"]')).toHaveCSS("padding-top", "8px")
 })

@@ -114,7 +113,7 @@ test("combines follow-up patches into one three-file stack inside Used", async (
    ],
  })
  const group = page.locator('[data-component="collapsed-tool-group"]')
-  await group.getByRole("button", { name: "Used 2 Shell, Patch", exact: true }).click()
+  await group.getByRole("button", { name: "Used Shell, Patch", exact: true }).click()
  await expect(group.getByText("2 files", { exact: true })).toBeVisible()
  await timeline.send(
    partUpdated(
@@ -129,10 +128,7 @@ test("combines follow-up patches into one three-file stack inside Used", async (
      ),
    ),
  )
-  await expect(group.getByRole("button", { name: "Used 3 Shell, Patch", exact: true })).toHaveAttribute(
-    "aria-expanded",
-    "true",
-  )
+  await expect(group.locator('[data-component="tag"]')).toHaveText("3")
  await expect(group.locator('[data-component="apply-patch-tool"]')).toHaveCount(1)
  await expect(group.getByText("3 files", { exact: true })).toBeVisible()
  await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["a.ts", "b.ts", "c.ts"])
@@ -162,8 +158,8 @@ test("keeps failed search calls and their error cards inside the collapsed stack
  await setupTimeline(page, { messages: [userMessage(), assistantMessage(parts)] })

  const group = page.locator('[data-timeline-part-ids="prt_error_glob,prt_error_grep"]')
-  const summary = group.getByRole("button", { name: "Used 2 Glob, Grep", exact: true })
-  await expect(summary.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("2 Glob, Grep")
+  const summary = group.getByRole("button", { name: "Used Glob, Grep" })
+  await expect(group.locator('[data-component="tag"]')).toHaveText("2")
  await summary.click()
  await expect(group.locator('[data-kind="tool-error-card"]')).toHaveCount(2)
  const glob = group.locator('[data-timeline-part-id="prt_error_glob"]')
@@ -52,7 +52,7 @@ test("shows parent lineage while the child timeline loads", async ({ page }) =>

  await page.goto(sessionHref(parentID))
  await expectSessionTitle(page, parentTitle)
-  await page.getByRole("button", { name: "Used 1 Agent", exact: true }).click()
+  await page.getByRole("button", { name: "Used Agent" }).click()
  await page.locator(`a[href="${sessionHref(childID)}"]`).click()
  await Promise.all([requested.promise, expect(page).toHaveURL(sessionHref(childID))])
  await Promise.all([
@@ -77,7 +77,7 @@ test("keeps the parent visible while the child session resolves", async ({ page
  await page.goto(sessionHref(parentID))
  await expectSessionTitle(page, parentTitle)

-  await page.getByRole("button", { name: "Used 1 Agent", exact: true }).click()
+  await page.getByRole("button", { name: "Used Agent" }).click()
  await page.locator(`a[href="${sessionHref(childID)}"]`).click()
  await requested.promise
  await Promise.all([expect(page).toHaveURL(sessionHref(parentID)), expectSessionTitle(page, parentTitle)]).finally(
@@ -195,7 +195,7 @@ async function setup(page: Page, events?: () => OpenCodeEvent[]) {
 async function openChildFromParent(page: Page) {
  await page.goto(sessionHref(parentID))
  await expectSessionTitle(page, parentTitle)
-  await page.getByRole("button", { name: "Used 1 Agent", exact: true }).click()
+  await page.getByRole("button", { name: "Used Agent" }).click()

  const card = page.locator(`a[href="${sessionHref(childID)}"]`)
  await expect(card).toBeVisible()
@@ -209,29 +209,6 @@ test("appearance experimental setting switches tab orientation", async ({ page }
  await page.setViewportSize({ width: 390, height: 360 })
  await version.scrollIntoViewIfNeeded()
  await expect(version).toBeInViewport()
-
-  // Reload the UI-selected preference without seeding settings storage.
-  await page.reload()
-  const href = `/server/${base64Encode(server)}/session/${sessionA.id}`
-  await expect(
-    page
-      .locator('[data-slot="titlebar-tabs"]')
-      .locator(`[data-titlebar-tab-link][href="${href}"]`)
-      .getByText(sessionA.title, { exact: true }),
-  ).toBeVisible()
-  await expect(page.locator('[data-slot="vertical-tabs-sidebar"]')).toHaveCount(0)
-
-  await page.setViewportSize({ width: 1280, height: 720 })
-  await expect(
-    page
-      .locator('[data-slot="vertical-tabs-sidebar"]')
-      .locator(`[data-titlebar-tab-link][href="${href}"]`)
-      .getByText(sessionA.title, { exact: true }),
-  ).toBeVisible()
-  await expect(page.locator('[data-slot="titlebar-tabs"]')).toHaveCount(0)
-  await page.keyboard.press("Control+,")
-  await settings.getByRole("tab", { name: "Appearance" }).click()
-  await expect(layout).toContainText("Vertical")
 })

 test("vertical tab preference falls back to horizontal on mobile", async ({ page }) => {
@@ -198,10 +198,6 @@ fixture(
 fixture(
  "precaches public files of every type and size, excluding deployment metadata and source maps",
  async ({ page, site, builds, context }) => {
-    for (const output of Object.values(builds)) {
-      expect(output["/sw.js.map"]).toBeUndefined()
-      expect(Object.keys(output).some((path) => path.startsWith("/_assets/") && path.endsWith(".map"))).toBe(true)
-    }
    await install(page, site.url)
    const files = ["/nested/data.json", "/nested/font.woff2", "/nested/module.wasm", "/large.bin"]
    await context.setOffline(true)
@@ -42,18 +42,21 @@
    "@playwright/test": "catalog:",
    "@sentry/vite-plugin": "catalog:",
    "@tailwindcss/vite": "4.3.3",
+    "@tsconfig/bun": "1.0.9",
    "@types/bun": "catalog:",
    "@types/luxon": "catalog:",
    "@types/node": "catalog:",
    "@typescript/native-preview": "catalog:",
-    "diff": "catalog:",
    "happy-dom": "20.11.1",
    "tw-animate-css": "1.4.0",
-    "vite": "8.2.2",
+    "typescript": "catalog:",
+    "vite": "8.2.1",
+    "vite-plugin-icons-spritesheet": "3.0.1",
    "vite-plugin-pwa": "1.3.0",
    "vite-plugin-solid": "2.11.14"
  },
  "dependencies": {
+    "@corvu/drawer": "catalog:",
    "@dnd-kit/abstract": "0.5.0",
    "@dnd-kit/dom": "0.5.0",
    "@dnd-kit/helpers": "0.5.0",
@@ -68,23 +71,28 @@
    "@pierre/trees": "1.0.0-beta.4",
    "@sentry/solid": "catalog:",
    "@solid-primitives/event-bus": "1.1.2",
-    "@solid-primitives/event-listener": "catalog:",
+    "@solid-primitives/event-listener": "2.4.5",
    "@solid-primitives/i18n": "2.2.1",
    "@solid-primitives/keyed": "1.5.3",
-    "@solid-primitives/media": "catalog:",
-    "@solid-primitives/resize-observer": "catalog:",
+    "@solid-primitives/media": "2.3.3",
+    "@solid-primitives/resize-observer": "2.1.5",
    "@solid-primitives/scheduled": "1.5.3",
    "@solid-primitives/storage": "catalog:",
    "@solidjs/meta": "catalog:",
    "@solidjs/router": "catalog:",
    "@tanstack/solid-query": "5.91.4",
    "@tanstack/solid-virtual": "catalog:",
+    "diff": "catalog:",
    "effect": "catalog:",
    "fuzzysort": "catalog:",
    "ghostty-web": "github:anomalyco/ghostty-web#83c0a07b8628b748aed073b232cb4b52a6ca11c1",
    "luxon": "catalog:",
+    "marked": "catalog:",
+    "marked-shiki": "catalog:",
    "remeda": "catalog:",
+    "shiki": "catalog:",
    "solid-js": "catalog:",
+    "solid-list": "catalog:",
    "solid-presence": "0.2.0",
    "tailwindcss": "4.3.3"
  }
@@ -1,4 +1,5 @@
 import { base64Encode } from "@opencode-ai/util/encode"
+import { getDirectory } from "@opencode-ai/util/path"
 import type { SessionMessageUser } from "@opencode-ai/client/promise"
 import { Session } from "@opencode-ai/schema/session"
 import { startTransition } from "solid-js"
@@ -12,7 +13,6 @@ import { useData, useServer } from "@/runtime/server/current"
 import { type ServerSDK, useServerSDK } from "@/runtime/server/client"
 import { useTabs } from "@/shell/tabs/tabs"
 import { useWorkspaceLocation } from "@/workspaces/location"
-import { createWorktree } from "@/workspaces/create"
 import { useSessionKey } from "@/session/session-layout"
 import { showToast } from "@/shell/notifications/toast"
 import { SessionRouteKey, SessionStateKey } from "@/runtime/server/scope"
@@ -192,17 +192,25 @@ async function resolveSessionDirectory(input: {
  if (input.worktree === "main") return input.projectDirectory
  if (input.worktree !== "create") return input.worktree

-  return createWorktree({
-    api: input.serverSDK.api,
-    directory: input.projectDirectory,
-    project: input.data.location.info({ directory: input.projectDirectory })?.project,
-    branch: input.branch,
-  }).catch((error) => {
-    showToast({
-      title: input.language.t("prompt.toast.worktreeCreateFailed.title"),
-      description: errorMessage(input.language, error),
+  return input.serverSDK.api.worktree
+    .create({
+      projectID: input.data.location.info({ directory: input.projectDirectory })?.project.id ?? "",
+      strategy: "git",
+      branch: input.branch,
+      directory: getDirectory(
+        input.data.location.info({ directory: input.projectDirectory })?.project.directory ?? input.projectDirectory,
+      ),
+    })
+    .then(async (created) => {
+      await input.serverSDK.api.location.get({ location: { directory: created.directory } })
+      return created.directory
+    })
+    .catch((error) => {
+      showToast({
+        title: input.language.t("prompt.toast.worktreeCreateFailed.title"),
+        description: errorMessage(input.language, error),
+      })
    })
-  })
 }

 function errorMessage(language: ReturnType<typeof useLanguage>, error: unknown) {
@@ -644,7 +644,7 @@ export function persisted<T>(
      : undefined
  if (channel) onCleanup(() => channel.close())

-  const [state, setState, init] = makePersisted<T, typeof store>(store, {
+  const [state, setState, init] = makePersisted(store, {
    name: config.key,
    storage,
    sync: channel ? messageSync(channel) : undefined,
@@ -1,135 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { createApiForServer } from "./api"
-import { readLocalImage } from "./image"
-
-function setup(
-  respond: (init?: RequestInit) => Response | Promise<Response> = () => new Response(new Uint8Array([0, 127, 255])),
-) {
-  const requests: Array<{ url: URL; init?: RequestInit }> = []
-  const api = createApiForServer({
-    server: { url: "https://server.example:4096", username: "image-user", password: "secret" },
-    fetch: (async (input: string | URL | Request, init?: RequestInit) => {
-      requests.push({ url: new URL(input instanceof Request ? input.url : input), init })
-      return respond(init)
-    }) as typeof fetch,
-  })
-  return { api, requests }
-}
-
-describe("readLocalImage", () => {
-  test.each([
-    ["images/screen #1 + 50% ?.PNG", "/workspace/project", "images/screen%20%231%20%2B%2050%25%20%3F.PNG"],
-    ["C:/tmp/opencode/screen #1.png", "C:/tmp/opencode/", "screen%20%231.png"],
-    ["d:/screen.png", "d:/", "screen.png"],
-    ["D:/charts/screen.png", "D:/charts/", "screen.png"],
-    ["Z:/charts/screen.png", "Z:/charts/", "screen.png"],
-    ["/tmp/opencode/screen #1.png", "/tmp/opencode/", "screen%20%231.png"],
-    ["/screen.png", "/", "screen.png"],
-  ])("reads %s with the correct location and authentication", async (path, directory, encoded) => {
-    const { api, requests } = setup()
-    const signal = new AbortController().signal
-    const blob = await readLocalImage(api, "/workspace/project", path, signal)
-
-    expect(blob).toBeInstanceOf(Blob)
-    expect(blob?.type).toBe("image/png")
-    expect(new Uint8Array(await blob!.arrayBuffer())).toEqual(new Uint8Array([0, 127, 255]))
-    expect(requests).toHaveLength(1)
-    expect(requests[0].url.origin).toBe("https://server.example:4096")
-    expect(requests[0].url.pathname).toBe(`/api/fs/read/${encoded}`)
-    expect([...requests[0].url.searchParams]).toEqual([["location[directory]", directory]])
-    expect(requests[0].init?.method).toBe("GET")
-    expect(new Headers(requests[0].init?.headers).get("authorization")).toBe(`Basic ${btoa("image-user:secret")}`)
-    expect(requests[0].init?.signal).toBe(signal)
-  })
-
-  test("preserves literal percent escapes and encodes the supplied relative location", async () => {
-    const { api, requests } = setup()
-    await readLocalImage(api, "C:/project #1 + 50%", "images/literal%20name.png", new AbortController().signal)
-
-    expect(requests[0].url.href).toBe(
-      "https://server.example:4096/api/fs/read/images/literal%2520name.png?location%5Bdirectory%5D=C%3A%2Fproject+%231+%2B+50%25",
-    )
-  })
-
-  test.each([
-    ["png", "image/png"],
-    ["jpeg", "image/jpeg"],
-    ["JPG", "image/jpeg"],
-    ["gif", "image/gif"],
-    ["webp", "image/webp"],
-    ["SVG", "image/svg+xml"],
-    ["avif", "image/avif"],
-    ["bmp", "image/bmp"],
-    ["ico", "image/x-icon"],
-  ])("uses the MIME type for .%s rather than the response header", async (extension, type) => {
-    const { api } = setup(
-      () => new Response("image bytes", { headers: { "content-type": "application/octet-stream" } }),
-    )
-    const blob = await readLocalImage(api, "/repo", `image.${extension}`, new AbortController().signal)
-    expect(blob?.type).toBe(type)
-    expect(await blob?.text()).toBe("image bytes")
-  })
-
-  test.each([
-    "https://example.com/image.png",
-    "HTTP://example.com/image.png",
-    "file:///tmp/image.png",
-    "data:image/png;base64,image.png",
-    "blob:https://example.com/image.png",
-    "custom+scheme:image.png",
-    "C:image.png",
-    "//server/share/image.png",
-    "\\\\server\\share\\image.png",
-    "//?/C:/image.png",
-    "///server/share/image.png",
-    "image.txt",
-    "image.html",
-    "image.constructor",
-    "image.png.txt",
-    "image",
-    "images.png/image",
-    "image.png/",
-    "",
-  ])("does not request unsupported input %s", async (path) => {
-    const { api, requests } = setup()
-    expect(await readLocalImage(api, "/repo", path, new AbortController().signal)).toBeUndefined()
-    expect(requests).toHaveLength(0)
-  })
-
-  test.each([400, 401])("propagates declared API errors (%s)", async (status) => {
-    const error = { _tag: "RequestError", message: "Cannot read image" }
-    const { api } = setup(() => Response.json(error, { status }))
-    await expect(readLocalImage(api, "/repo", "image.png", new AbortController().signal)).rejects.toEqual(error)
-  })
-
-  test.each([404, 500])("does not turn an unexpected HTTP status (%s) into a Blob", async (status) => {
-    const { api } = setup(() => new Response("Not an image", { status }))
-    await expect(readLocalImage(api, "/repo", "image.png", new AbortController().signal)).rejects.toMatchObject({
-      reason: "UnexpectedStatus",
-      cause: { status },
-    })
-  })
-
-  test("propagates transport failures", async () => {
-    const error = new Error("Connection lost")
-    const { api } = setup(() => Promise.reject(error))
-    await expect(readLocalImage(api, "/repo", "image.png", new AbortController().signal)).rejects.toMatchObject({
-      reason: "Transport",
-      cause: error,
-    })
-  })
-
-  test("forwards cancellation to an in-flight fetch", async () => {
-    const controller = new AbortController()
-    const { api, requests } = setup(
-      (init) =>
-        new Promise((_resolve, reject) => {
-          init?.signal?.addEventListener("abort", () => reject(init.signal?.reason), { once: true })
-        }),
-    )
-    const result = readLocalImage(api, "/repo", "image.png", controller.signal)
-    expect(requests[0].init?.signal).toBe(controller.signal)
-    controller.abort()
-    await expect(result).rejects.toMatchObject({ reason: "Transport", cause: controller.signal.reason })
-  })
-})
@@ -1,36 +0,0 @@
-import { getDirectory, getFilename } from "@opencode-ai/util/path"
-import type { OpenCodeClient } from "@opencode-ai/client/promise"
-
-const types = new Map([
-  ["png", "image/png"],
-  ["jpeg", "image/jpeg"],
-  ["jpg", "image/jpeg"],
-  ["gif", "image/gif"],
-  ["webp", "image/webp"],
-  ["svg", "image/svg+xml"],
-  ["avif", "image/avif"],
-  ["bmp", "image/bmp"],
-  ["ico", "image/x-icon"],
-])
-
-export async function readLocalImage(
-  api: Pick<OpenCodeClient, "file">,
-  directory: string,
-  path: string,
-  signal: AbortSignal,
-): Promise<Blob | undefined> {
-  const drive = /^[a-z]:\//i.test(path)
-  if (/^[\\/]{2}/.test(path) || (!drive && /^[a-z][a-z\d+.-]*:/i.test(path))) return
-  const type = types.get(path.match(/\.([^./]+)$/)?.[1]?.toLowerCase() ?? "")
-  if (!type) return
-  const absolute = drive || path.startsWith("/")
-  // Scope absolute images to their parent, including files outside the project.
-  const bytes = await api.file.read(
-    {
-      path: absolute ? getFilename(path) : path,
-      location: { directory: absolute ? getDirectory(path) : directory },
-    },
-    { signal },
-  )
-  return new Blob([new Uint8Array(bytes)], { type })
-}
@@ -1,6 +1,6 @@
 import { Menu } from "@opencode-ai/ui/menu"
 import { Icon } from "@opencode-ai/ui/icon"
-import { getFilename } from "@opencode-ai/util/path"
+import { getDirectory, getFilename } from "@opencode-ai/util/path"
 import { createStore } from "solid-js/store"
 import { createSignal, For, Show, type ComponentProps, type JSX } from "solid-js"
 import type { Project } from "@/runtime/server/types"
@@ -11,7 +11,6 @@ import { useSettingsDialog } from "@/settings/command"
 import { pathKey } from "@/workspaces/path-key"
 import { showToast } from "@/shell/notifications/toast"
 import { containsDirectory, sameDirectory, workspaceDirectories } from "@/workspaces/paths"
-import { createWorktree } from "@/workspaces/create"

 export function SessionWorkspaceMenu(props: {
  eligible?: boolean
@@ -56,14 +55,7 @@ export function SessionWorkspaceMenu(props: {
    setStore("selected", selection)

    try {
-      const destination =
-        selection === "create"
-          ? await createWorktree({
-              api: sdk.api,
-              directory: props.directory,
-              project: data.location.info({ directory: props.directory })?.project,
-            })
-          : selection
+      const destination = selection === "create" ? await createWorkspace(props.project, sdk) : selection
      if (!destination) return

      await sdk.api.session.move({ sessionID, directory: destination })
@@ -132,3 +124,13 @@ export function SessionWorkspaceMenu(props: {
    </Menu>
  )
 }
+
+async function createWorkspace(project: Project, serverSDK: ReturnType<typeof useServerSDK>) {
+  const created = await serverSDK.api.worktree.create({
+    projectID: project.id,
+    strategy: "git",
+    directory: getDirectory(project.worktree),
+  })
+  await serverSDK.api.location.get({ location: { directory: created.directory } })
+  return created.directory
+}
@@ -1,5 +1,5 @@
 import { TextField } from "@opencode-ai/ui/text-field"
-import type { captureException } from "@sentry/solid"
+import { captureException, isEnabled } from "@sentry/solid"
 import { Logo } from "@opencode-ai/ui/logo"
 import { Button } from "@opencode-ai/ui/button"
 import { Component, createSignal, onMount, Show } from "solid-js"
@@ -227,7 +227,6 @@ export const ErrorPage: Component<ErrorPageProps> = (props) => {
  let recordedFatalError: Promise<void> | undefined
  const [store, setStore] = createStore({
    actionError: undefined as string | undefined,
-    captureException: undefined as typeof captureException | undefined,
  })

  function ensureFatalErrorRecorded() {
@@ -244,11 +243,6 @@ export const ErrorPage: Component<ErrorPageProps> = (props) => {

  onMount(() => {
    void ensureFatalErrorRecorded().catch(() => undefined)
-    void import("@sentry/solid")
-      .then(({ captureException, isEnabled }) => {
-        if (isEnabled()) setStore("captureException", () => captureException)
-      })
-      .catch(() => undefined)
  })

  async function checkForUpdates() {
@@ -317,15 +311,15 @@ export const ErrorPage: Component<ErrorPageProps> = (props) => {
              {language.t("error.page.action.exportLogs")}
            </Button>
          </Show>
-          <Show when={store.captureException}>
-            {(capture) => {
+          <Show when={isEnabled}>
+            {(_) => {
              const [reported, setReported] = createSignal(false)
              return (
                <Button
                  size="large"
                  disabled={reported()}
                  onClick={() => {
-                    capture()(props.error)
+                    captureException(props.error)
                    setReported(true)
                  }}
                >
@@ -1,5 +1,4 @@
 import { DataProvider } from "@opencode-ai/session-ui/context"
-import { MarkdownProvider, type ReadMarkdownImage } from "@opencode-ai/session-ui/context/markdown"
 import { useNavigate, useParams } from "@solidjs/router"
 import { createMemo, type ParentProps } from "solid-js"
 import { useProviders } from "@/providers/catalog/providers"
@@ -9,7 +8,6 @@ import { sessionHref } from "@/shell/routes/session"
 import { useData } from "@/runtime/server/current"
 import { useServerSDK } from "@/runtime/server/client"
 import { useTabs } from "@/shell/tabs/tabs"
-import { readLocalImage } from "@/runtime/server/image"

 export function SessionUIProvider(
  props: ParentProps<{
@@ -23,10 +21,6 @@ export function SessionUIProvider(
  const serverSDK = useServerSDK()
  const tabs = useTabs()
  const directory = () => props.directory
-  const readImage = createMemo<ReadMarkdownImage>(() => {
-    const dir = directory()
-    return (path, signal) => readLocalImage(serverSDK.api, dir, path, signal)
-  })
  const href = (sessionID: string) => sessionHref(props.server, sessionID)
  const navigateToSession = async (sessionID: string) => {
    const tab = tabs.store.find(
@@ -66,9 +60,7 @@ export function SessionUIProvider(
      onNavigateToSession={navigateToSession}
      onSessionHref={href}
    >
-      <MarkdownProvider readImage={readImage()}>
-        <LocalProvider>{props.children}</LocalProvider>
-      </MarkdownProvider>
+      <LocalProvider>{props.children}</LocalProvider>
    </DataProvider>
  )
 }
@@ -1,90 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { OpenCode } from "@opencode-ai/client/promise"
-import { createWorktree } from "./create"
-
-describe("worktree creation", () => {
-  test.each(
-    [
-      { name: "clone", directory: "/copies/repo", root: "/copies/repo", canonical: "/copies/repo", parent: "/copies/" },
-      {
-        name: "clone subdirectory",
-        directory: "/copies/repo/packages/app",
-        root: "/copies/repo",
-        canonical: "/copies/repo",
-        parent: "/copies/",
-      },
-      {
-        name: "linked worktree subdirectory",
-        directory: "/linked/task/packages/app",
-        root: "/linked/task",
-        canonical: "/copies/repo",
-        parent: "/copies/",
-      },
-      {
-        name: "Windows clone",
-        directory: "C:\\copies\\repo\\packages\\app",
-        root: "C:\\copies\\repo",
-        canonical: "C:\\copies\\repo",
-        parent: "C:/copies/",
-      },
-    ].flatMap((input) => [true, false].map((cached) => ({ ...input, cached }))),
-  )("uses the clone-local main for $name (cached: $cached)", async (input) => {
-    const project = { id: "proj_clone", directory: input.root, canonical: input.canonical }
-    const requests: Request[] = []
-    const api = OpenCode.make({
-      baseUrl: "http://localhost:3000",
-      fetch: Object.assign(
-        async (input: RequestInfo | URL, init?: RequestInit) => {
-          const request = new Request(input, init)
-          requests.push(request)
-          if (request.method === "POST") return Response.json({ directory: "/created" })
-          return Response.json({ directory: new URL(request.url).searchParams.get("location[directory]"), project })
-        },
-        { preconnect() {} },
-      ),
-    })
-
-    expect(
-      await createWorktree({
-        api,
-        directory: input.directory,
-        project: input.cached ? project : undefined,
-        branch: "clone-only",
-      }),
-    ).toBe("/created")
-    expect(await requests.find((request) => request.method === "POST")?.json()).toEqual({
-      strategy: "git",
-      from: input.canonical,
-      branch: "clone-only",
-      directory: input.parent,
-    })
-    expect(requests.find((request) => request.method === "POST")?.url).toBe(
-      "http://localhost:3000/api/worktree/proj_clone",
-    )
-    expect(
-      requests
-        .filter((request) => request.method === "GET")
-        .map((request) => new URL(request.url).searchParams.get("location[directory]")),
-    ).toEqual(input.cached ? ["/created"] : [input.directory, "/created"])
-  })
-
-  test("does not fall back to a shared project when location lookup fails", async () => {
-    const requests: Request[] = []
-    const api = OpenCode.make({
-      baseUrl: "http://localhost:3000",
-      fetch: Object.assign(
-        async (input: RequestInfo | URL, init?: RequestInit) => {
-          requests.push(new Request(input, init))
-          return Response.json({ message: "unavailable" }, { status: 503 })
-        },
-        { preconnect() {} },
-      ),
-    })
-
-    await expect(createWorktree({ api, directory: "/copies/repo" })).rejects.toMatchObject({
-      reason: "UnexpectedStatus",
-      cause: { status: 503 },
-    })
-    expect(requests.map((request) => request.method)).toEqual(["GET"])
-  })
-})
@@ -1,20 +0,0 @@
-import type { LocationGetOutput, OpenCodeClient } from "@opencode-ai/client/promise"
-import { getDirectory } from "@opencode-ai/util/path"
-
-export async function createWorktree(input: {
-  api: Pick<OpenCodeClient, "location" | "worktree">
-  directory: string
-  project?: LocationGetOutput["project"]
-  branch?: string
-}) {
-  const project = input.project ?? (await input.api.location.get({ location: { directory: input.directory } })).project
-  const created = await input.api.worktree.create({
-    projectID: project.id,
-    strategy: "git",
-    from: project.canonical,
-    branch: input.branch,
-    directory: getDirectory(project.canonical),
-  })
-  await input.api.location.get({ location: { directory: created.directory } })
-  return created.directory
-}
@@ -1,85 +0,0 @@
-import { expect, test } from "bun:test"
-import { MemoryRouter, Route, createMemoryHistory, useNavigate, useParams } from "@solidjs/router"
-import { createEffect, onCleanup } from "solid-js"
-import { createComponent, render } from "solid-js/web"
-import { createSessionOwnership } from "@/session/session-ownership"
-
-test("session ownership follows navigation, back, forward, replacement, and route disposal", async () => {
-  const host = document.createElement("div")
-  const history = createMemoryHistory()
-  history.set({ value: "/session/A", replace: true, scroll: false })
-  const captured: ReturnType<ReturnType<typeof createSessionOwnership>["capture"]>[] = []
-  const navigate: ReturnType<typeof useNavigate>[] = []
-  const cleaned: string[] = []
-  const settle = () => new Promise((resolve) => setTimeout(resolve, 0))
-
-  const Session = () => {
-    const params = useParams<{ id: string }>()
-    const ownership = createSessionOwnership(() => params.id)
-    const label = document.createElement("div")
-    navigate.push(useNavigate())
-    createEffect(() => {
-      label.textContent = params.id
-      captured.push(ownership.capture())
-    })
-    onCleanup(() => cleaned.push("session"))
-    return label
-  }
-
-  const dispose = render(
-    () =>
-      createComponent(MemoryRouter, {
-        history,
-        get children() {
-          return [
-            createComponent(Route, { path: "/", component: () => "Home" }),
-            createComponent(Route, { path: "/session/:id", component: Session }),
-          ]
-        },
-      }),
-    host,
-  )
-
-  try {
-    expect(host.textContent).toBe("A")
-    expect(captured[0].current()).toBe(true)
-
-    navigate[0]("/session/B")
-    await settle()
-    expect(host.textContent).toBe("B")
-    expect(captured[0].current()).toBe(false)
-    expect(captured[1].current()).toBe(true)
-
-    history.back()
-    await settle()
-    expect(host.textContent).toBe("A")
-    expect(captured[0].current()).toBe(false)
-    expect(captured[1].current()).toBe(false)
-    expect(captured[2].current()).toBe(true)
-
-    history.forward()
-    await settle()
-    expect(host.textContent).toBe("B")
-    expect(captured[2].current()).toBe(false)
-    expect(captured[3].current()).toBe(true)
-    expect(navigate).toHaveLength(1)
-    expect(cleaned).toEqual([])
-
-    navigate[0]("/", { replace: true })
-    await settle()
-    expect(host.textContent).toBe("Home")
-    expect(captured.every((owner) => !owner.current())).toBe(true)
-    expect(cleaned).toEqual(["session"])
-
-    history.back()
-    await settle()
-    expect(host.textContent).toBe("A")
-    expect(captured[4].current()).toBe(true)
-    expect(navigate).toHaveLength(2)
-  } finally {
-    dispose()
-  }
-
-  expect(captured.every((owner) => !owner.current())).toBe(true)
-  expect(cleaned).toEqual(["session", "session"])
-})
@@ -1,89 +0,0 @@
-import { expect, test } from "bun:test"
-import {
-  createComputed,
-  createMemo,
-  createResource,
-  createRoot,
-  createSignal,
-  onCleanup,
-  startTransition,
-  Suspense,
-  type Accessor,
-  type JSX,
-} from "solid-js"
-import { createComponent, render } from "solid-js/web"
-
-// Solid 1.9.15 includes the former transition patch for solidjs/solid#2046.
-test("a memo created during a paused transition has a committed value", async () => {
-  const host = document.createElement("div")
-  const loaded = Promise.withResolvers<string>()
-  const started = Promise.withResolvers<void>()
-  const memos: Accessor<string>[] = []
-  const [session, setSession] = createSignal(false)
-  const dispose = render(
-    () =>
-      createComponent(Suspense, {
-        fallback: "Loading",
-        get children() {
-          return createMemo(() => {
-            if (!session()) return "Home"
-            memos.push(createMemo(() => "Session"))
-            const [data] = createResource(() => loaded.promise)
-            started.resolve()
-            return createMemo(() => data() ?? "")
-          }) as unknown as JSX.Element
-        },
-      }),
-    host,
-  )
-
-  try {
-    expect(host.textContent).toBe("Home")
-    const pending = startTransition(() => setSession(true))
-    await started.promise
-    expect(host.textContent).toBe("Home")
-    expect(memos).toHaveLength(1)
-    expect(memos[0]()).toBe("Session")
-
-    loaded.resolve("Session loaded")
-    await pending
-    expect(host.textContent).toBe("Session loaded")
-    expect(memos[0]()).toBe("Session")
-  } finally {
-    loaded.resolve("Session loaded")
-    dispose()
-  }
-})
-
-// Exercise each patched bundle independently; importing both dev formats emits Solid's duplicate-runtime warning.
-test.each(["solid.js", "solid.cjs", "dev.js", "dev.cjs", "server.js", "server.cjs"])(
-  "%s reentrant disposal cleans owned computations and callbacks exactly once",
-  async (file) => {
-    const runtime: {
-      createRoot: typeof createRoot
-      createComputed: typeof createComputed
-      onCleanup: typeof onCleanup
-    } = await import(`solid-js/dist/${file}`)
-    const cleaned: string[] = []
-    const dispose = runtime.createRoot((dispose) => {
-      runtime.onCleanup(() => cleaned.push("root"))
-      runtime.createComputed(() => {
-        runtime.onCleanup(() => cleaned.push("first"))
-      })
-      runtime.createComputed(() => {
-        runtime.onCleanup(() => cleaned.push("second"))
-        runtime.onCleanup(() => {
-          cleaned.push("reentrant")
-          // Bound the regression so an unpatched runtime fails without overflowing the stack.
-          if (cleaned.filter((item) => item === "reentrant").length === 1) dispose()
-        })
-      })
-      return dispose
-    })
-
-    expect(dispose).not.toThrow()
-    expect(cleaned.toSorted()).toEqual(["first", "reentrant", "root", "second"])
-    dispose()
-    expect(cleaned).toHaveLength(4)
-  },
-)
--- a/Show More
+++ b/Show More