chore: remove updated screenshot asset

.changeset/canonical-tool-results.md

@@ -1,8 +0,0 @@
----
-"@opencode-ai/plugin": minor
-"@opencode-ai/sdk": minor
-"@opencode-ai/client": minor
-"@opencode-ai/protocol": minor
----
-
-Replace the V2 tool result model with one canonical representation per fact. Tools lose `structured`, projection callbacks, the `Structured` generic, and the exported `Tool.settle` interpreter; tool responses carry schema-validated `output`, model-visible `content`, and optional compact JSON `metadata`. Code Mode receives the validated encoded output. Durable tool success stores non-empty model content plus optional metadata; failure stores one error plus the final bounded partial snapshot. Progress carries metadata only, while `execute.after` hooks receive the canonical terminal outcome and managed `outputPaths`. A one-time migration rewrites existing projected tool rows and moves provider-hosted result payloads into provider-owned result state.

.github/workflows/publish.yml

@@ -90,18 +90,11 @@ jobs:
           opencode-app-id: ${{ vars.OPENCODE_APP_ID }}
           opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}
 
-      - name: Build legacy CLI
-        if: github.ref_name != 'v2'
-        run: ./packages/opencode/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
-        env:
-          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
-          OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
-          GH_REPO: ${{ needs.version.outputs.repo }}
-          GH_TOKEN: ${{ steps.committer.outputs.token }}
-
-      - name: Build preview CLI
+      - name: Build
         id: build
-        run: ./packages/cli/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
+        run: |
+          ./packages/opencode/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
+          ./packages/cli/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
         env:
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
@@ -109,7 +102,6 @@ jobs:
           GH_TOKEN: ${{ steps.committer.outputs.token }}
 
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        if: github.ref_name != 'v2'
         with:
           name: opencode-cli
           path: |
@@ -117,7 +109,6 @@ jobs:
             packages/opencode/dist/opencode-linux*
 
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        if: github.ref_name != 'v2'
         with:
           name: opencode-cli-windows
           path: packages/opencode/dist/opencode-windows*
@@ -500,13 +491,11 @@ jobs:
           registry-url: "https://registry.npmjs.org"
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'v2'
         with:
           name: opencode-cli
           path: packages/opencode/dist
 
       - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        if: github.ref_name != 'v2'
         with:
           name: opencode-cli-windows
           path: packages/opencode/dist

.github/workflows/test.yml

@@ -97,11 +97,6 @@ jobs:
         working-directory: packages/client
         run: bun run check:generated
 
-      - name: Check generated documentation
-        if: runner.os == 'Linux'
-        working-directory: packages/docs
-        run: bun run check:generated
-
   e2e:
     name: e2e (${{ matrix.settings.name }})
     if: github.ref_name != 'v2' && github.head_ref != 'v2'

.opencode/command/translate.md

@@ -1,6 +1,6 @@
 ---
 description: translate English to other languages
-model: opencode/gpt-5.6-sol
+model: opencode/claude-opus-4-8
 ---
 
 run git diff and translate changed english doc and UI copy files to other international languages. Translate all languages in parallel to save time.

.opencode/skills/ideal-pseudocode/SKILL.md

@@ -1,68 +0,0 @@
----
-name: ideal-pseudocode
-description: Function-by-function refactoring loop driven by ideal pseudocode. Use when the user says "ideal pseudocode", asks to make a function read like its pseudocode, or wants a dense module cleaned up one function at a time.
----
-
-# Ideal Pseudocode
-
-Clean up one function at a time by writing the pseudocode it _should_ read as, naming every delta between that and the real code, and closing only the gaps the user approves.
-
-## Loop
-
-One function per round. Never touch code before the user picks a direction.
-
-1. **Pick the target** with the user — usually the next function up or down the call chain from the last round.
-2. **Read the current code** fresh from disk. It may have unsaved or parallel edits; ask before overwriting anything unexpected.
-3. **Distill.** Write the function's ideal pseudocode in a `ts`-fenced code block — TypeScript-flavored for syntax highlighting, but pseudocode: comments over mechanics, one line per idea, every arm of a loop visible as an arm. For a dense or unfamiliar function, first show the _current_ structure as pseudocode, then the ideal.
-4. **Name the deltas.** A numbered list; each delta is one concrete gap: control flow smuggled through combinators, a flag-typed parameter, colliding names, side-effect plumbing drowning a loop body, twin functions differing only by a filter. For each, give an honest cost/benefit and a decisive recommendation — including "leave it" when the density has reasons (state the reasons).
-5. **Verify before proposing.** Any API the proposal builds on (a combinator, schedule, matcher) gets checked against the installed version's source, not memory.
-6. **Get buy-in, then apply.** Minimal edits. Quarantine irreducible ugliness inside a small helper whose name is the pseudocode line it implements. Collapse shallow sibling functions into one deep function only when the distinguishing argument is a domain noun, not a behavior switch.
-7. **Validate.** Typecheck and the focused test suites from the package directory; rerun timing-sensitive tests repeatedly. Flag any semantic change the restructure introduced, even when tests pass.
-8. **Offer the next target** and stop.
-
-## Style
-
-- Keep each round tight: pseudocode block, deltas, recommendation, one question.
-- State mutation belongs in one visible place (usually the loop tail), never spread across error channels or callback closures.
-- Prefer early return and `if` chains for control flow; matchers are for producing values.
-- Compare names against the question each caller is actually asking; rename toward the domain noun.
-
-## Example round
-
-Every round should read like this (abridged from a real one, on an Effect step-runner):
-
-> `runStep` it is. The ideal pseudocode:
->
-> ```ts
-> // One logical step: one settled model call, however many attempts it takes.
-> // An attempt can end without settling in two ways:
-> //   transient provider failure -> retry the same call, same assistant message
-> //   compaction rewrote history -> rebuild the request and call again
-> function runStep(session, promotable, step) {
->   while (true) {
->     const result = callModel(session, promotable, step)
->
->     if (result.completed) return result
->
->     if (result.retryable) {
->       wait(retrySchedule) // exhausted -> publish Step.Failed, fail drain
->       promotable = none // never re-promote on a second attempt
->       continue
->     }
->
->     // compaction restarted the step: fresh request from rewritten history
->     promotable = none
->     step = result.step
->   }
-> }
-> ```
->
-> Comparing against the real thing, three deltas:
->
-> 1. **The retry arm doesn't live in the loop.** In the pseudocode, retry is just another loop arm. In the real code it's smuggled through the error channel: `Effect.tapError` mutating loop variables via `Effect.sync` closures, then `Effect.retryOrElse` re-running a suspended call. Four mutable variables mutated from three different places — the state flow is invisible unless you already know the trick.
-> 2. **`recoverOverflow: typeof compaction.compact | undefined`** — a function-typed parameter used as a one-shot armed/disarmed flag. The callee already closes over `compaction`; a boolean says what it is.
-> 3. **`assistantMessageID`** exists solely to resume the same durable message across retries — fine, but only legible once the retry arm is visible in the loop.
->
-> The unifying move for (1): a schedule driver, so a retryable failure becomes a caught value handled in the loop body exactly like the compaction arm. One honest trade: it's more manual than the blessed combinator — but the manual version is the loop the combinator was hiding, and the loop already exists for restarts. Two restart mechanisms, one control structure.
->
-> Want me to apply it — unified loop, simplified schedule input, boolean `recoverOverflow`?

infra/stage.ts

@@ -8,25 +8,6 @@ export const zoneID = "430ba34c138cfb5360826c4909f99be8"
 export const awsStage = $app.stage === "production" ? "production" : "dev"
 export const deployAws = $app.stage === awsStage
 
-if ($app.stage === "production") {
-  new cloudflare.DnsRecord("TrustCenter", {
-    zoneId: zoneID,
-    name: "trust.opencode.ai",
-    type: "CNAME",
-    content: "3a69a5bb27875189.vercel-dns-016.com",
-    proxied: false,
-    ttl: 60,
-  })
-
-  new cloudflare.DnsRecord("TrustCenterVerification", {
-    zoneId: zoneID,
-    name: "opencode.ai",
-    type: "TXT",
-    content: "compai-domain-verification=org_6993a99c6200a2d642bb115d",
-    ttl: 60,
-  })
-}
-
 new cloudflare.RegionalHostname("RegionalHostname", {
   hostname: domain,
   regionKey: "us",

nix/desktop.nix

@@ -8,8 +8,6 @@
   makeWrapper,
   writableTmpDirAsHomeHook,
   autoPatchelfHook,
-  copyDesktopItems,
-  makeDesktopItem,
   opencode,
 }:
 let
@@ -29,12 +27,9 @@ stdenv.mkDerivation (finalAttrs: {
     nodejs
     makeWrapper
     writableTmpDirAsHomeHook
-  ]
-  ++ lib.optionals stdenv.hostPlatform.isLinux [
+  ] ++ lib.optionals stdenv.hostPlatform.isLinux [
     autoPatchelfHook
-    copyDesktopItems
-  ]
-  ++ lib.optionals stdenv.hostPlatform.isDarwin [
+  ] ++ lib.optionals stdenv.hostPlatform.isDarwin [
     # Ad-hoc sign the .app: --config.mac.identity=null below skips signing.
     darwin.autoSignDarwinBinariesHook
   ];
@@ -43,37 +38,20 @@ stdenv.mkDerivation (finalAttrs: {
     (lib.getLib stdenv.cc.cc)
   ];
 
-  desktopItems = lib.optional stdenv.hostPlatform.isLinux (makeDesktopItem {
-    name = "ai.opencode.desktop";
-    desktopName = "OpenCode";
-    exec = "opencode-desktop %U";
-    icon = "ai.opencode.desktop";
-    # Electron 41 derives X11 WM_CLASS from app.name.
-    startupWMClass = "OpenCode";
-    categories = [ "Development" ];
-  });
-
   env = opencode.env // {
     ELECTRON_SKIP_BINARY_DOWNLOAD = "1";
   };
 
-  postPatch =
-    # NOTE: Relax Bun version check to be a warning instead of an error
-    ''
-      substituteInPlace packages/script/src/index.ts \
-        --replace-fail 'throw new Error(`This script requires bun@''${expectedBunVersionRange}' \
-                       'console.warn(`Warning: This script requires bun@''${expectedBunVersionRange}'
-    ''
-    # https://github.com/electron/electron/issues/31121
-    # mac builds use a .app bundle which doesnt have this issue
-    + lib.optionalString stdenv.isLinux ''
-      BASE_PATH=packages/desktop
-      FILES=(src/main/windows.ts)
-      for file in "''${FILES[@]}"; do
-        substituteInPlace $BASE_PATH/$file \
-          --replace-fail "process.resourcesPath" "'$out/opt/opencode-desktop/resources'"
-      done
-    '';
+  # https://github.com/electron/electron/issues/31121
+  # mac builds use a .app bundle which doesnt have this issue
+  postPatch = lib.optionalString stdenv.isLinux ''
+    BASE_PATH=packages/desktop
+    FILES=(src/main/windows.ts)
+    for file in "''${FILES[@]}"; do
+      substituteInPlace $BASE_PATH/$file \
+        --replace-fail "process.resourcesPath" "'$out/opt/opencode-desktop/resources'"
+    done
+  '';
 
   preBuild = ''
     cp -r "${electron.dist}" $HOME/.electron-dist
@@ -98,38 +76,27 @@ stdenv.mkDerivation (finalAttrs: {
     runHook postBuild
   '';
 
-  installPhase = ''
-    runHook preInstall
-  ''
-  + lib.optionalString stdenv.hostPlatform.isDarwin ''
-    mkdir -p $out/Applications
-    mv dist/mac*/*.app $out/Applications
-    makeWrapper "$out/Applications/OpenCode.app/Contents/MacOS/OpenCode" $out/bin/opencode-desktop
-  ''
-  + lib.optionalString stdenv.hostPlatform.isLinux ''
-    mkdir -p $out/opt/opencode-desktop
-    cp -r dist/linux*-unpacked/{resources,LICENSE*} $out/opt/opencode-desktop
-    install -Dm644 resources/icons/32x32.png \
-      "$out/share/icons/hicolor/32x32/apps/ai.opencode.desktop.png"
-    install -Dm644 resources/icons/64x64.png \
-      "$out/share/icons/hicolor/64x64/apps/ai.opencode.desktop.png"
-    install -Dm644 resources/icons/128x128.png \
-      "$out/share/icons/hicolor/128x128/apps/ai.opencode.desktop.png"
-    install -Dm644 resources/icons/128x128@2x.png \
-      "$out/share/icons/hicolor/256x256/apps/ai.opencode.desktop.png"
-    install -Dm644 resources/icons/icon.png \
-      "$out/share/icons/hicolor/512x512/apps/ai.opencode.desktop.png"
-    install -Dm644 resources/ai.opencode.desktop.metainfo.xml \
-      "$out/share/metainfo/ai.opencode.desktop.metainfo.xml"
-    makeWrapper ${lib.getExe electron} $out/bin/opencode-desktop \
-     --inherit-argv0 \
-     --set ELECTRON_FORCE_IS_PACKAGED 1 \
-     --add-flags $out/opt/opencode-desktop/resources/app.asar \
-     --add-flags "\''${NIXOS_OZONE_WL:+\''${WAYLAND_DISPLAY:+--ozone-platform-hint=auto --enable-features=WaylandWindowDecorations --enable-wayland-ime=true}}"
-  ''
-  + ''
-    runHook postInstall
-  '';
+  installPhase =
+    ''
+      runHook preInstall
+    ''
+    + lib.optionalString stdenv.hostPlatform.isDarwin ''
+      mkdir -p $out/Applications
+      mv dist/mac*/*.app $out/Applications
+      makeWrapper "$out/Applications/OpenCode.app/Contents/MacOS/OpenCode" $out/bin/opencode-desktop
+    ''
+    + lib.optionalString stdenv.hostPlatform.isLinux ''
+      mkdir -p $out/opt/opencode-desktop
+      cp -r dist/linux*-unpacked/{resources,LICENSE*} $out/opt/opencode-desktop
+      makeWrapper ${lib.getExe electron} $out/bin/opencode-desktop \
+        --inherit-argv0 \
+        --set ELECTRON_FORCE_IS_PACKAGED 1 \
+        --add-flags $out/opt/opencode-desktop/resources/app.asar \
+        --add-flags "\''${NIXOS_OZONE_WL:+\''${WAYLAND_DISPLAY:+--ozone-platform-hint=auto --enable-features=WaylandWindowDecorations --enable-wayland-ime=true}}"
+    ''
+    + ''
+      runHook postInstall
+    '';
 
   autoPatchelfIgnoreMissingDeps = [
     "libc.musl-x86_64.so.1"

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-0kcwV34P2C3yKg2eG9W2nW+OedrSBb+1TdpuUeYtauY=",
-    "aarch64-linux": "sha256-yHVygApQchAB34wrtFR4GU0CkmZOlLsl3wsp15u0xzs=",
-    "aarch64-darwin": "sha256-DyalcwyK2Wn5R6249keFcNVECbgtjYNjscOFqTi88FI=",
-    "x86_64-darwin": "sha256-BkGw0GWN9W9q+/g4FYR0MqxUuFP80BPoERO+ypz/arQ="
+    "x86_64-linux": "sha256-F1luclnqCPQk9yxfmeSYGaM/nScf28yBu9K3Fv+Xd24=",
+    "aarch64-linux": "sha256-XW0XZnsCRkU3MFJH9TjMRYZHffzVy3cQyiNCkec2gl4=",
+    "aarch64-darwin": "sha256-bf8kvORs3Fs2UYLp3PekF+AJR7NKOcHb+fIQA79RtMk=",
+    "x86_64-darwin": "sha256-sBdQPkzd7JXNW6Lbi9JHiAsfHwdLwTKWY+uPeXAv2Nw="
   }
 }

package.json

@@ -15,7 +15,7 @@
     "dev:www": "bun run --cwd packages/www dev",
     "dev:storybook": "bun --cwd packages/storybook storybook",
     "lint": "oxlint",
-    "lint:effect-patterns": "ast-grep scan -c script/ast-grep/sgconfig.yml packages/util/src packages/core/src packages/server/src packages/protocol/src packages/cli/src",
+    "lint:effect-patterns": "ast-grep scan -c script/ast-grep/sgconfig.yml packages/core/src packages/server/src packages/protocol/src packages/cli/src",
     "test:lint-rules": "ast-grep test -c script/ast-grep/sgconfig.yml",
     "typecheck": "bun turbo typecheck --concurrency=3",
     "typecheck:profile": "bun script/profile-typecheck.ts",
@@ -155,12 +155,12 @@
     "@types/node": "catalog:"
   },
   "patchedDependencies": {
+    "@ff-labs/fff-bun@0.9.3": "patches/@ff-labs%2Ffff-bun@0.9.3.patch",
     "@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.10": "patches/solid-js@1.9.10.patch",
     "@ai-sdk/xai@3.0.102": "patches/@ai-sdk%2Fxai@3.0.102.patch",
-    "@ai-sdk/mistral@3.0.51": "patches/@ai-sdk%2Fmistral@3.0.51.patch",
     "gcp-metadata@8.1.2": "patches/gcp-metadata@8.1.2.patch",
     "pacote@21.5.0": "patches/pacote@21.5.0.patch",
     "@ai-sdk/google@3.0.73": "patches/@ai-sdk%2Fgoogle@3.0.73.patch",

packages/ai/AGENTS.md

@@ -10,7 +10,7 @@
 
 ## Conventions
 
-Per-type constructors live on the type, not as top-level re-exports. Use `Message.system(...)`, `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `Model.make(...)`, `ToolDefinition.make(...)`, `ToolCallPart.make(...)`, `ToolResultPart.make(...)`, `ToolChoice.make(...)`, `ToolChoice.named(...)`, `SystemPart.make(...)`, and `GenerationOptions.make(...)` directly. The top-level `LLM` namespace is reserved for request-shaped call APIs: `LLM.request`, `LLM.generateTurn`, `LLM.streamTurn`, and `LLM.generateObject`. Two ways to construct the same thing is one too many.
+Per-type constructors live on the type, not as top-level re-exports. Use `Message.system(...)`, `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `Model.make(...)`, `ToolDefinition.make(...)`, `ToolCallPart.make(...)`, `ToolResultPart.make(...)`, `ToolChoice.make(...)`, `ToolChoice.named(...)`, `SystemPart.make(...)`, and `GenerationOptions.make(...)` directly. The top-level `LLM` namespace is reserved for request-shaped call APIs: `LLM.request`, `LLM.generate`, `LLM.stream`, `LLM.updateRequest`, and `LLM.generateObject`. Two ways to construct the same thing is one too many.
 
 ## Tests
 
@@ -54,7 +54,7 @@ Filter or narrow `LLMEvent` streams with `LLMEvent.is.*` (camelCase guards, e.g.
 
 A route is the registered, runnable composition of four orthogonal pieces:
 
-- **`Protocol`** (`src/route/protocol.ts`) — semantic API contract. Owns request body construction (`body.from`), the body schema (`body.schema`), the streaming-event schema (`stream.event`), and the event-to-`LLMEvent` state machine (`stream.step`). `Route.make(...)` validates and JSON-encodes the body from `body.schema` and decodes frames with `stream.event`. Examples: `OpenAIChat.protocol`, `OpenResponses.protocol`, `OpenAIResponses.protocol`, `AnthropicMessages.protocol`, `Gemini.protocol`, `BedrockConverse.protocol`.
+- **`Protocol`** (`src/route/protocol.ts`) — semantic API contract. Owns request body construction (`body.from`), the body schema (`body.schema`), the streaming-event schema (`stream.event`), and the event-to-`LLMEvent` state machine (`stream.step`). `Route.make(...)` validates and JSON-encodes the body from `body.schema` and decodes frames with `stream.event`. Examples: `OpenAIChat.protocol`, `OpenAIResponses.protocol`, `AnthropicMessages.protocol`, `Gemini.protocol`, `BedrockConverse.protocol`.
 - **`Endpoint`** (`src/route/endpoint.ts`) — URL construction. The host, path, and route query live on the endpoint. `Endpoint.path("/chat/completions", { baseURL })` is the common case; pass a function for paths that embed the model id or a body field (e.g. `Endpoint.path(({ body }) => `/model/${body.modelId}/converse-stream`)`).
 - **`Auth`** (`src/route/auth.ts`) — per-request transport authentication. Provider facades configure credentials onto the route before model selection, usually via `Auth.bearer(apiKey)` or `Auth.header(name, apiKey)`. Routes that need per-request signing (Bedrock SigV4, future Vertex IAM, Azure AAD) implement `Auth` as a function that signs the body and merges signed headers into the result.
 - **`Framing`** (`src/route/framing.ts`) — bytes → frames. SSE (`Framing.sse`) is shared; Bedrock keeps its AWS event-stream framing as a typed `Framing<object>` value alongside its protocol.
@@ -158,14 +158,13 @@ packages/ai/src/
   protocols/
     shared.ts               ProviderShared toolkit used inside protocol impls
     openai-chat.ts          protocol + route (compose OpenAIChat.protocol)
-    open-responses.ts         provider-neutral Responses protocol baseline
-    openai-responses.ts       OpenAI tools/events/transports composed over OpenResponses
+    openai-responses.ts
     anthropic-messages.ts
     gemini.ts
     bedrock-converse.ts
     bedrock-event-stream.ts framing for AWS event-stream binary frames
     openai-compatible-chat.ts route that reuses OpenAIChat.protocol, no canonical URL
-    openai-compatible-responses.ts deployment adapter that reuses OpenResponses.protocol, no canonical URL
+    openai-compatible-responses.ts route that reuses OpenAIResponses.protocol, no canonical URL
     utils/                  per-protocol helpers (auth, cache, media, tool-stream, ...)
   providers/
     openai-compatible.ts    generic Chat helper + family model helpers
@@ -176,7 +175,7 @@ packages/ai/src/
   tool-runtime.ts           narrow one-call typed tool dispatcher
 ```
 
-The dependency arrow points down: `providers/*.ts` files import protocol routes and auth-option utilities; protocol modules import `endpoint`, `auth`, `framing`, and transport pieces. Protocols do not import provider facades. Lower-level modules know nothing about provider catalog metadata. `OpenAIResponses` composes the provider-neutral `OpenResponses` protocol; the baseline never imports the OpenAI extension.
+The dependency arrow points down: `providers/*.ts` files import protocol routes and auth-option utilities; protocol modules import `endpoint`, `auth`, `framing`, and transport pieces. Protocols do not import provider facades. Lower-level modules know nothing about provider catalog metadata.
 
 ### Shared protocol helpers
 
@@ -223,7 +222,7 @@ Routes lower these into provider-native assistant tool-call messages and tool-re
 
 ### Tool dispatch
 
-`LLM.streamTurn(request)` and `LLM.generateTurn(request)` each run exactly one provider turn. Add tool schemas to `request.tools` with `Tool.toDefinitions(tools)`. When a caller wants the package's typed one-call execution behavior, pass each canonical local `tool-call` event to `ToolRuntime.dispatch(tools, call)`.
+`LLM.stream(request)` and `LLM.generate(request)` each run exactly one provider turn. Add tool schemas to `request.tools` with `Tool.toDefinitions(tools)`. When a caller wants the package's typed one-call execution behavior, pass each canonical local `tool-call` event to `ToolRuntime.dispatch(tools, call)`.
 
 ```ts
 const get_weather = tool({
@@ -240,8 +239,8 @@ const get_weather = tool({
 })
 
 const tools = { get_weather, get_time, ... }
-const events = yield* LLM.streamTurn(
-  LLMRequest.update(request, { tools: Tool.toDefinitions(tools) }),
+const events = yield* LLM.stream(
+  LLM.updateRequest(request, { tools: Tool.toDefinitions(tools) }),
 ).pipe(Stream.runCollect)
 
 const call = Array.from(events).find(LLMEvent.is.toolCall)

packages/ai/DESIGN.md

@@ -175,8 +175,8 @@ const request = LLM.request({
   prompt: "Say hello.",
 })
 
-// Current API: this performs one provider turn.
-const response = yield * LLM.generateTurn(request)
+// Current API: this performs one provider turn, despite the broad name.
+const response = yield * LLM.generate(request)
 
 // Current API: execution also needs LLMClient.layer and RequestExecutor services.
 ```
@@ -315,8 +315,7 @@ const longer = {
 }
 ```
 
-There is no `LLM.updateRequest(...)` helper. The current Schema-backed implementation
-uses `LLMRequest.update(...)` when canonical request data must be derived.
+There is no `LLM.updateRequest(...)` helper and no request Schema class.
 
 ### Conversation history
 
@@ -432,12 +431,12 @@ const request = LLM.request({
   tools: Tool.toDefinitions(tools),
 })
 
-const events = yield * LLM.streamTurn(request).pipe(Stream.runCollect)
+const events = yield * LLM.stream(request).pipe(Stream.runCollect)
 const call = Array.from(events).find(LLMEvent.is.toolCall)
 
 if (call && !call.providerExecuted) {
   const dispatched = yield * ToolRuntime.dispatch(tools, call)
-  const followUp = LLMRequest.update(request, {
+  const followUp = LLM.updateRequest(request, {
     messages: [...request.messages, Message.assistant([call]), Message.tool({ ...call, result: dispatched.result })],
   })
   // Caller must invoke the provider again and repeat the loop.
@@ -1076,7 +1075,7 @@ The redesign intentionally removes or changes these current concepts:
 | Current                                 | Proposed                                                    |
 | --------------------------------------- | ----------------------------------------------------------- |
 | Mandatory `LLM.request({ model, ... })` | Inline calls or model-free portable requests                |
-| No complete-run API                     | Add `LLM.generate` / `LLM.stream`                           |
+| `LLM.generate` means one turn           | `LLM.generate` means complete run                           |
 | `LLMClient.generate/stream`             | `LLM.generateTurn/streamTurn` for one turn                  |
 | `LLMClient.layer` requirement           | Standard Effect requirements exposed directly               |
 | Public `Route` mental model             | Hidden behind executable `Model`                            |

packages/ai/README.md

@@ -29,154 +29,27 @@ Run `LLMClient.stream(request)` instead of `generate` when you want incremental
 Use `Image.generate` with an image model for direct asset generation:
 
 ```ts
-import { Image, ImageInput } from "@opencode-ai/ai"
+import { Image } from "@opencode-ai/ai"
 import { OpenAI } from "@opencode-ai/ai/providers"
 
 const program = Effect.gen(function* () {
   const response = yield* Image.generate({
     model: OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).image("gpt-image-2"),
     prompt: "A robot tending a rooftop garden",
-    options: {
-      n: 2,
-      size: "1024x1024",
-      quality: "high", // inferred from the OpenAI image model
-      outputFormat: "webp",
-      future_option: true, // unknown native options pass through unchanged
-    },
+    count: 2,
+    size: { width: 1024, height: 1024 },
+    providerOptions: { openai: { quality: "high", outputFormat: "webp" } },
   })
 
   return response.images // GeneratedImage[] with owned bytes or a provider URL
 })
 ```
 
-Pass ordered image inputs to the same method for editing, composition, or image-conditioned generation:
-
-```ts
-const response =
-  yield *
-  Image.generate({
-    model,
-    prompt: "Combine these product photos into one studio scene",
-    images: [
-      ImageInput.bytes(firstBytes, "image/png"),
-      ImageInput.url("https://example.com/second.webp"),
-      ImageInput.file("file_123"),
-    ],
-    options,
-    http,
-  })
-```
-
-`ImageInput.fileUri(uri, mediaType)` represents provider file URIs such as Gemini Files. Raw strings are not
-accepted as image inputs, avoiding ambiguity between base64, URLs, and provider IDs. Empty or omitted `images`
-uses text-to-image generation; a non-empty array selects the provider's edit behavior without enforcing provider
-image-count limits locally. `images` is the only common image-editing field. OpenAI uses multipart for byte/data-URL
-edits and its JSON reference body for URL or file-ID edits. Its provider-specific `options.mask` accepts an
-`ImageInput` for inpainting:
-
-```ts
-yield *
-  Image.generate({
-    model: OpenAI.configure({ apiKey }).image("gpt-image-2"),
-    prompt,
-    images: [ImageInput.bytes(sourceBytes, "image/png")],
-    options: { mask: ImageInput.bytes(maskBytes, "image/png") },
-  })
-```
-
-The OpenAI adapter extracts this helper value into the edit request's native `mask` field rather than passing the
-tagged `ImageInput` object through as an ordinary option. On multipart requests, `http.body` can override option
-fields but not structural `model`, `prompt`, `image[]`, or `mask` fields, and the transport owns the multipart
-`Content-Type` boundary. For JSON requests, `http.body` remains the final raw-native overlay. Gemini does not fetch
-public HTTP URLs, and hosted Z.ai image generation does not accept image inputs. These cases fail with
-`InvalidRequest` before network I/O.
-
-Provider-native image options belong to each request. Raw `http.body` fields have final precedence over them:
-
-```ts
-const model = OpenAI.configure({ apiKey }).image("gpt-image-2")
-
-yield *
-  Image.generate({
-    model,
-    prompt,
-    options: { quality: "medium" },
-    http,
-  })
-```
-
-xAI image models use the same request API with xAI-native controls:
-
-```ts
-yield *
-  Image.generate({
-    model: XAI.configure({ apiKey }).image("any-model-id"),
-    prompt,
-    options: {
-      n: 2,
-      aspectRatio: "16:9",
-      resolution: "1k",
-      responseFormat: "b64_json",
-      future_option: true,
-    },
-    http,
-  })
-```
-
-Google's current Gemini image models use the same direct API:
-
-```ts
-import { Google } from "@opencode-ai/ai/providers"
-
-const googleProgram = Effect.gen(function* () {
-  const response = yield* Image.generate({
-    model: Google.configure({ apiKey }).image("any-model-id"),
-    prompt: "A robot tending a rooftop garden",
-    options: {
-      aspectRatio: "16:9",
-      imageSize: "2K",
-      seed: 42,
-      thinkingLevel: "HIGH",
-      includeThoughts: true,
-      futureOption: true,
-    },
-    http,
-  })
-
-  return response.images
-})
-```
-
-Google image options are request-scoped and inferred from the selected model. Known fields autocomplete while
-future string values and arbitrary native Gemini `generationConfig` fields remain available. Native fields override
-their mapped aliases, and `http.body` is the final deep overlay. The selected model ID is sent to Gemini
-`generateContent` without a local allowlist.
-
-Z.ai image models infer open Z.ai-native options from the selected model:
-
-```ts
-yield *
-  Image.generate({
-    model: ZAI.configure({ apiKey }).image("any-model-id"),
-    prompt,
-    options: {
-      quality: "hd",
-      userID: "user-123",
-      future_option: true,
-    },
-    http,
-  })
-```
-
-Z.ai does not include trustworthy MIME metadata for output URLs, so generated images use
-`application/octet-stream`. Output URLs expire after 30 days; download and persist them promptly if they must
-remain available.
-
 Conversational image generation remains part of the LLM interaction. OpenAI Responses exposes it through its hosted image tool:
 
 ```ts
 const program = Effect.gen(function* () {
-  const response = yield* LLM.generateTurn(
+  const response = yield* LLM.generate(
     LLM.request({
       model: OpenAI.configure({ apiKey }).responses("gpt-5"),
       prompt: "Design a solarpunk rooftop garden, then show me.",
@@ -193,7 +66,7 @@ The hosted result is represented as a provider-executed tool call and tool resul
 ## Public API
 
 - **`LLM.request({...})`** — build a provider-neutral `LLMRequest`. Accepts ergonomic inputs (`system: string`, `prompt: string`) that normalize into the canonical Schema classes.
-- **`LLM.generateTurn` / `LLM.streamTurn`** — execute exactly one provider turn, re-exported from `LLMClient` for one-import use.
+- **`LLM.generate` / `LLM.stream`** — re-exported from `LLMClient` for one-import use.
 - **`Message.user(...)` / `Message.assistant(...)` / `Message.tool(...)`** — message constructors from the canonical schema model.
 - **`Model.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model.
 - **`LLMClient.prepare(request)`** — compile a request through protocol body construction, validation, and HTTP preparation without sending. Useful for inspection and testing.
@@ -272,7 +145,7 @@ const gateway = CloudflareAIGateway.configure({
 }).model("workers-ai/@cf/meta/llama-3.1-8b-instruct")
 ```
 
-Included providers: OpenAI, Anthropic, Google (Gemini), Google Vertex Gemini and Anthropic, Amazon Bedrock, Azure OpenAI, Cloudflare AI Gateway, Cloudflare Workers AI, GitHub Copilot, OpenRouter, xAI, Z.ai, plus generic OpenAI-compatible Chat and Responses entrypoints and an Anthropic Messages-compatible entrypoint.
+Included providers: OpenAI, Anthropic, Google (Gemini), Google Vertex Gemini and Anthropic, Amazon Bedrock, Azure OpenAI, Cloudflare AI Gateway, Cloudflare Workers AI, GitHub Copilot, OpenRouter, xAI, plus generic OpenAI-compatible Chat and Responses entrypoints and an Anthropic Messages-compatible entrypoint.
 
 ### Package-like entrypoints
 
@@ -300,7 +173,7 @@ OpenAI Chat and OpenAI Responses are separate semantic entrypoints:
 - `@opencode-ai/ai/providers/google-vertex/responses`
 - `@opencode-ai/ai/providers/google-vertex/messages`
 
-Responses HTTP versus WebSocket is a scoped `transport` setting on the OpenAI Responses entrypoint, not another entrypoint. Azure follows the same Chat/Responses split at `providers/azure/chat` and `providers/azure/responses`. Generic OpenAI-compatible Chat remains at `providers/openai-compatible`; the Responses adapter at `providers/openai-compatible/responses` uses the provider-neutral Open Responses protocol. OpenAI Responses extends that baseline with OpenAI tools, event variants, metadata, defaults, and transports. Generic Anthropic Messages-compatible providers use `providers/anthropic-compatible`, which the named Anthropic provider composes. Google Gemini and Amazon Bedrock expose their single native API through their existing provider paths.
+Responses HTTP versus WebSocket is a scoped `transport` setting on the OpenAI Responses entrypoint, not another entrypoint. Azure follows the same Chat/Responses split at `providers/azure/chat` and `providers/azure/responses`. Generic OpenAI-compatible Chat remains at `providers/openai-compatible`; compatible Responses is separate at `providers/openai-compatible/responses`. Generic Anthropic Messages-compatible providers use `providers/anthropic-compatible`, which the named Anthropic provider composes. Google Gemini and Amazon Bedrock expose their single native API through their existing provider paths.
 
 Vertex Gemini, Vertex Chat, Vertex Responses, and Vertex Messages are separate API entrypoints. All accept `project`, `location`, and an optional `accessToken`; when no explicit token or auth override is supplied they lazily use Google Application Default Credentials. Vertex Gemini instead selects express mode when `apiKey` or `GOOGLE_VERTEX_API_KEY` is present. Vertex Chat targets MaaS models through the OpenAI-compatible Chat Completions endpoint, while Vertex Responses targets Grok models and defaults `store` to `false` as required by Vertex. `providers/google-vertex` remains the default alias for `providers/google-vertex/gemini`.
 

packages/ai/STATUS.md

@@ -1,6 +1,6 @@
 # LLM Provider Parity Status
 
-Last reviewed: 2026-07-24
+Last reviewed: 2026-07-17
 
 This file tracks the gap between the native `@opencode-ai/ai` package and the AI SDK provider packages that opencode still depends on for many catalog/runtime paths.
 
@@ -13,26 +13,26 @@ This file tracks the gap between the native `@opencode-ai/ai` package and the AI
 
 ## Current Implementation Snapshot
 
-| Native slice                       | Source                                                                                                                            | Current state                                                                                                                                                            | Main gaps                                                                                                                                                                                                                                                 |
-| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| OpenAI Chat                        | `src/protocols/openai-chat.ts`, `src/providers/openai.ts`                                                                         | Usable. Streams text, reasoning deltas, tool calls, usage, images, and common generation controls.                                                                       | No typed structured-output / `response_format` path. Limited typed OpenAI option surface compared with SDK escape hatches.                                                                                                                                |
-| OpenAI Responses HTTP              | `src/protocols/open-responses.ts`, `src/protocols/openai-responses.ts`, `src/providers/openai.ts`                                 | Usable. Extends the Open Responses baseline with hosted-tool event surfacing, reasoning replay metadata, GPT-5 defaults, and cache usage.                                | No explicit `previous_response_id` path. Typed options cover only a subset of Responses fields. Structured output is still mostly synthetic-tool based.                                                                                                   |
-| OpenAI Responses WebSocket         | `src/protocols/openai-responses.ts`, `src/route/transport/websocket.ts`                                                           | Present as `OpenAI.responsesWebSocket(...)`.                                                                                                                             | Runner/catalog support explicitly must not downgrade WebSocket routes; broader runtime selection is not complete.                                                                                                                                         |
-| OpenAI-compatible Chat             | `src/protocols/openai-compatible-chat.ts`, `src/providers/openai-compatible.ts`                                                   | Usable for generic Chat and several profiles: Baseten, Cerebras, DeepInfra, DeepSeek, Fireworks, Groq, TogetherAI.                                                       | Family quirks are mostly endpoint defaults, not full typed behavior.                                                                                                                                                                                      |
-| Open Responses-compatible          | `src/protocols/open-responses.ts`, `src/protocols/openai-compatible-responses.ts`, `src/providers/openai-compatible-responses.ts` | Usable for deployments that implement the provider-neutral Open Responses protocol. The deployment adapter does not inherit OpenAI tools, events, metadata, or defaults. | No named family profiles or recorded deployment coverage yet.                                                                                                                                                                                             |
-| Anthropic-compatible Messages      | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic-compatible.ts`                                                    | Usable for deployments that implement the Anthropic Messages wire protocol. Named Anthropic composes this base; MiniMax M3 has recorded text and tool-loop coverage.     | No named compatible family profiles yet.                                                                                                                                                                                                                  |
-| Anthropic Messages                 | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic.ts`                                                               | Usable. Supports tools, thinking, cache control, images, server-hosted tool events, and usage.                                                                           | Provider option surface is small. Beta/header handling, metadata, and newer Messages fields need a typed parity pass.                                                                                                                                     |
-| Gemini Developer API               | `src/protocols/gemini.ts`, `src/providers/google.ts`                                                                              | Usable for Google API key flow. Supports text, images, tools, thinking signatures, and cache usage.                                                                      | This is not Vertex. Typed provider options are narrow; many Gemini request fields currently require raw `http.body` overlays.                                                                                                                             |
-| Vertex Gemini                      | `src/protocols/gemini.ts`, `src/providers/google-vertex.ts`                                                                       | Usable through API-key express mode, explicit OAuth tokens, or ADC with project/location endpoint derivation, including tuned `endpoints/...` deployments.               | Core runner/catalog mapping and recorded provider coverage are missing.                                                                                                                                                                                   |
-| Vertex Chat                        | `src/protocols/openai-chat.ts`, `src/providers/google-vertex-chat.ts`                                                             | Usable for MaaS models through OpenAI-compatible Chat Completions with explicit OAuth tokens or ADC and project/location endpoint derivation.                            | Core runner/catalog mapping and recorded provider coverage are missing; MaaS family-specific request parity needs review.                                                                                                                                 |
-| Vertex Responses                   | `src/protocols/open-responses.ts`, `src/providers/google-vertex-responses.ts`                                                     | Usable for Grok models through Open Responses with explicit OAuth tokens or ADC, project/location endpoint derivation, and an explicit `store: false` Vertex default.    | Core runner/catalog mapping and recorded provider coverage are missing; stateful continuation is not supported by Vertex.                                                                                                                                 |
-| Vertex Messages                    | `src/protocols/anthropic-messages.ts`, `src/providers/google-vertex-messages.ts`                                                  | Usable through explicit OAuth tokens or ADC, including global, regional, and `eu`/`us` multi-region endpoints.                                                           | Core runner/catalog mapping and recorded provider coverage are missing; Vertex-specific hosted-tool parity needs review.                                                                                                                                  |
-| Bedrock Converse                   | `src/protocols/bedrock-converse.ts`, `src/providers/amazon-bedrock.ts`                                                            | Partial but real. Supports AWS event-stream framing, SigV4 with supplied credentials, bearer auth, tools, reasoning signatures, media, cache points, and recorded tests. | Native facade does not mirror the AI SDK plugin's default AWS credential chain/profile behavior. Runner/catalog mapping is missing. Guardrails, inference profiles, region-specific model ID fixes, and model-specific request fields need a parity pass. |
-| Azure OpenAI                       | `src/providers/azure.ts` using OpenAI Chat/Responses protocols                                                                    | Partial. Supports resource/base URL setup, API key auth, API version query, Chat, and Responses selectors.                                                               | Core runner does not map `@ai-sdk/azure` to this native facade. AAD/token auth and Azure-specific endpoint variants need review.                                                                                                                          |
-| Cloudflare AI Gateway / Workers AI | `src/providers/cloudflare.ts`                                                                                                     | Present via OpenAI-compatible Chat routes.                                                                                                                               | Useful but not part of the critical AI SDK replacement set yet. Needs per-product recorded coverage before relying on it broadly.                                                                                                                         |
-| OpenRouter                         | `src/providers/openrouter.ts`                                                                                                     | Present with OpenRouter-specific usage/reasoning/prompt-cache options over Chat.                                                                                         | Responses-style OpenRouter support is absent.                                                                                                                                                                                                             |
-| xAI                                | `src/providers/xai.ts`                                                                                                            | Present with Responses and Chat selectors.                                                                                                                               | Needs package-parity review against the AI SDK xAI provider.                                                                                                                                                                                              |
-| GitHub Copilot                     | `src/providers/github-copilot.ts`                                                                                                 | Present as explicit-base-URL OpenAI Chat/Responses facade.                                                                                                               | Runtime/catalog integration remains specialized and should stay separate from public OpenAI-compatible defaults.                                                                                                                                          |
+| Native slice                       | Source                                                                                         | Current state                                                                                                                                                            | Main gaps                                                                                                                                                                                                                                                 |
+| ---------------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| OpenAI Chat                        | `src/protocols/openai-chat.ts`, `src/providers/openai.ts`                                      | Usable. Streams text, reasoning deltas, tool calls, usage, images, and common generation controls.                                                                       | No typed structured-output / `response_format` path. Limited typed OpenAI option surface compared with SDK escape hatches.                                                                                                                                |
+| OpenAI Responses HTTP              | `src/protocols/openai-responses.ts`, `src/providers/openai.ts`                                 | Usable. Supports hosted-tool event surfacing, reasoning replay metadata, GPT-5 defaults, and cache usage.                                                                | No explicit `previous_response_id` path. Typed options cover only a subset of Responses fields. Structured output is still mostly synthetic-tool based.                                                                                                   |
+| OpenAI Responses WebSocket         | `src/protocols/openai-responses.ts`, `src/route/transport/websocket.ts`                        | Present as `OpenAI.responsesWebSocket(...)`.                                                                                                                             | Runner/catalog support explicitly must not downgrade WebSocket routes; broader runtime selection is not complete.                                                                                                                                         |
+| OpenAI-compatible Chat             | `src/protocols/openai-compatible-chat.ts`, `src/providers/openai-compatible.ts`                | Usable for generic Chat and several profiles: Baseten, Cerebras, DeepInfra, DeepSeek, Fireworks, Groq, TogetherAI.                                                       | Family quirks are mostly endpoint defaults, not full typed behavior.                                                                                                                                                                                      |
+| OpenAI-compatible Responses        | `src/protocols/openai-compatible-responses.ts`, `src/providers/openai-compatible-responses.ts` | Usable for deployments that implement the OpenAI Responses wire protocol.                                                                                                | No named family profiles or recorded deployment coverage yet.                                                                                                                                                                                             |
+| Anthropic-compatible Messages      | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic-compatible.ts`                 | Usable for deployments that implement the Anthropic Messages wire protocol. Named Anthropic composes this base; MiniMax M3 has recorded text and tool-loop coverage.       | No named compatible family profiles yet.                                                                                                                                                                                                                  |
+| Anthropic Messages                 | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic.ts`                            | Usable. Supports tools, thinking, cache control, images, server-hosted tool events, and usage.                                                                           | Provider option surface is small. Beta/header handling, metadata, and newer Messages fields need a typed parity pass.                                                                                                                                     |
+| Gemini Developer API               | `src/protocols/gemini.ts`, `src/providers/google.ts`                                           | Usable for Google API key flow. Supports text, images, tools, thinking signatures, and cache usage.                                                                      | This is not Vertex. Typed provider options are narrow; many Gemini request fields currently require raw `http.body` overlays.                                                                                                                             |
+| Vertex Gemini                      | `src/protocols/gemini.ts`, `src/providers/google-vertex.ts`                                    | Usable through API-key express mode, explicit OAuth tokens, or ADC with project/location endpoint derivation, including tuned `endpoints/...` deployments.               | Core runner/catalog mapping and recorded provider coverage are missing.                                                                                                                                                                                   |
+| Vertex Chat                        | `src/protocols/openai-chat.ts`, `src/providers/google-vertex-chat.ts`                          | Usable for MaaS models through OpenAI-compatible Chat Completions with explicit OAuth tokens or ADC and project/location endpoint derivation.                            | Core runner/catalog mapping and recorded provider coverage are missing; MaaS family-specific request parity needs review.                                                                                                                                 |
+| Vertex Responses                   | `src/protocols/openai-responses.ts`, `src/providers/google-vertex-responses.ts`                | Usable for Grok models through OpenAI-compatible Responses with explicit OAuth tokens or ADC, project/location endpoint derivation, and storage disabled by default.     | Core runner/catalog mapping and recorded provider coverage are missing; stateful continuation is not supported by Vertex.                                                                                                                                 |
+| Vertex Messages                    | `src/protocols/anthropic-messages.ts`, `src/providers/google-vertex-messages.ts`               | Usable through explicit OAuth tokens or ADC, including global, regional, and `eu`/`us` multi-region endpoints.                                                           | Core runner/catalog mapping and recorded provider coverage are missing; Vertex-specific hosted-tool parity needs review.                                                                                                                                  |
+| Bedrock Converse                   | `src/protocols/bedrock-converse.ts`, `src/providers/amazon-bedrock.ts`                         | Partial but real. Supports AWS event-stream framing, SigV4 with supplied credentials, bearer auth, tools, reasoning signatures, media, cache points, and recorded tests. | Native facade does not mirror the AI SDK plugin's default AWS credential chain/profile behavior. Runner/catalog mapping is missing. Guardrails, inference profiles, region-specific model ID fixes, and model-specific request fields need a parity pass. |
+| Azure OpenAI                       | `src/providers/azure.ts` using OpenAI Chat/Responses protocols                                 | Partial. Supports resource/base URL setup, API key auth, API version query, Chat, and Responses selectors.                                                               | Core runner does not map `@ai-sdk/azure` to this native facade. AAD/token auth and Azure-specific endpoint variants need review.                                                                                                                          |
+| Cloudflare AI Gateway / Workers AI | `src/providers/cloudflare.ts`                                                                  | Present via OpenAI-compatible Chat routes.                                                                                                                               | Useful but not part of the critical AI SDK replacement set yet. Needs per-product recorded coverage before relying on it broadly.                                                                                                                         |
+| OpenRouter                         | `src/providers/openrouter.ts`                                                                  | Present with OpenRouter-specific usage/reasoning/prompt-cache options over Chat.                                                                                         | Responses-style OpenRouter support is absent.                                                                                                                                                                                                             |
+| xAI                                | `src/providers/xai.ts`                                                                         | Present with Responses and Chat selectors.                                                                                                                               | Needs package-parity review against the AI SDK xAI provider.                                                                                                                                                                                              |
+| GitHub Copilot                     | `src/providers/github-copilot.ts`                                                              | Present as explicit-base-URL OpenAI Chat/Responses facade.                                                                                                               | Runtime/catalog integration remains specialized and should stay separate from public OpenAI-compatible defaults.                                                                                                                                          |
 
 ## V2 Runner Status
 
@@ -65,7 +65,7 @@ Other `aisdk:` packages, including Google Vertex, Azure, and Bedrock, currently
 ## Highest-Risk Gaps
 
 1. Runner support is narrower than the LLM package. The package has native provider facades for Google, Azure, and Bedrock, but the V2 Session runner only maps OpenAI, Anthropic, and explicit OpenAI-compatible Chat from `aisdk` catalog metadata.
-2. The Open Responses adapter is available through a separate package entrypoint, but the V2 runner still maps `@ai-sdk/openai-compatible` to Chat only. Catalog selection must become API-aware before Responses deployments can use it.
+2. OpenAI-compatible Responses is available as a separate package entrypoint, but the V2 runner still maps `@ai-sdk/openai-compatible` to Chat only. Catalog selection must become API-aware before Responses deployments can use it.
 3. Bedrock native auth is not AI SDK parity. The AI SDK plugin uses the default AWS provider chain, profile, container credentials, and Bedrock bearer token env behavior. Native Bedrock currently expects explicit credentials or bearer auth on the facade.
 4. Vertex Gemini, Vertex Chat, Vertex Responses, and Vertex Messages now have native package entrypoints, but the core runner does not map catalog metadata to them yet and recorded provider coverage is still missing.
 5. Azure is only a provider facade, not a full runtime replacement. Native Azure exists, but the catalog runner does not select it, and token auth/resource variants need review.
@@ -83,13 +83,13 @@ These are implementation/API slices, not separate npm packages.
 | OpenAI Chat                   | `@opencode-ai/ai/providers/openai/chat`                 | OpenAI `/chat/completions` semantics.                                        |
 | OpenAI Responses              | `@opencode-ai/ai/providers/openai/responses`            | OpenAI `/responses` semantics with HTTP/WebSocket selected through settings. |
 | OpenAI-compatible Chat        | `@opencode-ai/ai/providers/openai-compatible`           | Generic OpenAI-compatible `/chat/completions`.                               |
-| Open Responses-compatible     | `@opencode-ai/ai/providers/openai-compatible/responses` | Generic provider-neutral `/responses`.                                       |
+| OpenAI-compatible Responses   | `@opencode-ai/ai/providers/openai-compatible/responses` | Generic OpenAI-compatible `/responses`.                                      |
 | Anthropic-compatible Messages | `@opencode-ai/ai/providers/anthropic-compatible`        | Generic Anthropic-compatible `/messages`.                                    |
 | Anthropic Messages            | `@opencode-ai/ai/providers/anthropic`                   | Anthropic Messages API.                                                      |
 | Gemini Developer API          | `@opencode-ai/ai/providers/google`                      | Google AI Studio Gemini API.                                                 |
 | Vertex Gemini                 | `@opencode-ai/ai/providers/google-vertex/gemini`        | Vertex Gemini API; `providers/google-vertex` is the default alias.           |
 | Vertex Chat                   | `@opencode-ai/ai/providers/google-vertex/chat`          | Vertex OpenAI-compatible Chat Completions for MaaS models.                   |
-| Vertex Responses              | `@opencode-ai/ai/providers/google-vertex/responses`     | Vertex Open Responses for Grok models.                                       |
+| Vertex Responses              | `@opencode-ai/ai/providers/google-vertex/responses`     | Vertex OpenAI-compatible Responses for Grok models.                          |
 | Vertex Messages               | `@opencode-ai/ai/providers/google-vertex/messages`      | Vertex-hosted Anthropic Messages API.                                        |
 | Bedrock Converse              | `@opencode-ai/ai/providers/amazon-bedrock`              | AWS Bedrock Converse API.                                                    |
 | Bedrock Mantle                | Missing                                                 | AWS Bedrock Mantle OpenAI-compatible APIs.                                   |

packages/ai/example/call-sites.md

@@ -334,7 +334,7 @@ Final request call site stays boring:
 ```ts
 const response =
   yield *
-  LLM.generateTurn(
+  LLM.generate(
     LLM.request({
       model: DeepSeek.model("deepseek-chat"),
       prompt: "Hello.",

packages/ai/example/tutorial.ts

@@ -1,5 +1,5 @@
 import { Config, Effect, Formatter, Layer, Schema, Stream } from "effect"
-import { LLM, LLMClient, LLMRequest, Message, ProviderID, Tool, ToolRuntime } from "@opencode-ai/ai"
+import { LLM, LLMClient, Message, ProviderID, Tool, ToolRuntime } from "@opencode-ai/ai"
 import { Route, Auth, Endpoint, Framing, Protocol, RequestExecutor, WebSocketExecutor } from "@opencode-ai/ai/route"
 import { OpenAI } from "@opencode-ai/ai/providers"
 
@@ -65,7 +65,7 @@ const rawOverlayExample = LLM.request({
 // 3. `generate` sends the request and collects the event stream into one
 // response object. `response.text` is the collected text output.
 const generateOnce = Effect.gen(function* () {
-  const response = yield* LLM.generateTurn(request)
+  const response = yield* LLM.generate(request)
 
   console.log("\n== generate ==")
   console.log("generated text:", response.text)
@@ -74,14 +74,11 @@ const generateOnce = Effect.gen(function* () {
 
 // 4. `stream` exposes provider output as common `LLMEvent`s for UIs that want
 // incremental text, reasoning, tool input, usage, or finish events.
-const streamText = LLM.streamTurn(request).pipe(
+const streamText = LLM.stream(request).pipe(
   Stream.tap((event) =>
     Effect.sync(() => {
       if (event.type === "text-delta") process.stdout.write(`\ntext: ${event.text}`)
-      if (event.type === "finish")
-        process.stdout.write(
-          `\nfinish: ${event.reason.normalized}${event.reason.raw ? ` (${event.reason.raw})` : ""}\n`,
-        )
+      if (event.type === "finish") process.stdout.write(`\nfinish: ${event.reason}\n`)
     }),
   ),
   Stream.runDrain,
@@ -106,7 +103,7 @@ const streamWithTools = Effect.gen(function* () {
     generation: { maxTokens: 80, temperature: 0 },
     tools: Tool.toDefinitions(tools),
   })
-  const events = Array.from(yield* LLM.streamTurn(request).pipe(Stream.runCollect))
+  const events = Array.from(yield* LLM.stream(request).pipe(Stream.runCollect))
   for (const event of events) {
     if (event.type === "tool-call") console.log("tool call", event.name, event.input)
     if (event.type === "text-delta") process.stdout.write(event.text)
@@ -116,7 +113,7 @@ const streamWithTools = Effect.gen(function* () {
 
     // A durable agent would persist these messages before starting another
     // raw model turn. This tutorial keeps the boundary visible instead.
-    const followUp = LLMRequest.update(request, {
+    const followUp = LLM.updateRequest(request, {
       messages: [
         ...request.messages,
         Message.assistant([event]),
@@ -197,7 +194,7 @@ const FakeProtocol = Protocol.make<FakeBody, string, string, void>({
     event: Schema.String,
     initial: () => undefined,
     step: (_, frame) => Effect.succeed([undefined, [{ type: "text-delta", id: "text-0", text: frame }]] as const),
-    onHalt: () => [{ type: "finish", reason: { normalized: "stop" } }],
+    onHalt: () => [{ type: "finish", reason: "stop" }],
   },
 })
 

packages/ai/package.json

@@ -7,7 +7,7 @@
   "scripts": {
     "setup:recording-env": "bun run script/setup-recording-env.ts",
     "test": "bun test --timeout 30000 --only-failures",
-    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.types.json",
+    "typecheck": "tsgo --noEmit",
     "build": "tsc -p tsconfig.build.json"
   },
   "files": [

packages/ai/src/image-client.ts

@@ -1,21 +1,17 @@
 import { Context, Effect, Layer } from "effect"
 import { RequestExecutor } from "./route/executor"
-import type { ImageOptions, ImageRequest, ImageRequestFor, ImageResponse } from "./image"
+import type { ImageRequest, ImageResponse } from "./image"
 import type { LLMError } from "./schema"
 
 export type Execute = RequestExecutor.Interface["execute"]
 
 export interface Interface {
-  readonly generate: <Options extends ImageOptions>(
-    request: ImageRequestFor<Options>,
-  ) => Effect.Effect<ImageResponse, LLMError>
+  readonly generate: (request: ImageRequest) => Effect.Effect<ImageResponse, LLMError>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/ImageClient") {}
 
-export const generate = <Options extends ImageOptions>(
-  request: ImageRequestFor<Options>,
-): Effect.Effect<ImageResponse, LLMError> =>
+export const generate = (request: ImageRequest): Effect.Effect<ImageResponse, LLMError> =>
   Effect.gen(function* () {
     const client = yield* Service
     return yield* client.generate(request)

packages/ai/src/image.ts

@@ -1,119 +1,79 @@
 import { Effect, Schema } from "effect"
 import { HttpOptions, InvalidRequestReason, LLMError, ModelID, ProviderID, ProviderMetadata, Usage } from "./schema"
-import { ImageClient, Service, type Execute as ImageExecute } from "./image-client"
+import { ImageClient, type Execute as ImageExecute } from "./image-client"
 
-export interface ImageRoute<Options extends ImageOptions = ImageOptions> {
+export interface ImageRoute {
   readonly id: string
-  readonly generate: (
-    request: ImageRequestFor<Options>,
-    execute: ImageExecute,
-  ) => Effect.Effect<ImageResponse, LLMError>
+  readonly generate: (request: ImageRequest, execute: ImageExecute) => Effect.Effect<ImageResponse, LLMError>
 }
 
-export type ImageOptions = Record<string, unknown>
-
-export class ImageModel<Options extends ImageOptions = ImageOptions> {
-  declare protected readonly _Options: (options: Options) => Options
+export class ImageModel {
   readonly id: ModelID
   readonly provider: ProviderID
-  readonly route: ImageRoute<Options>
-  readonly http?: HttpOptions
+  readonly route: ImageRoute
+  readonly defaults?: ImageModelDefaults
 
-  constructor(input: ImageModel.Input<Options>) {
+  constructor(input: ImageModel.Input) {
     this.id = input.id
     this.provider = input.provider
     this.route = input.route
-    this.http = input.http
+    this.defaults = input.defaults
   }
 
-  static make<Options extends ImageOptions = ImageOptions>(input: ImageModel.MakeInput<Options>) {
-    return new ImageModel<Options>({
+  static make(input: ImageModel.MakeInput) {
+    return new ImageModel({
       id: ModelID.make(input.id),
       provider: ProviderID.make(input.provider),
       route: input.route,
-      http: input.http,
+      defaults: input.defaults,
     })
   }
 }
 
 export namespace ImageModel {
-  export interface Input<Options extends ImageOptions = ImageOptions> {
+  export interface Input {
     readonly id: ModelID
     readonly provider: ProviderID
-    readonly route: ImageRoute<Options>
-    readonly http?: HttpOptions
+    readonly route: ImageRoute
+    readonly defaults?: ImageModelDefaults
   }
 
-  export interface MakeInput<Options extends ImageOptions = ImageOptions>
-    extends Omit<Input<Options>, "id" | "provider"> {
+  export interface MakeInput extends Omit<Input, "id" | "provider"> {
     readonly id: string | ModelID
     readonly provider: string | ProviderID
   }
 }
 
+export interface ImageModelDefaults {
+  readonly providerOptions?: Record<string, Record<string, unknown>>
+  readonly http?: HttpOptions
+}
+
 export const ImageModelSchema = Schema.declare((value): value is ImageModel => value instanceof ImageModel, {
   expected: "Image.Model",
 })
 
-const ImageBytesInput = Schema.Struct({
-  type: Schema.Literal("bytes"),
-  data: Schema.Uint8Array,
-  mediaType: Schema.String,
-})
-const ImageUrlInput = Schema.Struct({
-  type: Schema.Literal("url"),
-  url: Schema.String,
-})
-const ImageFileIDInput = Schema.Struct({
-  type: Schema.Literal("file-id"),
-  id: Schema.String,
-})
-const ImageFileURIInput = Schema.Struct({
-  type: Schema.Literal("file-uri"),
-  uri: Schema.String,
-  mediaType: Schema.String,
-})
-
-export const ImageInputSchema = Schema.Union([
-  ImageBytesInput,
-  ImageUrlInput,
-  ImageFileIDInput,
-  ImageFileURIInput,
-]).pipe(Schema.toTaggedUnion("type"))
-export type ImageInput = Schema.Schema.Type<typeof ImageInputSchema>
-
-export const ImageInput = {
-  bytes: (data: Uint8Array, mediaType: string): ImageInput => ({ type: "bytes", data, mediaType }),
-  url: (url: string): ImageInput => ({ type: "url", url }),
-  file: (id: string): ImageInput => ({ type: "file-id", id }),
-  fileUri: (uri: string, mediaType: string): ImageInput => ({ type: "file-uri", uri, mediaType }),
-} as const
+export const ImageSize = Schema.Struct({
+  width: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+  height: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+}).annotate({ identifier: "Image.Size" })
+export type ImageSize = Schema.Schema.Type<typeof ImageSize>
 
 export class ImageRequest extends Schema.Class<ImageRequest>("Image.Request")({
   model: ImageModelSchema,
   prompt: Schema.String,
-  images: Schema.optional(Schema.Array(ImageInputSchema)),
-  options: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+  count: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
+  size: Schema.optional(ImageSize),
+  aspectRatio: Schema.optional(Schema.String),
+  seed: Schema.optional(Schema.Number),
+  providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))),
   http: Schema.optional(HttpOptions),
-}) {
-  declare protected readonly _ImageRequest: void
-}
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}) {}
 
-export type ImageRequestFor<Options extends ImageOptions = ImageOptions> = Omit<ImageRequest, "model" | "options"> & {
-  readonly model: ImageModel<Options>
-  readonly options?: Options
-}
-
-export type ImageModelOptions<Model> = Model extends ImageModel<infer Options> ? Options : never
-
-export type ImageRequestInput<Model extends object = ImageModel> = Omit<
-  ConstructorParameters<typeof ImageRequest>[0],
-  "model" | "options" | "http"
-> & {
-  readonly model: Model
-  readonly options?: NoInfer<ImageModelOptions<Model>>
+export type ImageRequestInput = Omit<ConstructorParameters<typeof ImageRequest>[0], "http"> & {
   readonly http?: HttpOptions.Input
-} & (Model extends ImageModel<ImageModelOptions<Model>> ? unknown : never)
+}
 
 export class GeneratedImage extends Schema.Class<GeneratedImage>("Image.Generated")({
   mediaType: Schema.String,
@@ -131,34 +91,24 @@ export class ImageResponse extends Schema.Class<ImageResponse>("Image.Response")
   }
 }
 
-export function request<const Model extends object>(
-  input: ImageRequestInput<Model>,
-): ImageRequestFor<ImageModelOptions<Model>>
-export function request(input: ImageRequest): ImageRequest
-export function request(input: ImageRequest | ImageRequestInput) {
+export const request = (input: ImageRequest | ImageRequestInput) => {
   if (input instanceof ImageRequest) return input
   return new ImageRequest({
     ...input,
-    model: input.model as unknown as ImageModel,
     http: input.http === undefined ? undefined : HttpOptions.make(input.http),
   })
 }
 
-export function generate<const Model extends object>(
-  input: ImageRequestInput<Model>,
-): Effect.Effect<ImageResponse, LLMError, Service>
-export function generate(input: ImageRequest): Effect.Effect<ImageResponse, LLMError, Service>
-export function generate(input: ImageRequest | ImageRequestInput) {
-  return Effect.try({
-    try: () => (input instanceof ImageRequest ? input : request(input)),
+export const generate = (input: ImageRequest | ImageRequestInput) =>
+  Effect.try({
+    try: () => request(input),
     catch: (error) =>
       new LLMError({
         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>)))
-}
+  }).pipe(Effect.flatMap(ImageClient.generate))
 
 export const Image = {
   request,

packages/ai/src/index.ts

@@ -11,8 +11,8 @@ export type {
   Service as LLMClientService,
 } from "./route/client"
 export * from "./schema"
-export { GeneratedImage, ImageInput, ImageInputSchema, ImageModel, ImageRequest, ImageResponse } from "./image"
-export type { ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute } from "./image"
+export { GeneratedImage, ImageModel, ImageRequest, ImageResponse, ImageSize } from "./image"
+export type { ImageModelDefaults, ImageRequestInput, ImageRoute } from "./image"
 export { Image } from "./image"
 export { Tool, ToolFailure, toDefinitions } from "./tool"
 export { ToolRuntime } from "./tool-runtime"

packages/ai/src/llm.ts

@@ -9,13 +9,24 @@ import {
   LLMRequest,
   LLMResponse,
   Message,
+  type ModelInput as SchemaModelInput,
   SystemPart,
   ToolChoice,
   ToolDefinition,
   type ContentPart,
+  ToolResultPart,
 } from "./schema"
 import { make as makeTool, toDefinitions, type ToolSchema } from "./tool"
 
+export type ModelInput = SchemaModelInput
+
+export type MessageInput = Message.Input
+
+export type ToolChoiceInput = ToolChoice.Input
+export type ToolChoiceMode = ToolChoice.Mode
+
+export type ToolResultInput = Parameters<typeof ToolResultPart.make>[0]
+
 /** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */
 export type RequestInput = Omit<
   ConstructorParameters<typeof LLMRequest>[0],
@@ -23,17 +34,21 @@ export type RequestInput = Omit<
 > & {
   readonly system?: string | SystemPart | ReadonlyArray<SystemPart>
   readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>
-  readonly messages?: ReadonlyArray<Message | Message.Input>
+  readonly messages?: ReadonlyArray<Message | MessageInput>
   readonly tools?: ReadonlyArray<ToolDefinition.Input>
-  readonly toolChoice?: ToolChoice.Input
+  readonly toolChoice?: ToolChoiceInput
   readonly generation?: GenerationOptions.Input
   readonly providerOptions?: ConstructorParameters<typeof LLMRequest>[0]["providerOptions"]
   readonly http?: HttpOptions.Input
 }
 
-export const generateTurn = LLMClient.generate
+export const generate = LLMClient.generate
 
-export const streamTurn = LLMClient.stream
+export const stream = LLMClient.stream
+
+export const requestInput = (input: LLMRequest): RequestInput => ({
+  ...LLMRequest.input(input),
+})
 
 export const request = (input: RequestInput) => {
   const {
@@ -59,11 +74,14 @@ export const request = (input: RequestInput) => {
   })
 }
 
+export const updateRequest = (input: LLMRequest, patch: Partial<RequestInput>) =>
+  request({ ...requestInput(input), ...patch })
+
 const GENERATE_OBJECT_TOOL_NAME = "generate_object"
 
 const GENERATE_OBJECT_TOOL_DESCRIPTION = "Return the structured result by calling this tool."
 
-type GenerateObjectBase = Omit<RequestInput, "tools" | "toolChoice">
+type GenerateObjectBase = Omit<RequestInput, "tools" | "toolChoice" | "responseFormat">
 
 export class GenerateObjectResponse<T> {
   constructor(

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

@@ -13,7 +13,6 @@ import {
   type JsonSchema,
   type LLMRequest,
   type MediaPart,
-  type ProviderOptions,
   type ProviderMetadata,
   type ToolCallPart,
   type ToolDefinition,
@@ -28,33 +27,9 @@ import { ToolSchemaProjection } from "./utils/tool-schema"
 import { ToolStream } from "./utils/tool-stream"
 
 const ADAPTER = "anthropic-messages"
-const MEDIA_MIMES = new Set<string>([...ProviderShared.IMAGE_MIMES, ...ProviderShared.PDF_MIMES])
 export const DEFAULT_BASE_URL = "https://api.anthropic.com/v1"
 export const PATH = "/messages"
 
-export type ThinkingInput =
-  | {
-      readonly type: "adaptive"
-      readonly display?: "summarized" | "omitted"
-    }
-  | {
-      readonly type: "disabled"
-    }
-  | ({ readonly type: "enabled" } & (
-      | { readonly budgetTokens: number; readonly budget_tokens?: number }
-      | { readonly budgetTokens?: number; readonly budget_tokens: number }
-    ))
-
-export interface OptionsInput {
-  readonly [key: string]: unknown
-  readonly thinking?: ThinkingInput
-  readonly effort?: string
-}
-
-export type ProviderOptionsInput = ProviderOptions & {
-  readonly anthropic?: OptionsInput
-}
-
 // =============================================================================
 // Request Body Schema
 // =============================================================================
@@ -81,17 +56,6 @@ const AnthropicImageBlock = Schema.Struct({
 })
 type AnthropicImageBlock = Schema.Schema.Type<typeof AnthropicImageBlock>
 
-const AnthropicDocumentBlock = Schema.Struct({
-  type: Schema.tag("document"),
-  source: Schema.Struct({
-    type: Schema.tag("base64"),
-    media_type: Schema.Literal("application/pdf"),
-    data: Schema.String,
-  }),
-  cache_control: Schema.optional(AnthropicCacheControl),
-})
-type AnthropicDocumentBlock = Schema.Schema.Type<typeof AnthropicDocumentBlock>
-
 const AnthropicThinkingBlock = Schema.Struct({
   type: Schema.tag("thinking"),
   thinking: Schema.String,
@@ -99,15 +63,6 @@ const AnthropicThinkingBlock = Schema.Struct({
   cache_control: Schema.optional(AnthropicCacheControl),
 })
 
-// Safety-filtered thinking arrives as an opaque encrypted `data` payload with
-// no visible text. It must round-trip verbatim so multi-turn thinking + tool
-// use conversations keep their reasoning continuity.
-const AnthropicRedactedThinkingBlock = Schema.Struct({
-  type: Schema.tag("redacted_thinking"),
-  data: Schema.String,
-  cache_control: Schema.optional(AnthropicCacheControl),
-})
-
 const AnthropicToolUseBlock = Schema.Struct({
   type: Schema.tag("tool_use"),
   id: Schema.String,
@@ -146,10 +101,13 @@ const AnthropicServerToolResultBlock = Schema.Struct({
 })
 type AnthropicServerToolResultBlock = Schema.Schema.Type<typeof AnthropicServerToolResultBlock>
 
-// Anthropic accepts either a plain string or an ordered array of text, image, and
-// document blocks inside `tool_result.content`. The array form keeps media as native
-// model input instead of JSON-stringifying base64 into prompt text.
-const AnthropicToolResultContent = Schema.Union([AnthropicTextBlock, AnthropicImageBlock, AnthropicDocumentBlock])
+// Anthropic accepts either a plain string or an ordered array of text/image
+// blocks inside `tool_result.content`. The array form is required when a tool
+// returns image bytes (screenshot, image search, etc.) so they can be passed
+// to the model as proper image inputs instead of being JSON-stringified into
+// the prompt — which silently inflates context by megabytes and can push the
+// conversation over the model's token limit.
+const AnthropicToolResultContent = Schema.Union([AnthropicTextBlock, AnthropicImageBlock])
 
 const AnthropicToolResultBlock = Schema.Struct({
   type: Schema.tag("tool_result"),
@@ -159,17 +117,11 @@ const AnthropicToolResultBlock = Schema.Struct({
   cache_control: Schema.optional(AnthropicCacheControl),
 })
 
-const AnthropicUserBlock = Schema.Union([
-  AnthropicTextBlock,
-  AnthropicImageBlock,
-  AnthropicDocumentBlock,
-  AnthropicToolResultBlock,
-])
+const AnthropicUserBlock = Schema.Union([AnthropicTextBlock, AnthropicImageBlock, AnthropicToolResultBlock])
 type AnthropicUserBlock = Schema.Schema.Type<typeof AnthropicUserBlock>
 const AnthropicAssistantBlock = Schema.Union([
   AnthropicTextBlock,
   AnthropicThinkingBlock,
-  AnthropicRedactedThinkingBlock,
   AnthropicToolUseBlock,
   AnthropicServerToolUseBlock,
   AnthropicServerToolResultBlock,
@@ -193,7 +145,7 @@ const AnthropicTool = Schema.Struct({
 type AnthropicTool = Schema.Schema.Type<typeof AnthropicTool>
 
 const AnthropicToolChoice = Schema.Union([
-  Schema.Struct({ type: Schema.Literals(["auto", "any", "none"]) }),
+  Schema.Struct({ type: Schema.Literals(["auto", "any"]) }),
   Schema.Struct({ type: Schema.tag("tool"), name: Schema.String }),
 ])
 
@@ -248,9 +200,6 @@ const AnthropicStreamBlock = Schema.Struct({
   text: Schema.optional(Schema.String),
   thinking: Schema.optional(Schema.String),
   signature: Schema.optional(Schema.String),
-  // redacted_thinking blocks arrive whole in content_block_start with the
-  // encrypted payload in `data`; there is no streaming delta sequence.
-  data: Schema.optional(Schema.String),
   input: Schema.optional(Schema.Unknown),
   // *_tool_result blocks arrive whole as content_block_start (no streaming
   // delta) with the structured payload in `content` and the originating
@@ -324,12 +273,6 @@ const signatureFromMetadata = (metadata: ProviderMetadata | undefined): string |
   return typeof anthropic.signature === "string" ? anthropic.signature : undefined
 }
 
-const redactedDataFromMetadata = (metadata: ProviderMetadata | undefined): string | undefined => {
-  const anthropic = metadata?.anthropic
-  if (!ProviderShared.isRecord(anthropic)) return undefined
-  return typeof anthropic.redactedData === "string" ? anthropic.redactedData : undefined
-}
-
 const lowerTool = (breakpoints: Cache.Breakpoints, tool: ToolDefinition, inputSchema: JsonSchema): AnthropicTool => ({
   name: tool.name,
   description: tool.description,
@@ -340,7 +283,7 @@ const lowerTool = (breakpoints: Cache.Breakpoints, tool: ToolDefinition, inputSc
 const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
   ProviderShared.matchToolChoice("Anthropic Messages", toolChoice, {
     auto: () => ({ type: "auto" as const }),
-    none: () => ({ type: "none" as const }),
+    none: () => undefined,
     required: () => ({ type: "any" as const }),
     tool: (name) => ({ type: "tool" as const, name }),
   })
@@ -373,23 +316,15 @@ const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult
   const wireType = serverToolResultType(part.name)
   if (!wireType)
     return yield* invalid(`Anthropic Messages does not know how to round-trip server tool result for ${part.name}`)
-  // Prefer the provider-owned replay payload; fall back to the result value for
-  // histories constructed directly from provider events.
-  const payload = part.providerMetadata?.anthropic?.["result"] ?? part.result.value
-  return { type: wireType, tool_use_id: part.id, content: payload } satisfies AnthropicServerToolResultBlock
+  return { type: wireType, tool_use_id: part.id, content: part.result.value } satisfies AnthropicServerToolResultBlock
 })
 
-const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part: MediaPart) {
-  const media = yield* ProviderShared.validateMedia("Anthropic Messages", part, MEDIA_MIMES)
-  if (media.mime === "application/pdf")
-    return {
-      type: "document" as const,
-      source: {
-        type: "base64" as const,
-        media_type: "application/pdf" as const,
-        data: media.base64,
-      },
-    } satisfies AnthropicDocumentBlock
+const lowerImage = Effect.fn("AnthropicMessages.lowerImage")(function* (part: MediaPart) {
+  const media = yield* ProviderShared.validateMedia(
+    "Anthropic Messages",
+    part,
+    new Set<string>(ProviderShared.IMAGE_MIMES),
+  )
   return {
     type: "image" as const,
     source: {
@@ -400,13 +335,25 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part: Me
   } satisfies AnthropicImageBlock
 })
 
-// Tool results may carry structured text, images, and documents. Keep media as provider-native
+// Tool results may carry structured text/images. Keep media as provider-native
 // content instead of JSON-stringifying base64 into a prompt string.
 const lowerToolResultContentItem = Effect.fn("AnthropicMessages.lowerToolResultContentItem")(function* (
   item: ToolContent,
 ) {
   if (item.type === "text") return { type: "text" as const, text: item.text } satisfies AnthropicTextBlock
-  return yield* lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name })
+  const media = yield* ProviderShared.validateToolFile(
+    "Anthropic Messages",
+    item,
+    new Set<string>(ProviderShared.IMAGE_MIMES),
+  )
+  return {
+    type: "image" as const,
+    source: {
+      type: "base64" as const,
+      media_type: media.mime,
+      data: media.base64,
+    },
+  } satisfies AnthropicImageBlock
 })
 
 const lowerToolResultContent = Effect.fn("AnthropicMessages.lowerToolResultContent")(function* (part: ToolResultPart) {
@@ -498,7 +445,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
           continue
         }
         if (part.type === "media") {
-          content.push(yield* lowerMedia(part))
+          content.push(yield* lowerImage(part))
           continue
         }
         return yield* ProviderShared.unsupportedContent("Anthropic Messages", "user", ["text", "media"])
@@ -515,16 +462,11 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
           continue
         }
         if (part.type === "reasoning") {
-          // Mirrors Vercel's @ai-sdk/anthropic: a signature marks visible
-          // thinking; only signature-less parts carrying redactedData
-          // round-trip as opaque redacted_thinking blocks.
-          const signature = part.encrypted ?? signatureFromMetadata(part.providerMetadata)
-          const redactedData = redactedDataFromMetadata(part.providerMetadata)
-          if (signature === undefined && redactedData !== undefined) {
-            content.push({ type: "redacted_thinking", data: redactedData })
-            continue
-          }
-          content.push({ type: "thinking", thinking: part.text, signature })
+          content.push({
+            type: "thinking",
+            thinking: part.text,
+            signature: part.encrypted ?? signatureFromMetadata(part.providerMetadata),
+          })
           continue
         }
         if (part.type === "tool-call") {
@@ -561,39 +503,39 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
   return messages
 })
 
-const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (request: LLMRequest) {
-  const input = request.providerOptions?.anthropic
-  return {
-    thinking: yield* resolveThinking(input?.thinking),
-    effort: typeof input?.effort === "string" ? input.effort : undefined,
-  }
-})
+const anthropicOptions = (request: LLMRequest) => request.providerOptions?.anthropic
 
-const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input: unknown) {
-  if (!ProviderShared.isRecord(input)) return undefined
-  if (input.type === "adaptive") {
+const lowerThinking = Effect.fn("AnthropicMessages.lowerThinking")(function* (request: LLMRequest) {
+  const thinking = anthropicOptions(request)?.thinking
+  if (!ProviderShared.isRecord(thinking)) return undefined
+  if (thinking.type === "adaptive") {
     const display =
-      input.display === "summarized"
+      thinking.display === "summarized"
         ? ("summarized" as const)
-        : input.display === "omitted"
+        : thinking.display === "omitted"
           ? ("omitted" as const)
           : undefined
     return { type: "adaptive" as const, ...(display === undefined ? {} : { display }) }
   }
-  if (input.type === "disabled") return { type: "disabled" as const }
-  if (input.type !== "enabled") return undefined
+  if (thinking.type === "disabled") return { type: "disabled" as const }
+  if (thinking.type !== "enabled") return undefined
   const budget =
-    typeof input.budgetTokens === "number"
-      ? input.budgetTokens
-      : typeof input.budget_tokens === "number"
-        ? input.budget_tokens
+    typeof thinking.budgetTokens === "number"
+      ? thinking.budgetTokens
+      : typeof thinking.budget_tokens === "number"
+        ? thinking.budget_tokens
         : undefined
-  if (budget === undefined)
-    return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens")
+  if (budget === undefined) return yield* invalid("Anthropic thinking provider option requires budgetTokens")
   return { type: "enabled" as const, budget_tokens: budget }
 })
 
+const outputConfig = (request: LLMRequest) => {
+  const effort = anthropicOptions(request)?.effort
+  return typeof effort === "string" ? { effort } : undefined
+}
+
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) {
+  const toolChoice = request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   const outputLimit = request.model.defaults?.limits?.output ?? request.model.route.defaults.limits?.output ?? 4096
@@ -602,7 +544,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
   // over-mark we keep their tool hints and shed the message-tail ones first.
   const breakpoints = Cache.newBreakpoints(ANTHROPIC_BREAKPOINT_CAP)
   const tools =
-    request.tools.length === 0
+    request.tools.length === 0 || request.toolChoice?.type === "none"
       ? undefined
       : request.tools.map((tool) =>
           lowerTool(
@@ -611,8 +553,6 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
             ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
           ),
         )
-  // Anthropic rejects tool_choice when tools are absent; "none" is only meaningful with tools present.
-  const toolChoice = tools === undefined || !request.toolChoice ? undefined : yield* lowerToolChoice(request.toolChoice)
   const system =
     request.system.length === 0
       ? undefined
@@ -627,7 +567,6 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
       `Anthropic Messages: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${ANTHROPIC_BREAKPOINT_CAP} per request.`,
     )
   }
-  const options = yield* resolveOptions(request)
   return {
     model: request.model.id,
     system,
@@ -640,8 +579,8 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     top_p: generation?.topP,
     top_k: generation?.topK,
     stop_sequences: generation?.stop,
-    thinking: options.thinking,
-    output_config: options.effort === undefined ? undefined : { effort: options.effort },
+    thinking: yield* lowerThinking(request),
+    output_config: outputConfig(request),
   }
 })
 
@@ -650,7 +589,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
 // =============================================================================
 const mapFinishReason = (reason: string | null | undefined): FinishReason => {
   if (reason === "end_turn" || reason === "stop_sequence" || reason === "pause_turn") return "stop"
-  if (reason === "max_tokens" || reason === "model_context_window_exceeded") return "length"
+  if (reason === "max_tokens") return "length"
   if (reason === "tool_use") return "tool-calls"
   if (reason === "refusal") return "content-filter"
   return "unknown"
@@ -734,9 +673,7 @@ const serverToolResultEvent = (block: NonNullable<AnthropicEvent["content_block"
     name: SERVER_TOOL_RESULT_NAMES[block.type],
     result: isError ? { type: "error", value: block.content } : { type: "json", value: block.content },
     providerExecuted: true,
-    // The complete payload is irreducible provider replay state: subsequent
-    // stateless requests must round-trip the typed result block verbatim.
-    providerMetadata: anthropicMetadata({ blockType: block.type, result: block.content }),
+    providerMetadata: anthropicMetadata({ blockType: block.type }),
   })
 }
 
@@ -796,25 +733,6 @@ const onContentBlockStart = (state: ParserState, event: AnthropicEvent): StepRes
     ]
   }
 
-  // Redacted thinking surfaces as an empty reasoning part carrying the opaque
-  // payload as `redactedData` metadata (same model as Vercel's
-  // @ai-sdk/anthropic). The existing content_block_stop closes the part.
-  if (block.type === "redacted_thinking" && block.data) {
-    const events: LLMEvent[] = []
-    return [
-      {
-        ...state,
-        lifecycle: Lifecycle.reasoningStart(
-          state.lifecycle,
-          events,
-          `reasoning-${event.index ?? 0}`,
-          anthropicMetadata({ redactedData: block.data }),
-        ),
-      },
-      events,
-    ]
-  }
-
   const result = serverToolResultEvent(block)
   if (!result) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
@@ -904,10 +822,7 @@ const onMessageDelta = (state: ParserState, event: AnthropicEvent): StepResult =
   const usage = mergeUsage(state.usage, mapUsage(event.usage))
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.finish(state.lifecycle, events, {
-    reason: {
-      normalized: mapFinishReason(event.delta?.stop_reason),
-      raw: event.delta?.stop_reason ?? undefined,
-    },
+    reason: mapFinishReason(event.delta?.stop_reason),
     usage,
     providerMetadata: event.delta?.stop_sequence
       ? anthropicMetadata({ stopSequence: event.delta.stop_sequence })

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

@@ -8,7 +8,6 @@ import {
   Usage,
   type CacheHint,
   type FinishReason,
-  type FinishReasonDetails,
   type JsonSchema,
   type LLMRequest,
   type ModelToolSchemaCompatibility,
@@ -53,7 +52,6 @@ const BedrockToolResultContentItem = Schema.Union([
   Schema.Struct({ text: Schema.String }),
   Schema.Struct({ json: Schema.Unknown }),
   BedrockMedia.ImageBlock,
-  BedrockMedia.DocumentBlock,
 ])
 
 const BedrockToolResultBlock = Schema.Struct({
@@ -66,15 +64,14 @@ const BedrockToolResultBlock = Schema.Struct({
 type BedrockToolResultBlock = Schema.Schema.Type<typeof BedrockToolResultBlock>
 
 const BedrockReasoningBlock = Schema.Struct({
-  reasoningContent: Schema.Union([
-    Schema.Struct({
-      reasoningText: Schema.Struct({
+  reasoningContent: Schema.Struct({
+    reasoningText: Schema.optional(
+      Schema.Struct({
         text: Schema.String,
         signature: Schema.optional(Schema.String),
       }),
-    }),
-    Schema.Struct({ redactedContent: Schema.String }),
-  ]),
+    ),
+  }),
 })
 
 const BedrockUserBlock = Schema.Union([
@@ -155,12 +152,6 @@ const BedrockUsageSchema = Schema.Struct({
 })
 type BedrockUsageSchema = Schema.Schema.Type<typeof BedrockUsageSchema>
 
-const BedrockStreamException = Schema.Struct({
-  message: Schema.optional(Schema.String),
-  originalMessage: Schema.optional(Schema.String),
-  originalStatusCode: Schema.optional(Schema.Number),
-})
-
 // Streaming event shape — the AWS event stream wraps each JSON payload by its
 // `:event-type` header (e.g. `messageStart`, `contentBlockDelta`). We
 // reconstruct that wrapping in `decodeFrames` below so the event schema can
@@ -188,11 +179,6 @@ const BedrockEvent = Schema.Struct({
             Schema.Struct({
               text: Schema.optional(Schema.String),
               signature: Schema.optional(Schema.String),
-              // Blob fields in Bedrock's JSON event stream are base64 strings.
-              redactedContent: Schema.optional(Schema.String),
-              // Vercel's Bedrock provider exposes the same delta under
-              // Anthropic's shorter `data` spelling.
-              data: Schema.optional(Schema.String),
             }),
           ),
         }),
@@ -212,11 +198,11 @@ const BedrockEvent = Schema.Struct({
       metrics: Schema.optional(Schema.Unknown),
     }),
   ),
-  internalServerException: Schema.optional(BedrockStreamException),
-  modelStreamErrorException: Schema.optional(BedrockStreamException),
-  validationException: Schema.optional(BedrockStreamException),
-  throttlingException: Schema.optional(BedrockStreamException),
-  serviceUnavailableException: Schema.optional(BedrockStreamException),
+  internalServerException: Schema.optional(Schema.Struct({ message: Schema.String })),
+  modelStreamErrorException: Schema.optional(Schema.Struct({ message: Schema.String })),
+  validationException: Schema.optional(Schema.Struct({ message: Schema.String })),
+  throttlingException: Schema.optional(Schema.Struct({ message: Schema.String })),
+  serviceUnavailableException: Schema.optional(Schema.Struct({ message: Schema.String })),
 })
 type BedrockEvent = Schema.Schema.Type<typeof BedrockEvent>
 
@@ -272,13 +258,6 @@ const reasoningSignature = (part: ReasoningPart) => {
   )
 }
 
-const reasoningRedactedData = (part: ReasoningPart) => {
-  const bedrock = part.providerMetadata?.bedrock
-  return ProviderShared.isRecord(bedrock) && typeof bedrock.redactedData === "string"
-    ? bedrock.redactedData
-    : undefined
-}
-
 const lowerToolCall = (part: ToolCallPart): BedrockToolUseBlock => ({
   toolUse: {
     toolUseId: part.id,
@@ -304,6 +283,8 @@ const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent
       data: item.uri,
       filename: item.name,
     })
+    if (!("image" in media))
+      return yield* ProviderShared.invalidRequest("Bedrock Converse only supports image media in tool results")
     content.push(media)
   }
   return content
@@ -368,13 +349,11 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
           continue
         }
         if (part.type === "reasoning") {
-          const signature = reasoningSignature(part)
-          const redactedData = reasoningRedactedData(part)
-          if (signature === undefined && redactedData !== undefined) {
-            content.push({ reasoningContent: { redactedContent: redactedData } })
-            continue
-          }
-          content.push({ reasoningContent: { reasoningText: { text: part.text, signature } } })
+          content.push({
+            reasoningContent: {
+              reasoningText: { text: part.text, signature: reasoningSignature(part) },
+            },
+          })
           continue
         }
         if (part.type === "tool-call") {
@@ -414,13 +393,8 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request:
   // tools → system → messages order to favour the highest-impact prefixes.
   const breakpoints = BedrockCache.breakpoints()
   const toolConfig =
-    request.tools.length > 0
-      ? {
-          tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, request.tools),
-          // Converse has no native "none". Keep definitions stable for prompt
-          // caching and omit only the unsupported choice.
-          toolChoice,
-        }
+    request.tools.length > 0 && request.toolChoice?.type !== "none"
+      ? { tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, request.tools), toolChoice }
       : undefined
   const system = request.system.length === 0 ? undefined : lowerSystem(breakpoints, request.system)
   const messages = yield* lowerMessages(request, breakpoints)
@@ -457,29 +431,27 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request:
 // =============================================================================
 const mapFinishReason = (reason: string): FinishReason => {
   if (reason === "end_turn" || reason === "stop_sequence") return "stop"
-  if (reason === "max_tokens" || reason === "model_context_window_exceeded") return "length"
+  if (reason === "max_tokens") return "length"
   if (reason === "tool_use") return "tool-calls"
   if (reason === "content_filtered" || reason === "guardrail_intervened") return "content-filter"
-  if (reason === "malformed_model_output" || reason === "malformed_tool_use") return "error"
   return "unknown"
 }
 
-// AWS reports inputTokens separately from cache reads and writes.
-// Bedrock does not break reasoning out of outputTokens for current models.
+// AWS Bedrock Converse reports `inputTokens` (inclusive total) with
+// `cacheReadInputTokens` and `cacheWriteInputTokens` as subsets. Pass
+// the total through and derive the non-cached breakdown. Bedrock does
+// not break reasoning out of `outputTokens` for any current model.
 const mapUsage = (usage: BedrockUsageSchema | undefined): Usage | undefined => {
   if (!usage) return undefined
-  const inputTokens = ProviderShared.sumTokens(
-    usage.inputTokens,
-    usage.cacheReadInputTokens,
-    usage.cacheWriteInputTokens,
-  )
+  const cacheTotal = (usage.cacheReadInputTokens ?? 0) + (usage.cacheWriteInputTokens ?? 0)
+  const nonCached = ProviderShared.subtractTokens(usage.inputTokens, cacheTotal)
   return new Usage({
-    inputTokens,
+    inputTokens: usage.inputTokens,
     outputTokens: usage.outputTokens,
-    nonCachedInputTokens: usage.inputTokens,
+    nonCachedInputTokens: nonCached,
     cacheReadInputTokens: usage.cacheReadInputTokens,
     cacheWriteInputTokens: usage.cacheWriteInputTokens,
-    totalTokens: ProviderShared.totalTokens(inputTokens, usage.outputTokens, usage.totalTokens),
+    totalTokens: ProviderShared.totalTokens(usage.inputTokens, usage.outputTokens, usage.totalTokens),
     providerMetadata: { bedrock: usage },
   })
 }
@@ -489,7 +461,7 @@ interface ParserState {
   // Bedrock splits the finish into `messageStop` (carries `stopReason`) and
   // `metadata` (carries usage). Hold the terminal event in state so `onHalt`
   // can emit exactly one finish after both chunks have had a chance to arrive.
-  readonly pendingFinish: { readonly reason: FinishReasonDetails; readonly usage?: Usage } | undefined
+  readonly pendingFinish: { readonly reason: FinishReason; readonly usage?: Usage } | undefined
   readonly hasToolCalls: boolean
   readonly lifecycle: Lifecycle.State
   readonly reasoningSignatures: Readonly<Record<number, string>>
@@ -540,26 +512,12 @@ const step = (state: ParserState, event: BedrockEvent) =>
       const index = event.contentBlockDelta.contentBlockIndex
       const reasoning = event.contentBlockDelta.delta.reasoningContent
       const events: LLMEvent[] = []
-      const redactedData = reasoning.redactedContent ?? reasoning.data
-      const providerMetadata = reasoning.signature
-        ? bedrockMetadata({ signature: reasoning.signature })
-        : redactedData !== undefined
-          ? bedrockMetadata({ redactedData })
-          : undefined
-      const lifecycle =
-        reasoning.text !== undefined || providerMetadata !== undefined
-          ? Lifecycle.reasoningDelta(
-              state.lifecycle,
-              events,
-              `reasoning-${index}`,
-              reasoning.text ?? "",
-              providerMetadata,
-            )
-          : state.lifecycle
       return [
         {
           ...state,
-          lifecycle,
+          lifecycle: reasoning.text
+            ? Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text)
+            : state.lifecycle,
           reasoningSignatures: reasoning.signature
             ? { ...state.reasoningSignatures, [index]: reasoning.signature }
             : state.reasoningSignatures,
@@ -620,30 +578,15 @@ const step = (state: ParserState, event: BedrockEvent) =>
       return [
         {
           ...state,
-          pendingFinish: {
-            reason: {
-              normalized: mapFinishReason(event.messageStop.stopReason),
-              raw: event.messageStop.stopReason,
-            },
-            usage: state.pendingFinish?.usage,
-          },
+          pendingFinish: { reason: mapFinishReason(event.messageStop.stopReason), usage: state.pendingFinish?.usage },
         },
         [],
       ] as const
     }
 
     if (event.metadata) {
-      const usage = mapUsage(event.metadata.usage) ?? state.pendingFinish?.usage
-      return [
-        {
-          ...state,
-          pendingFinish: {
-            reason: state.pendingFinish?.reason ?? { normalized: "stop" },
-            usage,
-          },
-        },
-        [],
-      ] as const
+      const usage = mapUsage(event.metadata.usage)
+      return [{ ...state, pendingFinish: { reason: state.pendingFinish?.reason ?? "stop", usage } }, []] as const
     }
 
     const exception = (
@@ -660,7 +603,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
         module: ADAPTER,
         method: "stream",
         reason: classifyProviderFailure({
-          message: exception[1]?.message ?? exception[1]?.originalMessage ?? "Bedrock Converse stream error",
+          message: exception[1]?.message ?? "Bedrock Converse stream error",
           code: exception[0],
         }),
       })
@@ -676,13 +619,8 @@ const onHalt = (state: ParserState): ReadonlyArray<LLMEvent> =>
     ? (() => {
         const events: LLMEvent[] = []
         Lifecycle.finish(state.lifecycle, events, {
-          reason: {
-            ...state.pendingFinish.reason,
-            normalized:
-              state.pendingFinish.reason.normalized === "stop" && state.hasToolCalls
-                ? "tool-calls"
-                : state.pendingFinish.reason.normalized,
-          },
+          reason:
+            state.pendingFinish.reason === "stop" && state.hasToolCalls ? "tool-calls" : state.pendingFinish.reason,
           usage: state.pendingFinish.usage,
         })
         return events

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

@@ -53,22 +53,8 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
       })
       cursor = { buffer: cursor.buffer, offset: cursor.offset + totalLength }
 
-      const messageType = decoded.headers[":message-type"]?.value
-      if (messageType === "error") {
-        const code = decoded.headers[":error-code"]?.value
-        const message = decoded.headers[":error-message"]?.value
-        return yield* ProviderShared.eventError(
-          route,
-          [code, message].filter((value): value is string => typeof value === "string").join(": ") ||
-            "Bedrock Converse event-stream error",
-        )
-      }
-      const eventType =
-        messageType === "event"
-          ? decoded.headers[":event-type"]?.value
-          : messageType === "exception"
-            ? decoded.headers[":exception-type"]?.value
-            : undefined
+      if (decoded.headers[":message-type"]?.value !== "event") continue
+      const eventType = decoded.headers[":event-type"]?.value
       if (typeof eventType !== "string") continue
       const payload = utf8.decode(decoded.body)
       if (!payload) continue

packages/ai/src/protocols/gemini.ts

@@ -11,7 +11,6 @@ import {
   type JsonSchema,
   type LLMRequest,
   type MediaPart,
-  type ProviderOptions,
   type ProviderMetadata,
   type TextPart,
   type ToolCallPart,
@@ -27,18 +26,6 @@ const ADAPTER = "gemini"
 const MEDIA_MIMES = new Set<string>(ProviderShared.MEDIA_MIMES)
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
 
-export interface OptionsInput {
-  readonly [key: string]: unknown
-  readonly thinkingConfig?: {
-    readonly thinkingBudget?: number
-    readonly includeThoughts?: boolean
-  }
-}
-
-export type ProviderOptionsInput = ProviderOptions & {
-  readonly gemini?: OptionsInput
-}
-
 // =============================================================================
 // Request Body Schema
 // =============================================================================
@@ -54,11 +41,9 @@ const GeminiInlineDataPart = Schema.Struct({
     data: Schema.String,
   }),
 })
-type GeminiInlineDataPart = Schema.Schema.Type<typeof GeminiInlineDataPart>
 
 const GeminiFunctionCallPart = Schema.Struct({
   functionCall: Schema.Struct({
-    id: Schema.optional(Schema.String),
     name: Schema.String,
     args: Schema.Unknown,
   }),
@@ -67,10 +52,8 @@ const GeminiFunctionCallPart = Schema.Struct({
 
 const GeminiFunctionResponsePart = Schema.Struct({
   functionResponse: Schema.Struct({
-    id: Schema.optional(Schema.String),
     name: Schema.String,
     response: Schema.Unknown,
-    parts: Schema.optional(Schema.Array(GeminiInlineDataPart)),
   }),
 })
 
@@ -214,15 +197,8 @@ const thoughtSignature = (providerMetadata: ProviderMetadata | undefined) => {
     : undefined
 }
 
-const functionCallId = (providerMetadata: ProviderMetadata | undefined) => {
-  const google = providerMetadata?.google
-  return ProviderShared.isRecord(google) && typeof google.functionCallId === "string"
-    ? google.functionCallId
-    : undefined
-}
-
 const lowerToolCall = (part: ToolCallPart) => ({
-  functionCall: { id: functionCallId(part.providerMetadata), name: part.name, args: part.input },
+  functionCall: { name: part.name, args: part.input },
   thoughtSignature: thoughtSignature(part.providerMetadata),
 })
 
@@ -279,7 +255,6 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
       if (part.result.type !== "content") {
         parts.push({
           functionResponse: {
-            id: functionCallId(part.providerMetadata),
             name: part.name,
             response: {
               name: part.name,
@@ -291,23 +266,20 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
       }
       const content: ReadonlyArray<ToolContent> = part.result.value
       const text = content.filter((item) => item.type === "text").map((item) => item.text)
-      const media: GeminiInlineDataPart[] = []
-      for (const item of content) {
-        if (item.type === "text") continue
-        const value = yield* ProviderShared.validateToolFile("Gemini", item, MEDIA_MIMES)
-        media.push({ inlineData: { mimeType: value.mime, data: value.base64 } })
-      }
       parts.push({
         functionResponse: {
-          id: functionCallId(part.providerMetadata),
           name: part.name,
           response: {
             name: part.name,
             content: text.join("\n"),
           },
-          parts: media.length > 0 ? media : undefined,
         },
       })
+      for (const item of content) {
+        if (item.type === "text") continue
+        const media = yield* ProviderShared.validateToolFile("Gemini", item, MEDIA_MIMES)
+        parts.push({ inlineData: { mimeType: media.mime, data: media.base64 } })
+      }
     }
     contents.push({ role: "user", parts })
   }
@@ -315,22 +287,21 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
   return contents
 })
 
-const resolveOptions = (request: LLMRequest) => {
-  const value = request.providerOptions?.gemini?.thinkingConfig
-  if (!ProviderShared.isRecord(value)) return {}
-  const thinkingConfig = {
+const geminiOptions = (request: LLMRequest) => request.providerOptions?.gemini
+
+const thinkingConfig = (request: LLMRequest) => {
+  const value = geminiOptions(request)?.thinkingConfig
+  if (!ProviderShared.isRecord(value)) return undefined
+  const result = {
     thinkingBudget: typeof value.thinkingBudget === "number" ? value.thinkingBudget : undefined,
     includeThoughts: typeof value.includeThoughts === "boolean" ? value.includeThoughts : undefined,
   }
-  return {
-    thinkingConfig: Object.values(thinkingConfig).some((item) => item !== undefined) ? thinkingConfig : undefined,
-  }
+  return Object.values(result).some((item) => item !== undefined) ? result : undefined
 }
 
 const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMRequest) {
-  const hasTools = request.tools.length > 0
+  const toolsEnabled = request.tools.length > 0 && request.toolChoice?.type !== "none"
   const generation = request.generation
-  const options = resolveOptions(request)
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   const generationConfig = {
     maxOutputTokens: generation?.maxTokens,
@@ -338,14 +309,14 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
     topP: generation?.topP,
     topK: generation?.topK,
     stopSequences: generation?.stop,
-    thinkingConfig: options.thinkingConfig,
+    thinkingConfig: thinkingConfig(request),
   }
 
   return {
     contents: yield* lowerMessages(request),
     systemInstruction:
       request.system.length === 0 ? undefined : { parts: [{ text: ProviderShared.joinText(request.system) }] },
-    tools: hasTools
+    tools: toolsEnabled
       ? [
           {
             functionDeclarations: request.tools.map((tool) =>
@@ -354,7 +325,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
           },
         ]
       : undefined,
-    toolConfig: hasTools && request.toolChoice ? yield* lowerToolConfig(request.toolChoice) : undefined,
+    toolConfig: toolsEnabled && request.toolChoice ? yield* lowerToolConfig(request.toolChoice) : undefined,
     generationConfig: Object.values(generationConfig).some((value) => value !== undefined)
       ? generationConfig
       : undefined,
@@ -398,22 +369,10 @@ const mapFinishReason = (finishReason: string | undefined, hasToolCalls: boolean
     finishReason === "SAFETY" ||
     finishReason === "BLOCKLIST" ||
     finishReason === "PROHIBITED_CONTENT" ||
-    finishReason === "SPII" ||
-    finishReason === "MODEL_ARMOR" ||
-    finishReason === "IMAGE_PROHIBITED_CONTENT" ||
-    finishReason === "IMAGE_RECITATION" ||
-    finishReason === "LANGUAGE"
+    finishReason === "SPII"
   )
     return "content-filter"
-  if (
-    finishReason === "MALFORMED_FUNCTION_CALL" ||
-    finishReason === "UNEXPECTED_TOOL_CALL" ||
-    finishReason === "NO_IMAGE" ||
-    finishReason === "TOO_MANY_TOOL_CALLS" ||
-    finishReason === "MISSING_THOUGHT_SIGNATURE" ||
-    finishReason === "MALFORMED_RESPONSE"
-  )
-    return "error"
+  if (finishReason === "MALFORMED_FUNCTION_CALL") return "error"
   return "unknown"
 }
 
@@ -430,10 +389,7 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> =>
             )
           : state.lifecycle
         Lifecycle.finish(lifecycle, events, {
-          reason: {
-            normalized: mapFinishReason(state.finishReason, state.hasToolCalls),
-            raw: state.finishReason,
-          },
+          reason: mapFinishReason(state.finishReason, state.hasToolCalls),
           usage: state.usage,
         })
         return events
@@ -485,10 +441,6 @@ const step = (state: ParserState, event: GeminiEvent) => {
     if ("functionCall" in part) {
       const input = part.functionCall.args
       const id = `tool_${nextToolCallId++}`
-      const metadata = {
-        ...(part.functionCall.id === undefined ? {} : { functionCallId: part.functionCall.id }),
-        ...(part.thoughtSignature === undefined ? {} : { thoughtSignature: part.thoughtSignature }),
-      }
       lifecycle = Lifecycle.reasoningEnd(
         lifecycle,
         events,
@@ -501,7 +453,9 @@ const step = (state: ParserState, event: GeminiEvent) => {
           id,
           name: part.functionCall.name,
           input,
-          providerMetadata: Object.keys(metadata).length > 0 ? googleMetadata(metadata) : undefined,
+          providerMetadata: part.thoughtSignature
+            ? googleMetadata({ thoughtSignature: part.thoughtSignature })
+            : undefined,
         }),
       )
       hasToolCalls = true

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

@@ -1,314 +0,0 @@
-import { Effect, Encoding, Schema } from "effect"
-import { Headers, HttpClientRequest } from "effect/unstable/http"
-import {
-  GeneratedImage,
-  ImageModel,
-  ImageResponse,
-  type ImageInput,
-  type ImageRequestFor,
-  type ImageRoute,
-} from "../image"
-import { Auth, type Definition as AuthDefinition } from "../route/auth"
-import {
-  InvalidProviderOutputReason,
-  LLMError,
-  Usage,
-  mergeHttpOptions,
-  mergeJsonRecords,
-  type HttpOptions,
-  type ProviderMetadata,
-} from "../schema"
-import { ProviderShared } from "./shared"
-import { ImageInputs } from "./utils/image-input"
-
-const ADAPTER = "google-images"
-export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
-
-export type GoogleImageString<Known extends string> = Known | (string & {})
-
-export type GoogleImageOptions = {
-  readonly aspectRatio?: GoogleImageString<
-    "1:1" | "2:3" | "3:2" | "3:4" | "4:3" | "4:5" | "5:4" | "9:16" | "16:9" | "21:9"
-  >
-  readonly imageSize?: GoogleImageString<"1K" | "2K" | "4K">
-  readonly seed?: number
-  readonly thinkingLevel?: GoogleImageString<"MINIMAL" | "LOW" | "MEDIUM" | "HIGH">
-  readonly includeThoughts?: boolean
-} & Record<string, unknown>
-
-export type GoogleImageBody = Record<string, unknown> & {
-  readonly contents: ReadonlyArray<{
-    readonly role: "user"
-    readonly parts: ReadonlyArray<Record<string, unknown>>
-  }>
-  readonly generationConfig: Record<string, unknown>
-}
-
-const GoogleUsage = Schema.StructWithRest(
-  Schema.Struct({
-    cachedContentTokenCount: Schema.optional(Schema.Number),
-    thoughtsTokenCount: Schema.optional(Schema.Number),
-    promptTokenCount: Schema.optional(Schema.Number),
-    candidatesTokenCount: Schema.optional(Schema.Number),
-    totalTokenCount: Schema.optional(Schema.Number),
-    promptTokensDetails: Schema.optional(Schema.Unknown),
-    candidatesTokensDetails: Schema.optional(Schema.Unknown),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
-
-const GoogleImageResponse = Schema.Struct({
-  candidates: Schema.optional(
-    Schema.Array(
-      Schema.Struct({
-        index: Schema.optional(Schema.Number),
-        content: Schema.optional(
-          Schema.Struct({
-            parts: Schema.Array(
-              Schema.Struct({
-                text: Schema.optional(Schema.String),
-                thought: Schema.optional(Schema.Boolean),
-                thoughtSignature: Schema.optional(Schema.String),
-                inlineData: Schema.optional(
-                  Schema.Struct({
-                    mimeType: Schema.String,
-                    data: Schema.String,
-                  }),
-                ),
-              }),
-            ),
-          }),
-        ),
-        finishReason: Schema.optional(Schema.String),
-        finishMessage: Schema.optional(Schema.String),
-        safetyRatings: Schema.optional(Schema.Unknown),
-        citationMetadata: Schema.optional(Schema.Unknown),
-        groundingMetadata: Schema.optional(Schema.Unknown),
-      }),
-    ),
-  ),
-  usageMetadata: Schema.optional(GoogleUsage),
-  modelVersion: Schema.optional(Schema.String),
-  responseId: Schema.optional(Schema.String),
-  promptFeedback: Schema.optional(Schema.Unknown),
-})
-
-export interface ModelInput {
-  readonly id: string
-  readonly auth: AuthDefinition
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions
-}
-
-const nativeOptions = (options: GoogleImageOptions | undefined) => {
-  const { aspectRatio, imageSize, seed, thinkingLevel, includeThoughts, ...native } = options ?? {}
-  const image = {
-    aspectRatio,
-    imageSize,
-  }
-  const thinkingConfig = {
-    thinkingLevel,
-    includeThoughts,
-  }
-  return (
-    mergeJsonRecords(
-      {
-        responseModalities: ["IMAGE"],
-        imageConfig: Object.values(image).some((value) => value !== undefined) ? image : undefined,
-        seed,
-        thinkingConfig: Object.values(thinkingConfig).some((value) => value !== undefined) ? thinkingConfig : undefined,
-      },
-      native,
-    ) ?? { responseModalities: ["IMAGE"] }
-  )
-}
-
-const invalidOutput = (message: string, providerMetadata?: ProviderMetadata) =>
-  new LLMError({
-    module: ADAPTER,
-    method: "generate",
-    reason: new InvalidProviderOutputReason({ message, route: ADAPTER, providerMetadata }),
-  })
-
-const applyQuery = (url: string, query: Record<string, string> | undefined) => {
-  if (!query) return url
-  const next = new URL(url)
-  Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value))
-  return next.toString()
-}
-
-export const model = (input: ModelInput) => {
-  const route: ImageRoute<GoogleImageOptions> = {
-    id: ADAPTER,
-    generate: Effect.fn("GoogleImages.generate")(function* (request: ImageRequestFor<GoogleImageOptions>, execute) {
-      const imageParts = yield* Effect.forEach(request.images ?? [], googleImagePart)
-      const http = mergeHttpOptions(request.model.http, request.http)
-      const requestBody = mergeJsonRecords(
-        {
-          contents: [{ role: "user", parts: [{ text: request.prompt }, ...imageParts] }],
-          generationConfig: nativeOptions(request.options),
-        },
-        http?.body,
-      ) as GoogleImageBody
-      const text = ProviderShared.encodeJson(requestBody)
-      const url = applyQuery(
-        `${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}/models/${request.model.id}:generateContent`,
-        http?.query,
-      )
-      const headers = yield* Auth.toEffect(input.auth)({
-        request,
-        method: "POST",
-        url,
-        body: text,
-        headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-      })
-      const response = yield* execute(
-        HttpClientRequest.post(url).pipe(
-          HttpClientRequest.setHeaders(headers),
-          HttpClientRequest.bodyText(text, "application/json"),
-        ),
-      )
-      const payload = yield* response.json.pipe(
-        Effect.mapError(() => invalidOutput("Failed to read the Google Images response")),
-      )
-      const decoded = yield* Schema.decodeUnknownEffect(GoogleImageResponse)(payload).pipe(
-        Effect.mapError(() => invalidOutput("Google Images returned an invalid response")),
-      )
-      const candidates = decoded.candidates ?? []
-      const candidateMetadata = candidates.map((candidate, candidateIndex) => ({
-        index: candidate.index ?? candidateIndex,
-        finishReason: candidate.finishReason,
-        finishMessage: candidate.finishMessage,
-        safetyRatings: candidate.safetyRatings,
-        citationMetadata: candidate.citationMetadata,
-        groundingMetadata: candidate.groundingMetadata,
-        parts: (candidate.content?.parts ?? []).map((part) =>
-          part.inlineData === undefined
-            ? {
-                type: "text",
-                text: part.text,
-                thought: part.thought,
-                thoughtSignature: part.thoughtSignature,
-              }
-            : {
-                type: "inlineData",
-                mediaType: part.inlineData.mimeType,
-                thought: part.thought,
-                thoughtSignature: part.thoughtSignature,
-              },
-        ),
-      }))
-      const encoded = candidates.flatMap((candidate, candidateIndex) =>
-        (candidate.content?.parts ?? []).flatMap((part, partIndex) =>
-          part.inlineData === undefined || part.thought === true
-            ? []
-            : [{ candidate, candidateIndex, partIndex, inlineData: part.inlineData }],
-        ),
-      )
-      const images = yield* Effect.forEach(encoded, (item) =>
-        Effect.fromResult(Encoding.decodeBase64(item.inlineData.data)).pipe(
-          Effect.mapError(() =>
-            invalidOutput(
-              `Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`,
-            ),
-          ),
-          Effect.map(
-            (data) =>
-              new GeneratedImage({
-                mediaType: item.inlineData.mimeType,
-                data,
-                providerMetadata: {
-                  google: {
-                    candidateIndex: item.candidate.index ?? item.candidateIndex,
-                    partIndex: item.partIndex,
-                    finishReason: item.candidate.finishReason,
-                    safetyRatings: item.candidate.safetyRatings,
-                    citationMetadata: item.candidate.citationMetadata,
-                    groundingMetadata: item.candidate.groundingMetadata,
-                    thoughtSignature: item.candidate.content?.parts[item.partIndex]?.thoughtSignature,
-                  },
-                },
-              }),
-          ),
-        ),
-      )
-      if (images.length === 0) {
-        const finishReasons = candidates.flatMap((candidate) =>
-          candidate.finishReason === undefined ? [] : [candidate.finishReason],
-        )
-        return yield* invalidOutput(
-          `Google Images returned no final images${
-            finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`
-          }; inspect reason.providerMetadata.google for prompt feedback and candidate details`,
-          {
-            google: {
-              promptFeedback: decoded.promptFeedback,
-              candidates: candidateMetadata,
-            },
-          },
-        )
-      }
-      const usage = decoded.usageMetadata
-      const outputTokens =
-        usage?.candidatesTokenCount === undefined
-          ? undefined
-          : usage.candidatesTokenCount + (usage.thoughtsTokenCount ?? 0)
-      return new ImageResponse({
-        images,
-        usage:
-          usage === undefined
-            ? undefined
-            : new Usage({
-                inputTokens: usage.promptTokenCount,
-                outputTokens,
-                nonCachedInputTokens: ProviderShared.subtractTokens(
-                  usage.promptTokenCount,
-                  usage.cachedContentTokenCount,
-                ),
-                cacheReadInputTokens: usage.cachedContentTokenCount,
-                reasoningTokens: usage.thoughtsTokenCount,
-                totalTokens: ProviderShared.totalTokens(usage.promptTokenCount, outputTokens, usage.totalTokenCount),
-                providerMetadata: { google: usage },
-              }),
-        providerMetadata: {
-          google: {
-            modelVersion: decoded.modelVersion,
-            responseId: decoded.responseId,
-            promptFeedback: decoded.promptFeedback,
-            candidates: candidateMetadata,
-          },
-        },
-      })
-    }),
-  }
-  return ImageModel.make<GoogleImageOptions>({ id: input.id, provider: "google", route, http: input.http })
-}
-
-const googleImagePart = (image: ImageInput): Effect.Effect<Record<string, unknown>, LLMError> => {
-  if (image.type === "bytes")
-    return Effect.succeed({ inlineData: { mimeType: image.mediaType, data: Encoding.encodeBase64(image.data) } })
-  if (image.type === "file-uri") return Effect.succeed({ fileData: { mimeType: image.mediaType, fileUri: image.uri } })
-  if (image.type === "url")
-    return ImageInputs.decodeDataUrl(image.url, ADAPTER).pipe(
-      Effect.flatMap((decoded) => {
-        if (decoded === undefined)
-          return Effect.fail(
-            ImageInputs.invalid(
-              ADAPTER,
-              "Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file URI",
-            ),
-          )
-        return Effect.succeed({
-          inlineData: { mimeType: decoded.mediaType, data: Encoding.encodeBase64(decoded.data) },
-        })
-      }),
-    )
-  return Effect.fail(
-    ImageInputs.invalid(ADAPTER, "Google generateContent requires Gemini file URIs rather than provider file IDs"),
-  )
-}
-
-export const GoogleImages = {
-  model,
-} as const

packages/ai/src/protocols/index.ts

@@ -6,4 +6,3 @@ export * as OpenAIImages from "./openai-images"
 export * as OpenAICompatibleChat from "./openai-compatible-chat"
 export * as OpenAICompatibleResponses from "./openai-compatible-responses"
 export * as OpenAIResponses from "./openai-responses"
-export * as OpenResponses from "./open-responses"

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

@@ -1,949 +0,0 @@
-import { Effect, Schema } from "effect"
-import { HttpTransport } from "../route/transport"
-import { Protocol } from "../route/protocol"
-import {
-  LLMError,
-  LLMEvent,
-  Usage,
-  type FinishReason,
-  type JsonSchema,
-  type LLMRequest,
-  type MediaPart,
-  type ProviderMetadata,
-  type ReasoningPart,
-  type TextPart,
-  type ToolCallPart,
-  type ToolDefinition,
-  type ToolContent,
-  type ToolResultPart,
-} from "../schema"
-import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared"
-import { classifyProviderFailure } from "../provider-error"
-import { OpenResponsesOptions } from "./utils/open-responses-options"
-import { Lifecycle } from "./utils/lifecycle"
-import { ToolSchemaProjection } from "./utils/tool-schema"
-import { ToolStream } from "./utils/tool-stream"
-
-const ADAPTER = "open-responses"
-const NAME = "Open Responses"
-const MEDIA_MIMES = new Set<string>([...ProviderShared.IMAGE_MIMES, ...ProviderShared.PDF_MIMES])
-export const PATH = "/responses"
-
-// =============================================================================
-// Request Body Schema
-// =============================================================================
-const OpenResponsesInputText = Schema.Struct({
-  type: Schema.tag("input_text"),
-  text: Schema.String,
-})
-const OpenResponsesInputImage = Schema.Struct({
-  type: Schema.tag("input_image"),
-  image_url: Schema.String,
-})
-const OpenResponsesInputFile = Schema.Struct({
-  type: Schema.tag("input_file"),
-  filename: Schema.String,
-  file_data: Schema.String,
-  mime_type: Schema.optional(Schema.String),
-})
-const MediaInput = Schema.Union([OpenResponsesInputImage, OpenResponsesInputFile])
-export type MediaInput = Schema.Schema.Type<typeof MediaInput>
-const OpenResponsesInputContent = Schema.Union([OpenResponsesInputText, MediaInput])
-
-const OpenResponsesOutputText = Schema.Struct({
-  type: Schema.tag("output_text"),
-  text: Schema.String,
-})
-
-const OpenResponsesReasoningSummaryText = Schema.Struct({
-  type: Schema.tag("summary_text"),
-  text: Schema.String,
-})
-
-const OpenResponsesReasoningItem = Schema.Struct({
-  type: Schema.tag("reasoning"),
-  id: Schema.optionalKey(Schema.String),
-  summary: Schema.Array(OpenResponsesReasoningSummaryText),
-  encrypted_content: optionalNull(Schema.String),
-})
-
-const OpenResponsesItemReference = Schema.Struct({
-  type: Schema.tag("item_reference"),
-  id: Schema.String,
-})
-
-// `function_call_output.output` accepts either a plain string or an ordered
-// array of content items so tools can return images and files in addition to text.
-// https://www.openresponses.org/reference
-const OpenResponsesFunctionCallOutputContent = Schema.Union([
-  OpenResponsesInputText,
-  OpenResponsesInputImage,
-  OpenResponsesInputFile,
-])
-
-const OpenResponsesFunctionCallOutput = Schema.Union([
-  Schema.String,
-  Schema.Array(OpenResponsesFunctionCallOutputContent),
-])
-
-const OpenResponsesInputItem = Schema.Union([
-  Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
-  Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenResponsesInputContent) }),
-  Schema.Struct({ role: Schema.tag("assistant"), content: Schema.Array(OpenResponsesOutputText) }),
-  OpenResponsesReasoningItem,
-  OpenResponsesItemReference,
-  Schema.Struct({
-    type: Schema.tag("function_call"),
-    call_id: Schema.String,
-    name: Schema.String,
-    arguments: Schema.String,
-  }),
-  Schema.Struct({
-    type: Schema.tag("function_call_output"),
-    call_id: Schema.String,
-    output: OpenResponsesFunctionCallOutput,
-  }),
-])
-type OpenResponsesInputItem = Schema.Schema.Type<typeof OpenResponsesInputItem>
-
-// Mutable counterpart of the schema reasoning item so `lowerMessages` can fold
-// multiple streamed summary parts into the same item before flushing.
-type OpenResponsesReasoningInput = {
-  type: "reasoning"
-  id: string
-  summary: Array<{ type: "summary_text"; text: string }>
-  encrypted_content?: string | null
-}
-type OpenResponsesReasoningReplay = Omit<OpenResponsesReasoningInput, "id">
-
-export const Tool = Schema.Struct({
-  type: Schema.tag("function"),
-  name: Schema.String,
-  description: Schema.String,
-  parameters: JsonObject,
-  strict: Schema.optional(Schema.Boolean),
-})
-
-export const ToolChoice = Schema.Union([
-  Schema.Literals(["auto", "none", "required"]),
-  Schema.Struct({ type: Schema.tag("function"), name: Schema.String }),
-])
-
-// Fields shared between the HTTP body and the WebSocket `response.create`
-// message. The HTTP body adds `stream: true`; the WebSocket message adds
-// `type: "response.create"`. Defining the shared shape once keeps the two
-// transports in sync without a destructure-and-strip dance.
-export const coreFields = {
-  model: Schema.String,
-  input: Schema.Array(OpenResponsesInputItem),
-  instructions: Schema.optional(Schema.String),
-  tools: optionalArray(Tool),
-  tool_choice: Schema.optional(ToolChoice),
-  store: Schema.optional(Schema.Boolean),
-  service_tier: Schema.optional(OpenResponsesOptions.ServiceTierSchema),
-  prompt_cache_key: Schema.optional(Schema.String),
-  include: optionalArray(OpenResponsesOptions.ResponseIncludableSchema),
-  reasoning: Schema.optional(
-    Schema.Struct({
-      effort: Schema.optional(OpenResponsesOptions.ReasoningEffort),
-      summary: Schema.optional(Schema.Literals(["auto", "concise", "detailed"])),
-    }),
-  ),
-  text: Schema.optional(
-    Schema.Struct({
-      verbosity: Schema.optional(OpenResponsesOptions.TextVerbositySchema),
-    }),
-  ),
-  max_output_tokens: Schema.optional(Schema.Number),
-  temperature: Schema.optional(Schema.Number),
-  top_p: Schema.optional(Schema.Number),
-}
-
-const OpenResponsesBody = Schema.Struct({
-  ...coreFields,
-  stream: Schema.Literal(true),
-})
-export type OpenResponsesBody = Schema.Schema.Type<typeof OpenResponsesBody>
-
-const OpenResponsesUsage = Schema.Struct({
-  input_tokens: Schema.optional(Schema.Number),
-  input_tokens_details: optionalNull(Schema.Struct({ cached_tokens: Schema.optional(Schema.Number) })),
-  output_tokens: Schema.optional(Schema.Number),
-  output_tokens_details: optionalNull(Schema.Struct({ reasoning_tokens: Schema.optional(Schema.Number) })),
-  total_tokens: Schema.optional(Schema.Number),
-})
-type OpenResponsesUsage = Schema.Schema.Type<typeof OpenResponsesUsage>
-
-export const StreamItem = Schema.StructWithRest(
-  Schema.Struct({
-    type: Schema.String,
-    id: Schema.optional(Schema.String),
-    call_id: Schema.optional(Schema.String),
-    name: Schema.optional(Schema.String),
-    arguments: Schema.optional(Schema.String),
-    encrypted_content: optionalNull(Schema.String),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
-export type StreamItem = Schema.Schema.Type<typeof StreamItem>
-
-// The Responses schema puts streaming error details at the top level and
-// response failures under `response.error`. WebSocket failures use an
-// event-level `error` envelope, so accept all three shapes here.
-// https://www.openresponses.org/specification
-const OpenResponsesErrorPayload = Schema.Struct({
-  code: optionalNull(Schema.String),
-  message: optionalNull(Schema.String),
-  param: optionalNull(Schema.String),
-})
-
-export const Event = Schema.StructWithRest(
-  Schema.Struct({
-    type: Schema.String,
-    delta: Schema.optional(Schema.String),
-    item_id: Schema.optional(Schema.String),
-    summary_index: Schema.optional(Schema.Number),
-    item: Schema.optional(StreamItem),
-    response: Schema.optional(
-      Schema.StructWithRest(
-        Schema.Struct({
-          id: Schema.optional(Schema.String),
-          service_tier: optionalNull(Schema.String),
-          incomplete_details: optionalNull(Schema.Struct({ reason: Schema.optional(Schema.String) })),
-          usage: optionalNull(OpenResponsesUsage),
-          error: optionalNull(OpenResponsesErrorPayload),
-        }),
-        [Schema.Record(Schema.String, Schema.Unknown)],
-      ),
-    ),
-    code: optionalNull(Schema.String),
-    message: Schema.optional(Schema.String),
-    param: optionalNull(Schema.String),
-    error: optionalNull(OpenResponsesErrorPayload),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
-export type Event = Schema.Schema.Type<typeof Event>
-
-export interface Extension {
-  readonly id: string
-  readonly name: string
-  readonly lowerMedia?: (input: {
-    readonly part: MediaPart
-    readonly media: ProviderShared.ValidatedMedia
-    readonly request: LLMRequest
-  }) => MediaInput | undefined
-}
-
-const BASE: Extension = { id: ADAPTER, name: NAME }
-
-export interface ParserState {
-  readonly id: string
-  readonly name: string
-  readonly providerMetadataKey: string
-  readonly tools: ToolStream.State<string>
-  readonly hasFunctionCall: boolean
-  readonly lifecycle: Lifecycle.State
-  readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>
-  readonly store: boolean | undefined
-}
-
-type ReasoningSummaryStatus = "active" | "can-conclude" | "concluded"
-
-interface ReasoningStreamItem {
-  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
-  // and matches the wire field.
-  readonly summaryParts: Readonly<Record<number, ReasoningSummaryStatus>>
-}
-
-// =============================================================================
-// Request Lowering
-// =============================================================================
-export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (
-  protocolName: string,
-  tool: ToolDefinition,
-  inputSchema: JsonSchema,
-) {
-  if (tool.native !== undefined)
-    return yield* ProviderShared.invalidRequest(`${protocolName} does not support provider-native tool ${tool.name}`)
-  return {
-    type: "function" as const,
-    name: tool.name,
-    description: tool.description,
-    parameters: ToolSchemaProjection.responses(inputSchema),
-    // TODO: Read this from Responses tool options so direct LLM callers can opt into strict schemas.
-    strict: false,
-  }
-})
-
-export const lowerToolChoice = (protocolName: string, toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
-  ProviderShared.matchToolChoice(protocolName, toolChoice, {
-    auto: () => "auto" as const,
-    none: () => "none" as const,
-    required: () => "required" as const,
-    tool: (toolName) => ({ type: "function" as const, name: toolName }),
-  })
-
-const lowerToolCall = (part: ToolCallPart): OpenResponsesInputItem => ({
-  type: "function_call",
-  call_id: part.id,
-  name: part.name,
-  arguments: ProviderShared.encodeJson(part.input),
-})
-
-const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenResponsesReasoningInput | undefined => {
-  const metadata = part.providerMetadata?.[providerMetadataKey]
-  if (!ProviderShared.isRecord(metadata) || typeof metadata.itemId !== "string" || metadata.itemId.length === 0)
-    return undefined
-  const encryptedContent =
-    typeof metadata.reasoningEncryptedContent === "string" || metadata.reasoningEncryptedContent === null
-      ? metadata.reasoningEncryptedContent
-      : undefined
-  return {
-    type: "reasoning",
-    id: metadata.itemId,
-    summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
-    encrypted_content: encryptedContent,
-  }
-}
-
-const hostedToolItemID = (part: ToolResultPart, providerMetadataKey: string) => {
-  const metadata = part.providerMetadata?.[providerMetadataKey]
-  return ProviderShared.isRecord(metadata) && typeof metadata.itemId === "string" && metadata.itemId.length > 0
-    ? metadata.itemId
-    : undefined
-}
-
-const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
-  part: MediaPart,
-  request: LLMRequest,
-  extension: Extension,
-) {
-  const media = yield* ProviderShared.validateMedia(extension.name, part, MEDIA_MIMES)
-  const extended = extension.lowerMedia?.({ part, media, request })
-  if (extended) return extended
-  if (media.mime === "application/pdf") {
-    return {
-      type: "input_file" as const,
-      filename: part.filename ?? "document.pdf",
-      file_data: media.dataUrl,
-    }
-  }
-  return { type: "input_image" as const, image_url: media.dataUrl }
-})
-
-const lowerUserContent = Effect.fn("OpenResponses.lowerUserContent")(function* (
-  part: LLMRequest["messages"][number]["content"][number],
-  request: LLMRequest,
-  extension: Extension,
-) {
-  if (part.type === "text") return { type: "input_text" as const, text: part.text }
-  if (part.type === "media") return yield* lowerMedia(part, request, extension)
-  return yield* ProviderShared.unsupportedContent(extension.name, "user", ["text", "media"])
-})
-
-// Tool results may carry structured text, images, and files. Keep media as provider-native
-// content instead of JSON-stringifying base64 into a prompt string.
-const lowerToolResultContentItem = Effect.fn("OpenResponses.lowerToolResultContentItem")(function* (
-  item: ToolContent,
-  request: LLMRequest,
-  extension: Extension,
-) {
-  if (item.type === "text") return { type: "input_text" as const, text: item.text }
-  return yield* lowerMedia(
-    { type: "media", mediaType: item.mime, data: item.uri, filename: item.name },
-    request,
-    extension,
-  )
-})
-
-const lowerToolResultOutput = Effect.fn("OpenResponses.lowerToolResultOutput")(function* (
-  part: ToolResultPart,
-  request: LLMRequest,
-  extension: Extension,
-) {
-  // Text/json/error results are encoded as a plain string for backward
-  // compatibility with existing cassettes and provider expectations.
-  if (part.result.type !== "content") return ProviderShared.toolResultText(part)
-  // Preserve the narrowed array element type when compiled through a consumer package.
-  const content: ReadonlyArray<ToolContent> = part.result.value
-  return yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request, extension))
-})
-
-const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (request: LLMRequest, extension: Extension) {
-  const system: OpenResponsesInputItem[] =
-    request.system.length === 0 ? [] : [{ role: "system", content: ProviderShared.joinText(request.system) }]
-  const input: OpenResponsesInputItem[] = [...system]
-  const store = OpenResponsesOptions.resolve(request).store
-  const providerMetadataKey = request.model.route.providerMetadataKey ?? "openresponses"
-
-  for (const message of request.messages) {
-    if (message.role === "system") {
-      const part = yield* ProviderShared.wrappedSystemUpdate(extension.name, message)
-      const previous = input.at(-1)
-      if (previous && "role" in previous && previous.role === "user")
-        input[input.length - 1] = {
-          role: "user",
-          content: [...previous.content, { type: "input_text", text: part.text }],
-        }
-      else input.push({ role: "user", content: [{ type: "input_text", text: part.text }] })
-      continue
-    }
-
-    if (message.role === "user") {
-      input.push({
-        role: "user",
-        content: yield* Effect.forEach(message.content, (part) => lowerUserContent(part, request, extension)),
-      })
-      continue
-    }
-
-    if (message.role === "assistant") {
-      const content: TextPart[] = []
-      const reasoningItems: Record<string, OpenResponsesReasoningReplay> = {}
-      const reasoningReferences = new Set<string>()
-      const hostedToolReferences = new Set<string>()
-      const flushText = () => {
-        if (content.length === 0) return
-        input.push({ role: "assistant", content: content.map((part) => ({ type: "output_text", text: part.text })) })
-        content.splice(0, content.length)
-      }
-      for (const part of message.content) {
-        if (part.type === "text") {
-          content.push(part)
-          continue
-        }
-        if (part.type === "reasoning") {
-          flushText()
-          const reasoning = lowerReasoning(part, providerMetadataKey)
-          if (!reasoning) continue
-          if (store !== false) {
-            if (!reasoningReferences.has(reasoning.id)) input.push({ type: "item_reference", id: reasoning.id })
-            reasoningReferences.add(reasoning.id)
-            continue
-          }
-          const existing = reasoningItems[reasoning.id]
-          if (existing) {
-            existing.summary.push(...reasoning.summary)
-            if (typeof reasoning.encrypted_content === "string")
-              existing.encrypted_content = reasoning.encrypted_content
-            continue
-          }
-          const replay = {
-            type: reasoning.type,
-            summary: reasoning.summary,
-            encrypted_content: reasoning.encrypted_content,
-          }
-          reasoningItems[reasoning.id] = replay
-          input.push(replay)
-          continue
-        }
-        if (part.type === "tool-call") {
-          flushText()
-          if (part.providerExecuted === true) continue
-          input.push(lowerToolCall(part))
-          continue
-        }
-        if (part.type === "tool-result" && part.providerExecuted === true) {
-          flushText()
-          const itemID = hostedToolItemID(part, providerMetadataKey)
-          if (store !== false && itemID && !hostedToolReferences.has(itemID))
-            input.push({ type: "item_reference", id: itemID })
-          if (store === false && part.result.type === "content") {
-            const content: ReadonlyArray<ToolContent> = part.result.value
-            input.push({
-              role: "user",
-              content: yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request, extension)),
-            })
-          }
-          if (itemID) hostedToolReferences.add(itemID)
-          continue
-        }
-        return yield* ProviderShared.unsupportedContent(extension.name, "assistant", [
-          "text",
-          "reasoning",
-          "tool-call",
-          "tool-result",
-        ])
-      }
-      flushText()
-      continue
-    }
-
-    for (const part of message.content) {
-      if (!ProviderShared.supportsContent(part, ["tool-result"]))
-        return yield* ProviderShared.unsupportedContent(extension.name, "tool", ["tool-result"])
-      input.push({
-        type: "function_call_output",
-        call_id: part.id,
-        output: yield* lowerToolResultOutput(part, request, extension),
-      })
-    }
-  }
-
-  // With store:false, Responses APIs only accept previous reasoning items when the
-  // complete item has encrypted state. Summary blocks for one item may carry
-  // that state only on the last block, so filter after they have been joined.
-  return store === false
-    ? input.filter(
-        (item) => !("type" in item) || item.type !== "reasoning" || typeof item.encrypted_content === "string",
-      )
-    : input
-})
-
-const lowerOptions = (request: LLMRequest) => {
-  const options = OpenResponsesOptions.resolve(request)
-  return {
-    ...(options.instructions ? { instructions: options.instructions } : {}),
-    ...(options.store !== undefined ? { store: options.store } : {}),
-    ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),
-    ...(options.include ? { include: options.include } : {}),
-    ...(options.reasoningEffort || options.reasoningSummary
-      ? { reasoning: { effort: options.reasoningEffort, summary: options.reasoningSummary } }
-      : {}),
-    ...(options.textVerbosity ? { text: { verbosity: options.textVerbosity } } : {}),
-    ...(options.serviceTier ? { service_tier: options.serviceTier } : {}),
-  }
-}
-
-export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (
-  request: LLMRequest,
-  extension: Extension = BASE,
-) {
-  const generation = request.generation
-  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  return {
-    model: request.model.id,
-    input: yield* lowerMessages(request, extension),
-    tools:
-      request.tools.length === 0
-        ? undefined
-        : yield* Effect.forEach(request.tools, (tool) =>
-            lowerTool(
-              extension.name,
-              tool,
-              ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
-            ),
-          ),
-    tool_choice: request.toolChoice ? yield* lowerToolChoice(extension.name, request.toolChoice) : undefined,
-    stream: true as const,
-    max_output_tokens: generation?.maxTokens,
-    temperature: generation?.temperature,
-    top_p: generation?.topP,
-    ...lowerOptions(request),
-  }
-})
-
-// =============================================================================
-// Stream Parsing
-// =============================================================================
-// Responses APIs report `input_tokens` (inclusive total) with a
-// `cached_tokens` subset, and `output_tokens` (inclusive total) with a
-// `reasoning_tokens` subset. Pass the totals through and derive the
-// non-cached breakdown.
-const mapUsage = (usage: OpenResponsesUsage | null | undefined, providerMetadataKey: string) => {
-  if (!usage) return undefined
-  const cached = usage.input_tokens_details?.cached_tokens
-  const reasoning = usage.output_tokens_details?.reasoning_tokens
-  const nonCached = ProviderShared.subtractTokens(usage.input_tokens, cached)
-  return new Usage({
-    inputTokens: usage.input_tokens,
-    outputTokens: usage.output_tokens,
-    nonCachedInputTokens: nonCached,
-    cacheReadInputTokens: cached,
-    reasoningTokens: reasoning,
-    totalTokens: ProviderShared.totalTokens(usage.input_tokens, usage.output_tokens, usage.total_tokens),
-    providerMetadata: { [providerMetadataKey]: usage },
-  })
-}
-
-const mapFinishReason = (event: Event, hasFunctionCall: boolean): FinishReason => {
-  const reason = event.response?.incomplete_details?.reason
-  if (reason === undefined || reason === null) {
-    if (hasFunctionCall) return "tool-calls"
-    if (event.type === "response.incomplete") return "unknown"
-    return "stop"
-  }
-  if (reason === "max_output_tokens") return "length"
-  if (reason === "content_filter") return "content-filter"
-  return hasFunctionCall ? "tool-calls" : "unknown"
-}
-
-export const providerMetadata = (state: ParserState, metadata: Record<string, unknown>): ProviderMetadata => ({
-  [state.providerMetadataKey]: metadata,
-})
-
-const isReasoningItem = (item: StreamItem): item is StreamItem & { type: "reasoning"; id: string } =>
-  item.type === "reasoning" && typeof item.id === "string" && item.id.length > 0
-
-export type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
-
-const NO_EVENTS: StepResult["1"] = []
-
-// `response.completed` / `response.incomplete` are clean finishes that emit a
-// `finish` event; `response.failed` is a hard failure. All three end the stream,
-// so keep this set aligned with `step` and the protocol's terminal predicate.
-const TERMINAL_TYPES = new Set(["response.completed", "response.incomplete", "response.failed"])
-export const terminal = (event: Event) => TERMINAL_TYPES.has(event.type)
-
-const onOutputTextDelta = (state: ParserState, event: Event): StepResult => {
-  if (!event.delta) return [state, NO_EVENTS]
-  const events: LLMEvent[] = []
-  return [
-    { ...state, lifecycle: Lifecycle.textDelta(state.lifecycle, events, event.item_id ?? "text-0", event.delta) },
-    events,
-  ]
-}
-
-const onOutputTextDone = (state: ParserState, event: Event): StepResult => {
-  const events: LLMEvent[] = []
-  return [{ ...state, lifecycle: Lifecycle.textEnd(state.lifecycle, events, event.item_id ?? "text-0") }, events]
-}
-
-export const onReasoningDelta = (state: ParserState, event: Event): StepResult => {
-  if (!event.delta) return [state, NO_EVENTS]
-  const events: LLMEvent[] = []
-  const itemID = event.item_id ?? "reasoning-0"
-  const id =
-    event.summary_index !== undefined || state.reasoningItems[itemID] ? `${itemID}:${event.summary_index ?? 0}` : itemID
-  return [
-    {
-      ...state,
-      lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, id, event.delta),
-    },
-    events,
-  ]
-}
-
-export const onReasoningDone = (state: ParserState, _event: Event): StepResult => [state, NO_EVENTS]
-
-const reasoningMetadata = (state: ParserState, item: StreamItem & { id: string }) =>
-  providerMetadata(state, { itemId: item.id, reasoningEncryptedContent: item.encrypted_content ?? null })
-
-// 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).
-// 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 && isReasoningItem(item)) {
-    const events: LLMEvent[] = []
-    return [
-      {
-        ...state,
-        lifecycle: Lifecycle.reasoningStart(state.lifecycle, events, `${item.id}:0`, reasoningMetadata(state, item)),
-        reasoningItems: {
-          ...state.reasoningItems,
-          [item.id]: { encryptedContent: item.encrypted_content, summaryParts: { 0: "active" } },
-        },
-      },
-      events,
-    ]
-  }
-  if (item?.type !== "function_call" || !item.id) return [state, NO_EVENTS]
-  const metadata = providerMetadata(state, { itemId: item.id })
-  const events: LLMEvent[] = []
-  const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-  return [
-    {
-      ...state,
-      lifecycle,
-      tools: ToolStream.start(state.tools, item.id, {
-        id: item.call_id ?? item.id,
-        name: item.name ?? "",
-        input: item.arguments ?? "",
-        providerMetadata: metadata,
-      }),
-    },
-    [
-      ...events,
-      LLMEvent.toolInputStart({ id: item.call_id ?? item.id, name: item.name ?? "", providerMetadata: metadata }),
-    ],
-  ]
-}
-
-const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResult => {
-  if (!event.item_id || event.summary_index === undefined) return [state, NO_EVENTS]
-  const item = state.reasoningItems[event.item_id] ?? { encryptedContent: undefined, summaryParts: {} }
-  if (event.summary_index === 0) {
-    if (state.reasoningItems[event.item_id]) return [state, NO_EVENTS]
-    const events: LLMEvent[] = []
-    return [
-      {
-        ...state,
-        lifecycle: Lifecycle.reasoningStart(
-          state.lifecycle,
-          events,
-          `${event.item_id}:0`,
-          providerMetadata(state, { itemId: event.item_id, reasoningEncryptedContent: null }),
-        ),
-        reasoningItems: {
-          ...state.reasoningItems,
-          [event.item_id]: { ...item, summaryParts: { 0: "active" } },
-        },
-      },
-      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 || event.summary_index === undefined) return [state, NO_EVENTS]
-  const item = state.reasoningItems[event.item_id]
-  if (!item) return [state, NO_EVENTS]
-  const events: LLMEvent[] = []
-  return [
-    {
-      ...state,
-      lifecycle:
-        state.store !== false
-          ? Lifecycle.reasoningEnd(
-              state.lifecycle,
-              events,
-              `${event.item_id}:${event.summary_index}`,
-              providerMetadata(state, { itemId: event.item_id }),
-            )
-          : state.lifecycle,
-      reasoningItems: {
-        ...state.reasoningItems,
-        [event.item_id]: {
-          ...item,
-          summaryParts: {
-            ...item.summaryParts,
-            [event.summary_index]: state.store !== false ? "concluded" : "can-conclude",
-          },
-        },
-      },
-    },
-    events,
-  ]
-}
-
-const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgumentsDelta")(function* (
-  state: ParserState,
-  event: Event,
-) {
-  if (!event.item_id || !event.delta) return [state, NO_EVENTS] satisfies StepResult
-  const result = ToolStream.appendExisting(
-    state.id,
-    state.tools,
-    event.item_id,
-    event.delta,
-    `${state.name} tool argument delta is missing its tool call`,
-  )
-  if (ToolStream.isError(result)) return yield* result
-  const events: LLMEvent[] = []
-  const lifecycle = result.events.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
-  events.push(...result.events)
-  return [{ ...state, lifecycle, tools: result.tools }, events] satisfies StepResult
-})
-
-const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (state: ParserState, event: Event) {
-  const item = event.item
-  if (!item) return [state, NO_EVENTS] satisfies StepResult
-
-  if (item.type === "message" && item.id) return onOutputTextDone(state, { ...event, item_id: item.id })
-
-  if (item.type === "function_call") {
-    if (!item.id || !item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
-    const tools = state.tools[item.id]
-      ? state.tools
-      : ToolStream.start(state.tools, item.id, { id: item.call_id, name: item.name })
-    const result =
-      item.arguments === undefined
-        ? yield* ToolStream.finish(state.id, tools, item.id)
-        : yield* ToolStream.finishWithInput(state.id, tools, item.id, item.arguments)
-    const events: LLMEvent[] = []
-    const resultEvents = result.events ?? []
-    const lifecycle = resultEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
-    events.push(...resultEvents)
-    return [
-      {
-        ...state,
-        lifecycle,
-        hasFunctionCall:
-          resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-          state.hasFunctionCall,
-        tools: result.tools,
-      },
-      events,
-    ] satisfies StepResult
-  }
-
-  if (isReasoningItem(item)) {
-    const events: LLMEvent[] = []
-    const metadata = reasoningMetadata(state, item)
-    const reasoningItem = state.reasoningItems[item.id]
-    if (reasoningItem) {
-      const lifecycle = Object.entries(reasoningItem.summaryParts)
-        .filter((entry) => entry[1] === "active" || entry[1] === "can-conclude")
-        .reduce(
-          (lifecycle, entry) => Lifecycle.reasoningEnd(lifecycle, events, `${item.id}:${entry[0]}`, metadata),
-          state.lifecycle,
-        )
-      const { [item.id]: _removed, ...reasoningItems } = state.reasoningItems
-      return [{ ...state, lifecycle, reasoningItems }, events] satisfies StepResult
-    }
-    if (!state.lifecycle.reasoning.has(item.id)) {
-      const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-      events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata: metadata }))
-      events.push(LLMEvent.reasoningEnd({ id: item.id, providerMetadata: metadata }))
-      return [{ ...state, lifecycle }, events] satisfies StepResult
-    }
-    return [
-      { ...state, lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, item.id, metadata) },
-      events,
-    ] satisfies StepResult
-  }
-
-  return [state, NO_EVENTS] satisfies StepResult
-})
-
-const onResponseFinish = (state: ParserState, event: Event): StepResult => {
-  const events: LLMEvent[] = []
-  const lifecycle = Lifecycle.finish(state.lifecycle, events, {
-    reason: {
-      normalized: mapFinishReason(event, state.hasFunctionCall),
-      raw: event.response?.incomplete_details?.reason,
-    },
-    usage: mapUsage(event.response?.usage, state.providerMetadataKey),
-    providerMetadata:
-      event.response?.id || event.response?.service_tier
-        ? providerMetadata(state, {
-            responseId: event.response.id,
-            serviceTier: event.response.service_tier,
-          })
-        : undefined,
-  })
-  return [{ ...state, lifecycle }, events]
-}
-
-// Build a single human-readable message from whatever the provider supplied.
-// When both code and message are present, prefix the code so consumers see
-// the failure mode (e.g. `rate_limit_exceeded: Slow down`) instead of just
-// the bare message — production rate limits and context-length failures used
-// to be indistinguishable from generic stream drops.
-const providerErrorMessage = (event: Event, fallback: string): string => {
-  const nested = event.error ?? event.response?.error ?? undefined
-  const message = event.message || nested?.message || undefined
-  const code = event.code || nested?.code || undefined
-  if (message && code) return `${code}: ${message}`
-  return message || code || fallback
-}
-
-const providerError = (state: ParserState, event: Event, fallback: string) => {
-  const code = event.code || event.error?.code || event.response?.error?.code || undefined
-  const message = providerErrorMessage(event, fallback)
-  return new LLMError({
-    module: state.id,
-    method: "stream",
-    reason: classifyProviderFailure({ message, code }),
-  })
-}
-
-export const step = (state: ParserState, event: Event) => {
-  if (event.type === "response.output_text.delta") return Effect.succeed(onOutputTextDelta(state, event))
-  if (event.type === "response.output_text.done") return Effect.succeed(onOutputTextDone(state, event))
-  if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta")
-    return Effect.succeed(onReasoningDelta(state, event))
-  if (event.type === "response.reasoning.done" || event.type === "response.reasoning_summary_text.done")
-    return Effect.succeed(onReasoningDone(state, event))
-  if (event.type === "response.reasoning_summary_part.added")
-    return Effect.succeed(onReasoningSummaryPartAdded(state, event))
-  if (event.type === "response.reasoning_summary_part.done")
-    return Effect.succeed(onReasoningSummaryPartDone(state, event))
-  if (event.type === "response.output_item.added") return Effect.succeed(onOutputItemAdded(state, event))
-  if (event.type === "response.function_call_arguments.delta") return onFunctionCallArgumentsDelta(state, event)
-  if (event.type === "response.output_item.done") return onOutputItemDone(state, event)
-  if (event.type === "response.completed" || event.type === "response.incomplete")
-    return Effect.succeed(onResponseFinish(state, event))
-  if (event.type === "response.failed") return providerError(state, event, `${state.name} response failed`)
-  if (event.type === "error") return providerError(state, event, `${state.name} stream error`)
-  return Effect.succeed<StepResult>([state, NO_EVENTS])
-}
-
-// =============================================================================
-// Protocol
-// =============================================================================
-/**
- * The provider-neutral Open Responses protocol. Provider-specific Responses
- * implementations compose this baseline with their own tools and event variants.
- */
-export const initial = (request: LLMRequest, extension: Extension = BASE): ParserState => ({
-  id: extension.id,
-  name: extension.name,
-  providerMetadataKey: request.model.route.providerMetadataKey ?? "openresponses",
-  hasFunctionCall: false,
-  tools: ToolStream.empty<string>(),
-  lifecycle: Lifecycle.initial(),
-  reasoningItems: {},
-  store: OpenResponsesOptions.resolve(request).store,
-})
-
-export const protocol = Protocol.make({
-  id: ADAPTER,
-  body: {
-    schema: OpenResponsesBody,
-    from: fromRequest,
-  },
-  stream: {
-    event: Protocol.jsonEvent(Event),
-    initial,
-    step,
-    terminal,
-  },
-})
-
-export const httpTransport = HttpTransport.sseJson.with<OpenResponsesBody>()
-
-export * as OpenResponses from "./open-responses"

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

@@ -5,11 +5,9 @@ import { Endpoint } from "../route/endpoint"
 import { HttpTransport } from "../route/transport"
 import { Protocol } from "../route/protocol"
 import {
-  LLMError,
   LLMEvent,
   Usage,
   type FinishReason,
-  type FinishReasonDetails,
   type JsonSchema,
   type LLMRequest,
   type MediaPart,
@@ -19,7 +17,6 @@ import {
   type ToolDefinition,
   type ToolContent,
 } from "../schema"
-import { classifyProviderFailure } from "../provider-error"
 import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared"
 import { OpenAIOptions } from "./utils/openai-options"
 import { Lifecycle } from "./utils/lifecycle"
@@ -28,7 +25,6 @@ import { ToolStream } from "./utils/tool-stream"
 
 const ADAPTER = "openai-chat"
 const IMAGE_MIMES = new Set<string>(ProviderShared.IMAGE_MIMES)
-const RESERVED_REASONING_FIELDS = new Set(["role", "content", "tool_calls"])
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/chat/completions"
 
@@ -74,18 +70,15 @@ const OpenAIChatMessage = Schema.Union([
     role: Schema.Literal("user"),
     content: Schema.Union([Schema.String, Schema.Array(OpenAIChatUserContent)]),
   }),
-  Schema.StructWithRest(
-    Schema.Struct({
-      role: Schema.Literal("assistant"),
-      content: Schema.NullOr(Schema.String),
-      tool_calls: optionalArray(OpenAIChatAssistantToolCall),
-      reasoning_content: Schema.optional(Schema.String),
-      reasoning: Schema.optional(Schema.String),
-      reasoning_text: Schema.optional(Schema.String),
-      reasoning_details: Schema.optional(Schema.Unknown),
-    }),
-    [Schema.Record(Schema.String, Schema.Unknown)],
-  ),
+  Schema.Struct({
+    role: Schema.Literal("assistant"),
+    content: Schema.NullOr(Schema.String),
+    tool_calls: optionalArray(OpenAIChatAssistantToolCall),
+    reasoning_content: Schema.optional(Schema.String),
+    reasoning: Schema.optional(Schema.String),
+    reasoning_text: Schema.optional(Schema.String),
+    reasoning_details: optionalArray(Schema.Unknown),
+  }),
   Schema.Struct({ role: Schema.Literal("tool"), tool_call_id: Schema.String, content: Schema.String }),
 ]).pipe(Schema.toTaggedUnion("role"))
 type OpenAIChatMessage = Schema.Schema.Type<typeof OpenAIChatMessage>
@@ -152,33 +145,23 @@ const OpenAIChatToolCallDelta = Schema.Struct({
 })
 type OpenAIChatToolCallDelta = Schema.Schema.Type<typeof OpenAIChatToolCallDelta>
 
-const OpenAIChatDelta = Schema.StructWithRest(
-  Schema.Struct({
-    content: optionalNull(Schema.String),
-    reasoning_content: optionalNull(Schema.String),
-    reasoning: optionalNull(Schema.String),
-    reasoning_text: optionalNull(Schema.String),
-    reasoning_details: optionalNull(Schema.Unknown),
-    tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
+const OpenAIChatDelta = Schema.Struct({
+  content: optionalNull(Schema.String),
+  reasoning_content: optionalNull(Schema.String),
+  reasoning: optionalNull(Schema.String),
+  reasoning_text: optionalNull(Schema.String),
+  reasoning_details: optionalNull(Schema.Array(Schema.Unknown)),
+  tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
+})
 
 const OpenAIChatChoice = Schema.Struct({
   delta: optionalNull(OpenAIChatDelta),
   finish_reason: optionalNull(Schema.String),
-  native_finish_reason: optionalNull(Schema.String),
-})
-
-const OpenAIChatError = Schema.Struct({
-  code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
-  message: Schema.String,
 })
 
 export const OpenAIChatEvent = Schema.Struct({
-  choices: optionalNull(Schema.Array(OpenAIChatChoice)),
+  choices: Schema.Array(OpenAIChatChoice),
   usage: optionalNull(OpenAIChatUsage),
-  error: optionalNull(OpenAIChatError),
 })
 export type OpenAIChatEvent = Schema.Schema.Type<typeof OpenAIChatEvent>
 type OpenAIChatRequestMessage = LLMRequest["messages"][number]
@@ -194,9 +177,9 @@ export interface ParserState {
   readonly pendingTools: Partial<Record<number, PendingToolDelta>>
   readonly toolCallEvents: ReadonlyArray<LLMEvent>
   readonly usage?: Usage
-  readonly finishReason?: FinishReasonDetails
+  readonly finishReason?: FinishReason
   readonly lifecycle: Lifecycle.State
-  readonly reasoningField?: string
+  readonly reasoningField?: "reasoning" | "reasoning_content" | "reasoning_text"
   readonly reasoningDetails: Array<unknown>
   readonly reasoningDetailsObserved: boolean
   readonly reasoningEmitted: boolean
@@ -244,7 +227,7 @@ const openAICompatibleReasoningContent = (native: unknown) =>
 
 const reasoningField = (part: ReasoningPart) => {
   const field = part.providerMetadata?.openai?.reasoningField
-  return typeof field === "string" ? field : undefined
+  if (field === "reasoning" || field === "reasoning_content" || field === "reasoning_text") return field
 }
 
 const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown) => {
@@ -276,7 +259,6 @@ const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (mes
 
 const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(function* (
   message: OpenAIChatRequestMessage,
-  configuredField?: string,
 ) {
   const content: TextPart[] = []
   const reasoning: ReasoningPart[] = []
@@ -303,25 +285,24 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
   const nativeReasoning = openAICompatibleReasoningContent(message.native?.openaiCompatible)
   const fullyStructured = reasoning.every((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails))
   const field = (() => {
-    if (configuredField !== undefined) return configuredField
-    if (reasoning.length === 0) return undefined
+    if (reasoning.length === 0) return
     if (observedField !== undefined) return observedField
     if (nativeReasoning !== undefined) return "reasoning_content"
     if (!fullyStructured) return "reasoning_content"
   })()
-  const reasoningText = (() => {
-    if (configuredField !== undefined) return reasoning.length === 0 ? (nativeReasoning ?? "") : text
+  const reasoningContent = (() => {
     if (reasoning.length === 0) return nativeReasoning
-    return text
+    if (field === "reasoning_content") return text
   })()
-  const result = {
+  return {
     role: "assistant" as const,
     content: content.length === 0 ? null : ProviderShared.joinText(content),
     tool_calls: toolCalls.length === 0 ? undefined : toolCalls,
+    reasoning_content: reasoningContent,
+    reasoning: reasoning.length > 0 && field === "reasoning" ? text : undefined,
+    reasoning_text: reasoning.length > 0 && field === "reasoning_text" ? text : undefined,
     reasoning_details: details,
   }
-  if (field === undefined || reasoningText === undefined) return result
-  return { ...result, [field]: reasoningText }
 })
 
 const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (message: OpenAIChatRequestMessage) {
@@ -347,12 +328,9 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (m
   return { messages, images }
 })
 
-const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (
-  message: OpenAIChatRequestMessage,
-  reasoningField?: string,
-) {
+const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (message: OpenAIChatRequestMessage) {
   if (message.role === "user") return [yield* lowerUserMessage(message)]
-  if (message.role === "assistant") return [yield* lowerAssistantMessage(message, reasoningField)]
+  if (message.role === "assistant") return [yield* lowerAssistantMessage(message)]
   return (yield* lowerToolMessages(message)).messages
 })
 
@@ -390,28 +368,24 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
       continue
     }
     flushImages()
-    messages.push(...(yield* lowerMessage(message, request.model.compatibility?.reasoningField)))
+    messages.push(...(yield* lowerMessage(message)))
   }
   flushImages()
   return messages
 })
 
-const lowerOptions = (request: LLMRequest) => {
-  const options = OpenAIOptions.resolve(request)
+const lowerOptions = Effect.fn("OpenAIChat.lowerOptions")(function* (request: LLMRequest) {
+  const store = OpenAIOptions.store(request)
+  const reasoningEffort = OpenAIOptions.reasoningEffort(request)
   return {
-    ...(options.store !== undefined ? { store: options.store } : {}),
-    ...(options.reasoningEffort ? { reasoning_effort: options.reasoningEffort } : {}),
+    ...(store !== undefined ? { store } : {}),
+    ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
   }
-}
+})
 
 const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (request: LLMRequest) {
   // `fromRequest` returns the provider body only. Endpoint, auth, framing,
   // validation, and HTTP execution are composed by `Route.make`.
-  const reasoningField = request.model.compatibility?.reasoningField
-  if (reasoningField && RESERVED_REASONING_FIELDS.has(reasoningField))
-    return yield* ProviderShared.invalidRequest(
-      `OpenAI Chat reasoning field conflicts with reserved field ${reasoningField}`,
-    )
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   return {
@@ -433,7 +407,7 @@ const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (request: LLMR
     presence_penalty: generation?.presencePenalty,
     seed: generation?.seed,
     stop: generation?.stop,
-    ...lowerOptions(request),
+    ...(yield* lowerOptions(request)),
   }
 })
 
@@ -448,7 +422,6 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
   if (reason === "length") return "length"
   if (reason === "content_filter") return "content-filter"
   if (reason === "function_call" || reason === "tool_calls") return "tool-calls"
-  if (reason === "error") return "error"
   return "unknown"
 }
 
@@ -473,18 +446,10 @@ const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
   })
 }
 
-const reasoningDelta = (
-  delta: Schema.Schema.Type<typeof OpenAIChatDelta> | null | undefined,
-  configuredField?: string,
-) => {
-  if (!delta) return undefined
-  const fields = new Set([configuredField, "reasoning_content", "reasoning", "reasoning_text"])
-  for (const field of fields) {
-    if (field === undefined) continue
-    const text = delta[field]
-    if (typeof text === "string" && text.length > 0) return { field, text }
-  }
-  return undefined
+const reasoningDelta = (delta: Schema.Schema.Type<typeof OpenAIChatDelta> | null | undefined) => {
+  if (delta?.reasoning_content) return { field: "reasoning_content", text: delta.reasoning_content } as const
+  if (delta?.reasoning) return { field: "reasoning", text: delta.reasoning } as const
+  if (delta?.reasoning_text) return { field: "reasoning_text", text: delta.reasoning_text } as const
 }
 
 const detailText = (details: ReadonlyArray<unknown>) => {
@@ -542,22 +507,10 @@ const reasoningMetadata = (field: ParserState["reasoningField"], details?: Reado
 
 const step = (state: ParserState, event: OpenAIChatEvent) =>
   Effect.gen(function* () {
-    if (event.error)
-      return yield* new LLMError({
-        module: ADAPTER,
-        method: "stream",
-        reason: classifyProviderFailure({
-          message: event.error.message,
-          code: event.error.code === undefined || event.error.code === null ? undefined : String(event.error.code),
-          status: typeof event.error.code === "number" ? event.error.code : undefined,
-        }),
-      })
     const events: LLMEvent[] = []
     const usage = mapUsage(event.usage) ?? state.usage
-    const choice = event.choices?.[0]
-    const finishReason = choice?.finish_reason
-      ? { normalized: mapFinishReason(choice.finish_reason), raw: choice.native_finish_reason ?? choice.finish_reason }
-      : state.finishReason
+    const choice = event.choices[0]
+    const finishReason = choice?.finish_reason ? mapFinishReason(choice.finish_reason) : state.finishReason
     const delta = choice?.delta
     const toolDeltas = delta?.tool_calls ?? []
     let tools = state.tools
@@ -565,7 +518,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
 
     let lifecycle = state.lifecycle
 
-    const reasoning = reasoningDelta(delta, state.reasoningField)
+    const reasoning = reasoningDelta(delta)
     const reasoningField = state.reasoningField ?? (!state.lifecycle.text.has("text-0") ? reasoning?.field : undefined)
     const detailDelta = Array.isArray(delta?.reasoning_details) ? delta.reasoning_details : undefined
     if (detailDelta !== undefined) appendReasoningDetails(state.reasoningDetails, detailDelta)
@@ -649,13 +602,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
 const finishEvents = (state: ParserState): ReadonlyArray<LLMEvent> => {
   const events: LLMEvent[] = []
   const hasToolCalls = state.toolCallEvents.length > 0
-  const reason = state.finishReason
-    ? {
-        ...state.finishReason,
-        normalized:
-          state.finishReason.normalized === "stop" && hasToolCalls ? "tool-calls" : state.finishReason.normalized,
-      }
-    : undefined
+  const reason = state.finishReason === "stop" && hasToolCalls ? "tool-calls" : state.finishReason
   const metadata = reasoningMetadata(
     state.reasoningField,
     state.reasoningDetailsObserved ? state.reasoningDetails : undefined,
@@ -688,12 +635,12 @@ export const protocol = Protocol.make({
   },
   stream: {
     event: Protocol.jsonEvent(OpenAIChatEvent),
-    initial: (request) => ({
+    initial: () => ({
       tools: ToolStream.empty<number>(),
       pendingTools: {},
       toolCallEvents: [],
       lifecycle: Lifecycle.initial(),
-      reasoningField: request.model.compatibility?.reasoningField,
+      reasoningField: undefined,
       reasoningDetails: [],
       reasoningDetailsObserved: false,
       reasoningEmitted: false,

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

@@ -1,22 +1,23 @@
 import { Route, type RouteRoutedModelInput } from "../route/client"
 import { Endpoint } from "../route/endpoint"
-import { OpenResponses } from "./open-responses"
+import { OpenAIResponses } from "./openai-responses"
 
 const ADAPTER = "openai-compatible-responses"
 
 export type OpenAICompatibleResponsesModelInput = RouteRoutedModelInput
 
 /**
- * Deployment adapter for providers that expose an Open Responses-compatible
- * `/responses` endpoint. Provider helpers configure identity, endpoint, and
- * auth while the semantic protocol remains provider-neutral.
+ * Route for providers that expose an OpenAI Responses-compatible `/responses`
+ * endpoint. Provider helpers configure identity, endpoint, and auth before
+ * model selection while this route reuses the OpenAI Responses protocol.
  */
 export const route = Route.make({
   id: ADAPTER,
-  providerMetadataKey: "openresponses",
-  protocol: OpenResponses.protocol,
-  endpoint: Endpoint.path(OpenResponses.PATH),
-  transport: OpenResponses.httpTransport,
+  providerMetadataKey: "openai",
+  protocol: OpenAIResponses.protocol,
+  endpoint: Endpoint.path(OpenAIResponses.PATH),
+  transport: OpenAIResponses.httpTransport,
+  defaults: { providerOptions: { openai: { store: false } } },
 })
 
 export * as OpenAICompatibleResponses from "./openai-compatible-responses"

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

@@ -1,51 +1,43 @@
 import { Effect, Encoding, Schema } from "effect"
-import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { Headers, HttpClientRequest } from "effect/unstable/http"
 import {
   ImageModel,
   GeneratedImage,
   ImageResponse,
-  type ImageInput,
-  type ImageRequestFor,
+  type ImageRequest,
+  type ImageModelDefaults,
   type ImageRoute,
 } from "../image"
 import { Auth, type Definition as AuthDefinition } from "../route/auth"
-import {
-  InvalidProviderOutputReason,
-  LLMError,
-  Usage,
-  mergeHttpOptions,
-  mergeJsonRecords,
-  type HttpOptions,
-} from "../schema"
+import { InvalidProviderOutputReason, LLMError, Usage, mergeHttpOptions, mergeJsonRecords } from "../schema"
 import { ProviderShared } from "./shared"
-import { ImageInputs } from "./utils/image-input"
 import { OpenAIImage } from "./utils/openai-image"
 
 const ADAPTER = "openai-images"
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/images/generations"
-export const EDIT_PATH = "/images/edits"
 
-export type OpenAIImageString<Known extends string> = Known | (string & {})
-
-export type OpenAIImageOptions = {
-  readonly mask?: ImageInput
-  readonly n?: number
-  readonly size?: OpenAIImageString<
-    "auto" | "256x256" | "512x512" | "1024x1024" | "1536x1024" | "1024x1536" | "1792x1024" | "1024x1792"
-  >
-  readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">
-  readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">
-  readonly moderation?: OpenAIImageString<"auto" | "low">
-  readonly outputFormat?: OpenAIImageString<"png" | "jpeg" | "webp">
+export interface OpenAIImageOptions {
+  readonly quality?: "auto" | "low" | "medium" | "high"
+  readonly background?: "auto" | "opaque" | "transparent"
+  readonly moderation?: "auto" | "low"
+  readonly outputFormat?: "png" | "jpeg" | "webp"
   readonly outputCompression?: number
-} & Record<string, unknown>
-
-export type OpenAIImageBody = Record<string, unknown> & {
-  readonly model: string
-  readonly prompt: string
 }
 
+const OpenAIImageBody = Schema.Struct({
+  model: Schema.String,
+  prompt: Schema.String,
+  n: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
+  size: Schema.optional(Schema.String),
+  quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])),
+  background: Schema.optional(Schema.Literals(["auto", "opaque", "transparent"])),
+  moderation: Schema.optional(Schema.Literals(["auto", "low"])),
+  output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
+  output_compression: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 100 }))),
+})
+export type OpenAIImageBody = Schema.Schema.Type<typeof OpenAIImageBody>
+
 const OpenAIImageResponse = Schema.Struct({
   data: Schema.Array(
     Schema.Struct({
@@ -71,16 +63,26 @@ export interface ModelInput {
   readonly auth: AuthDefinition
   readonly baseURL?: string
   readonly headers?: Record<string, string>
-  readonly http?: HttpOptions
+  readonly defaults?: ImageModelDefaults
 }
 
-const nativeOptions = (options: OpenAIImageOptions | undefined) => {
-  if (!options) return undefined
-  const { mask: _, outputFormat, outputCompression, ...native } = options
+const providerOptions = (request: ImageRequest): OpenAIImageOptions => ({
+  ...request.model.defaults?.providerOptions?.openai,
+  ...request.providerOptions?.openai,
+})
+
+const body = (request: ImageRequest): OpenAIImageBody => {
+  const options = providerOptions(request)
   return {
-    output_format: outputFormat,
-    output_compression: outputCompression,
-    ...native,
+    model: request.model.id,
+    prompt: request.prompt,
+    n: request.count,
+    size: request.size === undefined ? undefined : `${request.size.width}x${request.size.height}`,
+    quality: options.quality,
+    background: options.background,
+    moderation: options.moderation,
+    output_format: options.outputFormat,
+    output_compression: options.outputCompression,
   }
 }
 
@@ -98,93 +100,45 @@ const applyQuery = (url: string, query: Record<string, string> | undefined) => {
   return next.toString()
 }
 
+const PROTOCOL_BODY_FIELDS = new Set([
+  "model",
+  "prompt",
+  "n",
+  "size",
+  "quality",
+  "background",
+  "moderation",
+  "output_format",
+  "output_compression",
+])
+
+const bodyWithOverlay = Effect.fn("OpenAIImages.bodyWithOverlay")(function* (
+  imageBody: OpenAIImageBody,
+  overlay: Record<string, unknown> | undefined,
+) {
+  if (!overlay) return imageBody
+  const reserved = Object.keys(overlay).filter((key) => PROTOCOL_BODY_FIELDS.has(key))
+  if (reserved.length > 0)
+    return yield* ProviderShared.invalidRequest(
+      `http.body cannot overlay protocol-owned field(s): ${reserved.join(", ")}`,
+    )
+  return mergeJsonRecords(imageBody, overlay) ?? imageBody
+})
+
 export const model = (input: ModelInput) => {
-  const route: ImageRoute<OpenAIImageOptions> = {
+  const route: ImageRoute = {
     id: ADAPTER,
-    generate: Effect.fn("OpenAIImages.generate")(function* (request: ImageRequestFor<OpenAIImageOptions>, execute) {
-      const mask = request.options?.mask
-      if (mask !== undefined && (request.images?.length ?? 0) === 0)
-        return yield* ImageInputs.invalid(ADAPTER, "An OpenAI image mask requires at least one input image")
-      const http = mergeHttpOptions(request.model.http, request.http)
-      const sourceImages = request.images ?? []
-      const multipartImages = yield* Effect.forEach(sourceImages, (image) => {
-        if (image.type === "bytes") return Effect.succeed({ data: image.data, mediaType: image.mediaType })
-        if (image.type === "url") return ImageInputs.decodeDataUrl(image.url, ADAPTER)
-        return Effect.succeed(undefined)
-      })
-      const multipartMask =
-        mask === undefined
-          ? undefined
-          : mask.type === "bytes"
-            ? { data: mask.data, mediaType: mask.mediaType }
-            : mask.type === "url"
-              ? yield* ImageInputs.decodeDataUrl(mask.url, ADAPTER)
-              : undefined
-      const useMultipart =
-        sourceImages.length > 0 &&
-        multipartImages.every((image) => image !== undefined) &&
-        (mask === undefined || multipartMask !== undefined)
-      const path = sourceImages.length === 0 ? PATH : EDIT_PATH
-      const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${path}`, http?.query)
+    generate: Effect.fn("OpenAIImages.generate")(function* (request: ImageRequest, execute) {
+      if (request.aspectRatio !== undefined)
+        return yield* ProviderShared.invalidRequest("OpenAI Images does not support the common aspectRatio option")
+      if (request.seed !== undefined)
+        return yield* ProviderShared.invalidRequest("OpenAI Images does not support the common seed option")
 
-      if (useMultipart) {
-        const form = new FormData()
-        form.append("model", request.model.id)
-        form.append("prompt", request.prompt)
-        Object.entries(mergeJsonRecords(nativeOptions(request.options), http?.body) ?? {}).forEach(([key, value]) => {
-          if (["model", "prompt", "image", "image[]", "images", "mask"].includes(key)) return
-          form.append(key, typeof value === "string" ? value : ProviderShared.encodeJson(value))
-        })
-        multipartImages.forEach((image, index) => {
-          if (image === undefined) return
-          form.append("image[]", imageBlob(image.data, image.mediaType), `image-${index}`)
-        })
-        if (multipartMask !== undefined)
-          form.append("mask", imageBlob(multipartMask.data, multipartMask.mediaType), "mask")
-        const headers = yield* Auth.toEffect(input.auth)({
-          request,
-          method: "POST",
-          url,
-          body: "[multipart/form-data]",
-          headers: Headers.remove(Headers.fromInput({ ...input.headers, ...http?.headers }), "content-type"),
-        })
-        const response = yield* execute(
-          HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyFormData(form)),
-        )
-        return yield* parseResponse(response, request.options, http?.body)
-      }
-
-      const references = sourceImages.map((image) => {
-        if (image.type === "bytes") return { image_url: ImageInputs.dataUrl(image) }
-        if (image.type === "url") return { image_url: image.url }
-        if (image.type === "file-id") return { file_id: image.id }
-        return undefined
-      })
-      if (references.some((image) => image === undefined))
-        return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts image URLs, data URLs, bytes, and file IDs")
-      const maskReference =
-        mask === undefined
-          ? undefined
-          : mask.type === "bytes"
-            ? { image_url: ImageInputs.dataUrl(mask) }
-            : mask.type === "url"
-              ? { image_url: mask.url }
-              : mask.type === "file-id"
-                ? { file_id: mask.id }
-                : undefined
-      if (mask !== undefined && maskReference === undefined)
-        return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts masks as URLs, data URLs, bytes, or file IDs")
-      const requestBody = mergeJsonRecords(
-        {
-          model: request.model.id,
-          prompt: request.prompt,
-          images: references.length === 0 ? undefined : references,
-          mask: maskReference,
-        },
-        nativeOptions(request.options),
-        http?.body,
-      ) as OpenAIImageBody
-      const text = ProviderShared.encodeJson(requestBody)
+      const requestBody = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIImageBody))(body(request))
+      const http = mergeHttpOptions(request.model.defaults?.http, request.http)
+      const overlaidBody = yield* bodyWithOverlay(requestBody, http?.body)
+      const text = ProviderShared.encodeJson(overlaidBody)
+      const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${PATH}`, http?.query)
       const headers = yield* Auth.toEffect(input.auth)({
         request,
         method: "POST",
@@ -198,71 +152,55 @@ export const model = (input: ModelInput) => {
           HttpClientRequest.bodyText(text, "application/json"),
         ),
       )
-      return yield* parseResponse(response, request.options, http?.body)
-    }),
-  }
-  return ImageModel.make<OpenAIImageOptions>({ id: input.id, provider: "openai", route, http: input.http })
-}
-
-const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (
-  response: HttpClientResponse.HttpClientResponse,
-  options: OpenAIImageOptions | undefined,
-  overlay: Record<string, unknown> | undefined,
-) {
-  const payload = yield* response.json.pipe(
-    Effect.mapError(() => invalidOutput("Failed to read the OpenAI Images response")),
-  )
-  const decoded = yield* Schema.decodeUnknownEffect(OpenAIImageResponse)(payload).pipe(
-    Effect.mapError(() => invalidOutput("OpenAI Images returned an invalid response")),
-  )
-  const requestBody = mergeJsonRecords(nativeOptions(options), overlay)
-  const format =
-    decoded.output_format ?? (typeof requestBody?.output_format === "string" ? requestBody.output_format : "png")
-  const images = yield* Effect.forEach(decoded.data, (item, index) => {
-    if (item.b64_json)
-      return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
-        Effect.mapError(() => invalidOutput(`OpenAI Images result ${index} contains invalid base64 data`)),
-        Effect.map(
-          (data) =>
+      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 format = decoded.output_format ?? providerOptions(request).outputFormat ?? "png"
+      const images = yield* Effect.forEach(decoded.data, (item, index) => {
+        if (item.b64_json)
+          return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
+            Effect.mapError(() => invalidOutput(`OpenAI Images result ${index} contains invalid base64 data`)),
+            Effect.map(
+              (data) =>
+                new GeneratedImage({
+                  mediaType: `image/${format}`,
+                  data,
+                  providerMetadata:
+                    item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
+                }),
+            ),
+          )
+        if (item.url)
+          return Effect.succeed(
             new GeneratedImage({
               mediaType: `image/${format}`,
-              data,
+              data: item.url,
               providerMetadata:
                 item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
             }),
-        ),
-      )
-    if (item.url)
-      return Effect.succeed(
-        new GeneratedImage({
-          mediaType: `image/${format}`,
-          data: item.url,
-          providerMetadata:
-            item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
-        }),
-      )
-    return Effect.fail(invalidOutput(`OpenAI Images result ${index} has neither image data nor a URL`))
-  })
-  if (images.length === 0) return yield* invalidOutput("OpenAI Images returned no images")
-  return new ImageResponse({
-    images,
-    usage:
-      decoded.usage === undefined
-        ? undefined
-        : new Usage({
-            inputTokens: decoded.usage.input_tokens,
-            outputTokens: decoded.usage.output_tokens,
-            totalTokens: decoded.usage.total_tokens,
-            providerMetadata: { openai: decoded.usage },
-          }),
-    providerMetadata: { openai: { outputFormat: format } },
-  })
-})
-
-const imageBlob = (data: Uint8Array, mediaType: string) => {
-  const buffer = new ArrayBuffer(data.byteLength)
-  new Uint8Array(buffer).set(data)
-  return new Blob([buffer], { type: mediaType })
+          )
+        return Effect.fail(invalidOutput(`OpenAI Images result ${index} has neither image data nor a URL`))
+      })
+      if (images.length === 0) return yield* invalidOutput("OpenAI Images returned no images")
+      return new ImageResponse({
+        images,
+        usage:
+          decoded.usage === undefined
+            ? undefined
+            : new Usage({
+                inputTokens: decoded.usage.input_tokens,
+                outputTokens: decoded.usage.output_tokens,
+                totalTokens: decoded.usage.total_tokens,
+                providerMetadata: { openai: decoded.usage },
+              }),
+        providerMetadata: { openai: { outputFormat: format } },
+      })
+    }),
+  }
+  return ImageModel.make({ id: input.id, provider: "openai", route, defaults: input.defaults })
 }
 
 export const OpenAIImages = {

packages/ai/src/protocols/shared.ts

@@ -158,8 +158,7 @@ export const parseToolInput = (route: string, name: string, raw: string) =>
 export const IMAGE_MIMES = ["image/png", "image/jpeg", "image/gif", "image/webp"] as const
 export const VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"] as const
 export const AUDIO_MIMES = ["audio/wav", "audio/mp3", "audio/aiff", "audio/aac", "audio/ogg", "audio/flac"] as const
-export const PDF_MIMES = ["application/pdf"] as const
-export const MEDIA_MIMES = [...IMAGE_MIMES, ...VIDEO_MIMES, ...AUDIO_MIMES, ...PDF_MIMES] as const
+export const MEDIA_MIMES = [...IMAGE_MIMES, ...VIDEO_MIMES, ...AUDIO_MIMES] as const
 export const MAX_MEDIA_ENCODED_BYTES = 28 * 1024 * 1024
 export const MAX_MEDIA_DECODED_BYTES = 20 * 1024 * 1024
 

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

@@ -49,10 +49,10 @@ const DOCUMENT_FORMATS = {
   "text/markdown": "md",
 } as const satisfies Record<string, DocumentFormat>
 
-const documentBlock = (name: string, format: DocumentFormat, bytes: string): DocumentBlock => ({
+const documentBlock = (part: MediaPart, format: DocumentFormat, bytes: string): DocumentBlock => ({
   document: {
     format,
-    name,
+    name: part.filename ?? `document.${format}`,
     source: { bytes },
   },
 })
@@ -77,14 +77,12 @@ export const lower = Effect.fn("BedrockMedia.lower")(function* (part: MediaPart)
     return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support image media type ${part.mediaType}`)
   const documentFormat = DOCUMENT_FORMATS[mime as keyof typeof DOCUMENT_FORMATS]
   if (documentFormat) {
-    if (!part.filename)
-      return yield* ProviderShared.invalidRequest("Bedrock Converse document media requires a filename")
     const media = yield* ProviderShared.validateMedia(
       "Bedrock Converse",
       part,
       new Set<string>(Object.keys(DOCUMENT_FORMATS)),
     )
-    return documentBlock(part.filename, documentFormat, media.base64)
+    return documentBlock(part, documentFormat, media.base64)
   }
   return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.mediaType}`)
 })

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

@@ -1,34 +0,0 @@
-import { Effect, Encoding } from "effect"
-import type { ImageInput } from "../../image"
-import { InvalidRequestReason, LLMError } from "../../schema"
-
-const invalid = (module: string, message: string) =>
-  new LLMError({
-    module,
-    method: "generate",
-    reason: new InvalidRequestReason({ message }),
-  })
-
-export const dataUrl = (input: Extract<ImageInput, { readonly type: "bytes" }>) =>
-  `data:${input.mediaType};base64,${Encoding.encodeBase64(input.data)}`
-
-export const decodeDataUrl = (
-  url: string,
-  module: string,
-): Effect.Effect<{ readonly mediaType: string; readonly data: Uint8Array } | undefined, LLMError> => {
-  if (!url.startsWith("data:")) return Effect.succeed(undefined)
-  const match = /^data:([^;,]+);base64,(.*)$/s.exec(url)
-  if (!match) return Effect.fail(invalid(module, "Image data URLs must contain a MIME type and base64 data"))
-  return Effect.fromResult(Encoding.decodeBase64(match[2])).pipe(
-    Effect.mapError(() => invalid(module, "Image data URL contains invalid base64 data")),
-    Effect.map((data) => ({ mediaType: match[1], data })),
-  )
-}
-
-export const invalidImageInput = invalid
-
-export const ImageInputs = {
-  dataUrl,
-  decodeDataUrl,
-  invalid: invalidImageInput,
-} as const

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

@@ -1,4 +1,4 @@
-import { LLMEvent, type FinishReasonDetails, type ProviderMetadata, type Usage } from "../../schema"
+import { LLMEvent, type FinishReason, type ProviderMetadata, type Usage } from "../../schema"
 
 export interface State {
   readonly stepStarted: boolean
@@ -81,7 +81,7 @@ export const finish = (
   state: State,
   events: LLMEvent[],
   input: {
-    readonly reason: FinishReasonDetails
+    readonly reason: FinishReason
     readonly usage?: Usage
     readonly providerMetadata?: ProviderMetadata
   },

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

@@ -1,65 +0,0 @@
-import { Schema } from "effect"
-import { TextVerbosity, type LLMRequest } from "../../schema"
-
-export const ResponseIncludables = [
-  "file_search_call.results",
-  "web_search_call.results",
-  "web_search_call.action.sources",
-  "message.input_image.image_url",
-  "computer_call_output.output.image_url",
-  "code_interpreter_call.outputs",
-  "reasoning.encrypted_content",
-  "message.output_text.logprobs",
-] as const
-export type ResponseIncludable = (typeof ResponseIncludables)[number]
-
-export const ServiceTiers = ["auto", "default", "flex", "priority"] as const
-export type ServiceTier = (typeof ServiceTiers)[number]
-
-const TEXT_VERBOSITY = new Set<string>(["low", "medium", "high"])
-const INCLUDABLES = new Set<string>(ResponseIncludables)
-const SERVICE_TIERS = new Set<string>(ServiceTiers)
-
-const isTextVerbosity = (value: unknown): value is Schema.Schema.Type<typeof TextVerbosity> =>
-  typeof value === "string" && TEXT_VERBOSITY.has(value)
-
-const isServiceTier = (value: unknown): value is ServiceTier => typeof value === "string" && SERVICE_TIERS.has(value)
-
-export const ReasoningEffort = Schema.String
-export const TextVerbositySchema = TextVerbosity
-export const ResponseIncludableSchema = Schema.Literals(ResponseIncludables)
-export const ServiceTierSchema = Schema.Literals(ServiceTiers)
-
-export interface Resolved {
-  readonly instructions?: string
-  readonly store?: boolean
-  readonly promptCacheKey?: string
-  readonly reasoningEffort?: string
-  readonly reasoningSummary?: "auto" | "concise" | "detailed"
-  readonly include?: ReadonlyArray<ResponseIncludable>
-  readonly textVerbosity?: Schema.Schema.Type<typeof TextVerbosity>
-  readonly serviceTier?: ServiceTier
-}
-
-export const resolve = (request: LLMRequest): Resolved => {
-  const input = request.providerOptions?.[request.model.route.providerMetadataKey ?? "openresponses"]
-  const include = Array.isArray(input?.include)
-    ? input.include.filter((entry): entry is ResponseIncludable => INCLUDABLES.has(entry))
-    : []
-  const reasoningSummary = input?.reasoningSummary
-  return {
-    instructions: typeof input?.instructions === "string" ? input.instructions : undefined,
-    store: typeof input?.store === "boolean" ? input.store : undefined,
-    promptCacheKey: typeof input?.promptCacheKey === "string" ? input.promptCacheKey : undefined,
-    reasoningEffort: typeof input?.reasoningEffort === "string" ? input.reasoningEffort : undefined,
-    reasoningSummary:
-      reasoningSummary === "auto" || reasoningSummary === "concise" || reasoningSummary === "detailed"
-        ? reasoningSummary
-        : undefined,
-    include: include.length > 0 ? include : undefined,
-    textVerbosity: isTextVerbosity(input?.textVerbosity) ? input.textVerbosity : undefined,
-    serviceTier: isServiceTier(input?.serviceTier) ? input.serviceTier : undefined,
-  }
-}
-
-export * as OpenResponsesOptions from "./open-responses-options"

packages/ai/src/protocols/utils/openai-options.ts

@@ -1,23 +1,85 @@
-import { ReasoningEfforts } from "../../schema"
-import { OpenResponsesOptions } from "./open-responses-options"
+import { Schema } from "effect"
+import type { LLMRequest, TextVerbosity as TextVerbosityValue } from "../../schema"
+import { ReasoningEfforts, TextVerbosity } from "../../schema"
 
 export const OpenAIReasoningEfforts = ReasoningEfforts
 export type OpenAIReasoningEffort = string
 
 // Mirrors OpenAI's `ResponseIncludable` union from the official SDK. Keep this
 // in lockstep with `openai-node/src/resources/responses/responses.ts`.
-export const OpenAIResponseIncludables = OpenResponsesOptions.ResponseIncludables
-export type OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludable
-export const OpenAIServiceTiers = OpenResponsesOptions.ServiceTiers
-export type OpenAIServiceTier = OpenResponsesOptions.ServiceTier
+export const OpenAIResponseIncludables = [
+  "file_search_call.results",
+  "web_search_call.results",
+  "web_search_call.action.sources",
+  "message.input_image.image_url",
+  "computer_call_output.output.image_url",
+  "code_interpreter_call.outputs",
+  "reasoning.encrypted_content",
+  "message.output_text.logprobs",
+] as const
+export type OpenAIResponseIncludable = (typeof OpenAIResponseIncludables)[number]
+export const OpenAIServiceTiers = ["auto", "default", "flex", "priority"] as const
+export type OpenAIServiceTier = (typeof OpenAIServiceTiers)[number]
 
-export const OpenAIReasoningEffort = OpenResponsesOptions.ReasoningEffort
-export const OpenAITextVerbosity = OpenResponsesOptions.TextVerbositySchema
-export const OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludableSchema
-export const OpenAIServiceTier = OpenResponsesOptions.ServiceTierSchema
+const TEXT_VERBOSITY = new Set<string>(["low", "medium", "high"])
+const INCLUDABLES = new Set<string>(OpenAIResponseIncludables)
+const SERVICE_TIERS = new Set<string>(OpenAIServiceTiers)
+
+export const OpenAIReasoningEffort = Schema.String
+export const OpenAITextVerbosity = TextVerbosity
+export const OpenAIResponseIncludable = Schema.Literals(OpenAIResponseIncludables)
+export const OpenAIServiceTier = Schema.Literals(OpenAIServiceTiers)
 
 export const isReasoningEffort = (effort: unknown): effort is OpenAIReasoningEffort => typeof effort === "string"
 
-export const resolve = OpenResponsesOptions.resolve
+const isTextVerbosity = (value: unknown): value is TextVerbosityValue =>
+  typeof value === "string" && TEXT_VERBOSITY.has(value)
+
+const options = (request: LLMRequest) => request.providerOptions?.openai
+
+export const store = (request: LLMRequest): boolean | undefined => {
+  const value = options(request)?.store
+  return typeof value === "boolean" ? value : undefined
+}
+
+export const reasoningEffort = (request: LLMRequest): string | undefined => {
+  const value = options(request)?.reasoningEffort
+  return typeof value === "string" ? value : undefined
+}
+
+export const reasoningSummary = (request: LLMRequest): "auto" | undefined =>
+  options(request)?.reasoningSummary === "auto" ? "auto" : undefined
+
+// Resolve the OpenAI Responses `include` field. Filters out unknown
+// includable values defensively so a typo in upstream config drops the
+// invalid entry instead of poisoning the wire body. An empty array (either
+// passed directly or produced by filtering) is treated as "no include" and
+// returns undefined so the request body omits the field entirely.
+export const include = (request: LLMRequest): ReadonlyArray<OpenAIResponseIncludable> | undefined => {
+  const value = options(request)?.include
+  if (!Array.isArray(value)) return undefined
+  const filtered = value.filter((entry): entry is OpenAIResponseIncludable => INCLUDABLES.has(entry))
+  return filtered.length > 0 ? filtered : undefined
+}
+
+export const promptCacheKey = (request: LLMRequest) => {
+  const value = options(request)?.promptCacheKey
+  return typeof value === "string" ? value : undefined
+}
+
+export const textVerbosity = (request: LLMRequest) => {
+  const value = options(request)?.textVerbosity
+  return isTextVerbosity(value) ? value : undefined
+}
+
+export const serviceTier = (request: LLMRequest) => {
+  const value = options(request)?.serviceTier
+  return typeof value === "string" && SERVICE_TIERS.has(value) ? (value as OpenAIServiceTier) : undefined
+}
+
+export const instructions = (request: LLMRequest) => {
+  const value = options(request)?.instructions
+  return typeof value === "string" ? value : undefined
+}
 
 export * as OpenAIOptions from "./openai-options"

packages/ai/src/protocols/utils/tool-schema.ts

@@ -63,8 +63,6 @@ const openAI = (schema: JsonSchema): JsonSchema => {
   return isRecord(normalized) ? normalized : { type: "object" }
 }
 
-const responses = openAI
-
 const gemini = (schema: JsonSchema): JsonSchema => GeminiToolSchema.convert(schema) ?? {}
 
 const modelCompatibility = (
@@ -85,5 +83,4 @@ export const ToolSchemaProjection = {
   modelCompatibility,
   moonshot,
   openAI,
-  responses,
 } as const

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

@@ -1,202 +0,0 @@
-import { Effect, Encoding, Schema } from "effect"
-import { Headers, HttpClientRequest } from "effect/unstable/http"
-import { GeneratedImage, ImageModel, ImageResponse, type ImageRequestFor, type ImageRoute } from "../image"
-import { Auth, type Definition as AuthDefinition } from "../route/auth"
-import {
-  InvalidProviderOutputReason,
-  LLMError,
-  Usage,
-  mergeHttpOptions,
-  mergeJsonRecords,
-  type HttpOptions,
-} from "../schema"
-import { ProviderShared, optionalNull } from "./shared"
-import { ImageInputs } from "./utils/image-input"
-
-const ADAPTER = "xai-images"
-export const DEFAULT_BASE_URL = "https://api.x.ai/v1"
-export const PATH = "/images/generations"
-export const EDIT_PATH = "/images/edits"
-
-export type XAIImageString<Known extends string> = Known | (string & {})
-
-export type XAIImageOptions = {
-  readonly n?: number
-  readonly aspectRatio?: XAIImageString<
-    | "1:1"
-    | "3:4"
-    | "4:3"
-    | "9:16"
-    | "16:9"
-    | "2:3"
-    | "3:2"
-    | "9:19.5"
-    | "19.5:9"
-    | "9:20"
-    | "20:9"
-    | "1:2"
-    | "2:1"
-    | "auto"
-  >
-  readonly aspect_ratio?: XAIImageString<
-    | "1:1"
-    | "3:4"
-    | "4:3"
-    | "9:16"
-    | "16:9"
-    | "2:3"
-    | "3:2"
-    | "9:19.5"
-    | "19.5:9"
-    | "9:20"
-    | "20:9"
-    | "1:2"
-    | "2:1"
-    | "auto"
-  >
-  readonly resolution?: XAIImageString<"1k" | "2k">
-  readonly responseFormat?: XAIImageString<"url" | "b64_json">
-  readonly response_format?: XAIImageString<"url" | "b64_json">
-} & Record<string, unknown>
-
-type XAIImageBody = Record<string, unknown> & {
-  readonly model: string
-  readonly prompt: string
-}
-
-const XAIImageResponse = Schema.Struct({
-  data: Schema.Array(
-    Schema.Struct({
-      b64_json: optionalNull(Schema.String),
-      url: optionalNull(Schema.String),
-      revised_prompt: optionalNull(Schema.String),
-      mime_type: optionalNull(Schema.String),
-    }),
-  ),
-  usage: Schema.optional(Schema.Unknown),
-})
-
-export interface ModelInput {
-  readonly id: string
-  readonly auth: AuthDefinition
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions
-}
-
-const nativeOptions = (options: XAIImageOptions | undefined) => {
-  if (!options) return undefined
-  const { aspectRatio, responseFormat, ...native } = options
-  return {
-    aspect_ratio: aspectRatio,
-    response_format: responseFormat,
-    ...native,
-  }
-}
-
-const invalidOutput = (message: string) =>
-  new LLMError({
-    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)
-  Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value))
-  return next.toString()
-}
-
-export const model = (input: ModelInput) => {
-  const route: ImageRoute<XAIImageOptions> = {
-    id: ADAPTER,
-    generate: Effect.fn("XAIImages.generate")(function* (request: ImageRequestFor<XAIImageOptions>, execute) {
-      const http = mergeHttpOptions(request.model.http, request.http)
-      const imageReferences = (request.images ?? []).map((image) => {
-        if (image.type === "bytes") return { url: ImageInputs.dataUrl(image), type: "image_url" as const }
-        if (image.type === "url") return { url: image.url, type: "image_url" as const }
-        if (image.type === "file-id") return { file_id: image.id }
-        return undefined
-      })
-      if (imageReferences.some((image) => image === undefined))
-        return yield* ImageInputs.invalid(ADAPTER, "xAI Images accepts image URLs, data URLs, bytes, and file IDs")
-      const requestBody = mergeJsonRecords(
-        {
-          model: request.model.id,
-          prompt: request.prompt,
-          image: imageReferences.length === 1 ? imageReferences[0] : undefined,
-          images: imageReferences.length > 1 ? imageReferences : undefined,
-        },
-        nativeOptions(request.options),
-        http?.body,
-      ) as XAIImageBody
-      const text = ProviderShared.encodeJson(requestBody)
-      const url = applyQuery(
-        `${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${imageReferences.length === 0 ? PATH : EDIT_PATH}`,
-        http?.query,
-      )
-      const headers = yield* Auth.toEffect(input.auth)({
-        request,
-        method: "POST",
-        url,
-        body: text,
-        headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-      })
-      const response = yield* execute(
-        HttpClientRequest.post(url).pipe(
-          HttpClientRequest.setHeaders(headers),
-          HttpClientRequest.bodyText(text, "application/json"),
-        ),
-      )
-      const payload = yield* response.json.pipe(
-        Effect.mapError(() => invalidOutput("Failed to read the xAI Images response")),
-      )
-      const decoded = yield* Schema.decodeUnknownEffect(XAIImageResponse)(payload).pipe(
-        Effect.mapError(() => invalidOutput("xAI Images returned an invalid response")),
-      )
-      const images = yield* Effect.forEach(decoded.data, (item, index) => {
-        const mediaType = item.mime_type ?? "application/octet-stream"
-        if (item.b64_json)
-          return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
-            Effect.mapError(() => invalidOutput(`xAI Images result ${index} contains invalid base64 data`)),
-            Effect.map(
-              (data) =>
-                new GeneratedImage({
-                  mediaType,
-                  data,
-                  providerMetadata:
-                    item.revised_prompt === undefined || item.revised_prompt === null
-                      ? undefined
-                      : { xai: { revisedPrompt: item.revised_prompt } },
-                }),
-            ),
-          )
-        if (item.url)
-          return Effect.succeed(
-            new GeneratedImage({
-              mediaType,
-              data: item.url,
-              providerMetadata:
-                item.revised_prompt === undefined || item.revised_prompt === null
-                  ? undefined
-                  : { xai: { revisedPrompt: item.revised_prompt } },
-            }),
-          )
-        return Effect.fail(invalidOutput(`xAI Images result ${index} has neither image data nor a URL`))
-      })
-      if (images.length === 0) return yield* invalidOutput("xAI Images returned no images")
-      const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined
-      return new ImageResponse({
-        images,
-        usage: usage === undefined ? undefined : new Usage({ providerMetadata: { xai: usage } }),
-        providerMetadata: usage === undefined ? undefined : { xai: { usage } },
-      })
-    }),
-  }
-  return ImageModel.make<XAIImageOptions>({ id: input.id, provider: "xai", route, http: input.http })
-}
-
-export const XAIImages = {
-  model,
-} as const

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

@@ -1,132 +0,0 @@
-import { Effect, Schema } from "effect"
-import { Headers, HttpClientRequest } from "effect/unstable/http"
-import { GeneratedImage, ImageModel, ImageResponse, type ImageRequestFor, type ImageRoute } from "../image"
-import { Auth, type Definition as AuthDefinition } from "../route/auth"
-import { InvalidProviderOutputReason, LLMError, mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema"
-import { ProviderShared } from "./shared"
-import { ImageInputs } from "./utils/image-input"
-
-const ADAPTER = "zai-images"
-export const DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4"
-export const PATH = "/images/generations"
-
-export type ZAIImageString<Known extends string> = Known | (string & {})
-
-export type ZAIImageOptions = {
-  readonly size?: ZAIImageString<
-    "1024x1024" | "768x1344" | "864x1152" | "1344x768" | "1152x864" | "1440x720" | "720x1440"
-  >
-  readonly quality?: ZAIImageString<"hd" | "standard">
-  readonly userID?: string
-} & Record<string, unknown>
-
-type ZAIImageBody = Record<string, unknown> & {
-  readonly model: string
-  readonly prompt: string
-}
-
-const ZAIImageResponse = Schema.Struct({
-  created: Schema.optional(Schema.Int),
-  id: Schema.optional(Schema.String),
-  request_id: Schema.optional(Schema.String),
-  data: Schema.Array(Schema.Struct({ url: Schema.String })),
-  content_filter: Schema.optional(
-    Schema.Array(
-      Schema.Struct({
-        role: Schema.optional(Schema.String),
-        level: Schema.optional(Schema.Number),
-      }),
-    ),
-  ),
-})
-
-export interface ModelInput {
-  readonly id: string
-  readonly auth: AuthDefinition
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions
-}
-
-const nativeOptions = (options: ZAIImageOptions | undefined) => {
-  if (!options) return undefined
-  const { userID, ...native } = options
-  return {
-    user_id: userID,
-    ...native,
-  }
-}
-
-const invalidOutput = (message: string) =>
-  new LLMError({
-    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)
-  Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value))
-  return next.toString()
-}
-
-export const model = (input: ModelInput) => {
-  const route: ImageRoute<ZAIImageOptions> = {
-    id: ADAPTER,
-    generate: Effect.fn("ZAIImages.generate")(function* (request: ImageRequestFor<ZAIImageOptions>, execute) {
-      if ((request.images?.length ?? 0) > 0)
-        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 },
-        nativeOptions(request.options),
-        http?.body,
-      ) as ZAIImageBody
-      const text = ProviderShared.encodeJson(requestBody)
-      const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${PATH}`, http?.query)
-      const headers = yield* Auth.toEffect(input.auth)({
-        request,
-        method: "POST",
-        url,
-        body: text,
-        headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-      })
-      const response = yield* execute(
-        HttpClientRequest.post(url).pipe(
-          HttpClientRequest.setHeaders(headers),
-          HttpClientRequest.bodyText(text, "application/json"),
-        ),
-      )
-      const payload = yield* response.json.pipe(
-        Effect.mapError(() => invalidOutput("Failed to read the Z.ai Images response")),
-      )
-      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) =>
-            new GeneratedImage({
-              mediaType: "application/octet-stream",
-              data: item.url,
-            }),
-        ),
-        providerMetadata: {
-          zai: {
-            created: decoded.created,
-            id: decoded.id,
-            requestID: decoded.request_id,
-            contentFilter: decoded.content_filter,
-          },
-        },
-      })
-    }),
-  }
-  return ImageModel.make<ZAIImageOptions>({ id: input.id, provider: "zai", route, http: input.http })
-}
-
-export const ZAIImages = {
-  model,
-} as const

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

@@ -5,17 +5,12 @@ import type { ProviderAuthOption } from "../route/auth-options"
 import type { RouteDefaultsInput } from "../route/client"
 import { ProviderID, type ModelID } from "../schema"
 
-export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
-export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
-export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput
-
 export const id = ProviderID.make("anthropic-compatible")
 
 export type Config = RouteDefaultsInput &
   ProviderAuthOption<"optional"> & {
     readonly provider?: string
     readonly baseURL: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
   }
 
 export type Settings = ProviderPackage.Settings &
@@ -25,7 +20,6 @@ export type Settings = ProviderPackage.Settings &
   ) & {
     readonly baseURL: string
     readonly provider?: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
   }
 
 export const routes = [AnthropicMessages.route]
@@ -67,7 +61,6 @@ export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, se
     http: settings.body === undefined ? undefined : { body: { ...settings.body } },
     limits: settings.limits,
     provider: settings.provider,
-    providerOptions: settings.providerOptions,
   }).model(modelID)
 }
 

packages/ai/src/providers/anthropic.ts

@@ -6,19 +6,11 @@ import { ProviderID, type ModelID } from "../schema"
 import { AnthropicMessages } from "../protocols/anthropic-messages"
 import { AnthropicCompatible } from "./anthropic-compatible"
 
-export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
-export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
-export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput
-
 export const id = ProviderID.make("anthropic")
 
 export const routes = [AnthropicMessages.route]
 
-export type Config = RouteDefaultsInput &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
-  }
+export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & { readonly baseURL?: string }
 
 export type Settings = ProviderPackage.Settings &
   (
@@ -26,7 +18,6 @@ export type Settings = ProviderPackage.Settings &
     | { readonly apiKey?: never; readonly authToken?: string }
   ) & {
     readonly baseURL?: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
   }
 
 const auth = (options: ProviderAuthOption<"optional">) => {
@@ -61,6 +52,5 @@ export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, se
     headers: settings.headers === undefined ? undefined : { ...settings.headers },
     http: settings.body === undefined ? undefined : { body: { ...settings.body } },
     limits: settings.limits,
-    providerOptions: settings.providerOptions,
   }).model(modelID)
 }

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

@@ -6,13 +6,9 @@ import { Route, type RouteDefaultsInput } from "../route/client"
 import { Endpoint } from "../route/endpoint"
 import { Framing } from "../route/framing"
 import { Protocol } from "../route/protocol"
-import { ProviderID, type ModelID } from "../schema"
+import { ProviderID, type ModelID, type ProviderOptions } from "../schema"
 import { GoogleVertexShared } from "./google-vertex-shared"
 
-export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
-export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
-export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput
-
 const VERSION = "vertex-2023-10-16" as const
 
 // models.dev uses this provider id even though the API contract is Anthropic Messages.
@@ -23,7 +19,6 @@ export type Config = RouteDefaultsInput &
     readonly baseURL?: string
     readonly location?: string
     readonly project?: string
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
   }
 
 export interface Settings extends ProviderPackage.Settings {
@@ -32,7 +27,7 @@ export interface Settings extends ProviderPackage.Settings {
   readonly baseURL?: string
   readonly location?: string
   readonly project?: string
-  readonly providerOptions?: AnthropicMessages.ProviderOptionsInput
+  readonly providerOptions?: ProviderOptions
 }
 
 const route = Route.make({

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

@@ -25,7 +25,6 @@ export interface Settings extends ProviderPackage.Settings {
 const route = OpenAICompatibleResponses.route.with({
   id: "google-vertex-responses",
   provider: id,
-  providerOptions: { openresponses: { store: false } },
 })
 
 export const routes = [route]

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

@@ -4,12 +4,9 @@ import { Auth } from "../route/auth"
 import { Route, type RouteDefaultsInput } from "../route/client"
 import { Endpoint } from "../route/endpoint"
 import { Framing } from "../route/framing"
-import { ProviderID, type ModelID } from "../schema"
+import { ProviderID, type ModelID, type ProviderOptions } from "../schema"
 import { GoogleVertexShared } from "./google-vertex-shared"
 
-export type GeminiOptionsInput = Gemini.OptionsInput
-export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput
-
 export const id = ProviderID.make("google-vertex")
 
 export type Config = RouteDefaultsInput &
@@ -17,7 +14,6 @@ export type Config = RouteDefaultsInput &
     readonly baseURL?: string
     readonly location?: string
     readonly project?: string
-    readonly providerOptions?: Gemini.ProviderOptionsInput
   }
 
 export type Settings = ProviderPackage.Settings &
@@ -28,7 +24,7 @@ export type Settings = ProviderPackage.Settings &
     readonly baseURL?: string
     readonly location?: string
     readonly project?: string
-    readonly providerOptions?: Gemini.ProviderOptionsInput
+    readonly providerOptions?: ProviderOptions
   }
 
 const route = Route.make({

packages/ai/src/providers/google.ts

@@ -2,28 +2,19 @@ import type { RouteDefaultsInput } from "../route/client"
 import { Auth } from "../route/auth"
 import type { ProviderAuthOption } from "../route/auth-options"
 import type { ProviderPackage } from "../provider-package"
-import { HttpOptions, ProviderID, mergeHttpOptions, type ModelID } from "../schema"
-import { Gemini } from "../protocols/gemini"
-import { GoogleImages } from "../protocols/google-images"
-
-export type { GoogleImageOptions } from "../protocols/google-images"
-export type GeminiOptionsInput = Gemini.OptionsInput
-export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput
+import { ProviderID, type ModelID, type ProviderOptions } from "../schema"
+import * as Gemini from "../protocols/gemini"
 
 export const id = ProviderID.make("google")
 
 export const routes = [Gemini.route]
 
-export type Config = RouteDefaultsInput &
-  ProviderAuthOption<"optional"> & {
-    readonly baseURL?: string
-    readonly providerOptions?: Gemini.ProviderOptionsInput
-  }
+export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & { readonly baseURL?: string }
 
 export interface Settings extends ProviderPackage.Settings {
   readonly apiKey?: string
   readonly baseURL?: string
-  readonly providerOptions?: Gemini.ProviderOptionsInput
+  readonly providerOptions?: ProviderOptions
 }
 
 const auth = (options: ProviderAuthOption<"optional">) => {
@@ -40,18 +31,9 @@ const configuredRoute = (input: Config) => {
 
 export const configure = (input: Config = {}) => {
   const route = configuredRoute(input)
-  const image = (modelID: string | ModelID) =>
-    GoogleImages.model({
-      id: modelID,
-      auth: auth(input),
-      baseURL: input.baseURL,
-      headers: input.headers,
-      http: mergeHttpOptions(input.http === undefined ? undefined : HttpOptions.make(input.http)),
-    })
   return {
     id,
     model: (modelID: string | ModelID) => route.model({ id: modelID }),
-    image,
     configure,
   }
 }
@@ -66,5 +48,3 @@ export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, se
     limits: settings.limits,
     providerOptions: settings.providerOptions,
   }).model(modelID)
-
-export const image = provider.image

packages/ai/src/providers/index.ts

@@ -15,4 +15,3 @@ export * as OpenAICompatible from "./openai-compatible"
 export * as OpenAICompatibleResponses from "./openai-compatible-responses"
 export * as OpenRouter from "./openrouter"
 export * as XAI from "./xai"
-export * as ZAI from "./zai"

packages/ai/src/providers/open-responses-options.ts

@@ -1,20 +0,0 @@
-import type { ResponseIncludable, ServiceTier } from "../protocols/utils/open-responses-options"
-import type { ProviderOptions, ReasoningEffort, TextVerbosity } from "../schema"
-
-export interface OpenResponsesOptionsInput {
-  readonly [key: string]: unknown
-  readonly instructions?: string
-  readonly store?: boolean
-  readonly promptCacheKey?: string
-  readonly reasoningEffort?: ReasoningEffort
-  readonly reasoningSummary?: "auto" | "concise" | "detailed"
-  readonly include?: ReadonlyArray<ResponseIncludable>
-  readonly textVerbosity?: TextVerbosity
-  readonly serviceTier?: ServiceTier
-}
-
-export type OpenResponsesProviderOptionsInput = ProviderOptions & {
-  readonly openresponses?: OpenResponsesOptionsInput
-}
-
-export * as OpenResponsesProviderOptions from "./open-responses-options"

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

@@ -3,9 +3,7 @@ import { OpenAICompatibleResponses } from "../protocols/openai-compatible-respon
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
 import type { RouteDefaultsInput } from "../route/client"
 import { ProviderID, type ModelID } from "../schema"
-import type { OpenResponsesProviderOptionsInput } from "./open-responses-options"
-
-export type { OpenResponsesOptionsInput, OpenResponsesProviderOptionsInput } from "./open-responses-options"
+import type { OpenAIProviderOptionsInput } from "./openai-options"
 
 export const id = ProviderID.make("openai-compatible")
 
@@ -13,14 +11,13 @@ export type Config = RouteDefaultsInput &
   ProviderAuthOption<"optional"> & {
     readonly provider?: string
     readonly baseURL: string
-    readonly providerOptions?: OpenResponsesProviderOptionsInput
   }
 
 export interface Settings extends ProviderPackage.Settings {
   readonly apiKey?: string
   readonly baseURL: string
   readonly provider?: string
-  readonly providerOptions?: OpenResponsesProviderOptionsInput
+  readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
 export const routes = [OpenAICompatibleResponses.route]

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

@@ -1,10 +1,22 @@
-import type { ProviderOptions } from "../schema"
+import type { ProviderOptions, ReasoningEffort, TextVerbosity } from "../schema"
 import { mergeProviderOptions } from "../schema"
-import type { OpenResponsesOptionsInput } from "./open-responses-options"
+import type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options"
 
 export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options"
 
-export type OpenAIOptionsInput = OpenResponsesOptionsInput
+export interface OpenAIOptionsInput {
+  readonly [key: string]: unknown
+  readonly store?: boolean
+  readonly promptCacheKey?: string
+  readonly reasoningEffort?: ReasoningEffort
+  readonly reasoningSummary?: "auto"
+  // OpenAI Responses `include` wire field. Mirrors the official SDK's
+  // `ResponseIncludable[]` union exactly so AI SDK callers and direct
+  // native-SDK callers share one shape and no translation is required.
+  readonly include?: ReadonlyArray<OpenAIResponseIncludable>
+  readonly textVerbosity?: TextVerbosity
+  readonly serviceTier?: OpenAIServiceTier
+}
 
 export type OpenAIProviderOptionsInput = ProviderOptions & {
   readonly openai?: OpenAIOptionsInput

packages/ai/src/providers/openai.ts

@@ -5,7 +5,7 @@ import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions, type ModelID
 import * as OpenAIChat from "../protocols/openai-chat"
 import * as OpenAIResponses from "../protocols/openai-responses"
 import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options"
-import { OpenAIImages, type OpenAIImageString } from "../protocols/openai-images"
+import { OpenAIImages, type OpenAIImageOptions } from "../protocols/openai-images"
 
 export type { OpenAIOptionsInput, OpenAIResponseIncludable } from "./openai-options"
 export type { OpenAIImageOptions } from "../protocols/openai-images"
@@ -22,19 +22,22 @@ export type Config = RouteDefaultsInput &
     readonly baseURL?: string
     readonly queryParams?: Record<string, string>
     readonly providerOptions?: OpenAIProviderOptionsInput
+    readonly image?: ImageConfig
   }
 
+export interface ImageConfig {
+  readonly providerOptions?: OpenAIImageOptions
+}
+
 export interface ImageGenerationOptions {
-  readonly action?: OpenAIImageString<"auto" | "generate" | "edit">
-  readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">
-  readonly inputFidelity?: OpenAIImageString<"low" | "high">
+  readonly action?: "auto" | "generate" | "edit"
+  readonly background?: "auto" | "opaque" | "transparent"
+  readonly inputFidelity?: "low" | "high"
   readonly outputCompression?: number
-  readonly outputFormat?: OpenAIImageString<"png" | "jpeg" | "webp">
+  readonly outputFormat?: "png" | "jpeg" | "webp"
   readonly partialImages?: number
-  readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">
-  readonly size?: OpenAIImageString<
-    "auto" | "256x256" | "512x512" | "1024x1024" | "1536x1024" | "1024x1536" | "1792x1024" | "1024x1792"
-  >
+  readonly quality?: "auto" | "low" | "medium" | "high"
+  readonly size?: string
 }
 
 export const imageGeneration = (options: ImageGenerationOptions = {}) =>
@@ -70,7 +73,7 @@ export interface Settings extends ProviderPackage.Settings {
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "OPENAI_API_KEY")
 
 const defaults = (input: Config) => {
-  const { apiKey: _, auth: _auth, baseURL: _baseURL, queryParams: _queryParams, ...rest } = input
+  const { apiKey: _, auth: _auth, baseURL: _baseURL, queryParams: _queryParams, image: _image, ...rest } = input
   return rest
 }
 
@@ -96,10 +99,14 @@ export const configure = (input: Config = {}) => {
       auth: auth(input),
       baseURL: input.baseURL,
       headers: input.headers,
-      http: mergeHttpOptions(
-        input.http === undefined ? undefined : HttpOptions.make(input.http),
-        input.queryParams === undefined ? undefined : new HttpOptions({ query: input.queryParams }),
-      ),
+      defaults: {
+        providerOptions:
+          input.image?.providerOptions === undefined ? undefined : { openai: { ...input.image.providerOptions } },
+        http: mergeHttpOptions(
+          input.http === undefined ? undefined : HttpOptions.make(input.http),
+          input.queryParams === undefined ? undefined : new HttpOptions({ query: input.queryParams }),
+        ),
+      },
     })
 
   return {

packages/ai/src/providers/xai.ts

@@ -1,10 +1,9 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
 import type { RouteDefaultsInput } from "../route/client"
-import { HttpOptions, ProviderID, type ModelID } from "../schema"
+import { ProviderID, type ModelID } from "../schema"
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
 import * as OpenAIResponses from "../protocols/openai-responses"
-import { XAIImages } from "../protocols/xai-images"
 
 export const id = ProviderID.make("xai")
 
@@ -13,8 +12,6 @@ export type ModelOptions = RouteDefaultsInput &
     readonly baseURL?: string
   }
 
-export type { XAIImageOptions } from "../protocols/xai-images"
-
 export const routes = [OpenAIResponses.route, OpenAICompatibleChat.route]
 
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "XAI_API_KEY")
@@ -44,20 +41,11 @@ export const configure = (input: ModelOptions = {}) => {
   const chatRoute = configuredChatRoute(input)
   const responses = (modelID: string | ModelID) => responsesRoute.model({ id: modelID })
   const chat = (modelID: string | ModelID) => chatRoute.model({ id: modelID })
-  const image = (modelID: string | ModelID) =>
-    XAIImages.model({
-      id: modelID,
-      auth: auth(input),
-      baseURL: input.baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL,
-      headers: input.headers,
-      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-    })
   return {
     id,
     model: responses,
     responses,
     chat,
-    image,
     configure,
   }
 }
@@ -66,4 +54,3 @@ export const provider = configure()
 export const model = provider.model
 export const responses = provider.responses
 export const chat = provider.chat
-export const image = provider.image

packages/ai/src/providers/zai.ts

@@ -1,35 +0,0 @@
-import { ZAIImages } from "../protocols/zai-images"
-import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
-import { HttpOptions, ProviderID, type ModelID } from "../schema"
-
-export const id = ProviderID.make("zai")
-
-export type Config = ProviderAuthOption<"optional"> & {
-  readonly baseURL?: string
-  readonly headers?: Record<string, string>
-  readonly http?: HttpOptions.Input
-}
-
-export type { ZAIImageOptions } from "../protocols/zai-images"
-
-const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "ZAI_API_KEY")
-
-export const configure = (input: Config = {}) => {
-  const image = (modelID: string | ModelID) =>
-    ZAIImages.model({
-      id: modelID,
-      auth: auth(input),
-      baseURL: input.baseURL,
-      headers: input.headers,
-      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
-    })
-
-  return {
-    id,
-    image,
-    configure,
-  }
-}
-
-export const provider = configure()
-export const image = provider.image

packages/ai/src/route/client.ts

@@ -412,7 +412,7 @@ const streamRequestWith = (runtime: TransportRuntime) => (request: LLMRequest) =
   )
 
 const generateWith = (stream: Interface["stream"]) =>
-  Effect.fn("LLM.generateTurn")(function* (request: LLMRequest) {
+  Effect.fn("LLM.generate")(function* (request: LLMRequest) {
     const state = yield* stream(request).pipe(Stream.runFold(LLMResponse.empty, LLMResponse.reduce))
     const response = LLMResponse.complete(state)
     if (response) return response

packages/ai/src/route/protocol.ts

@@ -12,8 +12,7 @@ import type { LLMError, LLMEvent, LLMRequest, ProtocolID } from "../schema"
  * Examples:
  *
  * - `OpenAIChat.protocol` — chat completions style
- * - `OpenResponses.protocol` — provider-neutral Responses API baseline
- * - `OpenAIResponses.protocol` — OpenAI extensions to that baseline
+ * - `OpenAIResponses.protocol` — responses API
  * - `AnthropicMessages.protocol` — messages API with content blocks
  * - `Gemini.protocol` — generateContent
  * - `BedrockConverse.protocol` — Converse with binary event-stream framing

packages/ai/src/schema/events.ts

@@ -34,12 +34,11 @@ import { ProviderFailureClassification } from "./errors"
  *
  * **Semantics by provider**:
  *
- * - OpenAI Chat / Responses / Gemini: provider reports inclusive
+ * - OpenAI Chat / Responses / Gemini / Bedrock: provider reports inclusive
  *   `inputTokens` and an inclusive `outputTokens`; mapper subtracts to
  *   derive the breakdown.
- * - Anthropic and Bedrock report the input breakdown natively: Anthropic's
- *   `input_tokens` and Bedrock's `inputTokens` are non-cached only. Their
- *   mappers sum the breakdown to derive the inclusive `inputTokens`.
+ * - Anthropic: provider reports the breakdown natively (`input_tokens` is
+ *   non-cached only); mapper sums to derive the inclusive `inputTokens`.
  *   Anthropic does *not* break extended-thinking out of `output_tokens`, so
  *   `reasoningTokens` is `undefined` and `outputTokens` carries the
  *   combined total — a documented limitation of the Anthropic API.
@@ -191,16 +190,10 @@ export const ToolError = Schema.Struct({
 }).annotate({ identifier: "LLM.Event.ToolError" })
 export type ToolError = Schema.Schema.Type<typeof ToolError>
 
-export const FinishReasonDetails = Schema.Struct({
-  normalized: FinishReason,
-  raw: Schema.optional(Schema.String),
-}).annotate({ identifier: "LLM.FinishReasonDetails" })
-export type FinishReasonDetails = Schema.Schema.Type<typeof FinishReasonDetails>
-
 export const StepFinish = Schema.Struct({
   type: Schema.tag("step-finish"),
   index: Schema.Number,
-  reason: FinishReasonDetails,
+  reason: FinishReason,
   usage: Schema.optional(Usage),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.StepFinish" })
@@ -208,7 +201,7 @@ export type StepFinish = Schema.Schema.Type<typeof StepFinish>
 
 export const Finish = Schema.Struct({
   type: Schema.tag("finish"),
-  reason: FinishReasonDetails,
+  reason: FinishReason,
   usage: Schema.optional(Usage),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.Finish" })
@@ -371,7 +364,7 @@ interface ResponseState {
   readonly events: ReadonlyArray<LLMEvent>
   readonly message: Message
   readonly usage?: Usage
-  readonly finishReason?: FinishReasonDetails
+  readonly finishReason?: FinishReason
   readonly textParts: Readonly<Record<string, ContentAssembly>>
   readonly reasoningParts: Readonly<Record<string, ContentAssembly>>
   readonly toolInputs: Readonly<Record<string, ToolInputAssembly>>
@@ -399,7 +392,7 @@ const appendEvent = (state: ResponseState, event: LLMEvent): ResponseState => {
     return {
       ...state,
       events,
-      finishReason: state.finishReason ?? { normalized: "error" },
+      finishReason: state.finishReason ?? "error",
     }
   }
   return {
@@ -586,7 +579,7 @@ export class LLMResponse extends Schema.Class<LLMResponse>("LLM.Response")({
   message: Message,
   events: Schema.Array(LLMEvent),
   usage: Schema.optional(Usage),
-  finishReason: FinishReasonDetails,
+  finishReason: FinishReason,
 }) {
   /** Concatenated assistant text assembled from streamed `text-delta` events. */
   get text() {

packages/ai/src/schema/messages.ts

@@ -261,6 +261,13 @@ export namespace ToolChoice {
   }
 }
 
+export const ResponseFormat = Schema.Union([
+  Schema.Struct({ type: Schema.Literal("text") }),
+  Schema.Struct({ type: Schema.Literal("json"), schema: JsonSchema }),
+  Schema.Struct({ type: Schema.Literal("tool"), tool: ToolDefinition }),
+]).pipe(Schema.toTaggedUnion("type"))
+export type ResponseFormat = Schema.Schema.Type<typeof ResponseFormat>
+
 export class LLMRequest extends Schema.Class<LLMRequest>("LLM.Request")({
   id: Schema.optional(Schema.String),
   model: ModelSchema,
@@ -271,6 +278,7 @@ export class LLMRequest extends Schema.Class<LLMRequest>("LLM.Request")({
   generation: Schema.optional(GenerationOptions),
   providerOptions: Schema.optional(ProviderOptions),
   http: Schema.optional(HttpOptions),
+  responseFormat: Schema.optional(ResponseFormat),
   cache: Schema.optional(CachePolicy),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 }) {}
@@ -288,6 +296,7 @@ export namespace LLMRequest {
     generation: request.generation,
     providerOptions: request.providerOptions,
     http: request.http,
+    responseFormat: request.responseFormat,
     cache: request.cache,
     metadata: request.metadata,
   })

packages/ai/src/schema/options.ts

@@ -168,7 +168,6 @@ export type ModelToolSchemaCompatibility = Schema.Schema.Type<typeof ModelToolSc
 
 export class ModelCompatibility extends Schema.Class<ModelCompatibility>("LLM.ModelCompatibility")({
   toolSchema: Schema.optional(ModelToolSchemaCompatibility),
-  reasoningField: Schema.optional(Schema.String),
 }) {}
 
 export namespace ModelCompatibility {

packages/ai/src/tool-runtime.ts

@@ -68,29 +68,10 @@ const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement,
     events:
       settlement.result.type === "error"
         ? [
-            LLMEvent.toolError({
-              id: call.id,
-              name: call.name,
-              message: String(settlement.result.value),
-              error,
-              providerMetadata: call.providerMetadata,
-            }),
-            LLMEvent.toolResult({
-              id: call.id,
-              name: call.name,
-              result: settlement.result,
-              providerMetadata: call.providerMetadata,
-            }),
+            LLMEvent.toolError({ id: call.id, name: call.name, message: String(settlement.result.value), error }),
+            LLMEvent.toolResult({ id: call.id, name: call.name, result: settlement.result }),
           ]
-        : [
-            LLMEvent.toolResult({
-              id: call.id,
-              name: call.name,
-              result: settlement.result,
-              output: settlement.output,
-              providerMetadata: call.providerMetadata,
-            }),
-          ],
+        : [LLMEvent.toolResult({ id: call.id, name: call.name, result: settlement.result, output: settlement.output })],
   }
 }
 

packages/ai/test/adapter.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Effect, Schema, Stream } from "effect"
-import { LLM, LLMRequest, LLMResponse } from "../src"
+import { LLM, LLMResponse } from "../src"
 import { Route, Endpoint, LLMClient, Protocol, type FramingDef } from "../src/route"
 import { Model } from "../src/schema"
 import { testEffect } from "./lib/effect"
@@ -40,7 +40,7 @@ const fakeFraming: FramingDef<FakeEvent> = {
 
 const raiseEvent = (event: FakeEvent): import("../src/schema").LLMEvent =>
   event.type === "finish"
-    ? { type: "finish", reason: { normalized: event.reason } }
+    ? { type: "finish", reason: event.reason }
     : { type: "text-delta", id: "text-0", text: event.text }
 
 const fakeProtocol = Protocol.make<FakeBody, FakeEvent, FakeEvent, void>({
@@ -141,7 +141,7 @@ describe("llm route", () => {
     Effect.gen(function* () {
       const llm = yield* LLMClient.Service
       const prepared = yield* llm.prepare(
-        LLMRequest.update(request, { model: updateModel(request.model, { route: configuredGemini }) }),
+        LLM.updateRequest(request, { model: updateModel(request.model, { route: configuredGemini }) }),
       )
 
       expect(prepared.route).toBe("gemini-fake")
@@ -174,7 +174,7 @@ describe("llm route", () => {
       })
 
       const prepared = yield* (yield* LLMClient.Service).prepare(
-        LLMRequest.update(request, { model: updateModel(request.model, { route: duplicate }) }),
+        LLM.updateRequest(request, { model: updateModel(request.model, { route: duplicate }) }),
       )
 
       expect(prepared.body).toEqual({ body: "late-default" })

packages/ai/test/auth-options.types.ts

@@ -1,6 +1,7 @@
 import { Config } from "effect"
-import { Auth } from "../src/route"
+import type { Auth } from "../src/route/auth"
 import type { ModelFactory } from "../src/route/auth-options"
+import { Auth as RuntimeAuth } from "../src/route/auth"
 import * as OpenAIChat from "../src/protocols/openai-chat"
 import * as AmazonBedrock from "../src/providers/amazon-bedrock"
 import * as Anthropic from "../src/providers/anthropic"
@@ -27,7 +28,7 @@ type Model = {
   readonly id: string
 }
 
-declare const auth: Auth.Definition
+declare const auth: Auth
 declare const optionalAuthModel: ModelFactory<BaseOptions, "optional", Model>
 declare const requiredAuthModel: ModelFactory<BaseOptions, "required", Model>
 const configApiKey = Config.redacted("OPENAI_API_KEY")
@@ -75,9 +76,9 @@ OpenAI.responses("gpt-4.1-mini")
 OpenAI.configure({}).responses("gpt-4.1-mini")
 OpenAI.configure({ apiKey: "sk-test" }).responses("gpt-4.1-mini")
 OpenAI.configure({ apiKey: configApiKey }).responses("gpt-4.1-mini")
-OpenAI.configure({ auth: Auth.bearer("oauth-token") }).responses("gpt-4.1-mini")
+OpenAI.configure({ auth: RuntimeAuth.bearer("oauth-token") }).responses("gpt-4.1-mini")
 OpenAI.configure({
-  auth: Auth.headers({ authorization: "Bearer gateway" }),
+  auth: RuntimeAuth.headers({ authorization: "Bearer gateway" }),
   baseURL: "https://gateway.example.com/v1",
 }).responses("gpt-4.1-mini")
 OpenAI.configure({
@@ -101,62 +102,51 @@ OpenAI.configure({ generation: { maxTokens: "many" } })
 OpenAI.configure({ providerOptions: { openai: { store: "false" } } })
 
 // @ts-expect-error auth is an override, so OpenAI rejects apiKey with auth.
-OpenAI.configure({ apiKey: "sk-test", auth: Auth.bearer("oauth-token") })
+OpenAI.configure({ apiKey: "sk-test", auth: RuntimeAuth.bearer("oauth-token") })
 
 OpenAI.chat("gpt-4.1-mini")
 OpenAI.configure({ apiKey: "sk-test" }).chat("gpt-4.1-mini")
 OpenAI.configure({ apiKey: configApiKey }).chat("gpt-4.1-mini")
-OpenAI.configure({ auth: Auth.bearer("oauth-token") }).chat("gpt-4.1-mini")
+OpenAI.configure({ auth: RuntimeAuth.bearer("oauth-token") }).chat("gpt-4.1-mini")
 
 // @ts-expect-error OpenAI chat selectors only accept model ids.
 OpenAI.configure({ apiKey: "sk-test" }).chat("gpt-4.1-mini", {})
 
 // @ts-expect-error auth is an override, so OpenAI Chat rejects apiKey with auth.
-OpenAI.configure({ apiKey: "sk-test", auth: Auth.bearer("oauth-token") })
+OpenAI.configure({ apiKey: "sk-test", auth: RuntimeAuth.bearer("oauth-token") })
 
 // @ts-expect-error Azure requires at least one of `resourceName` or `baseURL`.
 Azure.configure()
 Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).responses("deployment")
 Azure.configure({ apiKey: configApiKey, resourceName: "resource" }).responses("deployment")
-Azure.configure({ auth: Auth.header("api-key", "azure-key"), resourceName: "resource" }).responses("deployment")
+Azure.configure({ auth: RuntimeAuth.header("api-key", "azure-key"), resourceName: "resource" }).responses("deployment")
 
 // @ts-expect-error Azure model selectors only accept deployment ids.
 Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).responses("deployment", {})
 
 // @ts-expect-error auth is an override, so Azure rejects apiKey with auth.
-Azure.configure({ resourceName: "resource", apiKey: "azure-key", auth: Auth.header("api-key", "override") })
+Azure.configure({ resourceName: "resource", apiKey: "azure-key", auth: RuntimeAuth.header("api-key", "override") })
 
 Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).chat("deployment")
 Azure.configure({ apiKey: configApiKey, resourceName: "resource" }).chat("deployment")
-Azure.configure({ auth: Auth.header("api-key", "azure-key"), resourceName: "resource" }).chat("deployment")
+Azure.configure({ auth: RuntimeAuth.header("api-key", "azure-key"), resourceName: "resource" }).chat("deployment")
 
 // @ts-expect-error Azure chat model selectors only accept deployment ids.
 Azure.configure({ apiKey: "azure-key", resourceName: "resource" }).chat("deployment", {})
 
 // @ts-expect-error auth is an override, so Azure Chat rejects apiKey with auth.
-Azure.configure({ resourceName: "resource", apiKey: "azure-key", auth: Auth.header("api-key", "override") })
+Azure.configure({ resourceName: "resource", apiKey: "azure-key", auth: RuntimeAuth.header("api-key", "override") })
 
 Anthropic.configure({ apiKey: "anthropic-key" }).model("claude-haiku")
-Anthropic.configure({
-  apiKey: "anthropic-key",
-  providerOptions: {
-    anthropic: { thinking: { type: "enabled", budgetTokens: 1_024 }, effort: "high" },
-  },
-}).model("claude-haiku")
 // @ts-expect-error Anthropic model selectors only accept model ids.
 Anthropic.configure({ apiKey: "anthropic-key" }).model("claude-haiku", {})
 // @ts-expect-error Anthropic package settings accept only one auth source.
 Anthropic.model("claude-sonnet-4-6", { apiKey: "anthropic-key", authToken: "anthropic-token" })
-// @ts-expect-error Enabled Anthropic thinking requires a token budget.
-Anthropic.configure({ providerOptions: { anthropic: { thinking: { type: "enabled" } } } })
-// @ts-expect-error Anthropic thinking budgets must be numbers.
-Anthropic.configure({ providerOptions: { anthropic: { thinking: { type: "enabled", budgetTokens: "large" } } } })
 
 AnthropicCompatible.configure({
   apiKey: "messages-key",
   baseURL: "https://messages.example.com/v1",
   provider: "example",
-  providerOptions: { anthropic: { thinking: { type: "disabled" } } },
 }).model("compatible-model")
 // @ts-expect-error Anthropic-compatible providers require a base URL.
 AnthropicCompatible.configure({ apiKey: "messages-key" })
@@ -170,21 +160,12 @@ AnthropicCompatible.model("compatible-model", {
 })
 
 Google.configure({ apiKey: "google-key" }).model("gemini-2.5-flash")
-Google.configure({
-  apiKey: "google-key",
-  providerOptions: { gemini: { thinkingConfig: { thinkingBudget: 0, includeThoughts: false } } },
-}).model("gemini-2.5-flash")
 // @ts-expect-error Google model selectors only accept model ids.
 Google.configure({ apiKey: "google-key" }).model("gemini-2.5-flash", {})
-// @ts-expect-error Gemini thinking budgets must be numbers.
-Google.configure({ providerOptions: { gemini: { thinkingConfig: { thinkingBudget: "large" } } } })
 
-GoogleVertex.configure({
-  apiKey: "vertex-key",
-  providerOptions: { gemini: { thinkingConfig: { thinkingBudget: 1_024 } } },
-}).model("gemini-3.5-flash")
+GoogleVertex.configure({ apiKey: "vertex-key" }).model("gemini-3.5-flash")
 GoogleVertex.configure({ accessToken: "vertex-token", project: "project" }).model("gemini-3.5-flash")
-GoogleVertex.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model("gemini-3.5-flash")
+GoogleVertex.configure({ auth: RuntimeAuth.bearer("vertex-token"), project: "project" }).model("gemini-3.5-flash")
 // @ts-expect-error Vertex Gemini model selectors only accept model ids.
 GoogleVertex.configure({ apiKey: "vertex-key" }).model("gemini-3.5-flash", {})
 // @ts-expect-error Vertex Gemini config accepts only one auth source.
@@ -193,7 +174,7 @@ GoogleVertex.configure({ accessToken: "vertex-token", apiKey: "vertex-key", proj
 GoogleVertex.model("gemini-3.5-flash", { accessToken: "vertex-token", apiKey: "vertex-key", project: "project" })
 
 GoogleVertexChat.configure({ accessToken: "vertex-token", project: "project" }).model("deepseek-ai/deepseek-v3.2-maas")
-GoogleVertexChat.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model(
+GoogleVertexChat.configure({ auth: RuntimeAuth.bearer("vertex-token"), project: "project" }).model(
   "deepseek-ai/deepseek-v3.2-maas",
 )
 // @ts-expect-error Vertex Chat package settings do not accept API keys.
@@ -206,12 +187,12 @@ GoogleVertexChat.configure({ accessToken: "vertex-token", project: "project" }).
 GoogleVertexChat.configure({
   accessToken: "vertex-token",
   // @ts-expect-error Vertex Chat config accepts only one auth source.
-  auth: Auth.bearer("vertex-token"),
+  auth: RuntimeAuth.bearer("vertex-token"),
   project: "project",
 })
 
 GoogleVertexResponses.configure({ accessToken: "vertex-token", project: "project" }).model("xai/grok-4.20-reasoning")
-GoogleVertexResponses.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model(
+GoogleVertexResponses.configure({ auth: RuntimeAuth.bearer("vertex-token"), project: "project" }).model(
   "xai/grok-4.20-reasoning",
 )
 // @ts-expect-error Vertex Responses package settings do not accept API keys.
@@ -224,18 +205,16 @@ GoogleVertexResponses.configure({ accessToken: "vertex-token", project: "project
 GoogleVertexResponses.configure({
   accessToken: "vertex-token",
   // @ts-expect-error Vertex Responses config accepts only one auth source.
-  auth: Auth.bearer("vertex-token"),
+  auth: RuntimeAuth.bearer("vertex-token"),
   project: "project",
 })
 
-GoogleVertexMessages.configure({
-  accessToken: "vertex-token",
-  project: "project",
-  providerOptions: { anthropic: { thinking: { type: "adaptive", display: "omitted" }, effort: "low" } },
-}).model("claude-sonnet-4-6")
+GoogleVertexMessages.configure({ accessToken: "vertex-token", project: "project" }).model("claude-sonnet-4-6")
 // @ts-expect-error Vertex Messages package settings do not accept API keys.
 GoogleVertexMessages.model("claude-sonnet-4-6", { apiKey: "vertex-key", project: "project" })
-GoogleVertexMessages.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model("claude-sonnet-4-6")
+GoogleVertexMessages.configure({ auth: RuntimeAuth.bearer("vertex-token"), project: "project" }).model(
+  "claude-sonnet-4-6",
+)
 GoogleVertexMessages.configure({ accessToken: "vertex-token", project: "project" }).model(
   "claude-sonnet-4-6",
   // @ts-expect-error Vertex Messages model selectors only accept model ids.
@@ -244,7 +223,7 @@ GoogleVertexMessages.configure({ accessToken: "vertex-token", project: "project"
 GoogleVertexMessages.configure({
   accessToken: "vertex-token",
   // @ts-expect-error Vertex Messages config accepts only one auth source.
-  auth: Auth.bearer("vertex-token"),
+  auth: RuntimeAuth.bearer("vertex-token"),
   project: "project",
 })
 

packages/ai/test/exports.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { ImageInput, LLM, LLMClient, Provider } from "@opencode-ai/ai"
+import { LLM, LLMClient, Provider } from "@opencode-ai/ai"
 import { Route, Protocol } from "@opencode-ai/ai/route"
 import { Provider as ProviderSubpath } from "@opencode-ai/ai/provider"
 import {
@@ -16,20 +16,14 @@ import {
   OpenAICompatibleChat,
   OpenAICompatibleResponses,
   OpenAIResponses,
-  OpenResponses,
 } from "@opencode-ai/ai/protocols"
 import * as AnthropicMessages from "@opencode-ai/ai/protocols/anthropic-messages"
 
 describe("public exports", () => {
   test("root exposes app-facing runtime APIs", () => {
     expect(LLM.request).toBeFunction()
-    expect(LLM.generateTurn).toBeFunction()
-    expect(LLM.streamTurn).toBeFunction()
-    expect(LLM).not.toHaveProperty("generate")
-    expect(LLM).not.toHaveProperty("stream")
     expect(LLMClient.Service).toBeFunction()
     expect(LLMClient.layer).toBeDefined()
-    expect(ImageInput.bytes).toBeFunction()
     expect(Provider.make).toBeFunction()
     expect(ProviderSubpath.make).toBe(Provider.make)
   })
@@ -84,9 +78,7 @@ describe("public exports", () => {
   test("protocol barrels expose supported low-level routes", () => {
     expect(OpenAIChat.route.id).toBe("openai-chat")
     expect(OpenAICompatibleChat.route.id).toBe("openai-compatible-chat")
-    expect(OpenResponses.protocol.id).toBe("open-responses")
     expect(OpenAICompatibleResponses.route.id).toBe("openai-compatible-responses")
-    expect(OpenAICompatibleResponses.route.protocol).toBe("open-responses")
     expect(OpenAIResponses.route.id).toBe("openai-responses")
     expect(OpenAIResponses.webSocketRoute.id).toBe("openai-responses-websocket")
     expect(AnthropicMessages.route.id).toBe("anthropic-messages")

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

@@ -1,35 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:anthropic",
-      "protocol:anthropic-messages",
-      "tool",
-      "tool-result"
-    ],
-    "name": "pdf/anthropic-tool-result",
-    "recordedAt": "2026-07-22T18:15:39.002Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"system\":[{\"type\":\"text\",\"text\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"role\":\"assistant\",\"content\":[{\"type\":\"tool_use\",\"id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"input\":{}}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"call_pdf_1\",\"content\":[{\"type\":\"text\",\"text\":\"PDF read successfully\"},{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}}]}]}],\"tools\":[{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"input_schema\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"model\":\"claude-haiku-4-5-20251001\",\"id\":\"msg_011CdHYzxyRpSVFgwTm6ccUr\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"stop_reason\":null,\"stop_sequence\":null,\"stop_details\":null,\"usage\":{\"input_tokens\":2229,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":0,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":2,\"service_tier\":\"standard\",\"inference_geo\":\"not_available\"}}        }\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}              }\n\nevent: ping\ndata: {\"type\": \"ping\"}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"ORCH\"}  }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"ID-7391\"}           }\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0               }\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"stop_details\":null},\"usage\":{\"input_tokens\":2229,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":9}       }\n\nevent: message_stop\ndata: {\"type\":\"message_stop\" }\n\n"
-      }
-    }
-  ]
-}

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

@@ -1,34 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:anthropic",
-      "protocol:anthropic-messages",
-      "user-input"
-    ],
-    "name": "pdf/anthropic-user-input",
-    "recordedAt": "2026-07-22T18:15:37.979Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}},{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"model\":\"claude-haiku-4-5-20251001\",\"id\":\"msg_011CdHYzsayb45rgfamcjFt3\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"stop_reason\":null,\"stop_sequence\":null,\"stop_details\":null,\"usage\":{\"input_tokens\":1602,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":0,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":2,\"service_tier\":\"standard\",\"inference_geo\":\"not_available\"}}           }\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}         }\n\nevent: ping\ndata: {\"type\": \"ping\"}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"ORCH\"}              }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"ID-7391\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0      }\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"stop_details\":null},\"usage\":{\"input_tokens\":1602,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":9}    }\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"              }\n\n"
-      }
-    }
-  ]
-}

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

@@ -1,36 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:amazon-bedrock",
-      "protocol:bedrock-converse",
-      "tool",
-      "tool-result"
-    ],
-    "name": "pdf/bedrock-tool-result",
-    "recordedAt": "2026-07-22T18:15:52.400Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://bedrock-runtime.us-east-1.amazonaws.com/model/us.anthropic.claude-haiku-4-5-20251001-v1%3A0/converse-stream",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"modelId\":\"us.anthropic.claude-haiku-4-5-20251001-v1:0\",\"messages\":[{\"role\":\"user\",\"content\":[{\"text\":\"Return only the verification code from the PDF.\"}]},{\"role\":\"assistant\",\"content\":[{\"toolUse\":{\"toolUseId\":\"call_pdf_1\",\"name\":\"read_pdf\",\"input\":{}}}]},{\"role\":\"user\",\"content\":[{\"toolResult\":{\"toolUseId\":\"call_pdf_1\",\"content\":[{\"text\":\"PDF read successfully\"},{\"document\":{\"format\":\"pdf\",\"name\":\"verification\",\"source\":{\"bytes\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}}}],\"status\":\"success\"}}]}],\"system\":[{\"text\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"}],\"inferenceConfig\":{\"maxTokens\":40,\"temperature\":0},\"toolConfig\":{\"tools\":[{\"toolSpec\":{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"inputSchema\":{\"json\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false}}}}]}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "application/vnd.amazon.eventstream"
-        },
-        "body": "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",
-        "bodyEncoding": "base64"
-      }
-    }
-  ]
-}

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

@@ -1,35 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:amazon-bedrock",
-      "protocol:bedrock-converse",
-      "user-input"
-    ],
-    "name": "pdf/bedrock-user-input",
-    "recordedAt": "2026-07-22T18:15:48.408Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://bedrock-runtime.us-east-1.amazonaws.com/model/us.anthropic.claude-haiku-4-5-20251001-v1%3A0/converse-stream",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"modelId\":\"us.anthropic.claude-haiku-4-5-20251001-v1:0\",\"messages\":[{\"role\":\"user\",\"content\":[{\"document\":{\"format\":\"pdf\",\"name\":\"verification\",\"source\":{\"bytes\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}}},{\"text\":\"Return only the verification code from the PDF.\"}]}],\"inferenceConfig\":{\"maxTokens\":40,\"temperature\":0}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "application/vnd.amazon.eventstream"
-        },
-        "body": "AAAAtgAAAFJ/wBIFCzpldmVudC10eXBlBwAMbWVzc2FnZVN0YXJ0DTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNCIsInJvbGUiOiJhc3Npc3RhbnQifURlAvAAAADGAAAAV/Z4BkULOmV2ZW50LXR5cGUHABFjb250ZW50QmxvY2tEZWx0YQ06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImNvbnRlbnRCbG9ja0luZGV4IjowLCJkZWx0YSI6eyJ0ZXh0IjoiT1JDSCJ9LCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk8ifU1V/fQAAADWAAAAV5aYkccLOmV2ZW50LXR5cGUHABFjb250ZW50QmxvY2tEZWx0YQ06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImNvbnRlbnRCbG9ja0luZGV4IjowLCJkZWx0YSI6eyJ0ZXh0IjoiSUQtIn0sInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaMDEyMzQ1In1Rr1g8AAAAoAAAAFfgCoSoCzpldmVudC10eXBlBwARY29udGVudEJsb2NrRGVsdGENOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJjb250ZW50QmxvY2tJbmRleCI6MCwiZGVsdGEiOnsidGV4dCI6IjcifSwicCI6ImFiY2RlZiJ9UwQMPQAAAM8AAABX+2hkNAs6ZXZlbnQtdHlwZQcAEWNvbnRlbnRCbG9ja0RlbHRhDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiY29udGVudEJsb2NrSW5kZXgiOjAsImRlbHRhIjp7InRleHQiOiIzOTEifSwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWSJ9ZmoyCwAAAJAAAABWNiwMuAs6ZXZlbnQtdHlwZQcAEGNvbnRlbnRCbG9ja1N0b3ANOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJjb250ZW50QmxvY2tJbmRleCI6MCwicCI6ImFiY2RlZmdoaWprbCJ9wtmmXgAAAIgAAABR+NhFWAs6ZXZlbnQtdHlwZQcAC21lc3NhZ2VTdG9wDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsicCI6ImFiY2RlZmciLCJzdG9wUmVhc29uIjoiZW5kX3R1cm4ifa8D/doAAADvAAAATl7C4/ALOmV2ZW50LXR5cGUHAAhtZXRhZGF0YQ06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7Im1ldHJpY3MiOnsibGF0ZW5jeU1zIjo0NTQ1fSwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXYiLCJ1c2FnZSI6eyJpbnB1dFRva2VucyI6MTYxNCwib3V0cHV0VG9rZW5zIjo2LCJzZXJ2ZXJUb29sVXNhZ2UiOnt9LCJ0b3RhbFRva2VucyI6MTYyMH19db4j2Q==",
-        "bodyEncoding": "base64"
-      }
-    }
-  ]
-}

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

@@ -1,53 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:google",
-      "protocol:gemini",
-      "tool",
-      "tool-result"
-    ],
-    "name": "pdf/gemini-tool-result",
-    "recordedAt": "2026-07-22T18:21:59.606Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:streamGenerateContent?alt=sse",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"Use read_pdf with path verification.pdf and return the verification code.\"}]}],\"systemInstruction\":{\"parts\":[{\"text\":\"Call read_pdf exactly once with path verification.pdf, then reply only with the verification code from its PDF.\"}]},\"tools\":[{\"functionDeclarations\":[{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"required\":[\"path\"],\"type\":\"object\",\"properties\":{\"path\":{\"type\":\"string\"}}}}]}],\"generationConfig\":{\"maxOutputTokens\":256,\"temperature\":0}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"candidates\": [{\"content\": {\"parts\": [{\"functionCall\": {\"name\": \"read_pdf\",\"args\": {\"path\": \"verification.pdf\"},\"id\": \"58shgmez\"},\"thoughtSignature\": \"EqkCCqYCARFNMg/JrCTv5i3zYENFBVpZNFL3pbzJmi5Eu387ncF703xFMB4pwyaP7a1gi49EqBhCI2hWOpesU5nZQOLAhGgExKGa2GM+HzpEB5g62r0NFblm/BGkVZaImTuHR7bytfRC5jHQlHKo4OS27OLUVjvkMkBIYsvjhDErY7niERbXJVpyxTVqUf1GgZMSu8kC9/5WDlMs9xVKNT/6KMW4PhhSR9nXg4KZUa+bC03/ydhsWWgBa5aLCgvTq7WPj217xIsmUkSiRedIffPsUSNjYdMHUvWi8bOlvM1veEEP6GIfv5h9gXXzjnHbEHfQxV8PZuBAyY7iM6nqyfkJNdkZ1HdB7DXMBsMsRN6SgrIrFoXX2WaGrkoEI5tdZx1t/gdwF1jEVT6k\"}],\"role\": \"model\"},\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 81,\"candidatesTokenCount\": 18,\"totalTokenCount\": 151,\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 81}],\"thoughtsTokenCount\": 52,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"RAphaui3OaSHz7IPy8Kb4Ak\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"\"}],\"role\": \"model\"},\"finishReason\": \"STOP\",\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 81,\"candidatesTokenCount\": 18,\"totalTokenCount\": 151,\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 81}],\"thoughtsTokenCount\": 52,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"RAphaui3OaSHz7IPy8Kb4Ak\"}\r\n\r\n"
-      }
-    },
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:streamGenerateContent?alt=sse",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"Use read_pdf with path verification.pdf and return the verification code.\"}]},{\"role\":\"model\",\"parts\":[{\"functionCall\":{\"id\":\"58shgmez\",\"name\":\"read_pdf\",\"args\":{\"path\":\"verification.pdf\"}},\"thoughtSignature\":\"EqkCCqYCARFNMg/JrCTv5i3zYENFBVpZNFL3pbzJmi5Eu387ncF703xFMB4pwyaP7a1gi49EqBhCI2hWOpesU5nZQOLAhGgExKGa2GM+HzpEB5g62r0NFblm/BGkVZaImTuHR7bytfRC5jHQlHKo4OS27OLUVjvkMkBIYsvjhDErY7niERbXJVpyxTVqUf1GgZMSu8kC9/5WDlMs9xVKNT/6KMW4PhhSR9nXg4KZUa+bC03/ydhsWWgBa5aLCgvTq7WPj217xIsmUkSiRedIffPsUSNjYdMHUvWi8bOlvM1veEEP6GIfv5h9gXXzjnHbEHfQxV8PZuBAyY7iM6nqyfkJNdkZ1HdB7DXMBsMsRN6SgrIrFoXX2WaGrkoEI5tdZx1t/gdwF1jEVT6k\"}]},{\"role\":\"user\",\"parts\":[{\"functionResponse\":{\"id\":\"58shgmez\",\"name\":\"read_pdf\",\"response\":{\"name\":\"read_pdf\",\"content\":\"PDF read successfully\"},\"parts\":[{\"inlineData\":{\"mimeType\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}}]}}]}],\"systemInstruction\":{\"parts\":[{\"text\":\"Call read_pdf exactly once with path verification.pdf, then reply only with the verification code from its PDF.\"}]},\"tools\":[{\"functionDeclarations\":[{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"required\":[\"path\"],\"type\":\"object\",\"properties\":{\"path\":{\"type\":\"string\"}}}}]}],\"generationConfig\":{\"maxOutputTokens\":256,\"temperature\":0}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"ORCHID-7391\"}],\"role\": \"model\"},\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 123,\"candidatesTokenCount\": 8,\"totalTokenCount\": 184,\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 123}],\"thoughtsTokenCount\": 53,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"RgphaoL6CMjQz7IPjOnEmQI\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"\",\"thoughtSignature\": \"EqECCp4CARFNMg9obBl8O6iU9lawUIWiE+1vztZm9NtaT9FuyJz343hd9ruz+xPco4Q1DY1GF81ZiSI2ElBkt8Wfwsqtix9LNGSMvbZhhk/ZnB54t05M/Dft1kujcMvEdZUWUI/jWaJ349tO1bKVH9MacG5+gl0n4y8DwyQZSV3xIcet547drSkcA/TM03RB+yj1/dcLHsvUjmv9EnO897vZgO2Dk4tbZ2NyCtOeQ3JKVhUTLg2pjkGk+POCNiOdESWiUzxdQKw9LiV6nnzi071tXNiMeVimq6d7xAzRVNapI2uXynvn9Uk3eyn85purOFa8cKriK9oD6vcyGMqgd9+gu2m3to0IHqd7o+2YSr1m5qV1xT1R2/WRQEtb1b1AuOAU6w==\"}],\"role\": \"model\"},\"finishReason\": \"STOP\",\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 1277,\"candidatesTokenCount\": 8,\"totalTokenCount\": 1338,\"promptTokensDetails\": [{\"modality\": \"IMAGE\",\"tokenCount\": 1102},{\"modality\": \"TEXT\",\"tokenCount\": 175}],\"thoughtsTokenCount\": 53,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"RgphaoL6CMjQz7IPjOnEmQI\"}\r\n\r\n"
-      }
-    }
-  ]
-}

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

@@ -1,34 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:google",
-      "protocol:gemini",
-      "user-input"
-    ],
-    "name": "pdf/gemini-user-input",
-    "recordedAt": "2026-07-22T18:20:55.140Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:streamGenerateContent?alt=sse",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"contents\":[{\"role\":\"user\",\"parts\":[{\"inlineData\":{\"mimeType\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}},{\"text\":\"Return only the verification code from the PDF.\"}]}],\"generationConfig\":{\"maxOutputTokens\":256,\"temperature\":0}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"ORCH\"}],\"role\": \"model\"},\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 10,\"candidatesTokenCount\": 2,\"totalTokenCount\": 127,\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 10}],\"thoughtsTokenCount\": 115,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"BQpharW2KaPgz7IP6uSLiAw\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"ID-7391\"}],\"role\": \"model\"},\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 10,\"candidatesTokenCount\": 8,\"totalTokenCount\": 133,\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 10}],\"thoughtsTokenCount\": 115,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"BQpharW2KaPgz7IP6uSLiAw\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"\",\"thoughtSignature\": \"EokECoYEARFNMg8L4fpLqaX8tIQZcvw2vLt3WsFjGqpuJGgna0/AGczwuzndRcf3LGIEaliCf4ijVOb1AG4/VPBh1kMzfjeAyHhvWIe4yQVoBwI7BjpFyLie+SnGTXQXKKy5ygRqRLFsV6DcAixNXXBHJw2x/2Nhtriryqs4fhWrL/P7ppHC10sMnTwN6Mw5x20NKwgT+rrw6lvYmQe9rdQsBJ6Zmp0GpPlwZZiAgzvwPfVoNwHSGb54xe/T9wjISjwWNgpedhbsIBDRZFDwruS4x57KBKeMPO69GLfeMP8PJ7rpR0HgT7nRbrl/OdykG/jqSMTvoRSqxawsD+Yr/DukgGatyfB5Ic+X4RhD07URpkGTAu/cakBtzhSmM/hpzKU9m/cId1UCjopLTtonUqSAKkroPdp8kIYw0MI2OZCNVwbDrdClUPmjRKfcTkcC2jNj1rS+WDFbm+mo+SP3rDSvvCdyJuiXHGKiM2EhbYnu42aHVC6w7eAe4Gv3Fq/0faW47r0ihbiAohFB9XUA+fD07g83EjIuc9Q6BRVTTcBfoRkrR/yFZKt3qwPq02W6rPD13/1wAnMtabNcxePMMGk7Dlxwng9yPS0NEge2KD+miOj9SC4aTvOTq2451tfK1x3UZqqb205zGOPbjizhH/CA/PGkG84hdkAG4mrUK0rEHqeWwRXDsxpyfto=\"}],\"role\": \"model\"},\"finishReason\": \"STOP\",\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 530,\"candidatesTokenCount\": 8,\"totalTokenCount\": 653,\"promptTokensDetails\": [{\"modality\": \"IMAGE\",\"tokenCount\": 520},{\"modality\": \"TEXT\",\"tokenCount\": 10}],\"thoughtsTokenCount\": 115,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"BQpharW2KaPgz7IP6uSLiAw\"}\r\n\r\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/zai-images/generates-an-image.json

@@ -1,28 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": ["prefix:zai-images", "provider:zai", "protocol:zai-images"],
-    "name": "zai-images/generates-an-image",
-    "recordedAt": "2026-07-19T16:03:55.761Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.z.ai/api/paas/v4/images/generations",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"cogview-4-250304\",\"prompt\":\"A simple flat red circle centered on a plain white background.\",\"size\":\"1024x1024\",\"quality\":\"standard\",\"user_id\":\"opencode-image-test\"}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "application/json; charset=UTF-8"
-        },
-        "body": "{\"created\":1784477028,\"data\":[{\"url\":\"https://mfile.z.ai/1784477035500-43574eab2b6e402da9063d6ac22dfefb.png?ufileattname=202607200003482062c3bba9b04f7d_watermark.png\"}],\"id\":\"202607200003482062c3bba9b04f7d\",\"request_id\":\"202607200003482062c3bba9b04f7d\"}"
-      }
-    }
-  ]
-}

packages/ai/test/image.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
-import { Image, ImageClient, ImageInput } from "../src"
-import { Google, OpenAI, XAI, ZAI } from "../src/providers"
+import { Image, ImageClient } from "../src"
+import { OpenAI } from "../src/providers"
 import { it } from "./lib/effect"
 import { dynamicResponse } from "./lib/http"
 
@@ -17,20 +17,13 @@ describe("Image", () => {
           http: { body: { deployment: "test" }, headers: { "x-default": "yes" } },
         }).image("gpt-image-2"),
         prompt: "A robot tending a rooftop garden",
-        options: {
-          n: 2,
-          size: "2048x2048",
-          quality: "future-quality",
-          outputFormat: "jpeg",
-          output_format: "avif",
-          outputCompression: 30,
-          output_compression: 40,
-          background: "opaque",
-          native_default: true,
-          future_option: true,
+        count: 2,
+        size: { width: 1024, height: 1024 },
+        providerOptions: {
+          openai: { quality: "high", outputFormat: "webp" },
         },
         http: {
-          body: { output_format: "webp", output_compression: 50, future_option: "http", request_metadata: "value" },
+          body: { request_metadata: "value" },
           headers: { "x-request": "yes" },
           query: { trace: "1" },
         },
@@ -56,13 +49,9 @@ describe("Image", () => {
                   model: "gpt-image-2",
                   prompt: "A robot tending a rooftop garden",
                   n: 2,
-                  size: "2048x2048",
-                  quality: "future-quality",
-                  background: "opaque",
+                  size: "1024x1024",
+                  quality: "high",
                   output_format: "webp",
-                  output_compression: 50,
-                  native_default: true,
-                  future_option: "http",
                   deployment: "test",
                   request_metadata: "value",
                 })
@@ -82,495 +71,23 @@ describe("Image", () => {
     ),
   )
 
-  it.effect("preserves native snake_case and unknown request options", () =>
+  it.effect("rejects invalid common and OpenAI image options locally", () =>
     Image.generate({
-      model: OpenAI.configure({
-        apiKey: "test",
-        baseURL: "https://api.openai.test/v1",
-      }).image("future-image-model"),
-      prompt: "A lighthouse in fog",
-      options: {
-        outputFormat: "jpeg",
-        output_format: "avif",
-        outputCompression: 30,
-        output_compression: 40,
-        provider_future_option: { enabled: true },
-      },
-    }).pipe(
-      Effect.tap((response) =>
-        Effect.sync(() => {
-          expect(response.image?.mediaType).toBe("image/avif")
-        }),
-      ),
-      Effect.provide(
-        ImageClient.layer.pipe(
-          Layer.provide(
-            dynamicResponse((input) => {
-              expect(JSON.parse(input.text)).toEqual({
-                model: "future-image-model",
-                prompt: "A lighthouse in fog",
-                output_format: "avif",
-                output_compression: 40,
-                provider_future_option: { enabled: true },
-              })
-              return Effect.succeed(
-                input.respond(JSON.stringify({ data: [{ b64_json: "AQID" }] }), {
-                  headers: { "content-type": "application/json" },
-                }),
-              )
-            }),
-          ),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("routes OpenAI byte inputs and masks through multipart edits", () =>
-    Image.generate({
-      model: OpenAI.configure({ apiKey: "test", baseURL: "https://api.openai.test/v1" }).image("future-model"),
-      prompt: "Combine these images",
-      images: [
-        ImageInput.bytes(Uint8Array.from([1, 2, 3]), "image/png"),
-        ImageInput.url("data:image/jpeg;base64,BAUG"),
-      ],
-      options: {
-        mask: ImageInput.bytes(Uint8Array.from([7, 8, 9]), "image/png"),
-        quality: "high",
-        future_option: true,
-      },
-      http: {
-        body: { quality: "low", model: "corrupt", prompt: "corrupt", image: "corrupt", "image[]": "corrupt" },
-        headers: { "content-type": "application/json" },
-      },
-    }).pipe(
-      Effect.provide(
-        ImageClient.layer.pipe(
-          Layer.provide(
-            dynamicResponse((input) =>
-              Effect.gen(function* () {
-                const request = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
-                expect(request.url).toBe("https://api.openai.test/v1/images/edits")
-                expect(request.headers.get("content-type")).toStartWith("multipart/form-data; boundary=")
-                expect(input.text).toContain('name="model"\r\n\r\nfuture-model')
-                expect(input.text).toContain('name="prompt"\r\n\r\nCombine these images')
-                expect(input.text.match(/name="image\[\]"/g)).toHaveLength(2)
-                expect(input.text).toContain('name="mask"')
-                expect(input.text).toContain('name="quality"\r\n\r\nlow')
-                expect(input.text).not.toContain("corrupt")
-                return input.respond(JSON.stringify({ data: [{ b64_json: "AQID" }] }), {
-                  headers: { "content-type": "application/json" },
-                })
-              }),
-            ),
-          ),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("routes OpenAI URL and file inputs through JSON edits", () =>
-    Image.generate({
-      model: OpenAI.configure({ apiKey: "test", baseURL: "https://api.openai.test/v1" }).image("future-model"),
-      prompt: "Combine these images",
-      images: [ImageInput.url("https://example.test/source.png"), ImageInput.file("file_123")],
-      options: { mask: ImageInput.file("file_mask") },
-      http: { body: { future_option: true } },
-    }).pipe(
-      Effect.provide(
-        ImageClient.layer.pipe(
-          Layer.provide(
-            dynamicResponse((input) => {
-              expect(JSON.parse(input.text)).toEqual({
-                model: "future-model",
-                prompt: "Combine these images",
-                images: [{ image_url: "https://example.test/source.png" }, { file_id: "file_123" }],
-                mask: { file_id: "file_mask" },
-                future_option: true,
-              })
-              return Effect.succeed(
-                input.respond(JSON.stringify({ data: [{ b64_json: "AQID" }] }), {
-                  headers: { "content-type": "application/json" },
-                }),
-              )
-            }),
-          ),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("routes ordered xAI image inputs through JSON edits", () =>
-    Image.generate({
-      model: XAI.configure({ apiKey: "test", baseURL: "https://api.xai.test/v1" }).image("future-model"),
-      prompt: "Combine these images",
-      images: [
-        ImageInput.bytes(Uint8Array.from([1, 2, 3]), "image/png"),
-        ImageInput.url("https://example.test/source.jpg"),
-        ImageInput.file("file_123"),
-      ],
-    }).pipe(
-      Effect.provide(
-        ImageClient.layer.pipe(
-          Layer.provide(
-            dynamicResponse((input) => {
-              expect(JSON.parse(input.text)).toEqual({
-                model: "future-model",
-                prompt: "Combine these images",
-                images: [
-                  { url: "data:image/png;base64,AQID", type: "image_url" },
-                  { url: "https://example.test/source.jpg", type: "image_url" },
-                  { file_id: "file_123" },
-                ],
-              })
-              return Effect.succeed(
-                input.respond(JSON.stringify({ data: [{ b64_json: "AQID", mime_type: "image/png" }] }), {
-                  headers: { "content-type": "application/json" },
-                }),
-              )
-            }),
-          ),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("uses xAI's singular image field for one input", () =>
-    Image.generate({
-      model: XAI.configure({ apiKey: "test", baseURL: "https://api.xai.test/v1" }).image("future-model"),
-      prompt: "Edit this image",
-      images: [ImageInput.file("file_123")],
-    }).pipe(
-      Effect.provide(
-        ImageClient.layer.pipe(
-          Layer.provide(
-            dynamicResponse((input) => {
-              expect(JSON.parse(input.text)).toEqual({
-                model: "future-model",
-                prompt: "Edit this image",
-                image: { file_id: "file_123" },
-              })
-              return Effect.succeed(
-                input.respond(JSON.stringify({ data: [{ b64_json: "AQID", mime_type: "image/png" }] }), {
-                  headers: { "content-type": "application/json" },
-                }),
-              )
-            }),
-          ),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("lowers ordered Google image inputs into generateContent parts", () =>
-    Image.generate({
-      model: Google.configure({ apiKey: "test", baseURL: "https://google.test/v1beta" }).image("future-model"),
-      prompt: "Combine these images",
-      images: [
-        ImageInput.bytes(Uint8Array.from([1, 2, 3]), "image/png"),
-        ImageInput.url("data:image/jpeg;base64,BAUG"),
-        ImageInput.fileUri("https://generativelanguage.googleapis.com/v1beta/files/123", "image/webp"),
-      ],
-    }).pipe(
-      Effect.provide(
-        ImageClient.layer.pipe(
-          Layer.provide(
-            dynamicResponse((input) => {
-              expect(JSON.parse(input.text).contents[0].parts).toEqual([
-                { text: "Combine these images" },
-                { inlineData: { mimeType: "image/png", data: "AQID" } },
-                { inlineData: { mimeType: "image/jpeg", data: "BAUG" } },
-                {
-                  fileData: {
-                    mimeType: "image/webp",
-                    fileUri: "https://generativelanguage.googleapis.com/v1beta/files/123",
-                  },
-                },
-              ])
-              return Effect.succeed(
-                input.respond(
-                  JSON.stringify({
-                    candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "AQID" } }] } }],
-                  }),
-                  { headers: { "content-type": "application/json" } },
-                ),
-              )
-            }),
-          ),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("rejects unsupported provider inputs before sending", () =>
-    Effect.gen(function* () {
-      const cases = [
-        Image.generate({
-          model: Google.configure({ apiKey: "test" }).image("model"),
-          prompt: "edit",
-          images: [ImageInput.url("https://example.test/image.png")],
-        }),
-        Image.generate({
-          model: ZAI.configure({ apiKey: "test" }).image("model"),
-          prompt: "edit",
-          images: [ImageInput.bytes(Uint8Array.from([1]), "image/png")],
-        }),
-      ]
-      yield* Effect.forEach(cases, (program) =>
-        program.pipe(
-          Effect.flip,
-          Effect.tap((error) => Effect.sync(() => expect(error.reason._tag).toBe("InvalidRequest"))),
-        ),
-      )
-    }).pipe(
-      Effect.provide(
-        ImageClient.layer.pipe(
-          Layer.provide(dynamicResponse(() => Effect.die("unsupported input reached the network"))),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("generates images through the Google generateContent API", () =>
-    Effect.gen(function* () {
-      const response = yield* Image.generate({
-        model: Google.configure({
-          apiKey: "test",
-          baseURL: "https://generativelanguage.test/v1beta/",
-          headers: { "x-default": "yes" },
-          http: { body: { labels: { deployment: "test" } }, query: { api: "v1" } },
-        }).image("any-model-id"),
-        prompt: "A robot tending a rooftop garden",
-        options: {
-          aspectRatio: "16:9",
-          imageSize: "2K",
-          seed: 42,
-          thinkingLevel: "HIGH",
-          includeThoughts: true,
-          futureOption: true,
-          imageConfig: { aspectRatio: "4:3", nativeImageOption: true },
-          thinkingConfig: { thinkingLevel: "LOW", nativeThinkingOption: true },
-        },
-        http: {
-          body: {
-            safetySettings: [],
-            generationConfig: {
-              imageConfig: { aspectRatio: "3:2", httpImageOption: true },
-              thinkingConfig: { includeThoughts: false, httpThinkingOption: true },
-              futureOption: "http",
-              httpOption: true,
-            },
-          },
-          headers: { "x-request": "yes" },
-          query: { trace: "1" },
-        },
-      })
-
-      expect(response.images).toHaveLength(3)
-      expect(response.images.map((image) => image.data)).toEqual([
-        Uint8Array.from([1, 2, 3]),
-        Uint8Array.from([4, 5, 6]),
-        Uint8Array.from([7, 8, 9]),
-      ])
-      expect(response.images.map((image) => image.mediaType)).toEqual(["image/png", "image/jpeg", "image/webp"])
-      expect(response.images[0].providerMetadata).toMatchObject({ google: { thoughtSignature: "signature-1" } })
-      expect(response.images[1].providerMetadata).toMatchObject({
-        google: { candidateIndex: 0, partIndex: 3, finishReason: "STOP" },
-      })
-      expect(response.images[2].providerMetadata).toMatchObject({ google: { candidateIndex: 7, partIndex: 0 } })
-      expect(response.usage?.inputTokens).toBe(5)
-      expect(response.usage?.outputTokens).toBe(10)
-      expect(response.usage?.reasoningTokens).toBe(3)
-      expect(response.usage?.providerMetadata).toMatchObject({ google: { serviceTier: "STANDARD" } })
-      expect(response.providerMetadata).toEqual({
-        google: {
-          modelVersion: "gemini-3.1-flash-image",
-          responseId: "response-1",
-          promptFeedback: undefined,
-          candidates: [
-            {
-              index: 0,
-              finishReason: "STOP",
-              finishMessage: undefined,
-              safetyRatings: [{ category: "safe" }],
-              citationMetadata: undefined,
-              groundingMetadata: undefined,
-              parts: [
-                {
-                  type: "inlineData",
-                  mediaType: "image/png",
-                  thought: undefined,
-                  thoughtSignature: "signature-1",
-                },
-                { type: "text", text: "planning", thought: true, thoughtSignature: "text-signature" },
-                {
-                  type: "inlineData",
-                  mediaType: "image/png",
-                  thought: true,
-                  thoughtSignature: "draft-signature",
-                },
-                {
-                  type: "inlineData",
-                  mediaType: "image/jpeg",
-                  thought: undefined,
-                  thoughtSignature: undefined,
-                },
-              ],
-            },
-            {
-              index: 7,
-              finishReason: undefined,
-              finishMessage: undefined,
-              safetyRatings: undefined,
-              citationMetadata: undefined,
-              groundingMetadata: undefined,
-              parts: [
-                {
-                  type: "inlineData",
-                  mediaType: "image/webp",
-                  thought: undefined,
-                  thoughtSignature: undefined,
-                },
-              ],
-            },
-          ],
-        },
-      })
-    }).pipe(
-      Effect.provide(
-        ImageClient.layer.pipe(
-          Layer.provide(
-            dynamicResponse((input) =>
-              Effect.gen(function* () {
-                const request = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
-                expect(request.url).toBe(
-                  "https://generativelanguage.test/v1beta/models/any-model-id:generateContent?api=v1&trace=1",
-                )
-                expect(request.headers.get("x-goog-api-key")).toBe("test")
-                expect(request.headers.get("x-default")).toBe("yes")
-                expect(request.headers.get("x-request")).toBe("yes")
-                expect(JSON.parse(input.text)).toEqual({
-                  contents: [{ role: "user", parts: [{ text: "A robot tending a rooftop garden" }] }],
-                  generationConfig: {
-                    responseModalities: ["IMAGE"],
-                    imageConfig: {
-                      aspectRatio: "3:2",
-                      imageSize: "2K",
-                      nativeImageOption: true,
-                      httpImageOption: true,
-                    },
-                    seed: 42,
-                    thinkingConfig: {
-                      thinkingLevel: "LOW",
-                      includeThoughts: false,
-                      nativeThinkingOption: true,
-                      httpThinkingOption: true,
-                    },
-                    futureOption: "http",
-                    httpOption: true,
-                  },
-                  labels: { deployment: "test" },
-                  safetySettings: [],
-                })
-                return input.respond(
-                  JSON.stringify({
-                    candidates: [
-                      {
-                        content: {
-                          parts: [
-                            {
-                              inlineData: { mimeType: "image/png", data: "AQID" },
-                              thoughtSignature: "signature-1",
-                            },
-                            { text: "planning", thought: true, thoughtSignature: "text-signature" },
-                            {
-                              inlineData: { mimeType: "image/png", data: "CgsM" },
-                              thought: true,
-                              thoughtSignature: "draft-signature",
-                            },
-                            { inlineData: { mimeType: "image/jpeg", data: "BAUG" } },
-                          ],
-                        },
-                        finishReason: "STOP",
-                        safetyRatings: [{ category: "safe" }],
-                      },
-                      {
-                        index: 7,
-                        content: { parts: [{ inlineData: { mimeType: "image/webp", data: "BwgJ" } }] },
-                      },
-                    ],
-                    usageMetadata: {
-                      promptTokenCount: 5,
-                      candidatesTokenCount: 7,
-                      thoughtsTokenCount: 3,
-                      totalTokenCount: 15,
-                      serviceTier: "STANDARD",
-                    },
-                    modelVersion: "gemini-3.1-flash-image",
-                    responseId: "response-1",
-                  }),
-                  { headers: { "content-type": "application/json" } },
-                )
-              }),
-            ),
-          ),
-        ),
-      ),
-    ),
-  )
-
-  it.effect("includes Google diagnostics when no final image is returned", () =>
-    Image.generate({
-      model: Google.configure({ apiKey: "test", baseURL: "https://generativelanguage.test/v1beta" }).image(
-        "gemini-3.1-flash-image",
-      ),
+      model: OpenAI.configure({ apiKey: "test", baseURL: "https://api.openai.test/v1" }).image("gpt-image-2"),
       prompt: "A robot tending a rooftop garden",
+      count: -1,
+      size: { width: -1, height: 0.5 },
+      providerOptions: { openai: { outputCompression: 101 } },
     }).pipe(
       Effect.flip,
       Effect.tap((error) =>
         Effect.sync(() => {
-          expect(error.reason._tag).toBe("InvalidProviderOutput")
-          if (error.reason._tag !== "InvalidProviderOutput") return
-          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 }],
-                },
-              ],
-            },
-          })
+          expect(error.reason._tag).toBe("InvalidRequest")
         }),
       ),
       Effect.provide(
         ImageClient.layer.pipe(
-          Layer.provide(
-            dynamicResponse((input) =>
-              Effect.succeed(
-                input.respond(
-                  JSON.stringify({
-                    candidates: [
-                      {
-                        content: { parts: [{ text: "blocked", thought: false }] },
-                        finishReason: "IMAGE_SAFETY",
-                        finishMessage: "The generated image was blocked by safety filters.",
-                        safetyRatings: [{ category: "HARM_CATEGORY_DANGEROUS_CONTENT", blocked: true }],
-                      },
-                    ],
-                    promptFeedback: { blockReason: "SAFETY" },
-                  }),
-                  { headers: { "content-type": "application/json" } },
-                ),
-              ),
-            ),
-          ),
+          Layer.provide(dynamicResponse(() => Effect.die("invalid request should not reach the provider"))),
         ),
       ),
     ),

packages/ai/test/image.types.ts

@@ -1,161 +0,0 @@
-import {
-  Image,
-  ImageInput,
-  ImageModel,
-  type ImageModelOptions,
-  type ImageOptions,
-  type ImageRequestFor,
-  type ImageRoute,
-} from "../src"
-import { Google, OpenAI, XAI, ZAI } from "../src/providers"
-
-type GoogleLikeOptions = {
-  readonly aspectRatio?: "1:1" | "16:9"
-  readonly imageSize?: "1K" | "2K"
-} & Record<string, unknown>
-
-declare const route: ImageRoute<GoogleLikeOptions>
-const google = ImageModel.make<GoogleLikeOptions>({ id: "gemini-image", provider: "google", route })
-// @ts-expect-error Extracted model options retain known provider fields.
-const invalidGoogleOptions: ImageModelOptions<typeof google> = { aspectRatio: "wide" }
-void invalidGoogleOptions
-
-Image.generate({
-  model: google,
-  prompt: "A lighthouse",
-  images: [
-    ImageInput.bytes(Uint8Array.from([1, 2, 3]), "image/png"),
-    ImageInput.url("data:image/jpeg;base64,AQID"),
-    ImageInput.fileUri("https://generativelanguage.googleapis.com/v1beta/files/example", "image/webp"),
-  ],
-  options: { aspectRatio: "16:9", imageSize: "2K", futureOption: true },
-})
-
-const googleProvider = Google.configure({ apiKey: "test" }).image("any-model-id")
-Image.generate({
-  model: googleProvider,
-  prompt: "A lighthouse",
-  options: {
-    aspectRatio: "16:9",
-    imageSize: "2K",
-    seed: 42,
-    thinkingLevel: "HIGH",
-    includeThoughts: true,
-    futureOption: true,
-  },
-})
-Image.generate({
-  model: googleProvider,
-  prompt: "A lighthouse",
-  options: { aspectRatio: "future-ratio", imageSize: "8K", thinkingLevel: "FUTURE" },
-})
-// @ts-expect-error Image generation options are request-scoped, not provider configuration.
-Google.configure({ image: { providerOptions: { imageSize: "2K" } } })
-// @ts-expect-error Known Google string options retain their value kind.
-Image.generate({ model: googleProvider, prompt: "A lighthouse", options: { imageSize: 2 } })
-// @ts-expect-error Known Google numeric options retain their value kind.
-Image.generate({ model: googleProvider, prompt: "A lighthouse", options: { seed: "42" } })
-// @ts-expect-error Known Google boolean options retain their value kind.
-Image.generate({ model: googleProvider, prompt: "A lighthouse", options: { includeThoughts: "yes" } })
-
-const openai = OpenAI.image("gpt-image-2")
-// @ts-expect-error Image generation options are request-scoped, not provider configuration.
-OpenAI.configure({ image: { options: { quality: "medium" } } })
-const futureOpenAIOptions: ImageModelOptions<typeof openai> = { quality: "future-quality" }
-void futureOpenAIOptions
-Image.generate({
-  model: openai,
-  prompt: "A lighthouse",
-  images: [ImageInput.url("https://example.com/source.png"), ImageInput.file("file_123")],
-  options: {
-    mask: ImageInput.bytes(Uint8Array.from([1]), "image/png"),
-    quality: "hd",
-    outputFormat: "webp",
-    size: "2048x2048",
-    future_option: true,
-  },
-})
-Image.generate({ model: openai, prompt: "A lighthouse", options: { quality: "future-quality", size: "256x256" } })
-Image.generate({ model: openai, prompt: "A lighthouse", options: { size: "1792x1024" } })
-Image.generate({ model: openai, prompt: "A lighthouse", options: { native_future_option: true } })
-// @ts-expect-error Known OpenAI string options retain their value kind.
-Image.generate({ model: openai, prompt: "A lighthouse", options: { quality: 1 } })
-// @ts-expect-error Known OpenAI numeric options retain their value kind.
-Image.generate({ model: openai, prompt: "A lighthouse", options: { outputCompression: "80" } })
-OpenAI.imageGeneration({ action: "future-action", quality: "future-quality", size: "2048x2048" })
-// @ts-expect-error Hosted image generation numeric options retain their value kind.
-OpenAI.imageGeneration({ partialImages: "2" })
-// @ts-expect-error Known Google-like options are inferred from the selected model.
-Image.generate({ model: google, prompt: "A lighthouse", options: { aspectRatio: "wide" } })
-
-const xai = XAI.configure({ apiKey: "test" }).image("any-model-id")
-// @ts-expect-error Image generation options are request-scoped, not provider configuration.
-XAI.configure({ image: { options: { resolution: "1k" } } })
-Image.generate({
-  model: xai,
-  prompt: "A lighthouse",
-  images: [ImageInput.url("data:image/png;base64,AQID"), ImageInput.file("file_123")],
-  options: {
-    n: 2,
-    aspectRatio: "future-ratio",
-    resolution: "future-resolution",
-    responseFormat: "future-format",
-    future_option: true,
-  },
-})
-Image.generate({
-  model: xai,
-  prompt: "A lighthouse",
-  options: { aspect_ratio: "16:9", response_format: "b64_json", native_future_option: true },
-})
-// @ts-expect-error Known xAI numeric options retain their value kind.
-Image.generate({ model: xai, prompt: "A lighthouse", options: { n: "2" } })
-// @ts-expect-error Known xAI string options retain their value kind.
-Image.generate({ model: xai, prompt: "A lighthouse", options: { resolution: 2 } })
-
-const zai = ZAI.configure({ apiKey: "test" }).image("any-model-id")
-// @ts-expect-error Image generation options are request-scoped, not provider configuration.
-ZAI.configure({ image: { options: { quality: "hd" } } })
-Image.generate({
-  model: zai,
-  prompt: "A lighthouse",
-  options: { quality: "future-quality", userID: "user-123", future_option: true },
-})
-Image.generate({ model: zai, prompt: "A lighthouse", options: { user_id: "raw-user" } })
-// @ts-expect-error Known Z.ai string options retain their value kind.
-Image.generate({ model: zai, prompt: "A lighthouse", options: { quality: 1 } })
-// @ts-expect-error Known Z.ai user IDs retain their value kind.
-Image.generate({ model: zai, prompt: "A lighthouse", options: { userID: 1 } })
-
-declare const generic: ImageModel<ImageOptions>
-Image.generate({ model: generic, prompt: "A lighthouse", options: { arbitrary: true } })
-const explicitImageInput: ImageInput = ImageInput.url("https://example.com/image.png")
-void explicitImageInput
-
-// @ts-expect-error Raw strings are ambiguous and are not image inputs.
-Image.generate({ model: openai, prompt: "A lighthouse", images: ["AQID"] })
-// @ts-expect-error Byte image inputs require an explicit MIME type.
-Image.generate({ model: openai, prompt: "A lighthouse", images: [{ type: "bytes", data: new Uint8Array() }] })
-// @ts-expect-error File URIs require an explicit MIME type for Gemini fileData.
-Image.generate({ model: google, prompt: "A lighthouse", images: [{ type: "file-uri", uri: "files/123" }] })
-
-const request = Image.request({
-  model: google,
-  prompt: "A lighthouse",
-  options: { aspectRatio: "1:1", futureOption: true },
-})
-const typedRequest: ImageRequestFor<GoogleLikeOptions> = request
-void typedRequest
-
-// @ts-expect-error Image requests no longer expose a common count option.
-Image.generate({ model: openai, prompt: "A lighthouse", count: 2 })
-// @ts-expect-error Image requests no longer expose a common size option.
-Image.generate({ model: openai, prompt: "A lighthouse", size: { width: 1024, height: 1024 } })
-// @ts-expect-error Image requests no longer expose a common aspectRatio option.
-Image.generate({ model: openai, prompt: "A lighthouse", aspectRatio: "16:9" })
-// @ts-expect-error Image requests no longer expose a common seed option.
-Image.generate({ model: openai, prompt: "A lighthouse", seed: 1 })
-// @ts-expect-error Image requests do not expose metadata.
-Image.generate({ model: openai, prompt: "A lighthouse", metadata: { trace: true } })
-// @ts-expect-error Masks are provider options, not a common image request field.
-Image.generate({ model: openai, prompt: "A lighthouse", mask: ImageInput.url("https://example.com/mask.png") })

packages/ai/test/lib/image.ts

@@ -1,29 +0,0 @@
-export const dimensions = (data: Uint8Array) => {
-  if (data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47)
-    return {
-      width: readUint32(data, 16),
-      height: readUint32(data, 20),
-    }
-  if (data[0] === 0xff && data[1] === 0xd8) {
-    for (let offset = 2; offset + 8 < data.length; ) {
-      if (data[offset] !== 0xff) {
-        offset++
-        continue
-      }
-      const marker = data[offset + 1]
-      if (
-        marker !== undefined &&
-        [0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf].includes(marker)
-      )
-        return {
-          width: (data[offset + 7] << 8) | data[offset + 8],
-          height: (data[offset + 5] << 8) | data[offset + 6],
-        }
-      offset += 2 + ((data[offset + 2] << 8) | data[offset + 3])
-    }
-  }
-  throw new Error("Unsupported image fixture format")
-}
-
-const readUint32 = (data: Uint8Array, offset: number) =>
-  ((data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3]) >>> 0

packages/ai/test/lib/tool-runtime.ts

@@ -59,12 +59,7 @@ export const runTools = <T extends Tools>(options: RunOptions<T>) =>
             ...request.messages,
             Message.assistant(state.assistantContent),
             ...dispatched.map(([call, dispatched]) =>
-              Message.tool({
-                id: call.id,
-                name: call.name,
-                result: dispatched.result,
-                providerMetadata: call.providerMetadata,
-              }),
+              Message.tool({ id: call.id, name: call.name, result: dispatched.result }),
             ),
           ],
         })
@@ -83,7 +78,7 @@ const indexStep = (event: LLMEvent, index: number): LLMEvent => {
 const stepState = (events: ReadonlyArray<LLMEvent>) => {
   const assistantContent: ContentPart[] = []
   const toolCalls: ToolCallPart[] = []
-  let reason: Extract<LLMEvent, { type: "finish" }>["reason"] = { normalized: "unknown" }
+  let reason: Extract<LLMEvent, { type: "finish" }>["reason"] = "unknown"
   let usage: Usage | undefined
   let providerMetadata: ProviderMetadata | undefined
 

packages/ai/test/llm.test.ts

@@ -2,16 +2,7 @@ import { describe, expect, test } from "bun:test"
 import { CacheHint, LLM, LLMResponse } from "../src"
 import * as OpenAIChat from "../src/protocols/openai-chat"
 import * as OpenAIResponses from "../src/protocols/openai-responses"
-import {
-  GenerationOptions,
-  LLMRequest,
-  Message,
-  Model,
-  ToolCallPart,
-  ToolChoice,
-  ToolDefinition,
-  ToolResultPart,
-} from "../src/schema"
+import { LLMRequest, Message, Model, ToolCallPart, ToolChoice, ToolDefinition, ToolResultPart } from "../src/schema"
 
 const chatRoute = OpenAIChat.route
 const responsesRoute = OpenAIResponses.route
@@ -40,8 +31,8 @@ describe("llm constructors", () => {
       model: Model.make({ id: "fake-model", provider: "fake", route: chatRoute }),
       prompt: "Say hello.",
     })
-    const updated = LLMRequest.update(base, {
-      generation: GenerationOptions.make({ maxTokens: 20 }),
+    const updated = LLM.updateRequest(base, {
+      generation: { maxTokens: 20 },
       messages: [...base.messages, Message.assistant("Hi.")],
     })
 
@@ -200,7 +191,7 @@ describe("llm constructors", () => {
       LLMResponse.text({
         events: [
           { type: "text-delta", id: "text-0", text: "hi" },
-          { type: "finish", reason: { normalized: "stop" } },
+          { type: "finish", reason: "stop" },
         ],
       }),
     ).toBe("hi")

packages/ai/test/provider-package.test.ts

@@ -59,7 +59,7 @@ describe("provider package entrypoints", () => {
       headers: { "x-application": "opencode" },
       body: { service_tier: "priority" },
       limits: { context: 200_000, output: 64_000 },
-      providerOptions: { openresponses: { reasoningEffort: "low", store: true } },
+      providerOptions: { openai: { reasoningEffort: "low", store: true } },
     })
 
     expect(String(selected.provider)).toBe("example")
@@ -72,7 +72,7 @@ describe("provider package entrypoints", () => {
     expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" })
     expect(selected.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
     expect(selected.route.defaults.providerOptions).toEqual({
-      openresponses: { reasoningEffort: "low", store: true },
+      openai: { reasoningEffort: "low", store: true },
     })
   })
 
@@ -85,7 +85,6 @@ describe("provider package entrypoints", () => {
       headers: { "x-application": "opencode" },
       body: { metadata: { user_id: "user_1" } },
       limits: { context: 200_000, output: 64_000 },
-      providerOptions: { anthropic: { effort: "low" } },
     })
 
     expect(String(selected.provider)).toBe("example")
@@ -97,19 +96,6 @@ describe("provider package entrypoints", () => {
     expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
     expect(selected.route.defaults.http?.body).toEqual({ metadata: { user_id: "user_1" } })
     expect(selected.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
-    expect(selected.route.defaults.providerOptions).toEqual({ anthropic: { effort: "low" } })
-  })
-
-  test("maps Anthropic provider options onto the executable model", async () => {
-    const Anthropic = await import("@opencode-ai/ai/providers/anthropic")
-    const selected = Anthropic.model("claude-sonnet-4-6", {
-      apiKey: "fixture",
-      providerOptions: { anthropic: { thinking: { type: "adaptive" } } },
-    })
-
-    expect(selected.route.defaults.providerOptions).toEqual({
-      anthropic: { thinking: { type: "adaptive" } },
-    })
   })
 
   test("requires an Anthropic-compatible base URL at runtime", async () => {
@@ -249,12 +235,12 @@ describe("provider package entrypoints", () => {
       path: "/chat/completions",
     })
     expect(responses.route.id).toBe("google-vertex-responses")
-    expect(responses.route.protocol).toBe("open-responses")
+    expect(responses.route.protocol).toBe("openai-responses")
     expect(responses.route.endpoint).toMatchObject({
       baseURL: "https://aiplatform.googleapis.com/v1/projects/vertex-project/locations/global/endpoints/openapi",
       path: "/responses",
     })
-    expect(responses.route.defaults.providerOptions).toEqual({ openresponses: { store: false } })
+    expect(responses.route.defaults.providerOptions).toEqual({ openai: { store: false } })
   })
 
   test("rejects conflicting Vertex auth settings at runtime", async () => {

packages/ai/test/provider/anthropic-messages.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
-import { CacheHint, LLM, LLMError, LLMRequest, Message, ToolCallPart, ToolDefinition, Usage } from "../../src"
+import { CacheHint, LLM, LLMError, Message, ToolCallPart, Usage } from "../../src"
 import { Auth, LLMClient } from "../../src/route"
 import * as AnthropicMessages from "../../src/protocols/anthropic-messages"
 import { continuationRequest, nativeAnthropicMessagesContinuation } from "../continuation-scenarios"
@@ -60,7 +60,7 @@ describe("Anthropic Messages route", () => {
   it.effect("lowers adaptive thinking settings with effort", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
-        LLMRequest.update(request, {
+        LLM.updateRequest(request, {
           providerOptions: {
             anthropic: { thinking: { type: "adaptive", display: "summarized" }, effort: "low" },
           },
@@ -74,42 +74,6 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("normalizes enabled and disabled thinking settings", () =>
-    Effect.gen(function* () {
-      const enabled = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
-        LLMRequest.update(request, {
-          providerOptions: { anthropic: { thinking: { type: "enabled", budgetTokens: 1_024 } } },
-        }),
-      )
-      const legacy = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
-        LLMRequest.update(request, {
-          providerOptions: { anthropic: { thinking: { type: "enabled", budget_tokens: 2_048 } } },
-        }),
-      )
-      const disabled = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
-        LLMRequest.update(request, {
-          providerOptions: { anthropic: { thinking: { type: "disabled" } } },
-        }),
-      )
-
-      expect(enabled.body.thinking).toEqual({ type: "enabled", budget_tokens: 1_024 })
-      expect(legacy.body.thinking).toEqual({ type: "enabled", budget_tokens: 2_048 })
-      expect(disabled.body.thinking).toEqual({ type: "disabled" })
-    }),
-  )
-
-  it.effect("rejects enabled thinking without a budget", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
-        LLMRequest.update(request, {
-          providerOptions: { anthropic: { thinking: { type: "enabled" } } },
-        }),
-      ).pipe(Effect.flip)
-
-      expect(error.message).toContain("Anthropic thinking provider option requires budgetTokens")
-    }),
-  )
-
   it.effect("lowers chronological system updates natively for Claude Opus 4.8 with cache hints", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
@@ -271,37 +235,9 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("keeps tools and sends tool_choice none", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
-        LLM.request({
-          id: "req_tool_choice_none",
-          model,
-          tools: [{ name: "lookup", description: "Look things up", inputSchema: { type: "object", properties: {} } }],
-          messages: [
-            Message.user("What is the weather?"),
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } })]),
-            Message.tool({ id: "call_1", name: "lookup", result: { forecast: "sunny" } }),
-          ],
-          toolChoice: "none",
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        {
-          name: "lookup",
-          description: "Look things up",
-          input_schema: { type: "object", properties: {} },
-        },
-      ])
-      expect(prepared.body.tool_choice).toEqual({ type: "none" })
-    }),
-  )
-
-  // Regression: read tool results must stay structured so base64 media data is
-  // not JSON-stringified into `tool_result.content`.
-  it.effect("lowers media tool-result content as structured blocks", () =>
+  // Regression: screenshot/read tool results must stay structured so base64
+  // image data is not JSON-stringified into `tool_result.content`.
+  it.effect("lowers image tool-result content as structured image blocks", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
         LLM.request({
@@ -317,7 +253,6 @@ describe("Anthropic Messages route", () => {
               result: [
                 { type: "text", text: "Image read successfully" },
                 { type: "file", uri: "data:image/png;base64,AAECAw==", mime: "image/png" },
-                { type: "file", uri: "data:application/pdf;base64,JVBERi0xLjQ=", mime: "application/pdf" },
               ],
             }),
           ],
@@ -328,7 +263,6 @@ describe("Anthropic Messages route", () => {
       expect(expectToolResult(prepared.body).content).toEqual([
         { type: "text", text: "Image read successfully" },
         { type: "image", source: { type: "base64", media_type: "image/png", data: "AAECAw==" } },
-        { type: "document", source: { type: "base64", media_type: "application/pdf", data: "JVBERi0xLjQ=" } },
       ])
     }),
   )
@@ -358,7 +292,7 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("rejects unsupported media in tool-result content with a clear error", () =>
+  it.effect("rejects non-image media in tool-result content with a clear error", () =>
     Effect.gen(function* () {
       const error = yield* LLMClient.prepare(
         LLM.request({
@@ -445,34 +379,6 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("round-trips redacted thinking as redacted_thinking blocks", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([
-              { type: "reasoning", text: "", providerMetadata: { anthropic: { redactedData: "opaque_1" } } },
-              { type: "reasoning", text: "visible", providerMetadata: { anthropic: { signature: "sig_1" } } },
-            ]),
-          ],
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({
-        messages: [
-          {
-            role: "assistant",
-            content: [
-              { type: "redacted_thinking", data: "opaque_1" },
-              { type: "thinking", thinking: "visible", signature: "sig_1" },
-            ],
-          },
-        ],
-      })
-    }),
-  )
-
   it.effect("parses text, reasoning, and usage stream fixtures", () =>
     Effect.gen(function* () {
       const body = sseEvents(
@@ -512,149 +418,12 @@ describe("Anthropic Messages route", () => {
       ])
       expect(response.events.at(-1)).toMatchObject({
         type: "finish",
-        reason: { normalized: "stop", raw: "end_turn" },
+        reason: "stop",
         providerMetadata: { anthropic: { stopSequence: "\n\nHuman:" } },
       })
     }),
   )
 
-  it.effect("parses redacted thinking into empty reasoning with redactedData metadata", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        { type: "message_start", message: { usage: { input_tokens: 5 } } },
-        { type: "content_block_start", index: 0, content_block: { type: "redacted_thinking", data: "opaque_1" } },
-        { type: "content_block_stop", index: 0 },
-        { type: "content_block_start", index: 1, content_block: { type: "text", text: "" } },
-        { type: "content_block_delta", index: 1, delta: { type: "text_delta", text: "Hello" } },
-        { type: "content_block_stop", index: 1 },
-        { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 2 } },
-        { type: "message_stop" },
-      )
-      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.events.find((event) => event.type === "reasoning-start")).toMatchObject({
-        providerMetadata: { anthropic: { redactedData: "opaque_1" } },
-      })
-      expect(response.message.content).toEqual([
-        { type: "reasoning", text: "", providerMetadata: { anthropic: { redactedData: "opaque_1" } } },
-        { type: "text", text: "Hello" },
-      ])
-    }),
-  )
-
-  it.effect("round-trips streamed redacted thinking with tool use into a continuation request", () =>
-    Effect.gen(function* () {
-      // Anthropic types `redacted_thinking.data` as an opaque string. Its
-      // contents are provider-owned and must be replayed without inspection.
-      const redactedData = "cmVkYWN0ZWQtdGhpbmtpbmc="
-      const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
-        }),
-      ).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              {
-                type: "content_block_start",
-                index: 0,
-                content_block: { type: "redacted_thinking", data: redactedData },
-              },
-              { type: "content_block_stop", index: 0 },
-              {
-                type: "content_block_start",
-                index: 1,
-                content_block: { type: "tool_use", id: "call_1", name: "lookup" },
-              },
-              {
-                type: "content_block_delta",
-                index: 1,
-                delta: { type: "input_json_delta", partial_json: '{"query":"weather"}' },
-              },
-              { type: "content_block_stop", index: 1 },
-              { type: "message_delta", delta: { stop_reason: "tool_use" }, usage: { output_tokens: 1 } },
-              { type: "message_stop" },
-            ),
-          ),
-        ),
-      )
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
-        LLM.request({
-          model,
-          messages: [
-            Message.user("Say hello."),
-            response.message,
-            Message.tool({ id: "call_1", name: "lookup", result: "sunny", resultType: "text" }),
-          ],
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        { role: "user", content: [{ type: "text", text: "Say hello." }] },
-        {
-          role: "assistant",
-          content: [
-            { type: "redacted_thinking", data: redactedData },
-            { type: "tool_use", id: "call_1", name: "lookup", input: { query: "weather" } },
-          ],
-        },
-        {
-          role: "user",
-          content: [
-            {
-              type: "tool_result",
-              tool_use_id: "call_1",
-              content: "sunny",
-              is_error: undefined,
-              cache_control: undefined,
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("maps context-window truncation to length", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              {
-                type: "message_delta",
-                delta: { stop_reason: "model_context_window_exceeded" },
-                usage: { output_tokens: 1 },
-              },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.finishReason).toEqual({ normalized: "length", raw: "model_context_window_exceeded" })
-    }),
-  )
-
-  it.effect("preserves pause_turn while normalizing it to stop", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              { type: "message_delta", delta: { stop_reason: "pause_turn" }, usage: { output_tokens: 1 } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: "pause_turn" })
-    }),
-  )
-
   it.effect("assembles streamed tool call input", () =>
     Effect.gen(function* () {
       const body = sseEvents(
@@ -666,8 +435,8 @@ describe("Anthropic Messages route", () => {
         { type: "message_delta", delta: { stop_reason: "tool_use" }, usage: { output_tokens: 1 } },
       )
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
       const usage = new Usage({
@@ -704,16 +473,10 @@ describe("Anthropic Messages route", () => {
           providerExecuted: undefined,
           providerMetadata: undefined,
         },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "tool-calls", raw: "tool_use" },
-          usage,
-          providerMetadata: undefined,
-        },
+        { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
         {
           type: "finish",
-          reason: { normalized: "tool-calls", raw: "tool_use" },
+          reason: "tool-calls",
           providerMetadata: undefined,
           usage,
         },
@@ -851,10 +614,8 @@ describe("Anthropic Messages route", () => {
         { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 8 } },
       )
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [
-            ToolDefinition.make({ name: "web_search", description: "Web search", inputSchema: { type: "object" } }),
-          ],
+        LLM.updateRequest(request, {
+          tools: [{ name: "web_search", description: "Web search", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
 
@@ -873,20 +634,10 @@ describe("Anthropic Messages route", () => {
         name: "web_search",
         result: { type: "json", value: [{ type: "web_search_result", url: "https://example.com", title: "Example" }] },
         providerExecuted: true,
-        // The complete payload rides in provider metadata as irreducible replay
-        // state for later stateless requests.
-        providerMetadata: {
-          anthropic: {
-            blockType: "web_search_tool_result",
-            result: [{ type: "web_search_result", url: "https://example.com", title: "Example" }],
-          },
-        },
+        providerMetadata: { anthropic: { blockType: "web_search_tool_result" } },
       })
       expect(response.text).toBe("Found it.")
-      expect(response.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "stop", raw: "end_turn" },
-      })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "stop" })
     }),
   )
 
@@ -914,10 +665,8 @@ describe("Anthropic Messages route", () => {
         { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 1 } },
       )
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [
-            ToolDefinition.make({ name: "web_search", description: "Web search", inputSchema: { type: "object" } }),
-          ],
+        LLM.updateRequest(request, {
+          tools: [{ name: "web_search", description: "Web search", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
 
@@ -1007,7 +756,7 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("continues a conversation with user media content", () =>
+  it.effect("continues a conversation with user image content", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(
         LLM.request({
@@ -1017,7 +766,6 @@ describe("Anthropic Messages route", () => {
             Message.user([
               { type: "text", text: "What is in this image?" },
               { type: "media", mediaType: "image/png", data: "AAECAw==" },
-              { type: "media", mediaType: "application/pdf", data: "JVBERi0xLjQ=", filename: "report.pdf" },
             ]),
           ],
         }),
@@ -1033,10 +781,6 @@ describe("Anthropic Messages route", () => {
                     content: [
                       { type: "text", text: "What is in this image?" },
                       { type: "image", source: { type: "base64", media_type: "image/png", data: "AAECAw==" } },
-                      {
-                        type: "document",
-                        source: { type: "base64", media_type: "application/pdf", data: "JVBERi0xLjQ=" },
-                      },
                     ],
                   },
                 ],

packages/ai/test/provider/bedrock-converse-cache.recorded.test.ts

@@ -13,8 +13,12 @@ const RECORDING_REGION = process.env.BEDROCK_RECORDING_REGION ?? "us-east-1"
 // call wouldn't deterministically prove cache mapping works. Override with
 // BEDROCK_CACHE_MODEL_ID if your account has access elsewhere.
 const model = AmazonBedrock.configure({
-  apiKey: process.env.AWS_BEARER_TOKEN_BEDROCK ?? "fixture",
-  region: RECORDING_REGION,
+  credentials: {
+    region: RECORDING_REGION,
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? "fixture",
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY ?? "fixture",
+    sessionToken: process.env.AWS_SESSION_TOKEN,
+  },
 }).model(process.env.BEDROCK_CACHE_MODEL_ID ?? "us.anthropic.claude-haiku-4-5-20251001-v1:0")
 
 const cacheRequest = LLM.request({
@@ -32,7 +36,7 @@ const recorded = recordedTests({
   prefix: "bedrock-converse-cache",
   provider: "amazon-bedrock",
   protocol: "bedrock-converse",
-  requires: ["AWS_BEARER_TOKEN_BEDROCK"],
+  requires: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
   // Two identical requests in one cassette — replay walks the cassette in
   // recording order so the second call replays the cached-hit interaction.
 })
@@ -41,20 +45,10 @@ describe("Bedrock Converse cache recorded", () => {
   recorded.effect.with("writes then reads cachePoint on identical second call", { tags: ["cache"] }, () =>
     Effect.gen(function* () {
       const first = yield* LLMClient.generate(cacheRequest)
-      expect(first.usage?.cacheWriteInputTokens ?? 0).toBeGreaterThan(0)
-      expect(first.usage?.inputTokens).toBe(
-        (first.usage?.nonCachedInputTokens ?? 0) +
-          (first.usage?.cacheReadInputTokens ?? 0) +
-          (first.usage?.cacheWriteInputTokens ?? 0),
-      )
+      expect(first.usage?.cacheReadInputTokens ?? 0).toBeGreaterThanOrEqual(0)
 
       const second = yield* LLMClient.generate(cacheRequest)
       expect(second.usage?.cacheReadInputTokens ?? 0).toBeGreaterThan(0)
-      expect(second.usage?.inputTokens).toBe(
-        (second.usage?.nonCachedInputTokens ?? 0) +
-          (second.usage?.cacheReadInputTokens ?? 0) +
-          (second.usage?.cacheWriteInputTokens ?? 0),
-      )
     }),
   )
 })

packages/ai/test/provider/bedrock-converse.test.ts

@@ -2,16 +2,7 @@ import { EventStreamCodec } from "@smithy/eventstream-codec"
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8"
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import {
-  CacheHint,
-  GenerationOptions,
-  LLM,
-  LLMRequest,
-  Message,
-  ToolCallPart,
-  ToolChoice,
-  ToolDefinition,
-} from "../../src"
+import { CacheHint, LLM, Message, ToolCallPart, ToolChoice } from "../../src"
 import { LLMClient } from "../../src/route"
 import { AmazonBedrock } from "../../src/providers"
 import * as BedrockConverse from "../../src/protocols/bedrock-converse"
@@ -43,26 +34,6 @@ const eventFrame = (type: string, payload: object) =>
     body: utf8Encoder.encode(JSON.stringify(payload)),
   })
 
-const exceptionFrame = (type: string, payload: object) =>
-  codec.encode({
-    headers: {
-      ":message-type": { type: "string", value: "exception" },
-      ":exception-type": { type: "string", value: type },
-      ":content-type": { type: "string", value: "application/json" },
-    },
-    body: utf8Encoder.encode(JSON.stringify(payload)),
-  })
-
-const errorFrame = (code: string, message: string) =>
-  codec.encode({
-    headers: {
-      ":message-type": { type: "string", value: "error" },
-      ":error-code": { type: "string", value: code },
-      ":error-message": { type: "string", value: message },
-    },
-    body: new Uint8Array(),
-  })
-
 const concat = (frames: ReadonlyArray<Uint8Array>) => {
   const total = frames.reduce((sum, frame) => sum + frame.length, 0)
   const out = new Uint8Array(total)
@@ -115,9 +86,7 @@ describe("Bedrock Converse route", () => {
   it.effect("passes topK through additionalModelRequestFields as top_k", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
-        LLMRequest.update(baseRequest, {
-          generation: GenerationOptions.make({ maxTokens: 64, temperature: 0, topK: 40 }),
-        }),
+        LLM.updateRequest(baseRequest, { generation: { maxTokens: 64, temperature: 0, topK: 40 } }),
       )
 
       // Converse's inferenceConfig has no topK; Anthropic/Nova read it from
@@ -154,13 +123,13 @@ describe("Bedrock Converse route", () => {
   it.effect("prepares tool config with toolSpec and toolChoice", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare(
-        LLMRequest.update(baseRequest, {
+        LLM.updateRequest(baseRequest, {
           tools: [
-            ToolDefinition.make({
+            {
               name: "lookup",
               description: "Lookup data",
               inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
-            }),
+            },
           ],
           toolChoice: ToolChoice.make({ type: "required" }),
         }),
@@ -185,36 +154,6 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
-  it.effect("keeps tools and omits the unsupported choice when tool choice is none", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
-        LLMRequest.update(baseRequest, {
-          tools: [
-            ToolDefinition.make({
-              name: "lookup",
-              description: "Lookup data",
-              inputSchema: { type: "object", properties: { query: { type: "string" } } },
-            }),
-          ],
-          toolChoice: ToolChoice.make({ type: "none" }),
-        }),
-      )
-
-      expect(prepared.body.toolConfig).toMatchObject({
-        tools: [
-          {
-            toolSpec: {
-              name: "lookup",
-              description: "Lookup data",
-              inputSchema: { json: { type: "object", properties: { query: { type: "string" } } } },
-            },
-          },
-        ],
-      })
-      expect(prepared.body.toolConfig?.toolChoice).toBeUndefined()
-    }),
-  )
-
   it.effect("lowers assistant tool-call + tool-result message history", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare(
@@ -321,10 +260,7 @@ describe("Bedrock Converse route", () => {
       // `metadata` (carries usage). We consolidate them into a single
       // terminal `finish` event with both.
       expect(finishes).toHaveLength(1)
-      expect(finishes[0]).toMatchObject({
-        type: "finish",
-        reason: { normalized: "stop", raw: "end_turn" },
-      })
+      expect(finishes[0]).toMatchObject({ type: "finish", reason: "stop" })
       expect(response.usage).toMatchObject({
         inputTokens: 5,
         outputTokens: 2,
@@ -333,69 +269,6 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
-  it.effect("maps truncation and malformed output stop reasons", () =>
-    Effect.gen(function* () {
-      const reasons = [
-        ["model_context_window_exceeded", "length"],
-        ["malformed_model_output", "error"],
-        ["malformed_tool_use", "error"],
-      ] as const
-
-      for (const [raw, normalized] of reasons) {
-        const response = yield* LLMClient.generate(baseRequest).pipe(
-          Effect.provide(fixedBytes(eventStreamBody(["messageStop", { stopReason: raw }]))),
-        )
-        expect(response.finishReason).toEqual({ normalized, raw })
-      }
-    }),
-  )
-
-  it.effect("adds cache reads and writes to Bedrock input usage", () =>
-    Effect.gen(function* () {
-      const body = eventStreamBody(
-        ["messageStart", { role: "assistant" }],
-        ["contentBlockDelta", { contentBlockIndex: 0, delta: { text: "Hello" } }],
-        ["contentBlockStop", { contentBlockIndex: 0 }],
-        ["messageStop", { stopReason: "end_turn" }],
-        [
-          "metadata",
-          {
-            usage: {
-              inputTokens: 5,
-              outputTokens: 2,
-              totalTokens: 12,
-              cacheReadInputTokens: 3,
-              cacheWriteInputTokens: 2,
-            },
-          },
-        ],
-      )
-      const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
-
-      expect(response.usage).toMatchObject({
-        inputTokens: 10,
-        nonCachedInputTokens: 5,
-        cacheReadInputTokens: 3,
-        cacheWriteInputTokens: 2,
-        outputTokens: 2,
-        totalTokens: 12,
-      })
-    }),
-  )
-
-  it.effect("preserves usage across later metadata events without usage", () =>
-    Effect.gen(function* () {
-      const body = eventStreamBody(
-        ["messageStop", { stopReason: "end_turn" }],
-        ["metadata", { usage: { inputTokens: 5, outputTokens: 2, totalTokens: 7 } }],
-        ["metadata", { metrics: { latencyMs: 100 } }],
-      )
-      const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
-
-      expect(response.usage).toMatchObject({ inputTokens: 5, outputTokens: 2, totalTokens: 7 })
-    }),
-  )
-
   it.effect("assembles streamed tool call input", () =>
     Effect.gen(function* () {
       const body = eventStreamBody(
@@ -413,8 +286,8 @@ describe("Bedrock Converse route", () => {
         ["messageStop", { stopReason: "tool_use" }],
       )
       const response = yield* LLMClient.generate(
-        LLMRequest.update(baseRequest, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup", inputSchema: { type: "object" } })],
+        LLM.updateRequest(baseRequest, {
+          tools: [{ name: "lookup", description: "Lookup", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedBytes(body)))
 
@@ -426,10 +299,7 @@ describe("Bedrock Converse route", () => {
         { type: "tool-input-delta", id: "tool_1", name: "lookup", text: '{"query"' },
         { type: "tool-input-delta", id: "tool_1", name: "lookup", text: ':"weather"}' },
       ])
-      expect(response.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "tool-calls", raw: "tool_use" },
-      })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "tool-calls" })
     }),
   )
 
@@ -455,7 +325,7 @@ describe("Bedrock Converse route", () => {
         name: "lookup",
         raw: '{"query":"partial',
       })
-      expect(response.finishReason).toEqual({ normalized: "tool-calls", raw: "end_turn" })
+      expect(response.finishReason).toBe("tool-calls")
     }),
   )
 
@@ -511,170 +381,12 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
-  it.effect("preserves reasoning signatures when contentBlockStop is missing", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(baseRequest).pipe(
-        Effect.provide(
-          fixedBytes(
-            eventStreamBody(
-              ["messageStart", { role: "assistant" }],
-              [
-                "contentBlockDelta",
-                { contentBlockIndex: 0, delta: { reasoningContent: { text: "Let me think." } } },
-              ],
-              [
-                "contentBlockDelta",
-                { contentBlockIndex: 0, delta: { reasoningContent: { signature: "sig_1" } } },
-              ],
-              ["messageStop", { stopReason: "end_turn" }],
-            ),
-          ),
-        ),
-      )
-
-      expect(response.events.find((event) => event.type === "reasoning-delta" && event.text === "")).toEqual({
-        type: "reasoning-delta",
-        id: "reasoning-0",
-        text: "",
-        providerMetadata: { bedrock: { signature: "sig_1" } },
-      })
-      expect(response.message.content).toEqual([
-        {
-          type: "reasoning",
-          text: "Let me think.",
-          providerMetadata: { bedrock: { signature: "sig_1" } },
-        },
-      ])
-
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
-        LLM.request({ model, messages: [response.message], cache: "none" }),
-      )
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "assistant",
-          content: [{ reasoningContent: { reasoningText: { text: "Let me think.", signature: "sig_1" } } }],
-        },
-      ])
-    }),
-  )
-
-  it.effect("preserves signature-only reasoning blocks", () =>
-    Effect.gen(function* () {
-      const body = eventStreamBody(
-        ["messageStart", { role: "assistant" }],
-        [
-          "contentBlockDelta",
-          { contentBlockIndex: 0, delta: { reasoningContent: { signature: "sig_1" } } },
-        ],
-        ["contentBlockStop", { contentBlockIndex: 0 }],
-        ["messageStop", { stopReason: "end_turn" }],
-      )
-      const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
-
-      expect(response.message.content).toEqual([
-        { type: "reasoning", text: "", providerMetadata: { bedrock: { signature: "sig_1" } } },
-      ])
-    }),
-  )
-
-  it.effect("accepts Vercel-compatible redacted reasoning data deltas", () =>
-    Effect.gen(function* () {
-      const redactedData = "cmVkYWN0ZWQtdGhpbmtpbmc="
-      const body = eventStreamBody(
-        ["messageStart", { role: "assistant" }],
-        ["contentBlockDelta", { contentBlockIndex: 0, delta: { reasoningContent: { data: redactedData } } }],
-        ["contentBlockStop", { contentBlockIndex: 0 }],
-        ["messageStop", { stopReason: "end_turn" }],
-      )
-      const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
-
-      expect(response.events.find((event) => event.type === "reasoning-delta" && event.text === "")).toEqual({
-        type: "reasoning-delta",
-        id: "reasoning-0",
-        text: "",
-        providerMetadata: { bedrock: { redactedData } },
-      })
-      expect(response.message.content).toEqual([
-        { type: "reasoning", text: "", providerMetadata: { bedrock: { redactedData } } },
-      ])
-    }),
-  )
-
-  it.effect("round-trips streamed redacted reasoning with tool use into a continuation request", () =>
-    Effect.gen(function* () {
-      // Bedrock represents redactedContent blobs as base64 strings on its JSON
-      // wire. The provider owns the payload and requires byte-exact replay.
-      const redactedData = "cmVkYWN0ZWQtdGhpbmtpbmc="
-      const response = yield* LLMClient.generate(
-        LLMRequest.update(baseRequest, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
-        }),
-      ).pipe(
-        Effect.provide(
-          fixedBytes(
-            eventStreamBody(
-              ["messageStart", { role: "assistant" }],
-              [
-                "contentBlockDelta",
-                { contentBlockIndex: 0, delta: { reasoningContent: { redactedContent: redactedData } } },
-              ],
-              ["contentBlockStop", { contentBlockIndex: 0 }],
-              [
-                "contentBlockStart",
-                {
-                  contentBlockIndex: 1,
-                  start: { toolUse: { toolUseId: "tool_1", name: "lookup" } },
-                },
-              ],
-              ["contentBlockDelta", { contentBlockIndex: 1, delta: { toolUse: { input: '{"query":"weather"}' } } }],
-              ["contentBlockStop", { contentBlockIndex: 1 }],
-              ["messageStop", { stopReason: "tool_use" }],
-            ),
-          ),
-        ),
-      )
-      expect(response.events.find((event) => event.type === "reasoning-delta" && event.text === "")).toEqual({
-        type: "reasoning-delta",
-        id: "reasoning-0",
-        text: "",
-        providerMetadata: { bedrock: { redactedData } },
-      })
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
-        LLM.request({
-          model,
-          messages: [
-            Message.user("Say hello."),
-            response.message,
-            Message.tool({ id: "tool_1", name: "lookup", result: "sunny", resultType: "text" }),
-          ],
-          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        { role: "user", content: [{ text: "Say hello." }] },
-        {
-          role: "assistant",
-          content: [
-            { reasoningContent: { redactedContent: redactedData } },
-            { toolUse: { toolUseId: "tool_1", name: "lookup", input: { query: "weather" } } },
-          ],
-        },
-        {
-          role: "user",
-          content: [{ toolResult: { toolUseId: "tool_1", content: [{ text: "sunny" }], status: "success" } }],
-        },
-      ])
-    }),
-  )
-
   it.effect("classifies throttlingException as a rate limit", () =>
     Effect.gen(function* () {
-      const body = concat([
-        eventFrame("messageStart", { role: "assistant" }),
-        exceptionFrame("throttlingException", { message: "Slow down" }),
-      ])
+      const body = eventStreamBody(
+        ["messageStart", { role: "assistant" }],
+        ["throttlingException", { message: "Slow down" }],
+      )
       const error = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)), Effect.flip)
 
       expect(error.reason).toMatchObject({ _tag: "RateLimit", message: "Slow down" })
@@ -685,7 +397,7 @@ describe("Bedrock Converse route", () => {
     Effect.gen(function* () {
       const error = yield* LLMClient.generate(baseRequest).pipe(
         Effect.provide(
-          fixedBytes(exceptionFrame("validationException", { message: "Input is too long for requested model" })),
+          fixedBytes(eventStreamBody(["validationException", { message: "Input is too long for requested model" }])),
         ),
         Effect.flip,
       )
@@ -698,44 +410,12 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
-  it.effect("uses originalMessage from model stream exception frames", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(baseRequest).pipe(
-        Effect.provide(
-          fixedBytes(
-            exceptionFrame("modelStreamErrorException", {
-              originalMessage: "Upstream model failed",
-              originalStatusCode: 500,
-            }),
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "Upstream model failed" })
-    }),
-  )
-
-  it.effect("fails unmodeled AWS event-stream errors", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(baseRequest).pipe(
-        Effect.provide(fixedBytes(errorFrame("BadStream", "Stream failed"))),
-        Effect.flip,
-      )
-
-      expect(error.reason).toMatchObject({
-        _tag: "InvalidProviderOutput",
-        message: "BadStream: Stream failed",
-      })
-    }),
-  )
-
   it.effect("rejects requests with no auth path", () =>
     Effect.gen(function* () {
       const unsignedModel = AmazonBedrock.configure({
         baseURL: "https://bedrock-runtime.test",
       }).model("anthropic.claude-3-5-sonnet-20240620-v1:0")
-      const error = yield* LLMClient.generate(LLMRequest.update(baseRequest, { model: unsignedModel })).pipe(
+      const error = yield* LLMClient.generate(LLM.updateRequest(baseRequest, { model: unsignedModel })).pipe(
         Effect.provide(fixedBytes(eventStreamBody(["messageStop", { stopReason: "end_turn" }]))),
         Effect.flip,
       )
@@ -754,7 +434,7 @@ describe("Bedrock Converse route", () => {
           secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
         },
       }).model("anthropic.claude-3-5-sonnet-20240620-v1:0")
-      const prepared = yield* LLMClient.prepare(LLMRequest.update(baseRequest, { model: signed }))
+      const prepared = yield* LLMClient.prepare(LLM.updateRequest(baseRequest, { model: signed }))
 
       expect(prepared.route).toBe("bedrock-converse")
       expect(prepared.model).toBe(signed)
@@ -869,12 +549,10 @@ describe("Bedrock Converse route", () => {
         LLM.request({
           id: "req_doc",
           model,
-          cache: "none",
           messages: [
             Message.user([
-              { type: "text", text: "Summarize these documents." },
               { type: "media", mediaType: "application/pdf", data: "UERGREFUQQ==", filename: "report.pdf" },
-              { type: "media", mediaType: "text/csv", data: "Q1NWREFUQQ==", filename: "data.csv" },
+              { type: "media", mediaType: "text/csv", data: "Q1NWREFUQQ==" },
             ]),
           ],
         }),
@@ -885,9 +563,10 @@ describe("Bedrock Converse route", () => {
           {
             role: "user",
             content: [
-              { text: "Summarize these documents." },
+              // Filename round-trips when supplied.
               { document: { format: "pdf", name: "report.pdf", source: { bytes: "UERGREFUQQ==" } } },
-              { document: { format: "csv", name: "data.csv", source: { bytes: "Q1NWREFUQQ==" } } },
+              // Falls back to a stable placeholder when filename is missing.
+              { document: { format: "csv", name: "document.csv", source: { bytes: "Q1NWREFUQQ==" } } },
             ],
           },
         ],
@@ -895,96 +574,6 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
-  it.effect("requires names for document media", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
-        LLM.request({
-          model,
-          messages: [Message.user({ type: "media", mediaType: "application/pdf", data: "UERGREFUQQ==" })],
-        }),
-      ).pipe(Effect.flip)
-
-      expect(error.message).toContain("document media requires a filename")
-    }),
-  )
-
-  it.effect("passes named document-only messages through for provider validation", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
-        LLM.request({
-          model,
-          cache: "none",
-          messages: [
-            Message.user({
-              type: "media",
-              mediaType: "application/pdf",
-              data: "UERGREFUQQ==",
-              filename: "report.pdf",
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "user",
-          content: [{ document: { format: "pdf", name: "report.pdf", source: { bytes: "UERGREFUQQ==" } } }],
-        },
-      ])
-    }),
-  )
-
-  it.effect("lowers document media in tool results", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "read", input: { path: "report.pdf" } })]),
-            Message.tool({
-              id: "call_1",
-              name: "read",
-              result: {
-                type: "content",
-                value: [
-                  { type: "text", text: "Read successfully" },
-                  {
-                    type: "file",
-                    uri: "data:application/pdf;base64,UERGREFUQQ==",
-                    mime: "application/pdf",
-                    name: "report",
-                  },
-                ],
-              },
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "assistant",
-          content: [{ toolUse: { toolUseId: "call_1", name: "read", input: { path: "report.pdf" } } }],
-        },
-        {
-          role: "user",
-          content: [
-            {
-              toolResult: {
-                toolUseId: "call_1",
-                status: "success",
-                content: [
-                  { text: "Read successfully" },
-                  { document: { format: "pdf", name: "report", source: { bytes: "UERGREFUQQ==" } } },
-                ],
-              },
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
   it.effect("rejects unsupported image media types", () =>
     Effect.gen(function* () {
       const error = yield* LLMClient.prepare(

packages/ai/test/provider/cloudflare.test.ts

@@ -47,7 +47,7 @@ describe("Cloudflare", () => {
 
   it.effect("posts to the derived gateway endpoint with bearer auth", () =>
     Effect.gen(function* () {
-      const response = yield* LLM.generateTurn(
+      const response = yield* LLM.generate(
         LLM.request({
           model: CloudflareAIGateway.configure({
             accountId: "test-account",
@@ -104,7 +104,7 @@ describe("Cloudflare", () => {
           index: 0,
         },
       ]
-      const response = yield* LLM.generateTurn(LLM.request({ model, prompt: "Say hello." })).pipe(
+      const response = yield* LLM.generate(LLM.request({ model, prompt: "Say hello." })).pipe(
         Effect.provide(
           dynamicResponse((input) =>
             Effect.succeed(
@@ -150,7 +150,7 @@ describe("Cloudflare", () => {
 
   it.effect("supports authenticated AI Gateway plus upstream provider auth", () =>
     Effect.gen(function* () {
-      yield* LLM.generateTurn(
+      yield* LLM.generate(
         LLM.request({
           model: CloudflareAIGateway.configure({
             accountId: "test-account",
@@ -221,7 +221,7 @@ describe("Cloudflare", () => {
 
   it.effect("posts direct Workers AI requests to the account endpoint with bearer auth", () =>
     Effect.gen(function* () {
-      const response = yield* LLM.generateTurn(
+      const response = yield* LLM.generate(
         LLM.request({
           model: CloudflareWorkersAI.configure({
             accountId: "test-account",
@@ -256,7 +256,7 @@ describe("Cloudflare", () => {
 
   it.effect("supports direct Workers AI token aliases through auth config", () =>
     Effect.gen(function* () {
-      yield* LLM.generateTurn(
+      yield* LLM.generate(
         LLM.request({
           model: CloudflareWorkersAI.configure({
             accountId: "test-account",

packages/ai/test/provider/gemini.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { LLM, LLMError, LLMRequest, Message, ToolCallPart, ToolDefinition, Usage } from "../../src"
+import { LLM, LLMError, Message, ToolCallPart, Usage } from "../../src"
 import { Auth, LLMClient } from "../../src/route"
 import * as Gemini from "../../src/protocols/gemini"
 import { ProviderShared } from "../../src/protocols/shared"
@@ -36,27 +36,6 @@ describe("Gemini route", () => {
     }),
   )
 
-  it.effect("normalizes Gemini thinking options", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<Gemini.GeminiBody>(
-        LLMRequest.update(request, {
-          providerOptions: { gemini: { thinkingConfig: { thinkingBudget: 0, includeThoughts: false } } },
-        }),
-      )
-      const filtered = yield* LLMClient.prepare<Gemini.GeminiBody>(
-        LLMRequest.update(request, {
-          providerOptions: { gemini: { thinkingConfig: { thinkingBudget: "invalid", includeThoughts: false } } },
-        }),
-      )
-
-      expect(prepared.body.generationConfig?.thinkingConfig).toEqual({
-        thinkingBudget: 0,
-        includeThoughts: false,
-      })
-      expect(filtered.body.generationConfig?.thinkingConfig).toEqual({ includeThoughts: false })
-    }),
-  )
-
   it.effect("lowers chronological system updates to wrapped user text in order", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<Gemini.GeminiBody>(
@@ -91,7 +70,6 @@ describe("Gemini route", () => {
             Message.user([
               { type: "text", text: "What is in this image?" },
               { type: "media", mediaType: "image/png", data: "AAECAw==" },
-              { type: "media", mediaType: "application/pdf", data: "JVBERi0xLjQ=" },
             ]),
             Message.assistant([ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } })]),
             Message.tool({ id: "call_1", name: "lookup", result: { forecast: "sunny" } }),
@@ -103,11 +81,7 @@ describe("Gemini route", () => {
         contents: [
           {
             role: "user",
-            parts: [
-              { text: "What is in this image?" },
-              { inlineData: { mimeType: "image/png", data: "AAECAw==" } },
-              { inlineData: { mimeType: "application/pdf", data: "JVBERi0xLjQ=" } },
-            ],
+            parts: [{ text: "What is in this image?" }, { inlineData: { mimeType: "image/png", data: "AAECAw==" } }],
           },
           {
             role: "model",
@@ -116,12 +90,7 @@ describe("Gemini route", () => {
           {
             role: "user",
             parts: [
-              {
-                functionResponse: {
-                  name: "lookup",
-                  response: { name: "lookup", content: '{"forecast":"sunny"}' },
-                },
-              },
+              { functionResponse: { name: "lookup", response: { name: "lookup", content: '{"forecast":"sunny"}' } } },
             ],
           },
         ],
@@ -141,7 +110,7 @@ describe("Gemini route", () => {
     }),
   )
 
-  it.effect("continues media tool results as inline model input without base64 text", () =>
+  it.effect("continues image tool results as inline vision input without base64 text", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<Gemini.GeminiBody>(
         LLM.request({
@@ -156,7 +125,6 @@ describe("Gemini route", () => {
                 value: [
                   { type: "text", text: "Image read successfully" },
                   { type: "file", uri: "data:image/png;base64,AAECAw==", mime: "image/png", name: "pixel.png" },
-                  { type: "file", uri: "data:application/pdf;base64,JVBERi0xLjQ=", mime: "application/pdf" },
                 ],
               },
             }),
@@ -173,12 +141,9 @@ describe("Gemini route", () => {
               functionResponse: {
                 name: "read",
                 response: { name: "read", content: "Image read successfully" },
-                parts: [
-                  { inlineData: { mimeType: "image/png", data: "AAECAw==" } },
-                  { inlineData: { mimeType: "application/pdf", data: "JVBERi0xLjQ=" } },
-                ],
               },
             },
+            { inlineData: { mimeType: "image/png", data: "AAECAw==" } },
           ],
         },
       ])
@@ -209,13 +174,8 @@ describe("Gemini route", () => {
         {
           role: "user",
           parts: [
-            {
-              functionResponse: {
-                name: "read",
-                response: { name: "read", content: "" },
-                parts: [{ inlineData: { mimeType: "image/jpeg", data: "/9j/" } }],
-              },
-            },
+            { functionResponse: { name: "read", response: { name: "read", content: "" } } },
+            { inlineData: { mimeType: "image/jpeg", data: "/9j/" } },
           ],
         },
       ])
@@ -254,22 +214,20 @@ describe("Gemini route", () => {
     }),
   )
 
-  it.effect("keeps tools and sends function calling mode NONE", () =>
+  it.effect("omits tools when tool choice is none", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare(
         LLM.request({
-          id: "req_tool_choice_none",
+          id: "req_no_tools",
           model,
           prompt: "Say hello.",
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
           toolChoice: { type: "none" },
         }),
       )
 
-      expect(prepared.body).toMatchObject({
+      expect(prepared.body).toEqual({
         contents: [{ role: "user", parts: [{ text: "Say hello." }] }],
-        tools: [{ functionDeclarations: [{ name: "lookup", description: "Lookup data" }] }],
-        toolConfig: { functionCallingConfig: { mode: "NONE" } },
       })
     }),
   )
@@ -394,16 +352,10 @@ describe("Gemini route", () => {
         { type: "text-delta", id: "text-0", text: "Hello" },
         { type: "text-delta", id: "text-0", text: "!" },
         { type: "text-end", id: "text-0" },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "stop", raw: "STOP" },
-          usage,
-          providerMetadata: undefined,
-        },
+        { type: "step-finish", index: 0, reason: "stop", usage, providerMetadata: undefined },
         {
           type: "finish",
-          reason: { normalized: "stop", raw: "STOP" },
+          reason: "stop",
           usage,
         },
       ])
@@ -420,10 +372,7 @@ describe("Gemini route", () => {
               parts: [
                 { text: "thinking", thought: true },
                 { text: "", thought: true, thoughtSignature: "thought_sig" },
-                {
-                  functionCall: { id: "provider_call", name: "lookup", args: { query: "weather" } },
-                  thoughtSignature: "tool_sig",
-                },
+                { functionCall: { name: "lookup", args: { query: "weather" } }, thoughtSignature: "tool_sig" },
               ],
             },
             finishReason: "STOP",
@@ -431,8 +380,8 @@ describe("Gemini route", () => {
         ],
       })
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
       const reasoning = response.events.find((event) => event.type === "reasoning-start")
@@ -449,10 +398,7 @@ describe("Gemini route", () => {
         id: "reasoning-0",
         providerMetadata: { google: { thoughtSignature: "thought_sig" } },
       })
-      expect(toolCall).toMatchObject({
-        id: "tool_0",
-        providerMetadata: { google: { functionCallId: "provider_call", thoughtSignature: "tool_sig" } },
-      })
+      expect(toolCall).toMatchObject({ providerMetadata: { google: { thoughtSignature: "tool_sig" } } })
       expect(response.events.findIndex((event) => event.type === "reasoning-end")).toBeLessThan(
         response.events.findIndex((event) => event.type === "tool-call"),
       )
@@ -470,13 +416,6 @@ describe("Gemini route", () => {
                 providerMetadata: toolCall?.providerMetadata,
               }),
             ]),
-            Message.tool({
-              id: "tool_0",
-              name: "lookup",
-              result: "done",
-              resultType: "text",
-              providerMetadata: toolCall?.providerMetadata,
-            }),
           ],
         }),
       )
@@ -485,22 +424,7 @@ describe("Gemini route", () => {
           role: "model",
           parts: [
             { text: "thinking", thought: true, thoughtSignature: "thought_sig" },
-            {
-              functionCall: { id: "provider_call", name: "lookup", args: { query: "weather" } },
-              thoughtSignature: "tool_sig",
-            },
-          ],
-        },
-        {
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                id: "provider_call",
-                name: "lookup",
-                response: { name: "lookup", content: "done" },
-              },
-            },
+            { functionCall: { name: "lookup", args: { query: "weather" } }, thoughtSignature: "tool_sig" },
           ],
         },
       ])
@@ -522,8 +446,8 @@ describe("Gemini route", () => {
         usageMetadata: { promptTokenCount: 5, candidatesTokenCount: 1 },
       })
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
       const usage = new Usage({
@@ -556,16 +480,10 @@ describe("Gemini route", () => {
           providerExecuted: undefined,
           providerMetadata: undefined,
         },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "tool-calls", raw: "STOP" },
-          usage,
-          providerMetadata: undefined,
-        },
+        { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
         {
           type: "finish",
-          reason: { normalized: "tool-calls", raw: "STOP" },
+          reason: "tool-calls",
           usage,
         },
       ])
@@ -580,7 +498,7 @@ describe("Gemini route", () => {
             content: {
               role: "model",
               parts: [
-                { functionCall: { id: "tool_0", name: "lookup", args: { query: "weather" } } },
+                { functionCall: { name: "lookup", args: { query: "weather" } } },
                 { functionCall: { name: "lookup", args: { query: "news" } } },
               ],
             },
@@ -589,25 +507,16 @@ describe("Gemini route", () => {
         ],
       })
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
 
       expect(response.toolCalls).toEqual([
-        {
-          type: "tool-call",
-          id: "tool_0",
-          name: "lookup",
-          input: { query: "weather" },
-          providerMetadata: { google: { functionCallId: "tool_0" } },
-        },
+        { type: "tool-call", id: "tool_0", name: "lookup", input: { query: "weather" } },
         { type: "tool-call", id: "tool_1", name: "lookup", input: { query: "news" } },
       ])
-      expect(response.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "tool-calls", raw: "STOP" },
-      })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "tool-calls" })
     }),
   )
 
@@ -627,41 +536,9 @@ describe("Gemini route", () => {
       )
 
       expect(length.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "finish"])
-      expect(length.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "length", raw: "MAX_TOKENS" },
-      })
+      expect(length.events.at(-1)).toMatchObject({ type: "finish", reason: "length" })
       expect(filtered.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "finish"])
-      expect(filtered.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "content-filter", raw: "SAFETY" },
-      })
-    }),
-  )
-
-  it.effect("maps current blocking and invalid-output finish reasons", () =>
-    Effect.gen(function* () {
-      const reasons = [
-        ["MODEL_ARMOR", "content-filter"],
-        ["IMAGE_PROHIBITED_CONTENT", "content-filter"],
-        ["IMAGE_RECITATION", "content-filter"],
-        ["LANGUAGE", "content-filter"],
-        ["UNEXPECTED_TOOL_CALL", "error"],
-        ["NO_IMAGE", "error"],
-        ["IMAGE_OTHER", "unknown"],
-        ["TOO_MANY_TOOL_CALLS", "error"],
-        ["MISSING_THOUGHT_SIGNATURE", "error"],
-        ["MALFORMED_RESPONSE", "error"],
-      ] as const
-
-      for (const [raw, normalized] of reasons) {
-        const response = yield* LLMClient.generate(request).pipe(
-          Effect.provide(
-            fixedResponse(sseEvents({ candidates: [{ content: { role: "model", parts: [] }, finishReason: raw }] })),
-          ),
-        )
-        expect(response.finishReason).toEqual({ normalized, raw })
-      }
+      expect(filtered.events.at(-1)).toMatchObject({ type: "finish", reason: "content-filter" })
     }),
   )
 

packages/ai/test/provider/google-images.recorded.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { Image, ImageInput } from "../../src"
-import { Google } from "../../src/providers"
-import { dimensions } from "../lib/image"
-import { recordedTests } from "../recorded-test"
-
-const model = Google.configure({
-  apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY ?? "fixture",
-}).image("gemini-3.1-flash-image")
-
-const recorded = recordedTests({
-  prefix: "google-images",
-  provider: "google",
-  protocol: "google-images",
-  requires: ["GOOGLE_GENERATIVE_AI_API_KEY"],
-})
-
-describe("Google Images recorded", () => {
-  recorded.effect("generates an image", () =>
-    Effect.gen(function* () {
-      const response = yield* Image.generate({
-        model,
-        prompt: "A simple flat blue circle centered on a plain white background.",
-        options: { aspectRatio: "1:1" },
-      })
-
-      expect(response.images).toHaveLength(1)
-      expect(response.image?.mediaType).toMatch(/^image\//)
-      expect(response.image?.data).toBeInstanceOf(Uint8Array)
-      expect(response.image?.data.length).toBeGreaterThan(0)
-    }),
-  )
-
-  recorded.effect("edits an image", () =>
-    Effect.gen(function* () {
-      const response = yield* Image.generate({
-        model,
-        prompt:
-          "Transform this minimal source into a bright orange sun icon with eight rounded rays on a pale blue background.",
-        images: [
-          ImageInput.bytes(
-            yield* Effect.promise(() => Bun.file("test/fixtures/images/edit-source.jpg").bytes()),
-            "image/jpeg",
-          ),
-        ],
-        options: { aspectRatio: "1:1" },
-      })
-
-      expect(response.image?.mediaType).toBe("image/jpeg")
-      expect(response.image?.data).toBeInstanceOf(Uint8Array)
-      if (!(response.image?.data instanceof Uint8Array)) throw new Error("Expected owned Google image bytes")
-      expect(dimensions(response.image.data)).toEqual({ width: 1024, height: 1024 })
-    }),
-  )
-})

packages/ai/test/provider/openai-chat-reasoning.recorded.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { LLM, LLMEvent, LLMResponse, Model } from "../../src"
+import { LLM, LLMEvent, LLMResponse } from "../../src"
 import { OpenAIChat } from "../../src/protocols/openai-chat"
 import * as OpenAICompatible from "../../src/providers/openai-compatible"
 import * as OpenRouter from "../../src/providers/openrouter"
@@ -11,28 +11,22 @@ import { expectWeatherToolLoop, goldenWeatherToolLoopRequest, runWeatherToolLoop
 const cases = [
   {
     name: "OpenRouter",
-    model: Model.update(
-      OpenRouter.configure({
-        apiKey: process.env.OPENROUTER_API_KEY ?? "fixture",
-        providerOptions: { openrouter: { reasoning: { max_tokens: 1024 } } },
-      }).model("anthropic/claude-sonnet-4.6"),
-      { compatibility: { reasoningField: "reasoning" } },
-    ),
+    model: OpenRouter.configure({
+      apiKey: process.env.OPENROUTER_API_KEY ?? "fixture",
+      providerOptions: { openrouter: { reasoning: { max_tokens: 1024 } } },
+    }).model("anthropic/claude-sonnet-4.6"),
     requires: ["OPENROUTER_API_KEY"],
     cassette: "openrouter-reasoning",
     structured: true,
   },
   {
     name: "Vercel AI Gateway",
-    model: Model.update(
-      OpenAICompatible.configure({
-        provider: "vercel-ai-gateway",
-        baseURL: "https://ai-gateway.vercel.sh/v1",
-        apiKey: process.env.AI_GATEWAY_API_KEY ?? "fixture",
-        http: { body: { reasoning: { enabled: true, max_tokens: 1024 } } },
-      }).model("anthropic/claude-sonnet-4.6"),
-      { compatibility: { reasoningField: "reasoning" } },
-    ),
+    model: OpenAICompatible.configure({
+      provider: "vercel-ai-gateway",
+      baseURL: "https://ai-gateway.vercel.sh/v1",
+      apiKey: process.env.AI_GATEWAY_API_KEY ?? "fixture",
+      http: { body: { reasoning: { enabled: true, max_tokens: 1024 } } },
+    }).model("anthropic/claude-sonnet-4.6"),
     requires: ["AI_GATEWAY_API_KEY"],
     cassette: "vercel-ai-gateway-reasoning",
     structured: true,

packages/ai/test/provider/openai-chat.test.ts

@@ -1,18 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Effect, Schema, Stream } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
-import {
-  HttpOptions,
-  LLM,
-  LLMError,
-  LLMEvent,
-  LLMRequest,
-  Message,
-  Model,
-  ToolCallPart,
-  ToolDefinition,
-  Usage,
-} from "../../src"
+import { LLM, LLMError, LLMEvent, Message, Model, ToolCallPart, Usage } from "../../src"
 import * as Azure from "../../src/providers/azure"
 import * as OpenAI from "../../src/providers/openai"
 import * as OpenAIChat from "../../src/protocols/openai-chat"
@@ -103,45 +92,6 @@ describe("OpenAI Chat route", () => {
     }),
   )
 
-  it.effect("writes reasoning to a configured custom field on every assistant message", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({
-          model: Model.update(model, { compatibility: { reasoningField: "vendor_reasoning" } }),
-          messages: [
-            Message.assistant([
-              {
-                type: "reasoning",
-                text: "thinking",
-                providerMetadata: { openai: { reasoningField: "reasoning" } },
-              },
-              { type: "text", text: "Hello" },
-            ]),
-            Message.assistant("Done"),
-          ],
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        { role: "assistant", content: "Hello", vendor_reasoning: "thinking" },
-        { role: "assistant", content: "Done", vendor_reasoning: "" },
-      ])
-    }),
-  )
-
-  it.effect("rejects reasoning fields that conflict with assistant message fields", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
-        LLM.request({
-          model: Model.update(model, { compatibility: { reasoningField: "content" } }),
-          messages: [Message.assistant([{ type: "reasoning", text: "thinking" }])],
-        }),
-      ).pipe(Effect.flip)
-
-      expect(error.message).toContain("reserved field content")
-    }),
-  )
-
   it.effect("maps OpenAI provider options to Chat options", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
@@ -173,7 +123,7 @@ describe("OpenAI Chat route", () => {
 
   it.effect("adds native query params to the Chat Completions URL", () =>
     LLMClient.generate(
-      LLMRequest.update(request, {
+      LLM.updateRequest(request, {
         model: Model.update(model, { route: model.route.with({ endpoint: { query: { "api-version": "v1" } } }) }),
       }),
     ).pipe(
@@ -193,7 +143,7 @@ describe("OpenAI Chat route", () => {
 
   it.effect("uses Azure api-key header for static OpenAI Chat keys", () =>
     LLMClient.generate(
-      LLMRequest.update(request, {
+      LLM.updateRequest(request, {
         model: Azure.configure({
           baseURL: "https://opencode-test.openai.azure.com/openai/v1/",
           apiKey: "azure-key",
@@ -219,15 +169,15 @@ describe("OpenAI Chat route", () => {
 
   it.effect("applies serializable HTTP overlays after payload lowering", () =>
     LLMClient.generate(
-      LLMRequest.update(request, {
+      LLM.updateRequest(request, {
         model: model.route
           .with({ auth: Auth.bearer("fresh-key"), headers: { authorization: "Bearer stale" } })
           .model({ id: model.id }),
-        http: HttpOptions.make({
+        http: {
           body: { metadata: { source: "test" } },
           headers: { authorization: "Bearer request", "x-custom": "yes" },
           query: { debug: "1" },
-        }),
+        },
       }),
     ).pipe(
       Effect.provide(
@@ -580,16 +530,10 @@ describe("OpenAI Chat route", () => {
         { type: "text-delta", id: "text-0", text: "Hello" },
         { type: "text-delta", id: "text-0", text: "!" },
         { type: "text-end", id: "text-0" },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "stop", raw: "stop" },
-          usage,
-          providerMetadata: undefined,
-        },
+        { type: "step-finish", index: 0, reason: "stop", usage, providerMetadata: undefined },
         {
           type: "finish",
-          reason: { normalized: "stop", raw: "stop" },
+          reason: "stop",
           usage,
         },
       ])
@@ -626,33 +570,6 @@ describe("OpenAI Chat route", () => {
     }),
   )
 
-  it.effect("parses and replays a configured custom reasoning field", () =>
-    Effect.gen(function* () {
-      const custom = Model.update(model, { compatibility: { reasoningField: "vendor_reasoning" } })
-      const response = yield* LLMClient.generate(LLMRequest.update(request, { model: custom })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { vendor_reasoning: "thinking" } }] },
-              { choices: [{ delta: { content: "Hello" } }] },
-              { choices: [{ delta: {}, finish_reason: "stop" }] },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("thinking")
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        openai: { reasoningField: "vendor_reasoning" },
-      })
-
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model: custom, messages: [response.message] }),
-      )
-      expect(replay.body.messages).toEqual([{ role: "assistant", content: "Hello", vendor_reasoning: "thinking" }])
-    }),
-  )
-
   it.effect("preserves and replays reasoning details alongside scalar reasoning", () =>
     Effect.gen(function* () {
       const details = [
@@ -660,8 +577,8 @@ describe("OpenAI Chat route", () => {
         { type: "reasoning.encrypted", data: "opaque", format: "anthropic-claude-v1", index: 1 },
       ]
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
         }),
       ).pipe(
         Effect.provide(
@@ -1033,8 +950,8 @@ describe("OpenAI Chat route", () => {
         deltaChunk({}, "tool_calls"),
       )
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
 
@@ -1052,14 +969,8 @@ describe("OpenAI Chat route", () => {
           providerExecuted: undefined,
           providerMetadata: undefined,
         },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "tool-calls", raw: "tool_calls" },
-          usage: undefined,
-          providerMetadata: undefined,
-        },
-        { type: "finish", reason: { normalized: "tool-calls", raw: "tool_calls" }, usage: undefined },
+        { type: "step-finish", index: 0, reason: "tool-calls", usage: undefined, providerMetadata: undefined },
+        { type: "finish", reason: "tool-calls", usage: undefined },
       ])
     }),
   )
@@ -1076,8 +987,8 @@ describe("OpenAI Chat route", () => {
         deltaChunk({}, "tool_calls"),
       )
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
 
@@ -1098,8 +1009,8 @@ describe("OpenAI Chat route", () => {
         deltaChunk({}, "tool_calls"),
       )
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
 
@@ -1116,8 +1027,8 @@ describe("OpenAI Chat route", () => {
         deltaChunk({}, "tool_calls"),
       )
       const error = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)), Effect.flip)
 
@@ -1134,8 +1045,8 @@ describe("OpenAI Chat route", () => {
         }),
         deltaChunk({ tool_calls: [{ index: 0, function: { arguments: ':"weather"}' } }] }),
       )
-      const input = LLMRequest.update(request, {
-        tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+      const input = LLM.updateRequest(request, {
+        tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
       })
       const events: LLMEvent[] = []
       const streamError = yield* LLMClient.stream(input).pipe(

packages/ai/test/provider/openai-compatible-chat.test.ts

@@ -1,7 +1,7 @@
 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"
+import { LLM, Message, ToolCallPart } from "../../src"
 import { Auth, LLMClient } from "../../src/route"
 import * as OpenAICompatible from "../../src/providers/openai-compatible"
 import * as OpenAICompatibleChat from "../../src/protocols/openai-compatible-chat"
@@ -53,9 +53,9 @@ describe("OpenAI-compatible Chat route", () => {
   it.effect("prepares generic Chat target", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
-          toolChoice: ToolChoice.make({ type: "required" }),
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
+          toolChoice: { type: "required" },
         }),
       )
 
@@ -232,10 +232,7 @@ describe("OpenAI-compatible Chat route", () => {
 
       expect(response.text).toBe("Hello!")
       expect(response.usage).toMatchObject({ inputTokens: 5, outputTokens: 2, totalTokens: 7 })
-      expect(response.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "stop", raw: "stop" },
-      })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "stop" })
     }),
   )
 })

packages/ai/test/provider/openai-compatible-responses.test.ts

@@ -1,22 +1,17 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { LLM, LLMEvent } from "../../src"
+import { LLM } from "../../src"
 import { configure } from "../../src/providers/openai-compatible-responses"
-import { OpenAI } from "../../src/providers"
-import { OpenResponses } from "../../src/protocols/open-responses"
 import { OpenAICompatibleResponses } from "../../src/protocols/openai-compatible-responses"
 import { OpenAIResponses } from "../../src/protocols/openai-responses"
 import { LLMClient } from "../../src/route"
 import { it } from "../lib/effect"
-import { fixedResponse } from "../lib/http"
-import { sseEvents } from "../lib/sse"
 
-describe("Open Responses-compatible route", () => {
-  it.effect("uses the Open Responses baseline for a configured deployment", () =>
+describe("OpenAI-compatible Responses route", () => {
+  it.effect("reuses the OpenAI Responses protocol for a configured deployment", () =>
     Effect.gen(function* () {
-      expect(OpenAICompatibleResponses.route.body).toBe(OpenResponses.protocol.body)
-      expect(OpenAICompatibleResponses.route.transport).toBe(OpenResponses.httpTransport)
-      expect(OpenAICompatibleResponses.route.body).not.toBe(OpenAIResponses.protocol.body)
+      expect(OpenAICompatibleResponses.route.body).toBe(OpenAIResponses.protocol.body)
+      expect(OpenAICompatibleResponses.route.transport).toBe(OpenAIResponses.httpTransport)
 
       const model = configure({
         apiKey: "test-key",
@@ -32,7 +27,7 @@ describe("Open Responses-compatible route", () => {
       )
 
       expect(prepared.route).toBe("openai-compatible-responses")
-      expect(prepared.protocol).toBe("open-responses")
+      expect(prepared.protocol).toBe("openai-responses")
       expect(prepared.model).toMatchObject({
         id: "example-model",
         provider: "example",
@@ -50,67 +45,9 @@ describe("Open Responses-compatible route", () => {
           { role: "system", content: "You are concise." },
           { role: "user", content: [{ type: "input_text", text: "Say hello." }] },
         ],
+        store: false,
         stream: true,
       })
     }),
   )
-
-  it.effect("rejects OpenAI-native tools", () =>
-    Effect.gen(function* () {
-      const model = configure({
-        apiKey: "test-key",
-        baseURL: "https://responses.example.test/v1",
-      }).model("example-model")
-      const error = yield* LLMClient.prepare(
-        LLM.request({ model, prompt: "Draw.", tools: [OpenAI.imageGeneration()] }),
-      ).pipe(Effect.flip)
-
-      expect(error.reason._tag).toBe("InvalidRequest")
-      expect(error.message).toContain("Open Responses does not support provider-native tool image_generation")
-    }),
-  )
-
-  it.effect("reads standard options from the Open Responses namespace", () =>
-    Effect.gen(function* () {
-      const model = configure({
-        apiKey: "test-key",
-        baseURL: "https://responses.example.test/v1",
-        providerOptions: { openresponses: { reasoningEffort: "low", store: true } },
-      }).model("example-model")
-      const prepared = yield* LLMClient.prepare(LLM.request({ model, prompt: "Think." }))
-
-      expect(prepared.body).toMatchObject({
-        reasoning: { effort: "low" },
-        store: true,
-      })
-    }),
-  )
-
-  it.effect("does not interpret OpenAI hosted-tool items", () =>
-    Effect.gen(function* () {
-      const model = configure({
-        apiKey: "test-key",
-        baseURL: "https://responses.example.test/v1",
-        provider: "example",
-      }).model("example-model")
-      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Search." })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.done",
-                item: { type: "web_search_call", id: "ws_1", status: "completed", action: { query: "news" } },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.toolCalls).toEqual([])
-      expect(response.events.find(LLMEvent.is.finish)).toMatchObject({
-        providerMetadata: { openresponses: { responseId: "resp_1" } },
-      })
-    }),
-  )
 })

packages/ai/test/provider/openai-images.recorded.test.ts

@@ -1,12 +1,18 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Image, ImageInput } from "../../src"
+import { Image } from "../../src"
 import { OpenAI } from "../../src/providers"
-import { dimensions } from "../lib/image"
 import { recordedTests } from "../recorded-test"
 
 const model = OpenAI.configure({
   apiKey: process.env.OPENAI_API_KEY ?? "fixture",
+  image: {
+    providerOptions: {
+      quality: "low",
+      outputFormat: "jpeg",
+      outputCompression: 10,
+    },
+  },
 }).image("gpt-image-1-mini")
 
 const recorded = recordedTests({
@@ -22,7 +28,7 @@ describe("OpenAI Images recorded", () => {
       const response = yield* Image.generate({
         model,
         prompt: "A simple flat black circle centered on a plain white background.",
-        options: { quality: "low", outputFormat: "jpeg", outputCompression: 10, size: "1024x1024" },
+        size: { width: 1024, height: 1024 },
       })
 
       expect(response.images).toHaveLength(1)
@@ -31,32 +37,4 @@ describe("OpenAI Images recorded", () => {
       expect(response.image?.data.length).toBeGreaterThan(0)
     }),
   )
-
-  recorded.effect.with(
-    "edits an image",
-    {
-      options: {
-        match: (incoming, recorded) => incoming.method === recorded.method && incoming.url === recorded.url,
-      },
-    },
-    () =>
-      Effect.gen(function* () {
-        const response = yield* Image.generate({
-          model,
-          prompt: "Keep the simple shape and change it from black to bright green.",
-          images: [
-            ImageInput.bytes(
-              yield* Effect.promise(() => Bun.file("test/fixtures/images/edit-source.jpg").bytes()),
-              "image/jpeg",
-            ),
-          ],
-          options: { quality: "low", outputFormat: "jpeg", outputCompression: 10, size: "1024x1024" },
-        })
-
-        expect(response.image?.mediaType).toBe("image/jpeg")
-        expect(response.image?.data).toBeInstanceOf(Uint8Array)
-        if (!(response.image?.data instanceof Uint8Array)) throw new Error("Expected owned OpenAI image bytes")
-        expect(dimensions(response.image.data)).toEqual({ width: 1024, height: 1024 })
-      }),
-  )
 })

packages/ai/test/provider/openai-responses-images.recorded.test.ts

@@ -29,7 +29,7 @@ describe("OpenAI Responses image generation recorded", () => {
           partialImages: 0,
         }),
       ]
-      const response = yield* LLM.generateTurn(
+      const response = yield* LLM.generate(
         LLM.request({
           model: openai.responses("gpt-5-mini"),
           messages: [initial],
@@ -49,7 +49,7 @@ describe("OpenAI Responses image generation recorded", () => {
       expect(result.result.value[0].mime).toBe("image/jpeg")
       expect(result.result.value[0].uri.startsWith("data:image/jpeg;base64,")).toBe(true)
 
-      const edited = yield* LLM.generateTurn(
+      const edited = yield* LLM.generate(
         LLM.request({
           model: openai.responses("gpt-5-mini"),
           messages: [initial, response.message, Message.user("Now make the triangle blue.")],

packages/ai/test/provider/openai-responses.test.ts

@@ -1,22 +1,10 @@
 import { describe, expect } from "bun:test"
 import { ConfigProvider, Effect, Layer, Stream } from "effect"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
-import {
-  LLM,
-  LLMError,
-  LLMEvent,
-  LLMRequest,
-  Message,
-  Model,
-  ToolCallPart,
-  ToolDefinition,
-  ToolResultPart,
-  Usage,
-} from "../../src"
+import { LLM, LLMError, LLMEvent, Message, Model, ToolCallPart, ToolResultPart, Usage } from "../../src"
 import { Auth, LLMClient, RequestExecutor, WebSocketExecutor } from "../../src/route"
 import * as Azure from "../../src/providers/azure"
 import * as OpenAI from "../../src/providers/openai"
-import * as XAI from "../../src/providers/xai"
 import * as OpenAIResponses from "../../src/protocols/openai-responses"
 import * as ProviderShared from "../../src/protocols/shared"
 import { continuationRequest, nativeOpenAIResponsesContinuation } from "../continuation-scenarios"
@@ -28,8 +16,6 @@ const model = OpenAIResponses.route
   .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
   .model({ id: "gpt-4.1-mini" })
 
-const xaiModel = XAI.configure({ apiKey: "test", baseURL: "https://api.x.ai/v1" }).responses("grok-4.5")
-
 const request = LLM.request({
   id: "req_1",
   model,
@@ -107,7 +93,7 @@ describe("OpenAI Responses route", () => {
 
   it.effect("lowers semantic service tier options", () =>
     Effect.gen(function* () {
-      const input = LLMRequest.update(request, { providerOptions: { openai: { serviceTier: "priority" } } })
+      const input = LLM.updateRequest(request, { providerOptions: { openai: { serviceTier: "priority" } } })
       expect(input.providerOptions).toEqual({ openai: { serviceTier: "priority" } })
       const prepared = yield* LLMClient.prepare(input)
 
@@ -119,7 +105,7 @@ describe("OpenAI Responses route", () => {
   it.effect("passes through custom OpenAI reasoning effort strings", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLMRequest.update(request, { providerOptions: { openai: { reasoningEffort: "experimental" } } }),
+        LLM.updateRequest(request, { providerOptions: { openai: { reasoningEffort: "experimental" } } }),
       )
 
       expect(prepared.body.reasoning).toEqual({ effort: "experimental" })
@@ -129,7 +115,7 @@ describe("OpenAI Responses route", () => {
   it.effect("omits unsupported semantic service tiers", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare(
-        LLMRequest.update(request, { providerOptions: { openai: { serviceTier: "unsupported" } } }),
+        LLM.updateRequest(request, { providerOptions: { openai: { serviceTier: "unsupported" } } }),
       )
 
       expect(prepared.body).not.toHaveProperty("service_tier")
@@ -139,9 +125,9 @@ describe("OpenAI Responses route", () => {
   it.effect("flattens top-level object unions in function schemas", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLMRequest.update(request, {
+        LLM.updateRequest(request, {
           tools: [
-            ToolDefinition.make({
+            {
               name: "read",
               description: "Read a path or resource.",
               inputSchema: {
@@ -163,7 +149,7 @@ describe("OpenAI Responses route", () => {
                   },
                 ],
               },
-            }),
+            },
           ],
         }),
       )
@@ -218,7 +204,7 @@ describe("OpenAI Responses route", () => {
   it.effect("prepares OpenAI Responses WebSocket target", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare(
-        LLMRequest.update(request, {
+        LLM.updateRequest(request, {
           model: OpenAIResponses.webSocketRoute
             .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
             .model({ id: "gpt-4.1-mini" }),
@@ -302,7 +288,7 @@ describe("OpenAI Responses route", () => {
   it.effect("adds native query params to the Responses URL", () =>
     Effect.gen(function* () {
       yield* LLMClient.generate(
-        LLMRequest.update(request, {
+        LLM.updateRequest(request, {
           model: Model.update(model, { route: model.route.with({ endpoint: { query: { "api-version": "v1" } } }) }),
         }),
       ).pipe(
@@ -324,7 +310,7 @@ describe("OpenAI Responses route", () => {
   it.effect("uses Azure api-key header for static OpenAI Responses keys", () =>
     Effect.gen(function* () {
       yield* LLMClient.generate(
-        LLMRequest.update(request, {
+        LLM.updateRequest(request, {
           model: Azure.configure({
             baseURL: "https://opencode-test.openai.azure.com/openai/v1/",
             apiKey: "azure-key",
@@ -351,7 +337,7 @@ describe("OpenAI Responses route", () => {
 
   it.effect("loads OpenAI default auth from Effect Config", () =>
     LLMClient.generate(
-      LLMRequest.update(request, {
+      LLM.updateRequest(request, {
         model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/" }).responses("gpt-4.1-mini"),
       }),
     ).pipe(
@@ -372,7 +358,7 @@ describe("OpenAI Responses route", () => {
 
   it.effect("lets explicit auth override OpenAI default API key auth", () =>
     LLMClient.generate(
-      LLMRequest.update(request, {
+      LLM.updateRequest(request, {
         model: OpenAI.configure({
           baseURL: "https://api.openai.test/v1/",
           auth: Auth.bearer("oauth-token"),
@@ -538,77 +524,7 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("lowers PDF tool-result content as structured input_file array", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLM.request({
-          id: "req_tool_result_pdf",
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "read", input: {} })]),
-            Message.tool({
-              id: "call_1",
-              name: "read",
-              resultType: "content",
-              result: [
-                {
-                  type: "file",
-                  uri: "data:application/pdf;base64,JVBERi0xLjQ=",
-                  mime: "application/pdf",
-                  name: "report.pdf",
-                },
-              ],
-            }),
-          ],
-        }),
-      )
-
-      expect(expectToolOutput(prepared.body).output).toEqual([
-        {
-          type: "input_file",
-          filename: "report.pdf",
-          file_data: "data:application/pdf;base64,JVBERi0xLjQ=",
-        },
-      ])
-    }),
-  )
-
-  it.effect("uses xAI inline file encoding for PDF tool results", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLM.request({
-          model: xaiModel,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "read", input: {} })]),
-            Message.tool({
-              id: "call_1",
-              name: "read",
-              resultType: "content",
-              result: [
-                {
-                  type: "file",
-                  uri: "data:application/pdf;base64,JVBERi0xLjQ=",
-                  mime: "application/pdf",
-                  name: "report.pdf",
-                },
-              ],
-            }),
-          ],
-        }),
-      )
-
-      expect(expectToolOutput(prepared.body).output).toEqual([
-        {
-          type: "input_file",
-          filename: "report.pdf",
-          file_data: "JVBERi0xLjQ=",
-          mime_type: "application/pdf",
-        },
-      ])
-    }),
-  )
-
-  it.effect("rejects unsupported media in tool-result content with a clear error", () =>
+  it.effect("rejects non-image media in tool-result content with a clear error", () =>
     Effect.gen(function* () {
       const error = yield* LLMClient.prepare(
         LLM.request({
@@ -867,13 +783,13 @@ describe("OpenAI Responses route", () => {
         {
           type: "step-finish",
           index: 0,
-          reason: { normalized: "stop", raw: undefined },
+          reason: "stop",
           providerMetadata: { openai: { responseId: "resp_1", serviceTier: "default" } },
           usage,
         },
         {
           type: "finish",
-          reason: { normalized: "stop", raw: undefined },
+          reason: "stop",
           providerMetadata: { openai: { responseId: "resp_1", serviceTier: "default" } },
           usage,
         },
@@ -881,34 +797,6 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("maps incomplete response reasons", () =>
-    Effect.gen(function* () {
-      const generate = (incompleteDetails: object) =>
-        LLMClient.generate(request).pipe(
-          Effect.provide(
-            fixedResponse(
-              sseEvents({
-                type: "response.incomplete",
-                response: { id: "resp_incomplete", incomplete_details: incompleteDetails },
-              }),
-            ),
-          ),
-        )
-
-      const length = yield* generate({ reason: "max_output_tokens" })
-      const contentFilter = yield* generate({ reason: "content_filter" })
-      const unknown = yield* generate({})
-      const custom = yield* generate({ reason: "provider_limit" })
-
-      expect([length.finishReason, contentFilter.finishReason, unknown.finishReason, custom.finishReason]).toEqual([
-        { normalized: "length", raw: "max_output_tokens" },
-        { normalized: "content-filter", raw: "content_filter" },
-        { normalized: "unknown", raw: undefined },
-        { normalized: "unknown", raw: "provider_limit" },
-      ])
-    }),
-  )
-
   // OpenAI's documented stream orders output text within one message item; no
   // provider-valid same-kind overlap is evidenced, so done boundaries close it.
   it.effect("closes sequential output messages before starting the next", () =>
@@ -959,8 +847,8 @@ describe("OpenAI Responses route", () => {
         { type: "text-delta", id: "msg_1", text: "Hello" },
         { type: "reasoning-end", id: "rs_1" },
         { type: "text-end", id: "msg_1" },
-        { type: "step-finish", index: 0, reason: { normalized: "stop", raw: undefined } },
-        { type: "finish", reason: { normalized: "stop", raw: undefined } },
+        { type: "step-finish", index: 0, reason: "stop" },
+        { type: "finish", reason: "stop" },
       ])
       expect(response.events.filter((event) => event.type === "finish")).toHaveLength(1)
       expect(response.message.content).toEqual([
@@ -1005,7 +893,7 @@ describe("OpenAI Responses route", () => {
   it.effect("streams each reasoning summary part as a separate block", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, { providerOptions: { openai: { store: false } } }),
+        LLM.updateRequest(request, { providerOptions: { openai: { store: false } } }),
       ).pipe(
         Effect.provide(
           fixedResponse(
@@ -1051,8 +939,8 @@ describe("OpenAI Responses route", () => {
           id: "rs_1:1",
           providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
         },
-        { type: "step-finish", index: 0, reason: { normalized: "stop", raw: undefined } },
-        { type: "finish", reason: { normalized: "stop", raw: undefined } },
+        { type: "step-finish", index: 0, reason: "stop" },
+        { type: "finish", reason: "stop" },
       ])
     }),
   )
@@ -1060,7 +948,7 @@ describe("OpenAI Responses route", () => {
   it.effect("closes reasoning summary parts when storage is not disabled", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, { providerOptions: { openai: { store: true } } }),
+        LLM.updateRequest(request, { providerOptions: { openai: { store: true } } }),
       ).pipe(
         Effect.provide(
           fixedResponse(
@@ -1387,8 +1275,8 @@ describe("OpenAI Responses route", () => {
         { type: "response.completed", response: { usage: { input_tokens: 5, output_tokens: 1 } } },
       )
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
       const usage = new Usage({
@@ -1435,16 +1323,10 @@ describe("OpenAI Responses route", () => {
           providerExecuted: undefined,
           providerMetadata: { openai: { itemId: "item_1" } },
         },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "tool-calls", raw: undefined },
-          usage,
-          providerMetadata: undefined,
-        },
+        { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
         {
           type: "finish",
-          reason: { normalized: "tool-calls", raw: undefined },
+          reason: "tool-calls",
           providerMetadata: undefined,
           usage,
         },
@@ -1473,8 +1355,8 @@ describe("OpenAI Responses route", () => {
         { type: "response.completed", response: { usage: { input_tokens: 5, output_tokens: 1 } } },
       )
       const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        LLM.updateRequest(request, {
+          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
 
@@ -1484,7 +1366,7 @@ describe("OpenAI Responses route", () => {
         name: "lookup",
         raw: '{"query":"partial',
       })
-      expect(response.finishReason.normalized).toBe("tool-calls")
+      expect(response.finishReason).toBe("tool-calls")
       expect(response.events.some(LLMEvent.is.toolCall)).toBeFalse()
     }),
   )
@@ -1511,7 +1393,7 @@ describe("OpenAI Responses route", () => {
         name: "lookup",
         raw: '{"query":"partial',
       })
-      expect(response.finishReason.normalized).toBe("tool-calls")
+      expect(response.finishReason).toBe("tool-calls")
     }),
   )
 
@@ -1644,64 +1526,20 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("lowers user image and PDF content", () =>
+  it.effect("lowers user image content", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
         LLM.request({
           id: "req_media",
           model,
-          messages: [
-            Message.user([
-              { type: "media", mediaType: "image/png", data: "AAECAw==" },
-              { type: "media", mediaType: "application/pdf", data: "JVBERi0xLjQ=", filename: "report.pdf" },
-            ]),
-          ],
+          messages: [Message.user({ type: "media", mediaType: "image/png", data: "AAECAw==" })],
         }),
       )
 
       expect(prepared.body.input).toEqual([
         {
           role: "user",
-          content: [
-            { type: "input_image", image_url: "data:image/png;base64,AAECAw==" },
-            {
-              type: "input_file",
-              filename: "report.pdf",
-              file_data: "data:application/pdf;base64,JVBERi0xLjQ=",
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("uses xAI inline file encoding for user PDFs", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLM.request({
-          model: xaiModel,
-          messages: [
-            Message.user({
-              type: "media",
-              mediaType: "application/pdf",
-              data: "data:application/pdf;base64,JVBERi0xLjQ=",
-              filename: "report.pdf",
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.input).toEqual([
-        {
-          role: "user",
-          content: [
-            {
-              type: "input_file",
-              filename: "report.pdf",
-              file_data: "JVBERi0xLjQ=",
-              mime_type: "application/pdf",
-            },
-          ],
+          content: [{ type: "input_image", image_url: "data:image/png;base64,AAECAw==" }],
         },
       ])
     }),
@@ -1713,11 +1551,11 @@ describe("OpenAI Responses route", () => {
         LLM.request({
           id: "req_media",
           model,
-          messages: [Message.user({ type: "media", mediaType: "application/x-tar", data: "AAECAw==" })],
+          messages: [Message.user({ type: "media", mediaType: "application/pdf", data: "AAECAw==" })],
         }),
       ).pipe(Effect.flip)
 
-      expect(error.message).toContain("OpenAI Responses does not support media type application/x-tar")
+      expect(error.message).toContain("OpenAI Responses does not support media type application/pdf")
     }),
   )