refactor(ai): move credential lowering into providers

.changeset/device-authorization-url.md

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

.changeset/idempotent-prompt-reuse.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/core": patch
----
-
-Prompt and synthetic inbox ID reuse is now idempotent: reusing an ID within the same Session succeeds and returns the first admission, ignoring the retried payload, metadata, and delivery mode. Previously reuse with a differing payload failed with a conflict. Cross-Session and cross-type reuse still fail, and control items keep their operation-specific conflict behavior.

.changeset/nested-instruction-reinjection.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/core": patch
----
-
-Nested AGENTS.md instructions are re-injected after compaction. Previously the in-memory dedup claim outlived the synthetic message that compaction dropped from model-visible history, so nested instructions were silently lost for the rest of the process lifetime. The claim now only guards in-flight loads; the synthetic message metadata in durable history is the sole lasting ledger, so any history truncation (compaction, revert) self-heals on the next read in that subtree.

.changeset/plugin-effect-runtime.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/plugin": patch
----
-
-Export the Effect runtime used by Effect plugins and safely adapt its tool schemas across host module instances.

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

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

.changeset/steer-resume-simplified.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/core": patch
----
-
-Simplify interrupt continuation: the steer-scoped resume decision now lives in SessionExecution as a post-cleanup inbox check, and the run coordinator drops its continuation state machine. Wakes arriving during cancellation cleanup now restart a normal full drain, and interrupting an idle session with continue now resumes pending steering input. Recovery-applied moves now end with the same full wake as inbox-admitted moves, retrying any stranded inbox work at the new location. Interrupting with continue now also resumes a next-in-line control item: between-turn manual compaction and moves run under any drain scope, while queued prompts remain parked.

.changeset/terminal-form-recovery.md

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

.changeset/unify-request-envelope.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/core": patch
----
-
-Title generation and compaction summaries now build their model requests through the shared session request boundary, gaining unsupported-media filtering and image bounds while explicitly opting out of session context hooks: plugins that shape the agent conversation do not observe title or compaction requests. Title requests gain the fork-aware session prompt cache key, and compaction summaries in forked sessions reuse the fork root's prompt cache key instead of the fork's own.

.github/workflows/deploy-posts.yml

@@ -1,37 +0,0 @@
-name: deploy-posts
-
-on:
-  push:
-    branches:
-      - v2
-    paths:
-      - packages/posts/**
-      - bun.lock
-      - .github/workflows/deploy-posts.yml
-  workflow_dispatch:
-
-concurrency:
-  group: deploy-posts-${{ github.ref_name }}
-  cancel-in-progress: false
-
-permissions:
-  contents: read
-
-jobs:
-  deploy:
-    if: github.repository == 'anomalyco/opencode' && github.ref_name == 'v2'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-
-      - uses: ./.github/actions/setup-bun
-
-      - name: Build
-        working-directory: packages/posts
-        run: bun run build
-
-      - name: Deploy
-        working-directory: packages/posts
-        run: bun run deploy
-        env:
-          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

.github/workflows/deploy-www.yml

@@ -27,6 +27,7 @@ jobs:
         working-directory: packages/www
         run: bun run build
         env:
+          BLUME_ENV: ${{ github.ref_name == 'v2' && 'production' || 'dev' }}
           CLOUDFLARE_ENV: ${{ github.ref_name == 'v2' && 'production' || 'dev' }}
 
       - name: Deploy

.github/workflows/publish.yml

@@ -91,7 +91,7 @@ jobs:
 
       - uses: ./.github/actions/setup-bun
         with:
-          bun-version: 1.4.0
+          bun-version: canary # Bun 1.4 until its stable release is published
 
       - name: Setup git committer
         id: committer
@@ -113,7 +113,7 @@ jobs:
         id: build
         run: ./packages/cli/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
         env:
-          BUN_COMPILE_RELEASE: bun-v1.4.0
+          BUN_COMPILE_RELEASE: canary
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
           GH_REPO: ${{ needs.version.outputs.repo }}
@@ -195,33 +195,9 @@ jobs:
           path: packages/cli/dist/cli-*
           if-no-files-found: error
 
-  build-node-app-archive:
-    needs: version
-    runs-on: blacksmith-4vcpu-ubuntu-2404
-    timeout-minutes: 30
-    if: github.repository == 'anomalyco/opencode'
-    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-
-      - uses: ./.github/actions/setup-bun
-
-      - name: Build app archive
-        run: bun packages/cli/script/build-node.ts --app-archive-only --app-archive=.cache/app-archive.bin --skip-install
-        env:
-          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
-          OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
-
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: opencode-node-app-archive
-          path: packages/cli/.cache/app-archive.bin
-          if-no-files-found: error
-
   build-node-cli:
-    needs:
-      - version
-      - build-node-app-archive
-    if: github.repository == 'anomalyco/opencode'
+    needs: version
+    if: github.repository == 'anomalyco/opencode' && false # Temporarily disabled
     strategy:
       fail-fast: false
       matrix:
@@ -234,7 +210,6 @@ jobs:
             host: macos-26
           - target: windows-arm64
             host: blacksmith-4vcpu-windows-2025
-            bun_install_flags: --cpu=*
           - target: windows-x64
             host: blacksmith-4vcpu-windows-2025
     runs-on: ${{ matrix.settings.host }}
@@ -246,19 +221,14 @@ jobs:
 
       - uses: ./.github/actions/setup-bun
         with:
-          install-flags: ${{ matrix.settings.bun_install_flags }}
+          install-flags: --os=* --cpu=*
 
       - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: "26.4.0"
 
-      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        with:
-          name: opencode-node-app-archive
-          path: packages/cli/.cache
-
       - name: Build
-        run: bun packages/cli/script/build-node.ts --target=${{ matrix.settings.target }} --skip-install --outdir=dist/node --app-archive=.cache/app-archive.bin
+        run: bun packages/cli/script/build-node.ts --target=${{ matrix.settings.target }} --skip-install --outdir=dist/node
         env:
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
@@ -573,7 +543,6 @@ jobs:
       - version
       - build-cli
       - sign-cli-macos
-      - build-node-app-archive
       - build-node-cli
       - sign-cli-windows
       - build-electron

.github/workflows/test.yml

@@ -50,14 +50,6 @@ jobs:
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
 
-      - name: Test Effect simplification rules
-        if: runner.os == 'Linux'
-        run: bun run test:effect-simplification-rules
-
-      - name: Check Effect simplifications
-        if: runner.os == 'Linux'
-        run: bun run lint:effect-simplifications
-
       - name: Configure git identity
         run: |
           git config --global user.email "bot@opencode.ai"
@@ -84,11 +76,6 @@ jobs:
         env:
           OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: ${{ runner.os == 'Windows' && 'true' || 'false' }}
 
-      - name: Verify published codemode package
-        if: runner.os == 'Linux'
-        working-directory: packages/codemode
-        run: bun run script/publish.ts --dry-run
-
       - name: Verify compiled service lifecycle
         if: always()
         timeout-minutes: 10

.opencode/tui.json

@@ -1,3 +1,19 @@
 {
-  "$schema": "https://opencode.ai/tui.json"
+  "$schema": "https://opencode.ai/tui.json",
+  "plugin": [
+    [
+      "./plugins/tui-smoke.tsx",
+      {
+        "enabled": false,
+        "label": "workspace",
+        "keybinds": {
+          "smoke_modal": "ctrl+alt+m",
+          "smoke_screen": "ctrl+alt+o",
+          "smoke_screen_home": "escape,ctrl+shift+h",
+          "smoke_screen_modal": "ctrl+alt+m",
+          "smoke_dialog_close": "escape,q"
+        }
+      }
+    ]
+  ]
 }

AGENTS.md

@@ -1,5 +1,5 @@
 - After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`. Do not edit generated client files directly.
-- Keep runtime dependencies directed from Schema to Core and Protocol, then from Core and Protocol to Server. Client runtime code may depend on Schema and Protocol but never Core or Server; `sdk` composes Client, Core, and Server.
+- Keep runtime dependencies directed from Schema to Core and Protocol, then from Core and Protocol to Server. Client runtime code may depend on Schema and Protocol but never Core or Server; `sdk-next` composes Client, Core, and Server.
 - Current implementation changes belong in `packages/core`, `packages/cli`, `packages/server`, `packages/protocol`, `packages/schema`, and related generated client surfaces when required.
 - The default branch in this repo is `v2`.
 - Base all new branches and worktrees on `v2`, or `origin/v2` when the local `v2` ref is unavailable. Do not base them on `dev`.
@@ -176,7 +176,7 @@ const table = sqliteTable("session", {
 
 - Keep durable events minimal: record irreducible new facts and do not repeat state derivable by folding the ordered aggregate history. Enrich projections and read models with previous or derived state when consumers need self-contained views.
 - Keep durable prompt admission separate from model execution. `Session.prompt(...)` publishes `session.inbox.enqueued`, whose projection inserts one durable `session_inbox` row, before scheduling advisory `SessionExecution.wake(sessionID)` unless `resume: false` requests admit-only behavior. Delivery publishes `session.inbox.delivered`; its projection consumes the inbox row and inserts the visible message in the same transaction. `session_inbox` stores only unconsumed work.
-- Reusing a Session ID adopts the existing Session. Reusing a user or synthetic inbox item ID is idempotent when Session and type match: the first admission wins and the retried payload, metadata, and delivery mode are ignored, whether the item is still pending or already delivered (reconciled from the projected message without retained enqueue history). Cross-Session or cross-type reuse fails. Control items keep their operation-specific conflict behavior.
+- Reusing a Session ID adopts the existing Session. While a user or synthetic inbox item is pending, reusing its ID reconciles only when Session, type, complete payload, metadata, and delivery match; conflicting reuse fails. Once delivered, retry reconciliation for those message-producing items uses the projected message and does not require retained enqueue history or the original delivery mode. Control items keep their operation-specific conflict behavior.
 - Keep `SessionExecution` process-global and Session-ID based. Its local implementation owns the process-local Session coordinator and discovers placement through `SessionStore` plus `LocationServiceMap.get(session.location)` only when a drain starts; no layer should take a Session ID. V2 interruption targets the active process-local ownership chain for that Session; interruption of a known but idle or locally unowned Session is a no-op, while the public API rejects an unknown Session.
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
 - Preserve one explicit `llm.stream(request)` call per Physical Attempt and reload projected history before durable continuation. A logical Step may use generic pre-output retries, one full-context retry after continuation rejection, incomplete-stream continuation, or one overflow-compaction rebuild. Generic retries retain the logical step number and do not consume another agent-step allowance. Do not delegate orchestration to an in-memory tool loop.

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-LvDHCOm8OAZfvb0I0L6AbdOevRoQmEJnnqrSgAiNHv8=",
-    "aarch64-linux": "sha256-O0L0iHjb4cwl9xWHIna8VFHyQzoAKzfY8oMpVNayMOg=",
-    "aarch64-darwin": "sha256-ETP8FE71NqufYDUbR7tBdsMEOVQ44wLmsZBeZiSRBRY=",
-    "x86_64-darwin": "sha256-WUcoLldDriT3QxcdlnBQhuPrxDNub0EDvvZXk/pDMpY="
+    "x86_64-linux": "sha256-IxkSw0gK/qkMHZGVHqjwgM9BKhzbQX6hyF9SWUNtpzg=",
+    "aarch64-linux": "sha256-YVjpbil0QswVwi6NtVYFq3xCqpsfveG1chlNVCVI0MU=",
+    "aarch64-darwin": "sha256-CdL2mI84pawH2H5i9qu8A6IWbkmKOYHlJS+DI/Mafdw=",
+    "x86_64-darwin": "sha256-NtswwfU5WYv99bEmI4XeLwjhBGcS9ZMYLRo4MQRNtLo="
   }
 }

package.json

@@ -15,44 +15,42 @@
     "dev:stats": "bun sst shell --stage=production -- bun run --cwd packages/stats/app dev",
     "dev:www": "bun run --cwd packages/www dev",
     "dev:storybook": "bun --cwd packages/storybook storybook",
-    "bench:devex": "bun run --cwd packages/app test:bench:devex",
     "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-simplifications": "ast-grep scan -c script/ast-grep/effect-simplifications/sgconfig.yml --off=unused-suppression packages",
     "test:lint-rules": "ast-grep test -c script/ast-grep/sgconfig.yml",
-    "test:effect-simplification-rules": "ast-grep test -c script/ast-grep/effect-simplifications/sgconfig.yml",
     "typecheck": "bun turbo typecheck --concurrency=3",
     "typecheck:profile": "bun script/profile-typecheck.ts",
     "typecheck:profile:packages": "bun script/profile-typecheck-packages.ts",
     "upgrade-opentui": "bun run script/upgrade-opentui.ts",
     "postinstall": "bun run --cwd packages/core fix-node-pty",
     "prepare": "husky",
-    "reserve-packages": "bun script/reserve-package-names.ts",
     "random": "echo 'Random script'",
     "sso": "aws sso login --sso-session=opencode --no-browser",
+    "translate:app": "bun run script/translate-app.ts",
     "test": "echo 'do not run tests from root' && exit 1"
   },
   "workspaces": {
     "packages": [
       "packages/*",
       "packages/console/*",
-      "packages/stats/*"
+      "packages/stats/*",
+      "packages/slack"
     ],
     "catalog": {
-      "@effect/opentelemetry": "4.0.0-rc.111",
-      "@effect/platform-node": "4.0.0-rc.111",
-      "@effect/platform-node-shared": "4.0.0-rc.111",
-      "@effect/sql-sqlite-bun": "4.0.0-rc.111",
+      "@effect/opentelemetry": "4.0.0-beta.107",
+      "@effect/platform-node": "4.0.0-beta.107",
+      "@effect/platform-node-shared": "4.0.0-beta.107",
+      "@effect/sql-sqlite-bun": "4.0.0-beta.107",
       "@npmcli/arborist": "9.4.0",
       "@types/bun": "1.3.13",
       "@types/cross-spawn": "6.0.6",
       "@octokit/rest": "22.0.0",
       "@hono/standard-validator": "0.2.0",
       "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.7",
-      "@opentui/keymap": "0.5.7",
-      "@opentui/solid": "0.5.7",
-      "@tanstack/solid-virtual": "3.13.37",
+      "@opentui/core": "0.5.4",
+      "@opentui/keymap": "0.5.4",
+      "@opentui/solid": "0.5.4",
+      "@tanstack/solid-virtual": "3.13.32",
       "@shikijs/stream": "4.2.0",
       "@standard-schema/spec": "1.1.0",
       "ulid": "3.0.1",
@@ -71,9 +69,9 @@
       "@tailwindcss/vite": "4.1.11",
       "diff": "8.0.2",
       "dompurify": "3.3.1",
-      "drizzle-kit": "1.0.0-rc.5-ab785fc",
-      "drizzle-orm": "1.0.0-rc.5-169397b",
-      "effect": "4.0.0-rc.111",
+      "drizzle-kit": "1.0.0-rc.2",
+      "drizzle-orm": "1.0.0-rc.2",
+      "effect": "4.0.0-beta.107",
       "ai": "6.0.168",
       "cross-spawn": "7.0.6",
       "hono": "4.10.7",
@@ -129,6 +127,7 @@
     "@aws-sdk/client-s3": "3.933.0",
     "@opencode-ai/plugin": "workspace:*",
     "@opencode-ai/script": "workspace:*",
+    "@opencode-ai/sdk": "1.18.5",
     "heap-snapshot-toolkit": "1.1.3",
     "typescript": "catalog:"
   },
@@ -166,6 +165,7 @@
     "@npmcli/agent@4.0.2": "patches/@npmcli%2Fagent@4.0.2.patch",
     "@silvia-odwyer/photon-node@0.3.4": "patches/@silvia-odwyer%2Fphoton-node@0.3.4.patch",
     "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
+    "drizzle-orm@1.0.0-rc.2": "patches/drizzle-orm@1.0.0-rc.2.patch",
     "solid-js@1.9.10": "patches/solid-js@1.9.10.patch",
     "@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",
@@ -173,7 +173,7 @@
     "@ai-sdk/google@3.0.73": "patches/@ai-sdk%2Fgoogle@3.0.73.patch",
     "@pierre/trees@1.0.0-beta.4": "patches/@pierre%2Ftrees@1.0.0-beta.4.patch",
     "@modelcontextprotocol/sdk@1.29.0": "patches/@modelcontextprotocol%2Fsdk@1.29.0.patch",
-    "@tanstack/virtual-core@3.17.8": "patches/@tanstack%2Fvirtual-core@3.17.8.patch",
-    "@ff-labs/fff-bun@0.10.5": "patches/@ff-labs%2Ffff-bun@0.10.5.patch"
+    "@tanstack/virtual-core@3.17.3": "patches/@tanstack%2Fvirtual-core@3.17.3.patch",
+    "@ff-labs/fff-bun@0.10.1": "patches/@ff-labs%2Ffff-bun@0.10.1.patch"
   }
 }

packages/ai/AGENTS.md

@@ -71,7 +71,7 @@ export const route = Route.make({
 })
 ```
 
-Route defaults are request-shaping defaults such as `headers`, `limits`, `generation`, `providerOptions`, and `http`. Endpoint host/query belongs on the route endpoint. Selected `LanguageModel` values carry only model id, provider id, and the configured route value. Model capability/catalog metadata lives outside this package; protocol support is enforced by request lowering and typed `AIError`s.
+Route defaults are request-shaping defaults such as `headers`, `limits`, `generation`, `providerOptions`, and `http`. Endpoint host/query belongs on the route endpoint. Selected `LanguageModel` values carry model identity and the configured route; low-level callers may also attach model-specific defaults and compatibility metadata. Model capability/catalog metadata lives outside this package; protocol support is enforced by request lowering and typed `AIError`s.
 
 The four-axis decomposition is the reason DeepSeek, TogetherAI, Cerebras, Baseten, Fireworks, and DeepInfra all reuse `OpenAIChat.protocol` verbatim — each provider deployment is a 5-15 line `Route.make(...)` call instead of a 300-400 line route clone. Bug fixes in one protocol propagate to every consumer of that protocol in a single commit.
 
@@ -88,7 +88,7 @@ For providers where the URL is derived from typed inputs (Azure resource name, B
 Provider-facing APIs are configured facades over route values. Endpoint/auth/resource/API-version setup happens before model selection, and model selectors accept only a model or deployment id:
 
 ```ts
-const openai = OpenAI.configure({ apiKey, baseURL })
+const openai = OpenAI.configure({ apiKey, baseURL, store: false })
 const model = openai.responses("gpt-4o-mini")
 
 const azure = Azure.configure({ resourceName, apiKey, apiVersion: "v1" })
@@ -108,17 +108,22 @@ Keep provider facades small and explicit:
 - Resolve `apiKey` → `Auth` with `AuthOptions.bearer(options, "<PROVIDER>_API_KEY")` (it honors an explicit `auth` override and falls back to `Auth.config(envVar)` so missing keys surface a typed `Authentication` error rather than a runtime crash).
 - Use separate top-level facades for products with different required setup, such as `CloudflareAIGateway` and `CloudflareWorkersAI`.
 
+Provider facades and model-derived `LLMRequest.providerOptions` are provider-specific, so expose typed native options flat at those boundaries. Provider package settings keep deployment configuration separate from their typed `providerOptions` field, except facades such as OpenAI whose settings are already unambiguous when flat. The selected `LanguageModel<Options>` carries request-option typing; the route decodes the flat runtime record. Keep provider metadata namespaced because replay may contain metadata from multiple layers.
+
 `Provider.make(...)` remains available for simple static provider definitions, but new built-in providers should prefer plain configured facades unless a helper removes real duplication without adding runtime behavior.
 
 ### Provider Package Entrypoints
 
-Catalog-selected native providers use package-like export paths from `@opencode-ai/ai`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model(modelID, settings)`, where settings are serializable provider configuration plus common `headers`, `body`, and `limits` overlays.
+Catalog-selected native providers use package-like export paths from `@opencode-ai/ai`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model({ id, settings, credential, defaults })`. Core selects and refreshes the optional `key | oauth` credential; the provider package interprets it as route authentication. Serializable provider settings remain separate from common `headers`, `body`, and `limits` defaults.
 
 ```ts
 import { model } from "@opencode-ai/ai/providers/openai/responses"
 
-const selected = model("gpt-5", {
-  apiKey,
+const selected = model({
+  id: "gpt-5",
+  settings: {},
+  credential: { type: "key", value: apiKey },
+  defaults: {},
 })
 ```
 
@@ -213,7 +218,7 @@ Errors must be expressed as `ToolFailure`. The runtime catches it and emits a `t
 - Input failed the `parameters` Schema.
 - The handler returned a `ToolFailure`.
 
-Provider-defined / hosted tools (Anthropic `web_search` / `code_execution` / `web_fetch`, OpenAI Responses `web_search_call` / `file_search_call` / `code_interpreter_call` / `mcp_call` / `image_generation_call` / `computer_use_call`) pass through the runtime untouched:
+Provider-defined / hosted tools (Anthropic `web_search` / `code_execution` / `web_fetch`, OpenAI Responses `web_search_call` / `file_search_call` / `code_interpreter_call` / `mcp_call` / `local_shell_call` / `image_generation_call` / `computer_use_call`) pass through the runtime untouched:
 
 - Routes surface the model's call as a `tool-call` event with `providerExecuted: true`, and the provider's result as a matching `tool-result` event with `providerExecuted: true`.
 - Callers detect `providerExecuted` on `tool-call` and **skip local dispatch** — no handler is invoked and no `tool-error` is raised for "unknown tool". The provider already executed it.

packages/ai/README.md

@@ -305,18 +305,26 @@ 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, OpenRouter, xAI, Z.ai, plus generic OpenAI-compatible Chat and Responses entrypoints and an Anthropic Messages-compatible entrypoint. GitHub Copilot remains a Core-owned AI SDK integration rather than an AI-package provider.
 
 ### Package-like entrypoints
 
-Native catalog integrations load provider behavior through package-like entrypoints. These are export paths from the same `@opencode-ai/ai` npm package, not independently published packages. Each entrypoint exports the same `model(modelID, settings)` contract, and `settings` contains serializable provider configuration plus common `headers` and `body` overlays.
+Native catalog integrations load provider behavior through package-like entrypoints. These are export paths from the same `@opencode-ai/ai` npm package, not independently published packages. Each entrypoint exports the same `model({ id, settings, credential, defaults })` contract. Core selects and refreshes the optional `key | oauth` credential, while the provider package interprets it as route authentication. Serializable provider settings remain separate from common `headers`, `body`, and `limits` defaults.
 
 ```ts
 import { model } from "@opencode-ai/ai/providers/openai/responses"
 
-const selected = model("gpt-5", {
-  apiKey: process.env.OPENAI_API_KEY,
-  headers: { "x-application": "opencode" },
+const apiKey = process.env.OPENAI_API_KEY
+if (!apiKey) throw new Error("OPENAI_API_KEY is required")
+
+const selected = model({
+  id: "gpt-5",
+  settings: {},
+  credential: { type: "key", value: apiKey },
+  defaults: {
+    headers: { "x-application": "opencode" },
+    limits: { context: 200_000, output: 64_000 },
+  },
 })
 ```
 
@@ -340,30 +348,57 @@ Tuned Vertex Gemini deployments use model ids shaped like `endpoints/1234567890`
 ```ts
 import { model } from "@opencode-ai/ai/providers/google-vertex/gemini"
 
-model("gemini-3.5-flash", { project: "my-project", location: "global" })
+model({
+  id: "gemini-3.5-flash",
+  settings: { project: "my-project", location: "global" },
+  defaults: {},
+})
 ```
 
 ```ts
 import { model } from "@opencode-ai/ai/providers/google-vertex/chat"
 
-model("deepseek-ai/deepseek-v3.2-maas", { project: "my-project", location: "global" })
+model({
+  id: "deepseek-ai/deepseek-v3.2-maas",
+  settings: { project: "my-project", location: "global" },
+  defaults: {},
+})
 ```
 
 ```ts
 import { model } from "@opencode-ai/ai/providers/google-vertex/responses"
 
-model("xai/grok-4.20-reasoning", { project: "my-project", location: "global" })
+model({
+  id: "xai/grok-4.20-reasoning",
+  settings: { project: "my-project", location: "global" },
+  defaults: {},
+})
 ```
 
 ```ts
 import { model } from "@opencode-ai/ai/providers/google-vertex/messages"
 
-model("claude-sonnet-4-6", { project: "my-project", location: "global" })
+model({
+  id: "claude-sonnet-4-6",
+  settings: { project: "my-project", location: "global" },
+  defaults: {},
+})
 ```
 
-Provider facades such as `OpenAI.configure(...).responses(...)` remain the direct application API. Package-like entrypoints are the self-similar loading contract used when a catalog selects behavior by export path.
+Provider facades such as `OpenAI.configure(...).responses(...)` remain the direct application API. Package-like entrypoints are the self-similar loading contract used when a catalog selects behavior by export path. The entrypoints listed above implement that contract and are covered by `test/provider-package.test.ts`.
 
-Other provider exports listed above remain direct facades until they explicitly implement the package-like contract. Exporting a provider facade does not implicitly make it a catalog-loadable provider package.
+## How OpenCode uses this package
+
+OpenCode does not call provider facades directly from the CLI or server. Core owns the integration:
+
+1. `packages/core/src/model-resolver.ts` resolves catalog metadata and an active integration credential into a `LanguageModel`. Native package entrypoints expose `model({ id, settings, credential, defaults })`; catalog packages without a native mapping fall back through Core's AI SDK adapter.
+2. `packages/core/src/session/model-request.ts` lowers Session state, instructions, tools, and plugin hooks into one canonical `LLMRequest`.
+3. `packages/core/src/session/runner/llm.ts` calls the yielded `LLMClient.Service` once per physical attempt and persists provider-neutral `LLMEvent`s.
+4. Core owns retries, continuation, compaction, permissions, durable tool execution, and Session history. None of that orchestration belongs in this package.
+
+Title generation, compaction, standalone generation, and transient Session generation also build `LLMRequest`s and use the same `LLMClient.Service`. Core's `AISDK` adapter wraps remaining Vercel AI SDK models in executable routes so native and fallback providers present the same request and event model to callers.
+
+This separation is intentional: `@opencode-ai/ai` owns one model call, provider protocols, and transport; Core owns the durable agent runtime.
 
 ## Provider options & HTTP overlays
 
@@ -376,6 +411,16 @@ Request options in order of stability:
 
 Route/provider defaults are overridden by request-level values for each axis.
 
+Provider-specific facades accept their own options directly because the provider is already known:
+
+```ts
+const model = OpenAI.configure({
+  apiKey,
+  store: false,
+  reasoningEffort: "high",
+}).responses("gpt-5")
+```
+
 The selected model supplies the provider-specific option type, so per-request overrides stay flat while the canonical runtime request remains provider-neutral:
 
 ```ts

packages/ai/example/tutorial.ts

@@ -17,13 +17,12 @@ import { OpenAI } from "@opencode-ai/ai/providers"
 const apiKey = Config.redacted("OPENAI_API_KEY")
 
 // 1. Pick a model. The provider helper records provider identity, protocol
-// choice, capabilities, deployment options, authentication, and defaults.
+// choice, deployment options, authentication, and defaults. Catalog capabilities
+// remain application-owned and are not part of LanguageModel.
 const model = OpenAI.configure({
   apiKey,
   generation: { maxTokens: 160 },
-  providerOptions: {
-    store: false,
-  },
+  store: false,
 }).model("gpt-4o-mini")
 
 // 2. Build a provider-neutral request. This is useful when reusing one request
@@ -74,8 +73,8 @@ const streamText = LLM.stream(request).pipe(
   Stream.runDrain,
 )
 
-// 5. Tools are typed with Effect Schema. Provider turns remain explicit:
-// advertise definitions on the request, stream one turn, dispatch local calls,
+// 5. Tools are typed with Effect Schema. Model calls remain explicit:
+// advertise definitions on the request, stream one call, dispatch local calls,
 // then persist/build follow-up history in the enclosing product flow.
 const tools = {
   get_weather: Tool.make({
@@ -102,7 +101,7 @@ const streamWithTools = Effect.gen(function* () {
     console.log("tool result", event.name, dispatched.result)
 
     // A durable agent would persist these messages before starting another
-    // raw model turn. This tutorial keeps the boundary visible instead.
+    // model call. This tutorial keeps the boundary visible instead.
     const followUp = LLMRequest.update(request, {
       messages: [
         ...request.messages,

packages/ai/script/setup-recording-env.ts

@@ -370,7 +370,7 @@ const responseError = Effect.fn("RecordingEnv.responseError")(function* (
   response: HttpClientResponse.HttpClientResponse,
 ) {
   if (response.status >= 200 && response.status < 300) return undefined
-  const body = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
+  const body = yield* response.text.pipe(Effect.catch(() => Effect.succeed("")))
   return `${response.status}${body ? `: ${body.slice(0, 180)}` : ""}`
 })
 

packages/ai/src/index.ts

@@ -37,6 +37,9 @@ export type {
   LanguageModelOptions as ProviderLanguageModelOptions,
 } from "./provider.js"
 export type {
+  Credential as ProviderPackageCredential,
+  Defaults as ProviderPackageDefaults,
   Definition as ProviderPackageDefinition,
+  ModelInput as ProviderPackageModelInput,
   Settings as ProviderPackageSettings,
 } from "./provider-package.js"

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

@@ -1,4 +1,3 @@
-import { Buffer } from "node:buffer"
 import { Effect, Schema } from "effect"
 import { Tool } from "@opencode-ai/schema/tool"
 import { Route } from "../route/client.js"
@@ -32,20 +31,6 @@ import { ToolStream } from "./utils/tool-stream.js"
 const ADAPTER = "anthropic-messages"
 export const DEFAULT_BASE_URL = "https://api.anthropic.com/v1"
 export const PATH = "/messages"
-export const DEFAULT_MAX_TOKENS = 32_000
-
-const SSE_EVENTS = new Set([
-  "message",
-  "message_start",
-  "message_delta",
-  "message_stop",
-  "content_block_start",
-  "content_block_delta",
-  "content_block_stop",
-  "ping",
-  "error",
-])
-export const framing = Framing.sseEvents(SSE_EVENTS)
 
 export type ThinkingInput =
   | {
@@ -55,7 +40,7 @@ export type ThinkingInput =
   | {
       readonly type: "disabled"
     }
-  | ({ readonly type: "enabled"; readonly display?: "summarized" | "omitted" } & (
+  | ({ readonly type: "enabled" } & (
       | { readonly budgetTokens: number; readonly budget_tokens?: number }
       | { readonly budgetTokens?: number; readonly budget_tokens: number }
     ))
@@ -64,19 +49,6 @@ export interface OptionsInput {
   readonly [key: string]: unknown
   readonly thinking?: ThinkingInput
   readonly effort?: string
-  readonly service_tier?: "auto" | "standard_only"
-  readonly serviceTier?: "auto" | "standard_only"
-  // SDK Metadata:2649 {user_id?: string | null}
-  readonly metadata?: { readonly user_id?: string | null }
-  // SDK MessageCreateParamsContainer:2596 ContainerParams|string
-  readonly container?: string | { readonly id?: string | null; readonly skills?: ReadonlyArray<Record<string, unknown>> | null }
-  readonly inference_geo?: string | null
-  readonly inferenceGeo?: string | null
-  readonly cache_control?: { readonly type: "ephemeral"; readonly ttl?: "5m" | "1h" }
-  readonly cacheControl?: { readonly type: "ephemeral"; readonly ttl?: "5m" | "1h" }
-  // SDK OutputConfig:2684 {effort, format: JSONOutputFormat}
-  readonly output_config?: { readonly effort?: string | null; readonly format?: { readonly type: "json_schema"; readonly schema: Record<string, unknown> } | null }
-  readonly outputConfig?: { readonly effort?: string | null; readonly format?: { readonly type: "json_schema"; readonly schema: Record<string, unknown> } | null }
 }
 
 export type ProviderOptionsInput = OptionsInput
@@ -96,61 +68,25 @@ const AnthropicTextBlock = Schema.Struct({
 })
 type AnthropicTextBlock = Schema.Schema.Type<typeof AnthropicTextBlock>
 
-// SDK: Base64ImageSource:201 {type:"base64", media_type:"image/jpeg"|... , data}, URLImageSource:3817 {type:"url", url}, FileImageSource:2350 {type:"file", file_id}
-// SDK: ImageBlockParam:2356 {source: Base64|URL|File, cache_control, transformations:2381 {oversized_image?}}
-const AnthropicBase64ImageSource = Schema.Struct({
-  type: Schema.tag("base64"),
-  media_type: Schema.String,
-  data: Schema.String,
-})
-const AnthropicURLImageSource = Schema.Struct({ type: Schema.tag("url"), url: Schema.String })
-const AnthropicFileImageSource = Schema.Struct({ type: Schema.tag("file"), file_id: Schema.String })
-const AnthropicImageSource = Schema.Union([
-  AnthropicBase64ImageSource,
-  AnthropicURLImageSource,
-  AnthropicFileImageSource,
-])
-const AnthropicImageTransformations = Schema.Struct({
-  oversized_image: Schema.optional(Schema.Literals(["downsize", "error"])),
-})
-
 const AnthropicImageBlock = Schema.Struct({
   type: Schema.tag("image"),
-  source: AnthropicImageSource,
+  source: Schema.Struct({
+    type: Schema.tag("base64"),
+    media_type: Schema.String,
+    data: Schema.String,
+  }),
   cache_control: Schema.optional(AnthropicCacheControl),
-  transformations: Schema.optional(AnthropicImageTransformations),
 })
 type AnthropicImageBlock = Schema.Schema.Type<typeof AnthropicImageBlock>
 
-// SDK: Base64PDFSource:209 {type:"base64", media_type:"application/pdf", data}, PlainTextSource:2716 {type:"text", media_type:"text/plain", data},
-// SDK: URLPDFSource:3823 {type:"url", url}, FileDocumentSource:2344 {type:"file", file_id}, ContentBlockSource:2266 {type:"content", content}
-// SDK: DocumentBlockParam:2297 {source: 5-way union, cache_control, citations, context, title}
-const AnthropicBase64PDFSource = Schema.Struct({
-  type: Schema.tag("base64"),
-  media_type: Schema.Literal("application/pdf"),
-  data: Schema.String,
-})
-const AnthropicPlainTextSource = Schema.Struct({
-  type: Schema.tag("text"),
-  media_type: Schema.Literal("text/plain"),
-  data: Schema.String,
-})
-const AnthropicURLPDFSource = Schema.Struct({ type: Schema.tag("url"), url: Schema.String })
-const AnthropicFileDocumentSource = Schema.Struct({ type: Schema.tag("file"), file_id: Schema.String })
-const AnthropicDocumentSource = Schema.Union([
-  AnthropicBase64PDFSource,
-  AnthropicPlainTextSource,
-  AnthropicURLPDFSource,
-  AnthropicFileDocumentSource,
-])
-
 const AnthropicDocumentBlock = Schema.Struct({
   type: Schema.tag("document"),
-  source: AnthropicDocumentSource,
+  source: Schema.Struct({
+    type: Schema.tag("base64"),
+    media_type: Schema.Literal("application/pdf"),
+    data: Schema.String,
+  }),
   cache_control: Schema.optional(AnthropicCacheControl),
-  title: Schema.optional(Schema.String),
-  context: Schema.optional(Schema.String),
-  citations: Schema.optional(Schema.Struct({ enabled: Schema.Boolean })),
 })
 type AnthropicDocumentBlock = Schema.Schema.Type<typeof AnthropicDocumentBlock>
 
@@ -255,18 +191,14 @@ const AnthropicTool = Schema.Struct({
 type AnthropicTool = Schema.Schema.Type<typeof AnthropicTool>
 
 const AnthropicToolChoice = Schema.Union([
-  Schema.Struct({
-    type: Schema.Literals(["auto", "any", "none"]),
-    disable_parallel_tool_use: Schema.optional(Schema.Boolean),
-  }),
-  Schema.Struct({ type: Schema.tag("tool"), name: Schema.String, disable_parallel_tool_use: Schema.optional(Schema.Boolean) }),
+  Schema.Struct({ type: Schema.Literals(["auto", "any", "none"]) }),
+  Schema.Struct({ type: Schema.tag("tool"), name: Schema.String }),
 ])
 
 const AnthropicThinking = Schema.Union([
   Schema.Struct({
     type: Schema.tag("enabled"),
     budget_tokens: Schema.Number,
-    display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
   }),
   Schema.Struct({
     type: Schema.tag("adaptive"),
@@ -277,28 +209,10 @@ const AnthropicThinking = Schema.Union([
   }),
 ])
 
-// SDK OutputConfig:2684 {effort?: "low"|"medium"|"high"|"xhigh"|"max"|null, format?: JSONOutputFormat:2399}
-const AnthropicJsonOutputFormat = Schema.Struct({
-  type: Schema.Literal("json_schema"),
-  schema: JsonObject,
-})
 const AnthropicOutputConfig = Schema.Struct({
   effort: Schema.optional(Schema.String),
-  format: Schema.optional(Schema.NullOr(AnthropicJsonOutputFormat)),
 })
 
-// SDK Metadata:2649 {user_id?: string|null}
-const AnthropicMetadata = Schema.Struct({ user_id: optionalNull(Schema.String) })
-
-// SDK MessageCreateParamsContainer:2596 ContainerParams|string; ContainerParams:2172 {id?, skills?}
-const AnthropicContainer = Schema.Union([
-  Schema.String,
-  Schema.Struct({
-    id: optionalNull(Schema.String),
-    skills: optionalNull(Schema.Array(JsonObject)),
-  }),
-])
-
 const AnthropicBodyFields = {
   model: Schema.String,
   system: optionalArray(AnthropicTextBlock),
@@ -313,19 +227,13 @@ const AnthropicBodyFields = {
   stop_sequences: optionalArray(Schema.String),
   thinking: Schema.optional(AnthropicThinking),
   output_config: Schema.optional(AnthropicOutputConfig),
-  // SDK top-level passthrough: cache_control:4638, container:4643, inference_geo:4649, metadata:4654, service_tier:4670
-  cache_control: Schema.optional(AnthropicCacheControl),
-  container: Schema.optional(Schema.NullOr(AnthropicContainer)),
-  inference_geo: Schema.optional(Schema.NullOr(Schema.String)),
-  metadata: Schema.optional(AnthropicMetadata),
-  service_tier: Schema.optional(Schema.Literals(["auto", "standard_only"])),
 }
 export const AnthropicMessagesBody = Schema.Struct(AnthropicBodyFields)
 export type AnthropicMessagesBody = Schema.Schema.Type<typeof AnthropicMessagesBody>
 
 const AnthropicUsage = Schema.StructWithRest(
   Schema.Struct({
-    input_tokens: optionalNull(Schema.Number),
+    input_tokens: Schema.optional(Schema.Number),
     output_tokens: Schema.optional(Schema.Number),
     cache_creation_input_tokens: optionalNull(Schema.Number),
     cache_read_input_tokens: optionalNull(Schema.Number),
@@ -447,40 +355,22 @@ const lowerTool = (breakpoints: Cache.Breakpoints, tool: ToolDefinition, inputSc
 
 const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
   ProviderShared.matchToolChoice("Anthropic Messages", toolChoice, {
-    auto: () => ({
-      type: "auto" as const,
-      ...(toolChoice.disableParallelToolUse === undefined
-        ? {}
-        : { disable_parallel_tool_use: toolChoice.disableParallelToolUse }),
-    }),
+    auto: () => ({ type: "auto" as const }),
     none: () => ({ type: "none" as const }),
-    required: () => ({
-      type: "any" as const,
-      ...(toolChoice.disableParallelToolUse === undefined
-        ? {}
-        : { disable_parallel_tool_use: toolChoice.disableParallelToolUse }),
-    }),
-    tool: (name) => ({
-      type: "tool" as const,
-      name,
-      ...(toolChoice.disableParallelToolUse === undefined
-        ? {}
-        : { disable_parallel_tool_use: toolChoice.disableParallelToolUse }),
-    }),
+    required: () => ({ type: "any" as const }),
+    tool: (name) => ({ type: "tool" as const, name }),
   })
 
-const scrubToolCallID = (id: string) => id.replace(/[^a-zA-Z0-9_-]/g, "_")
-
 const lowerToolCall = (part: ToolCallPart): AnthropicToolUseBlock => ({
   type: "tool_use",
-  id: scrubToolCallID(part.id),
+  id: part.id,
   name: part.name,
   input: part.input,
 })
 
 const lowerServerToolCall = (part: ToolCallPart): AnthropicServerToolUseBlock => ({
   type: "server_tool_use",
-  id: scrubToolCallID(part.id),
+  id: part.id,
   name: part.name,
   input: part.input,
 })
@@ -502,155 +392,10 @@ const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult
   // 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: scrubToolCallID(part.id), content: payload } satisfies AnthropicServerToolResultBlock
+  return { type: wireType, tool_use_id: part.id, content: payload } satisfies AnthropicServerToolResultBlock
 })
 
-const fileIdFromMetadata = (metadata: MediaPart["metadata"]): string | undefined => {
-  if (!ProviderShared.isRecord(metadata)) return undefined
-  const anthropic = metadata.anthropic
-  if (ProviderShared.isRecord(anthropic)) {
-    if (typeof anthropic.file_id === "string") return anthropic.file_id
-    if (typeof anthropic.fileId === "string") return anthropic.fileId
-  }
-  if (typeof metadata.file_id === "string") return metadata.file_id
-  if (typeof metadata.fileId === "string") return metadata.fileId
-  return undefined
-}
-
-const transformationsFromMetadata = (
-  metadata: MediaPart["metadata"],
-): AnthropicImageBlock["transformations"] | undefined => {
-  if (!ProviderShared.isRecord(metadata)) return undefined
-  const anthropic = ProviderShared.isRecord(metadata.anthropic) ? metadata.anthropic : undefined
-  const raw = anthropic?.transformations ?? metadata.transformations
-  if (ProviderShared.isRecord(raw)) {
-    const value = raw.oversized_image
-    if (value === "downsize" || value === "error") return { oversized_image: value }
-  }
-  if (anthropic && (anthropic.oversized_image === "downsize" || anthropic.oversized_image === "error"))
-    return { oversized_image: anthropic.oversized_image }
-  return undefined
-}
-
-const documentTitleFromPart = (part: MediaPart): string | undefined => {
-  if (ProviderShared.isRecord(part.metadata)) {
-    const anthropic = part.metadata.anthropic
-    if (ProviderShared.isRecord(anthropic) && typeof anthropic.title === "string") return anthropic.title
-    if (typeof part.metadata.title === "string") return part.metadata.title
-  }
-  if (typeof part.filename === "string" && part.filename.length > 0) return part.filename
-  return undefined
-}
-
-const documentContextFromMetadata = (metadata: MediaPart["metadata"]): string | undefined => {
-  if (!ProviderShared.isRecord(metadata)) return undefined
-  const anthropic = ProviderShared.isRecord(metadata.anthropic) ? metadata.anthropic : undefined
-  if (anthropic && typeof anthropic.context === "string") return anthropic.context
-  if (typeof metadata.context === "string") return metadata.context
-  return undefined
-}
-
-const citationsFromMetadata = (
-  metadata: MediaPart["metadata"],
-): AnthropicDocumentBlock["citations"] | undefined => {
-  if (!ProviderShared.isRecord(metadata)) return undefined
-  const raw = ProviderShared.isRecord(metadata.anthropic)
-    ? (metadata.anthropic.citations ?? metadata.citations)
-    : metadata.citations
-  if (ProviderShared.isRecord(raw) && typeof raw.enabled === "boolean") return { enabled: raw.enabled }
-  return undefined
-}
-
-const isHttpUrl = (value: string) => /^https?:\/\//i.test(value.trim())
-
-const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (
-  part: MediaPart,
-  breakpoints?: Cache.Breakpoints,
-) {
-  const mime = part.mediaType.toLowerCase()
-  const cacheControlValue = breakpoints ? cacheControl(breakpoints, part.cache) : undefined
-  const fileId = fileIdFromMetadata(part.metadata)
-
-  // SDK file sources: FileImageSource:2350 / FileDocumentSource:2344 {type:"file", file_id}
-  if (fileId) {
-    if (mime.startsWith("image/"))
-      return {
-        type: "image" as const,
-        source: { type: "file" as const, file_id: fileId },
-        ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
-        ...(transformationsFromMetadata(part.metadata) === undefined
-          ? {}
-          : { transformations: transformationsFromMetadata(part.metadata)! }),
-      } satisfies AnthropicImageBlock
-    return {
-      type: "document" as const,
-      source: { type: "file" as const, file_id: fileId },
-      ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
-      ...(documentTitleFromPart(part) === undefined ? {} : { title: documentTitleFromPart(part)! }),
-      ...(documentContextFromMetadata(part.metadata) === undefined
-        ? {}
-        : { context: documentContextFromMetadata(part.metadata)! }),
-      ...(citationsFromMetadata(part.metadata) === undefined
-        ? {}
-        : { citations: citationsFromMetadata(part.metadata)! }),
-    } satisfies AnthropicDocumentBlock
-  }
-
-  const rawString = typeof part.data === "string" ? part.data.trim() : undefined
-  // SDK URL sources: URLImageSource:3817 / URLPDFSource:3823 {type:"url", url}
-  if (rawString && isHttpUrl(rawString) && !rawString.startsWith("data:")) {
-    if (mime.startsWith("image/"))
-      return {
-        type: "image" as const,
-        source: { type: "url" as const, url: rawString },
-        ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
-        ...(transformationsFromMetadata(part.metadata) === undefined
-          ? {}
-          : { transformations: transformationsFromMetadata(part.metadata)! }),
-      } satisfies AnthropicImageBlock
-    if (mime === "application/pdf")
-      return {
-        type: "document" as const,
-        source: { type: "url" as const, url: rawString },
-        ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
-        ...(documentTitleFromPart(part) === undefined ? {} : { title: documentTitleFromPart(part)! }),
-        ...(documentContextFromMetadata(part.metadata) === undefined
-          ? {}
-          : { context: documentContextFromMetadata(part.metadata)! }),
-        ...(citationsFromMetadata(part.metadata) === undefined
-          ? {}
-          : { citations: citationsFromMetadata(part.metadata)! }),
-      } satisfies AnthropicDocumentBlock
-  }
-
-  // SDK PlainTextSource:2716 {type:"text", media_type:"text/plain", data}
-  if (mime === "text/plain") {
-    const textData =
-      typeof part.data !== "string"
-        ? Buffer.from(part.data).toString("utf8")
-        : part.data.startsWith("data:")
-          ? (() => {
-              const comma = part.data.indexOf(",")
-              const payload = comma >= 0 ? part.data.slice(comma + 1) : part.data
-              return part.data.includes(";base64")
-                ? Buffer.from(payload, "base64").toString("utf8")
-                : decodeURIComponent(payload)
-            })()
-          : part.data
-    return {
-      type: "document" as const,
-      source: { type: "text" as const, media_type: "text/plain" as const, data: textData },
-      ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
-      ...(documentTitleFromPart(part) === undefined ? {} : { title: documentTitleFromPart(part)! }),
-      ...(documentContextFromMetadata(part.metadata) === undefined
-        ? {}
-        : { context: documentContextFromMetadata(part.metadata)! }),
-      ...(citationsFromMetadata(part.metadata) === undefined
-        ? {}
-        : { citations: citationsFromMetadata(part.metadata)! }),
-    } satisfies AnthropicDocumentBlock
-  }
-
+const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part: MediaPart) {
   const media = ProviderShared.normalizeMedia(part)
   if (media.mime === "application/pdf")
     return {
@@ -660,14 +405,6 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (
         media_type: "application/pdf" as const,
         data: media.base64,
       },
-      ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
-      ...(documentTitleFromPart(part) === undefined ? {} : { title: documentTitleFromPart(part)! }),
-      ...(documentContextFromMetadata(part.metadata) === undefined
-        ? {}
-        : { context: documentContextFromMetadata(part.metadata)! }),
-      ...(citationsFromMetadata(part.metadata) === undefined
-        ? {}
-        : { citations: citationsFromMetadata(part.metadata)! }),
     } satisfies AnthropicDocumentBlock
   if (!media.mime.startsWith("image/"))
     return yield* invalid(`Anthropic Messages does not support media type ${part.mediaType}`)
@@ -678,10 +415,6 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (
       media_type: media.mime,
       data: media.base64,
     },
-    ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
-    ...(transformationsFromMetadata(part.metadata) === undefined
-      ? {}
-      : { transformations: transformationsFromMetadata(part.metadata)! }),
   } satisfies AnthropicImageBlock
 })
 
@@ -790,7 +523,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
           continue
         }
         if (part.type === "media") {
-          content.push(yield* lowerMedia(part, breakpoints))
+          content.push(yield* lowerMedia(part))
           continue
         }
         return yield* ProviderShared.unsupportedContent("Anthropic Messages", "user", ["text", "media"])
@@ -841,7 +574,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
         return yield* ProviderShared.unsupportedContent("Anthropic Messages", "tool", ["tool-result"])
       content.push({
         type: "tool_result",
-        tool_use_id: scrubToolCallID(part.id),
+        tool_use_id: part.id,
         content: yield* lowerToolResultContent(part),
         is_error: part.result.type === "error" ? true : undefined,
         cache_control: cacheControl(breakpoints, part.cache),
@@ -857,74 +590,24 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
 })
 
 const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (request: LLMRequest) {
-  const input = request.providerOptions as Record<string, unknown> | undefined
-  const rawServiceTier = (input as Record<string, unknown> | undefined)?.service_tier ?? (input as Record<string, unknown> | undefined)?.serviceTier
-  const service_tier =
-    rawServiceTier === "auto" || rawServiceTier === "standard_only"
-      ? (rawServiceTier as "auto" | "standard_only")
-      : undefined
-  const rawMetadata = (input as Record<string, unknown> | undefined)?.metadata
-  const metadata =
-    ProviderShared.isRecord(rawMetadata) &&
-    (typeof rawMetadata.user_id === "string" || rawMetadata.user_id === null)
-      ? { user_id: rawMetadata.user_id as string | null }
-      : undefined
-  const container =
-    typeof (input as Record<string, unknown> | undefined)?.container === "string" ||
-    ProviderShared.isRecord((input as Record<string, unknown> | undefined)?.container)
-      ? ((input as Record<string, unknown>).container as string | { id?: string | null; skills?: ReadonlyArray<Record<string, unknown>> | null })
-      : undefined
-  const rawInferenceGeo =
-    (input as Record<string, unknown> | undefined)?.inference_geo ??
-    (input as Record<string, unknown> | undefined)?.inferenceGeo
-  const inference_geo = typeof rawInferenceGeo === "string" ? rawInferenceGeo : undefined
-  const rawCacheControl =
-    (input as Record<string, unknown> | undefined)?.cache_control ??
-    (input as Record<string, unknown> | undefined)?.cacheControl
-  const cache_control =
-    ProviderShared.isRecord(rawCacheControl) && rawCacheControl.type === "ephemeral"
-      ? (rawCacheControl as { type: "ephemeral"; ttl?: "5m" | "1h" })
-      : undefined
-  const rawOutputConfig =
-    (input as Record<string, unknown> | undefined)?.output_config ??
-    (input as Record<string, unknown> | undefined)?.outputConfig
-  const outputConfigEffort =
-    typeof (input as Record<string, unknown> | undefined)?.effort === "string"
-      ? ((input as Record<string, unknown>).effort as string)
-      : ProviderShared.isRecord(rawOutputConfig) && typeof rawOutputConfig.effort === "string"
-        ? (rawOutputConfig.effort as string)
-        : undefined
-  const outputConfigFormat =
-    ProviderShared.isRecord(rawOutputConfig) && ProviderShared.isRecord(rawOutputConfig.format)
-      ? (rawOutputConfig.format as { type: "json_schema"; schema: Record<string, unknown> })
-      : undefined
-  const output_config =
-    outputConfigEffort === undefined && outputConfigFormat === undefined
-      ? undefined
-      : {
-          ...(outputConfigEffort === undefined ? {} : { effort: outputConfigEffort }),
-          ...(outputConfigFormat === undefined ? {} : { format: outputConfigFormat }),
-        }
+  const input = request.providerOptions
   return {
     thinking: yield* resolveThinking(input?.thinking),
-    effort: outputConfigEffort,
-    output_config,
-    service_tier,
-    metadata,
-    container,
-    inference_geo,
-    cache_control,
+    effort: typeof input?.effort === "string" ? input.effort : undefined,
   }
 })
 
 const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input: unknown) {
   if (!ProviderShared.isRecord(input)) return undefined
-  const display =
-    input.display === "summarized" || input.display === "omitted"
-      ? (input.display as "summarized" | "omitted")
-      : undefined
-  if (input.type === "adaptive")
+  if (input.type === "adaptive") {
+    const display =
+      input.display === "summarized"
+        ? ("summarized" as const)
+        : input.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
   const budget =
@@ -935,12 +618,13 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
         : undefined
   if (budget === undefined)
     return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens")
-  return { type: "enabled" as const, budget_tokens: budget, ...(display === undefined ? {} : { display }) }
+  return { type: "enabled" as const, budget_tokens: budget }
 })
 
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) {
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
+  const outputLimit = request.model.defaults?.limits?.output ?? request.model.route.defaults.limits?.output ?? 4096
   // Allocate the 4-breakpoint budget in invalidation order: tools → system →
   // messages. Tools live highest in the cache hierarchy, so when callers
   // over-mark we keep their tool hints and shed the message-tail ones first.
@@ -979,19 +663,13 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     tools,
     tool_choice: toolChoice,
     stream: true as const,
-    max_tokens: generation?.maxTokens ?? DEFAULT_MAX_TOKENS,
+    max_tokens: generation?.maxTokens ?? outputLimit,
     temperature: generation?.temperature,
     top_p: generation?.topP,
     top_k: generation?.topK,
     stop_sequences: generation?.stop,
     thinking: options.thinking,
-    output_config: options.output_config,
-    // top-level passthrough per SDK MessageCreateParamsBase:4638,4643,4649,4654,4670
-    cache_control: options.cache_control,
-    container: options.container,
-    inference_geo: options.inference_geo,
-    metadata: options.metadata,
-    service_tier: options.service_tier,
+    output_config: options.effort === undefined ? undefined : { effort: options.effort },
   }
 })
 
@@ -1014,7 +692,7 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 // expose that subset through `output_tokens_details.thinking_tokens`.
 const mapUsage = (usage: AnthropicUsage | undefined): Usage | undefined => {
   if (!usage) return undefined
-  const nonCached = usage.input_tokens ?? undefined
+  const nonCached = usage.input_tokens
   const cacheRead = usage.cache_read_input_tokens ?? undefined
   const cacheWrite = usage.cache_creation_input_tokens ?? undefined
   const inputTokens = ProviderShared.sumTokens(nonCached, cacheRead, cacheWrite)
@@ -1102,8 +780,7 @@ const onContentBlockStart = (state: ParserState, event: AnthropicEvent): StepRes
   const block = event.content_block
   if (!block) return [state, NO_EVENTS]
 
-  if (block.type === "tool_use" || block.type === "server_tool_use") {
-    if (event.index === undefined || !block.id) return [state, NO_EVENTS]
+  if ((block.type === "tool_use" || block.type === "server_tool_use") && event.index !== undefined) {
     const events: LLMEvent[] = []
     const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
     return [
@@ -1111,7 +788,7 @@ const onContentBlockStart = (state: ParserState, event: AnthropicEvent): StepRes
         ...state,
         lifecycle,
         tools: ToolStream.start(state.tools, event.index, {
-          id: block.id,
+          id: block.id ?? String(event.index),
           name: block.name ?? "",
           input:
             block.input !== undefined && (!ProviderShared.isRecord(block.input) || Object.keys(block.input).length > 0)
@@ -1123,7 +800,7 @@ const onContentBlockStart = (state: ParserState, event: AnthropicEvent): StepRes
       [
         ...events,
         LLMEvent.toolInputStart({
-          id: block.id,
+          id: block.id ?? String(event.index),
           name: block.name ?? "",
           providerExecuted: block.type === "server_tool_use" ? true : undefined,
         }),
@@ -1313,28 +990,15 @@ const providerErrorMessage = (event: AnthropicEvent): string => {
 }
 
 const onError = (event: AnthropicEvent) =>
-  Effect.fail(
-    new AIError({
-      module: ADAPTER,
-      method: "stream",
-      reason: classifyProviderFailure({ message: providerErrorMessage(event), code: event.error?.type }),
-    }),
-  )
+  new AIError({
+    module: ADAPTER,
+    method: "stream",
+    reason: classifyProviderFailure({ message: providerErrorMessage(event), code: event.error?.type }),
+  })
 
 const step = (state: ParserState, event: AnthropicEvent) => {
   if (event.type === "message_start") return Effect.succeed(onMessageStart(state, event))
-  if (event.type === "content_block_start") {
-    const block = event.content_block
-    if (block && (block.type === "tool_use" || block.type === "server_tool_use")) {
-      if (event.index === undefined)
-        return Effect.fail(ProviderShared.eventError(ADAPTER, `Anthropic ${block.type} missing index`))
-      if (!block.id)
-        return Effect.fail(
-          ProviderShared.eventError(ADAPTER, `Anthropic tool_use missing id at index ${event.index}`),
-        )
-    }
-    return Effect.succeed(onContentBlockStart(state, event))
-  }
+  if (event.type === "content_block_start") return Effect.succeed(onContentBlockStart(state, event))
   if (event.type === "content_block_delta") return onContentBlockDelta(state, event)
   if (event.type === "content_block_stop") return onContentBlockStop(state, event)
   if (event.type === "message_delta") return Effect.succeed(onMessageDelta(state, event))
@@ -1373,12 +1037,9 @@ export const route = Route.make({
   provider: "anthropic",
   providerMetadataKey: "anthropic",
   protocol,
-  endpoint: Endpoint.path(
-    (input) => (input.request.model.provider === "anthropic" ? `${PATH}?beta=true` : PATH),
-    { baseURL: DEFAULT_BASE_URL },
-  ),
+  endpoint: Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL }),
   auth: Auth.none,
-  framing,
+  framing: Framing.sse,
   headers: () => ({ "anthropic-version": "2023-06-01" }),
 })
 

packages/ai/src/protocols/gemini.ts

@@ -17,7 +17,7 @@ import {
   type ToolCallPart,
   type ToolDefinition,
 } from "../schema/index.js"
-import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
+import { JsonObject, optionalArray, ProviderShared } from "./shared.js"
 import { GeminiToolSchema } from "./utils/gemini-tool-schema.js"
 import { Lifecycle } from "./utils/lifecycle.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
@@ -37,17 +37,6 @@ const requiresThoughtSignatureFallback = (modelID: string) => {
   return !/(^|\/)gemini-robotics-er-1\.5(?:[.-]|$)/i.test(modelID)
 }
 
-// Gemini 3 accepts media nested inside function responses; matched Gemini 2.5 variants reject it,
-// so their tool-result attachments lower as a separate user turn instead.
-const routesLegacyToolMedia = (modelID: string) => /gemini-2[.-]5(?:[.-]|$)/i.test(modelID)
-
-// Blacklist: Gemini 1.x/2.x ignore or reject explicit function call ids.
-// Every other model id (Gemini 3+, gemma, anything unrecognized) gets them.
-const omitsFunctionCallIds = (modelID: string) => {
-  const match = /^gemini(?:-live)?-(\d+)/i.exec(modelID)
-  return match !== null && Number(match[1]) < 3
-}
-
 export interface OptionsInput {
   readonly [key: string]: unknown
   readonly cachedContent?: string
@@ -82,15 +71,10 @@ export type ProviderOptionsInput = OptionsInput
 // =============================================================================
 // Request Body Schema
 // =============================================================================
-// Gemini is known to send explicit `null` for optional streaming fields
-// (usage counts, flags, whole subtrees), so every response-side optional uses
-// `optionalNull` instead of bare `Schema.optional`. The same part/content
-// schemas lower the outbound request body; encoding drops `undefined` keys,
-// so the shared schemas stay safe there.
 const GeminiTextPart = Schema.Struct({
   text: Schema.String,
-  thought: optionalNull(Schema.Boolean),
-  thoughtSignature: optionalNull(Schema.String),
+  thought: Schema.optional(Schema.Boolean),
+  thoughtSignature: Schema.optional(Schema.String),
 })
 
 const GeminiInlineDataPart = Schema.Struct({
@@ -103,11 +87,11 @@ type GeminiInlineDataPart = Schema.Schema.Type<typeof GeminiInlineDataPart>
 
 const GeminiFunctionCallPart = Schema.Struct({
   functionCall: Schema.Struct({
-    id: optionalNull(Schema.String),
+    id: Schema.optional(Schema.String),
     name: Schema.String,
     args: Schema.optional(Schema.Unknown),
   }),
-  thoughtSignature: optionalNull(Schema.String),
+  thoughtSignature: Schema.optional(Schema.String),
 })
 
 const GeminiFunctionResponsePart = Schema.Struct({
@@ -127,8 +111,8 @@ const GeminiContentPart = Schema.Union([
 ])
 
 const GeminiContent = Schema.Struct({
-  role: optionalNull(Schema.Literals(["user", "model"])),
-  parts: optionalNull(Schema.Array(GeminiContentPart)),
+  role: Schema.Literals(["user", "model"]),
+  parts: Schema.Array(GeminiContentPart),
 })
 type GeminiContent = Schema.Schema.Type<typeof GeminiContent>
 
@@ -191,45 +175,44 @@ const GeminiBody = Schema.Struct(GeminiBodyFields)
 export type GeminiBody = Schema.Schema.Type<typeof GeminiBody>
 
 const GeminiUsage = Schema.Struct({
-  cachedContentTokenCount: optionalNull(Schema.Number),
-  thoughtsTokenCount: optionalNull(Schema.Number),
-  promptTokenCount: optionalNull(Schema.Number),
-  candidatesTokenCount: optionalNull(Schema.Number),
-  totalTokenCount: optionalNull(Schema.Number),
+  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),
 })
 type GeminiUsage = Schema.Schema.Type<typeof GeminiUsage>
 
 const GeminiCandidate = Schema.Struct({
-  content: optionalNull(GeminiContent),
-  finishReason: optionalNull(Schema.String),
+  content: Schema.optional(GeminiContent),
+  finishReason: Schema.optional(Schema.String),
 })
 
 const GeminiPromptFeedback = Schema.StructWithRest(
   Schema.Struct({
-    blockReason: optionalNull(Schema.String),
-    blockReasonMessage: optionalNull(Schema.String),
-    safetyRatings: optionalNull(Schema.Unknown),
+    blockReason: Schema.optional(Schema.String),
+    blockReasonMessage: Schema.optional(Schema.String),
+    safetyRatings: Schema.optional(Schema.Unknown),
   }),
   [Schema.Record(Schema.String, Schema.Unknown)],
 )
 type GeminiPromptFeedback = Schema.Schema.Type<typeof GeminiPromptFeedback>
 
 const GeminiEvent = Schema.Struct({
-  candidates: optionalNull(Schema.Array(GeminiCandidate)),
-  promptFeedback: optionalNull(GeminiPromptFeedback),
-  usageMetadata: optionalNull(GeminiUsage),
+  candidates: optionalArray(GeminiCandidate),
+  promptFeedback: Schema.optional(GeminiPromptFeedback),
+  usageMetadata: Schema.optional(GeminiUsage),
 })
 type GeminiEvent = Schema.Schema.Type<typeof GeminiEvent>
 
 interface ParserState {
   readonly finishReason?: string
   readonly hasToolCalls: boolean
+  readonly nextToolCallId: number
   readonly promptFeedback?: GeminiPromptFeedback
   readonly usage?: Usage
   readonly lifecycle: Lifecycle.State
   readonly reasoningSignature?: string
-  readonly textSignature?: string
-  readonly seenCallIds?: ReadonlySet<string>
 }
 
 // =============================================================================
@@ -287,31 +270,27 @@ const thoughtSignature = (providerMetadata: ProviderMetadata | undefined) => {
     : undefined
 }
 
-const lowerToolCall = (part: ToolCallPart, omitIds: boolean) => ({
-  functionCall: { ...(omitIds ? {} : { id: part.id }), name: part.name, args: part.input },
+const functionCallId = (providerMetadata: ProviderMetadata | undefined) => {
+  const google = providerMetadata?.google
+  return ProviderShared.isRecord(google) && typeof google.functionCallId === "string"
+    ? google.functionCallId
+    : undefined
+}
+
+const lowerToolCall = (part: ToolCallPart) => ({
+  functionCall: { id: functionCallId(part.providerMetadata), name: part.name, args: part.input },
   thoughtSignature: thoughtSignature(part.providerMetadata),
 })
 
 const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMRequest) {
   const contents: GeminiContent[] = []
-  const omitCallIds = omitsFunctionCallIds(request.model.id)
-  const legacyToolMedia = routesLegacyToolMedia(request.model.id)
-  let pendingMedia: GeminiInlineDataPart[] | undefined
-  const flushMedia = () => {
-    if (!pendingMedia) return
-    contents.push({ role: "user", parts: [{ text: "Attached media from tool result:" }, ...pendingMedia] })
-    pendingMedia = undefined
-  }
 
   for (const message of request.messages) {
-    if (message.role !== "tool") flushMedia()
     if (message.role === "system") {
       const part = yield* ProviderShared.wrappedSystemUpdate("Gemini", message)
       const previous = contents.at(-1)
-      // Gemini rejects a continuation whose function-response turn carries extra
-      // parts, so an update after a tool result starts its own user turn.
-      if (previous?.role === "user" && !(previous.parts ?? []).some((item) => "functionResponse" in item))
-        contents[contents.length - 1] = { role: "user", parts: [...(previous.parts ?? []), { text: part.text }] }
+      if (previous?.role === "user")
+        contents[contents.length - 1] = { role: "user", parts: [...previous.parts, { text: part.text }] }
       else contents.push({ role: "user", parts: [{ text: part.text }] })
       continue
     }
@@ -335,7 +314,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
         if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
           return yield* ProviderShared.unsupportedContent("Gemini", "assistant", ["text", "reasoning", "tool-call"])
         if (part.type === "text") {
-          parts.push({ text: part.text, thoughtSignature: thoughtSignature(part.providerMetadata) })
+          parts.push({ text: part.text })
           continue
         }
         if (part.type === "reasoning") {
@@ -343,7 +322,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
           continue
         }
         if (part.type === "tool-call") {
-          const lowered = lowerToolCall(part, omitCallIds)
+          const lowered = lowerToolCall(part)
           const signature = lowered.thoughtSignature
           parts.push({
             ...lowered,
@@ -368,7 +347,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
       if (part.result.type !== "content") {
         parts.push({
           functionResponse: {
-            ...(omitCallIds ? {} : { id: part.id }),
+            id: functionCallId(part.providerMetadata),
             name: part.name,
             response: {
               name: part.name,
@@ -386,28 +365,21 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
         const value = ProviderShared.normalizeToolFile(item)
         media.push({ inlineData: { mimeType: value.mime, data: value.base64 } })
       }
-      if (legacyToolMedia && media.length > 0) (pendingMedia ??= []).push(...media)
       parts.push({
         functionResponse: {
-          ...(omitCallIds ? {} : { id: part.id }),
+          id: functionCallId(part.providerMetadata),
           name: part.name,
           response: {
             name: part.name,
             content: text.join("\n"),
           },
-          parts: legacyToolMedia || media.length === 0 ? undefined : media,
+          parts: media.length > 0 ? media : undefined,
         },
       })
     }
-    // Gemini requires every response to a parallel call batch in one user turn,
-    // so consecutive tool results join the open function-response turn.
-    const previous = contents.at(-1)
-    if (previous?.role === "user" && (previous.parts ?? []).some((item) => "functionResponse" in item))
-      contents[contents.length - 1] = { role: "user", parts: [...(previous.parts ?? []), ...parts] }
-    else contents.push({ role: "user", parts })
+    contents.push({ role: "user", parts })
   }
 
-  flushMedia()
   return contents
 })
 
@@ -493,25 +465,21 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
 // to produce the inclusive `outputTokens` the rest of the contract expects.
 const mapUsage = (usage: GeminiUsage | undefined) => {
   if (!usage) return undefined
-  // Explicit provider nulls decode as `null`; normalize to `undefined` so the
-  // token arithmetic below treats them like absent counts.
-  const promptTokens = usage.promptTokenCount ?? undefined
-  const cached = usage.cachedContentTokenCount ?? undefined
-  const thoughts = usage.thoughtsTokenCount ?? undefined
-  const visible = usage.candidatesTokenCount ?? undefined
-  const nonCached = ProviderShared.subtractTokens(promptTokens, cached)
+  const cached = usage.cachedContentTokenCount
+  const nonCached = ProviderShared.subtractTokens(usage.promptTokenCount, cached)
   // `candidatesTokenCount` is visible-only; sum with thoughts to produce the
   // inclusive `outputTokens` the contract expects. Only compute the total
   // when the visible component is reported — otherwise we'd fabricate an
   // inclusive number from a partial breakdown.
-  const outputTokens = visible !== undefined ? visible + (thoughts ?? 0) : undefined
+  const outputTokens =
+    usage.candidatesTokenCount !== undefined ? usage.candidatesTokenCount + (usage.thoughtsTokenCount ?? 0) : undefined
   return new Usage({
-    inputTokens: promptTokens,
+    inputTokens: usage.promptTokenCount,
     outputTokens,
     nonCachedInputTokens: nonCached,
     cacheReadInputTokens: cached,
-    reasoningTokens: thoughts,
-    totalTokens: ProviderShared.totalTokens(promptTokens, outputTokens, usage.totalTokenCount ?? undefined),
+    reasoningTokens: usage.thoughtsTokenCount,
+    totalTokens: ProviderShared.totalTokens(usage.promptTokenCount, outputTokens, usage.totalTokenCount),
     providerMetadata: { google: usage },
   })
 }
@@ -546,24 +514,19 @@ const mapFinishReason = (finishReason: string | undefined, hasToolCalls: boolean
 }
 
 const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
-  // `?? undefined` normalizes an explicit `null` blockReason back to absent so
-  // the "nothing to finish" check below keeps its meaning.
-  const promptBlockReason =
-    state.finishReason === undefined ? (state.promptFeedback?.blockReason ?? undefined) : undefined
+  const promptBlockReason = state.finishReason === undefined ? state.promptFeedback?.blockReason : undefined
   const finishReason = state.finishReason ?? promptBlockReason
   if (finishReason === undefined && state.usage === undefined) return []
 
   const events: LLMEvent[] = []
-  let lifecycle = state.lifecycle
-  if (state.reasoningSignature !== undefined)
-    lifecycle = Lifecycle.reasoningEnd(
-      lifecycle,
-      events,
-      "reasoning-0",
-      googleMetadata({ thoughtSignature: state.reasoningSignature }),
-    )
-  if (state.textSignature !== undefined)
-    lifecycle = Lifecycle.textEnd(lifecycle, events, "text-0", googleMetadata({ thoughtSignature: state.textSignature }))
+  const lifecycle = state.reasoningSignature
+    ? Lifecycle.reasoningEnd(
+        state.lifecycle,
+        events,
+        "reasoning-0",
+        googleMetadata({ thoughtSignature: state.reasoningSignature }),
+      )
+    : state.lifecycle
   Lifecycle.finish(lifecycle, events, {
     reason: {
       normalized:
@@ -593,17 +556,12 @@ const step = (state: ParserState, event: GeminiEvent) => {
   const events: LLMEvent[] = []
   let hasToolCalls = nextState.hasToolCalls
   let lifecycle = nextState.lifecycle
+  let nextToolCallId = nextState.nextToolCallId
   let reasoningSignature = nextState.reasoningSignature
-  let textSignature = nextState.textSignature
-  // Supplier ids must be tracked across chunks of the same response, not just within one event's parts.
-  const seenCallIds = new Set(nextState.seenCallIds)
 
-  for (const part of candidate.content.parts ?? []) {
-    const signature = "thoughtSignature" in part && part.thoughtSignature ? part.thoughtSignature : undefined
-    // Gemini attaches replay signatures to thought parts, visible text, or function calls;
-    // each block kind must retain the signature attached to its own parts.
-    if (signature !== undefined && "thought" in part && part.thought) reasoningSignature = signature
-    else if (signature !== undefined && "text" in part) textSignature = signature
+  for (const part of candidate.content.parts) {
+    if ("thoughtSignature" in part && part.thoughtSignature && "thought" in part && part.thought)
+      reasoningSignature = part.thoughtSignature
     if ("text" in part && part.text.length > 0) {
       if (part.thought) {
         lifecycle = Lifecycle.reasoningDelta(
@@ -611,7 +569,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
           events,
           "reasoning-0",
           part.text,
-          signature ? googleMetadata({ thoughtSignature: signature }) : undefined,
+          part.thoughtSignature ? googleMetadata({ thoughtSignature: part.thoughtSignature }) : undefined,
         )
         continue
       }
@@ -621,27 +579,17 @@ const step = (state: ParserState, event: GeminiEvent) => {
         "reasoning-0",
         reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined,
       )
-      lifecycle = Lifecycle.textDelta(
-        lifecycle,
-        events,
-        "text-0",
-        part.text,
-        textSignature ? googleMetadata({ thoughtSignature: textSignature }) : undefined,
-      )
-      textSignature = undefined
+      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", part.text)
       continue
     }
 
     if ("functionCall" in part) {
       const input = part.functionCall.args === undefined ? {} : part.functionCall.args
-      // Gemini 2.0+ supplies a unique function call ID on the part; when omitted (e.g. Gemini 1.5),
-      // generate a globally unique ID rather than a per-request counter to prevent cross-request collisions in downstream registries.
-      // A repeated supplier id would replay as two identical calls, so only the first occurrence keeps it.
-      // A `null` supplier id normalizes to absent so the generated-id fallback applies.
-      const supplied = part.functionCall.id ?? undefined
-      const duplicate = supplied !== undefined && seenCallIds.has(supplied)
-      if (supplied !== undefined) seenCallIds.add(supplied)
-      const id = supplied !== undefined && !duplicate ? supplied : `tool_${crypto.randomUUID().replaceAll("-", "")}`
+      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,
@@ -654,8 +602,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
           id,
           name: part.functionCall.name,
           input,
-          providerMetadata:
-            part.thoughtSignature ? googleMetadata({ thoughtSignature: part.thoughtSignature }) : undefined,
+          providerMetadata: Object.keys(metadata).length > 0 ? googleMetadata(metadata) : undefined,
         }),
       )
       hasToolCalls = true
@@ -667,9 +614,8 @@ const step = (state: ParserState, event: GeminiEvent) => {
       ...nextState,
       hasToolCalls,
       lifecycle,
+      nextToolCallId,
       reasoningSignature,
-      textSignature,
-      seenCallIds,
       finishReason: candidate.finishReason ?? nextState.finishReason,
     },
     events,
@@ -691,7 +637,7 @@ export const protocol = Protocol.make({
   },
   stream: {
     event: Protocol.jsonEvent(GeminiEvent),
-    initial: () => ({ hasToolCalls: false, lifecycle: Lifecycle.initial() }),
+    initial: () => ({ hasToolCalls: false, nextToolCallId: 0, lifecycle: Lifecycle.initial() }),
     step,
     onHalt: finish,
   },

packages/ai/src/protocols/index.ts

@@ -8,4 +8,3 @@ export * as OpenAICompatibleResponses from "./openai-compatible-responses.js"
 export * as OpenAIResponses from "./openai-responses.js"
 export * as OpenResponses from "./open-responses.js"
 export * as OpenResponsesChannel from "./open-responses-channel.js"
-export * as XAIResponses from "./xai-responses.js"

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

@@ -10,7 +10,6 @@ import {
 } from "../route/transport/index.js"
 import * as ProviderShared from "./shared.js"
 import { OpenResponses } from "./open-responses.js"
-import { OpenResponsesContinuation } from "./open-responses-continuation.js"
 
 const WebSocketResponseCreate = Schema.StructWithRest(Schema.Struct({ type: Schema.tag("response.create") }), [
   Schema.Record(Schema.String, Schema.Unknown),
@@ -23,9 +22,12 @@ export interface Options {
   readonly id: string
   readonly name: string
   readonly rotateAfterMs?: number
-  readonly enabled?: (url: string) => boolean
-  readonly url?: (url: string) => string
   readonly headers?: (headers: Headers.Headers) => Headers.Headers
+  readonly driver?: (input: {
+    readonly request: Readonly<Record<string, unknown>>
+    readonly message: string
+    readonly base: WebSocketChannelDriver
+  }) => WebSocketChannelDriver
 }
 
 export interface Prepared {
@@ -112,8 +114,6 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
           responseID = created
           return { type: "frame", frame }
         }
-        // Keepalives carry no response state and may arrive before response.created.
-        if (event.type === "keepalive") return { type: "frame", frame }
         if (!responseID)
           return yield* ProviderShared.eventError(
             options.id,
@@ -147,25 +147,18 @@ export const transport = <Body>(options: Options): Transport<Body, Prepared, str
       Effect.gen(function* () {
         const parts = yield* HttpTransport.jsonRequestParts(input)
         const headers = Headers.remove(options.headers?.(parts.headers) ?? parts.headers, "content-length")
-        const channel =
-          input.webSocket && (options.enabled?.(parts.url) ?? true)
-            ? yield* Effect.gen(function* () {
-                const create = yield* message(parts.jsonBody)
-                const base = driver(options, create.message)
-                return {
-                  url: yield* WebSocketTransport.toWebSocketUrl(options.url?.(parts.url) ?? parts.url),
-                  headers,
-                  rotateAfterMs: options.rotateAfterMs,
-                  driver: OpenResponsesContinuation.driver({
-                    id: options.id,
-                    name: options.name,
-                    request: create.request,
-                    message: create.message,
-                    base,
-                  }),
-                }
-              })
-            : undefined
+        const channel = input.webSocket
+          ? yield* Effect.gen(function* () {
+              const create = yield* message(parts.jsonBody)
+              const base = driver(options, create.message)
+              return {
+                url: yield* WebSocketTransport.toWebSocketUrl(parts.url),
+                headers,
+                rotateAfterMs: options.rotateAfterMs,
+                driver: options.driver?.({ request: create.request, message: create.message, base }) ?? base,
+              }
+            })
+          : undefined
         return {
           http: {
             request: ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),

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

@@ -5,7 +5,6 @@ import { Protocol } from "../route/protocol.js"
 import {
   AIError,
   LLMEvent,
-  ProviderInternalReason,
   Usage,
   type FinishReason,
   type JsonSchema,
@@ -43,12 +42,8 @@ const OpenResponsesInputImage = Schema.Struct({
 const OpenResponsesInputFile = Schema.Struct({
   type: Schema.tag("input_file"),
   filename: Schema.String,
-  file_data: Schema.optional(Schema.String),
-  file_url: Schema.optional(Schema.String),
-})
-const OpenResponsesInputVideo = Schema.Struct({
-  type: Schema.tag("input_video"),
-  video_url: 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>
@@ -59,14 +54,9 @@ const OpenResponsesOutputText = Schema.Struct({
   text: Schema.String,
 })
 
-export const MessagePhase = Schema.NullOr(Schema.Literals(["commentary", "final_answer"]))
+export const MessagePhase = Schema.Literals(["commentary", "final_answer"])
 type MessagePhase = Schema.Schema.Type<typeof MessagePhase>
 
-const messagePhase = (value: unknown): MessagePhase | undefined => {
-  if (value === null || value === "commentary" || value === "final_answer") return value
-  return undefined
-}
-
 const OpenResponsesReasoningSummaryText = Schema.Struct({
   type: Schema.tag("summary_text"),
   text: Schema.String,
@@ -91,7 +81,6 @@ const OpenResponsesFunctionCallOutputContent = Schema.Union([
   OpenResponsesInputText,
   OpenResponsesInputImage,
   OpenResponsesInputFile,
-  OpenResponsesInputVideo,
 ])
 
 const OpenResponsesFunctionCallOutput = Schema.Union([
@@ -104,8 +93,6 @@ export const InputItem = Schema.Union([
   Schema.Struct({ role: Schema.tag("developer"), content: Schema.String }),
   Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenResponsesInputContent) }),
   Schema.Struct({
-    type: Schema.tag("message"),
-    id: Schema.optionalKey(Schema.String),
     role: Schema.tag("assistant"),
     content: Schema.Array(OpenResponsesOutputText),
     phase: Schema.optionalKey(MessagePhase),
@@ -114,7 +101,6 @@ export const InputItem = Schema.Union([
   OpenResponsesItemReference,
   Schema.Struct({
     type: Schema.tag("function_call"),
-    id: Schema.optionalKey(Schema.String),
     call_id: Schema.String,
     name: Schema.String,
     arguments: Schema.String,
@@ -129,8 +115,6 @@ type OpenResponsesInputItem = Schema.Schema.Type<typeof InputItem>
 type LoweredInputItem =
   | OpenResponsesInputItem
   | {
-      readonly type: "message"
-      readonly id?: string
       readonly role: "assistant"
       readonly content: ReadonlyArray<{ readonly type: "output_text"; readonly text: string }>
       readonly phase?: MessagePhase | null
@@ -144,6 +128,8 @@ type OpenResponsesReasoningInput = {
   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,
@@ -173,14 +159,6 @@ export const coreFields = {
   tools: optionalArray(Tool),
   tool_choice: Schema.optional(ToolChoice),
   store: Schema.optional(Schema.Boolean),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  safety_identifier: Schema.optional(Schema.String),
-  stream_options: Schema.optional(
-    Schema.Struct({
-      include_obfuscation: Schema.optional(Schema.Boolean),
-    }),
-  ),
-  top_logprobs: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 20 }))),
   truncation: Schema.optional(OpenResponsesOptions.TruncationSchema),
   service_tier: Schema.optional(OpenResponsesOptions.ServiceTierSchema),
   prompt_cache_key: Schema.optional(Schema.String),
@@ -201,8 +179,6 @@ export const coreFields = {
   parallel_tool_calls: Schema.optional(Schema.Boolean),
   temperature: Schema.optional(Schema.Number),
   top_p: Schema.optional(Schema.Number),
-  presence_penalty: Schema.optional(Schema.Number),
-  frequency_penalty: Schema.optional(Schema.Number),
 }
 
 const OpenResponsesBody = Schema.Struct({
@@ -248,7 +224,6 @@ const OpenResponsesErrorPayload = Schema.Struct({
   message: optionalNull(Schema.String),
   param: optionalNull(Schema.String),
 })
-type OpenResponsesErrorPayload = Schema.Schema.Type<typeof OpenResponsesErrorPayload>
 
 const WebSocketErrorHeader = Schema.Union([Schema.String, Schema.Number, Schema.Boolean])
 export const WebSocketErrorEvent = Schema.StructWithRest(
@@ -313,9 +288,6 @@ export const Event = Schema.StructWithRest(
 )
 export type Event = Schema.Schema.Type<typeof Event>
 
-// Which lowered input item a persisted item id is about to be attached to.
-export type ItemKind = "message" | "reasoning" | "function-call" | "reference"
-
 export interface Extension {
   readonly id: string
   readonly name: string
@@ -324,10 +296,7 @@ export interface Extension {
     readonly media: ProviderShared.NormalizedMedia
     readonly request: LLMRequest
   }) => MediaInput | undefined
-  // Optional grammar check applied before a persisted item id is resent as
-  // part of replayed history. Returning false drops the id; every lowered
-  // item treats a dropped id the same as an absent one.
-  readonly acceptsItemID?: (kind: ItemKind, id: string) => boolean
+  readonly messagePhase?: (value: unknown) => MessagePhase | null | undefined
 }
 
 const BASE: Extension = { id: ADAPTER, name: NAME }
@@ -340,6 +309,7 @@ export interface ParserState {
   readonly hasFunctionCall: boolean
   readonly lifecycle: Lifecycle.State
   readonly messageItems: ReadonlySet<string>
+  readonly messagePhase: (value: unknown) => MessagePhase | null | undefined
   readonly messagePhases: Readonly<Record<string, MessagePhase | null>>
   readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>
   readonly store: boolean | undefined
@@ -353,10 +323,6 @@ interface ReasoningStreamItem {
   // strings, but typing the map as `Record<number, ...>` documents intent
   // and matches the wire field.
   readonly summaryParts: Readonly<Record<number, ReasoningSummaryStatus>>
-  // Summary indexes that received at least one streamed delta. The `:0` block
-  // is started eagerly when the item opens, so block existence cannot tell
-  // whether a `.done` final would duplicate streamed text.
-  readonly deltaIndexes: ReadonlySet<number>
 }
 
 // =============================================================================
@@ -373,7 +339,7 @@ export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (
     type: "function" as const,
     name: tool.name,
     description: tool.description,
-    parameters: inputSchema,
+    parameters: ToolSchemaProjection.responses(inputSchema),
     // The common tool definition does not currently express Responses strict-schema policy.
     strict: false,
   }
@@ -387,81 +353,52 @@ export const lowerToolChoice = (protocolName: string, toolChoice: NonNullable<LL
     tool: (toolName) => ({ type: "function" as const, name: toolName }),
   })
 
-// Servers validate item ids on replayed history, and a malformed or oversized
-// id can fail an otherwise valid request. Only server-issued tokens are worth
-// resending; anything else is treated as absent so the item is resent without
-// an id (or skipped, for items that cannot be expressed without one).
-const ITEM_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/
-const itemID = (providerMetadata: ProviderMetadata | undefined, providerMetadataKey: string) => {
-  const metadata = providerMetadata?.[providerMetadataKey]
-  return ProviderShared.isRecord(metadata) &&
-    typeof metadata.itemId === "string" &&
-    ITEM_ID_PATTERN.test(metadata.itemId)
-    ? metadata.itemId
-    : undefined
-}
+const lowerToolCall = (part: ToolCallPart): OpenResponsesInputItem => ({
+  type: "function_call",
+  call_id: part.id,
+  name: part.name,
+  arguments: ProviderShared.encodeJson(part.input),
+})
 
-const acceptsItemID = (extension: Extension, kind: ItemKind, id: string | undefined): id is string =>
-  id !== undefined && (extension.acceptsItemID?.(kind, id) ?? true)
-
-const lowerToolCall = (
-  part: ToolCallPart,
-  providerMetadataKey: string,
-  extension: Extension,
-): OpenResponsesInputItem => {
-  const id = itemID(part.providerMetadata, providerMetadataKey)
-  return {
-    type: "function_call",
-    ...(acceptsItemID(extension, "function-call", id) ? { id } : {}),
-    call_id: part.id,
-    name: part.name,
-    arguments: ProviderShared.encodeJson(part.input),
-  }
-}
-
-const lowerReasoning = (
-  part: ReasoningPart,
-  providerMetadataKey: string,
-  extension: Extension,
-): OpenResponsesReasoningInput | undefined => {
+const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenResponsesReasoningInput | undefined => {
   const metadata = part.providerMetadata?.[providerMetadataKey]
-  const id = itemID(part.providerMetadata, providerMetadataKey)
-  if (!ProviderShared.isRecord(metadata) || !acceptsItemID(extension, "reasoning", id)) return undefined
+  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,
+    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,
-  target: "message" | "tool-result",
 ) {
   const media = ProviderShared.normalizeMedia(part)
   const extended = extension.lowerMedia?.({ part, media, request })
   if (extended) return extended
-  const url =
-    typeof part.data === "string" && (part.data.startsWith("https://") || part.data.startsWith("http://"))
-      ? part.data
-      : undefined
   if (!media.mime.startsWith("image/")) {
-    if (target === "tool-result" && media.mime.startsWith("video/"))
-      return { type: "input_video" as const, video_url: url ?? media.dataUrl }
     return {
       type: "input_file" as const,
       filename: part.filename ?? (media.mime === "application/pdf" ? "document.pdf" : "file"),
-      ...(url ? { file_url: url } : { file_data: media.dataUrl }),
+      file_data: media.dataUrl,
     }
   }
-  return { type: "input_image" as const, image_url: url ?? media.dataUrl }
+  return { type: "input_image" as const, image_url: media.dataUrl }
 })
 
 const lowerUserContent = Effect.fnUntraced(function* (
@@ -470,17 +407,10 @@ const lowerUserContent = Effect.fnUntraced(function* (
   extension: Extension,
 ) {
   if (part.type === "text") return { type: "input_text" as const, text: part.text }
-  if (part.type === "media") return yield* lowerMessageMedia(part, request, extension)
+  if (part.type === "media") return yield* lowerMedia(part, request, extension)
   return yield* ProviderShared.unsupportedContent(extension.name, "user", ["text", "media"])
 })
 
-const lowerMessageMedia = Effect.fnUntraced(function* (part: MediaPart, request: LLMRequest, extension: Extension) {
-  const lowered = yield* lowerMedia(part, request, extension, "message")
-  if (lowered.type === "input_video")
-    return yield* ProviderShared.invalidRequest(`${extension.name} user messages do not support input_video`)
-  return lowered
-})
-
 // 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.fnUntraced(function* (
@@ -493,20 +423,6 @@ const lowerToolResultContentItem = Effect.fnUntraced(function* (
     { type: "media", mediaType: item.mime, data: item.uri, filename: item.name },
     request,
     extension,
-    "tool-result",
-  )
-})
-
-const lowerHostedToolResultContentItem = Effect.fnUntraced(function* (
-  item: Content,
-  request: LLMRequest,
-  extension: Extension,
-) {
-  if (item.type === "text") return { type: "input_text" as const, text: item.text }
-  return yield* lowerMessageMedia(
-    { type: "media", mediaType: item.mime, data: item.uri, filename: item.name },
-    request,
-    extension,
   )
 })
 
@@ -549,27 +465,24 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
 
     if (message.role === "assistant") {
       const content: TextPart[] = []
-      const reasoningItems: Record<string, OpenResponsesReasoningInput> = {}
+      const reasoningItems: Record<string, OpenResponsesReasoningReplay> = {}
       const reasoningReferences = new Set<string>()
       const hostedToolReferences = new Set<string>()
       const flushText = () => {
         if (content.length === 0) return
-        const groups = content.reduce<
-          Array<{ id: string | undefined; phase: MessagePhase | null | undefined; parts: TextPart[] }>
-        >((groups, part) => {
-          const metadata = part.providerMetadata?.[providerMetadataKey]
-          const rawID = itemID(part.providerMetadata, providerMetadataKey)
-          const id = acceptsItemID(extension, "message", rawID) ? rawID : undefined
-          const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase) : undefined
-          const group = groups.at(-1)
-          if (group && group.id === id && group.phase === phase) group.parts.push(part)
-          else groups.push({ id, phase, parts: [part] })
-          return groups
-        }, [])
+        const groups = content.reduce<Array<{ phase: MessagePhase | null | undefined; parts: TextPart[] }>>(
+          (groups, part) => {
+            const metadata = part.providerMetadata?.[providerMetadataKey]
+            const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase, extension) : undefined
+            const group = groups.at(-1)
+            if (group && group.phase === phase) group.parts.push(part)
+            else groups.push({ phase, parts: [part] })
+            return groups
+          },
+          [],
+        )
         input.push(
           ...groups.map((group) => ({
-            type: "message" as const,
-            ...(group.id === undefined ? {} : { id: group.id }),
             role: "assistant" as const,
             content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
             ...(group.phase === undefined ? {} : { phase: group.phase }),
@@ -584,7 +497,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
         }
         if (part.type === "reasoning") {
           flushText()
-          const reasoning = lowerReasoning(part, providerMetadataKey, extension)
+          const reasoning = lowerReasoning(part, providerMetadataKey)
           if (!reasoning) continue
           if (store !== false) {
             if (!reasoningReferences.has(reasoning.id)) input.push({ type: "item_reference", id: reasoning.id })
@@ -598,37 +511,34 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
               existing.encrypted_content = reasoning.encrypted_content
             continue
           }
-          reasoningItems[reasoning.id] = reasoning
-          input.push(reasoning)
+          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, providerMetadataKey, extension))
+          input.push(lowerToolCall(part))
           continue
         }
         if (part.type === "tool-result" && part.providerExecuted === true) {
           flushText()
-          const id = itemID(part.providerMetadata, providerMetadataKey)
-          const reference = acceptsItemID(extension, "reference", id) ? id : undefined
-          if (store !== false && reference && !hostedToolReferences.has(reference))
-            input.push({ type: "item_reference", id: reference })
-          if (store === false) {
-            // The server is not storing this exchange, so the tool outcome has to
-            // travel in the input. Non-content results degrade to their text form.
-            const content: ReadonlyArray<Content> =
-              part.result.type === "content"
-                ? part.result.value
-                : [{ type: "text", text: ProviderShared.toolResultText(part) }]
+          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<Content> = part.result.value
             input.push({
               role: "user",
-              content: yield* Effect.forEach(content, (item) =>
-                lowerHostedToolResultContentItem(item, request, extension),
-              ),
+              content: yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request, extension)),
             })
           }
-          if (reference) hostedToolReferences.add(reference)
+          if (itemID) hostedToolReferences.add(itemID)
           continue
         }
         return yield* ProviderShared.unsupportedContent(extension.name, "assistant", [
@@ -665,17 +575,10 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
 
 const lowerOptions = (request: LLMRequest) => {
   const options = OpenResponsesOptions.resolve(request)
-  const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey)
   return {
     ...(options.instructions ? { instructions: options.instructions } : {}),
     ...(options.store !== undefined ? { store: options.store } : {}),
-    ...(options.metadata ? { metadata: options.metadata } : {}),
-    ...(options.safetyIdentifier ? { safety_identifier: options.safetyIdentifier } : {}),
-    ...(options.streamOptions?.includeObfuscation !== undefined
-      ? { stream_options: { include_obfuscation: options.streamOptions.includeObfuscation } }
-      : {}),
-    ...(options.topLogprobs !== undefined ? { top_logprobs: options.topLogprobs } : {}),
-    ...(cacheKey ? { prompt_cache_key: cacheKey } : {}),
+    ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
     ...(options.include ? { include: options.include } : {}),
     ...(options.reasoningEffort || options.reasoningSummary
       ? { reasoning: { effort: options.reasoningEffort, summary: options.reasoningSummary } }
@@ -724,8 +627,6 @@ export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWith
     max_output_tokens: generation?.maxTokens,
     temperature: generation?.temperature,
     top_p: generation?.topP,
-    presence_penalty: generation?.presencePenalty,
-    frequency_penalty: generation?.frequencyPenalty,
     ...lowerOptions(request),
   }
 })
@@ -791,10 +692,10 @@ const TERMINAL_TYPES = new Set(["error", "response.completed", "response.incompl
 export const terminal = (event: Event) => TERMINAL_TYPES.has(event.type)
 
 const onOutputTextDelta = (state: ParserState, event: Event, id: string): StepResult => {
-  if (!event.delta || !state.messageItems.has(id)) return [state, NO_EVENTS]
+  if (!event.delta) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
   const phase = state.messagePhases[id]
-  const metadata = providerMetadata(state, { itemId: id, ...(phase === undefined ? {} : { phase }) })
+  const metadata = phase === undefined ? undefined : providerMetadata(state, { phase })
   const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata)
   return [{ ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) }, events]
 }
@@ -809,33 +710,20 @@ const onOutputTextDone = (state: ParserState, event: Event, id: string): StepRes
 }
 
 export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
-  const item = state.reasoningItems[itemID]
-  if (!event.delta || !item) return [state, NO_EVENTS]
-  const index = event.summary_index ?? 0
+  if (!event.delta) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
+  const id =
+    event.summary_index !== undefined || state.reasoningItems[itemID] ? `${itemID}:${event.summary_index ?? 0}` : itemID
   return [
     {
       ...state,
-      lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, `${itemID}:${index}`, event.delta),
-      reasoningItems: {
-        ...state.reasoningItems,
-        [itemID]: { ...item, deltaIndexes: new Set([...item.deltaIndexes, index]) },
-      },
+      lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, id, event.delta),
     },
     events,
   ]
 }
 
-// Some compatible gateways emit a reasoning final without streaming any
-// deltas, mirroring `response.output_text.done`. Reconcile the complete text
-// as a single delta unless that summary index already streamed one.
-export const onReasoningDone = (state: ParserState, event: Event, itemID: string): StepResult => {
-  const item = state.reasoningItems[itemID]
-  if (!item || typeof event.text !== "string") return [state, NO_EVENTS]
-  const index = event.summary_index ?? 0
-  if (item.deltaIndexes.has(index)) return [state, NO_EVENTS]
-  return onReasoningDelta(state, { ...event, delta: event.text }, itemID)
-}
+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 })
@@ -854,17 +742,18 @@ const reasoningMetadata = (state: ParserState, item: StreamItem & { id: string }
 // best-effort, not guaranteed.
 const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
   const item = event.item
-  if (item?.type === "message" && item.id) {
-    const phase = messagePhase(item.phase)
+  if (item?.type === "message" && item.id)
     return [
       {
         ...state,
         messageItems: new Set([...state.messageItems, item.id]),
-        messagePhases: phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase },
+        messagePhases: (() => {
+          const phase = state.messagePhase(item.phase)
+          return phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase }
+        })(),
       },
       NO_EVENTS,
     ]
-  }
   if (item && isReasoningItem(item)) {
     const events: LLMEvent[] = []
     return [
@@ -873,11 +762,7 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
         lifecycle: Lifecycle.reasoningStart(state.lifecycle, events, `${item.id}:0`, reasoningMetadata(state, item)),
         reasoningItems: {
           ...state.reasoningItems,
-          [item.id]: {
-            encryptedContent: item.encrypted_content,
-            summaryParts: { 0: "active" },
-            deltaIndexes: new Set(),
-          },
+          [item.id]: { encryptedContent: item.encrypted_content, summaryParts: { 0: "active" } },
         },
       },
       events,
@@ -907,9 +792,27 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
 
 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]
-  if (!item) return [state, NO_EVENTS]
-  if (event.summary_index === 0) 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)
@@ -988,7 +891,7 @@ const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgu
   state: ParserState,
   event: Event,
 ) {
-  if (!event.item_id || !event.delta || !state.tools[event.item_id]) return [state, NO_EVENTS] satisfies StepResult
+  if (!event.item_id || !event.delta) return [state, NO_EVENTS] satisfies StepResult
   const result = ToolStream.appendExisting(
     state.id,
     state.tools,
@@ -1008,7 +911,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
   if (!item) return [state, NO_EVENTS] satisfies StepResult
 
   if (item.type === "message" && item.id) {
-    const itemPhase = messagePhase(item.phase)
+    const itemPhase = state.messagePhase(item.phase)
     const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase
     const events: LLMEvent[] = []
     const messageItems = new Set(state.messageItems)
@@ -1021,7 +924,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
           state.lifecycle,
           events,
           item.id,
-          providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) }),
+          phase === undefined ? undefined : providerMetadata(state, { phase }),
         ),
         messageItems,
         messagePhases,
@@ -1034,11 +937,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     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,
-          providerMetadata: providerMetadata(state, { itemId: item.id }),
-        })
+      : 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)
@@ -1089,19 +988,11 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
   return [state, NO_EVENTS] satisfies StepResult
 })
 
-const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (state: ParserState, event: Event) {
-  // Some compatible providers omit output_item.done even after completing the response.
-  const pending =
-    event.type === "response.completed"
-      ? yield* ToolStream.finishAll(state.id, state.tools)
-      : { tools: state.tools, events: NO_EVENTS }
-  const events: LLMEvent[] = [...pending.events]
-  const hasFunctionCall =
-    pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-    state.hasFunctionCall
+const onResponseFinish = (state: ParserState, event: Event): StepResult => {
+  const events: LLMEvent[] = []
   const lifecycle = Lifecycle.finish(state.lifecycle, events, {
     reason: {
-      normalized: mapFinishReason(event, hasFunctionCall),
+      normalized: mapFinishReason(event, state.hasFunctionCall),
       raw: event.response?.incomplete_details?.reason,
     },
     usage: mapUsage(event.response?.usage, state.providerMetadataKey),
@@ -1113,48 +1004,35 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
           })
         : undefined,
   })
-  return [{ ...state, lifecycle, hasFunctionCall, tools: pending.tools }, events] satisfies StepResult
-})
+  return [{ ...state, lifecycle }, events]
+}
 
-// Build the prettiest summary available from whatever the provider supplied.
+// 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. Returns undefined when
-// the payload carries no usable summary.
-const providerErrorMessage = (event: Event, nested: OpenResponsesErrorPayload | undefined): string | undefined => {
+// 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
+  return message || code || fallback
 }
 
 export const providerFailure = (id: string, event: Event, fallback: string) => {
-  const nested = event.error ?? event.response?.error ?? undefined
-  const code = event.code || nested?.code || undefined
-  // Keep the full raw payload on the error even when the message is a summary.
-  const body = JSON.stringify(nested ?? event) ?? ""
-  const summary = providerErrorMessage(event, nested)
-  const message = summary ?? (body === "{}" ? fallback : body)
+  const code = event.code || event.error?.code || event.response?.error?.code || undefined
+  const message = providerErrorMessage(event, fallback)
   const status =
     typeof event.status === "number"
       ? event.status
       : typeof event.status_code === "number"
         ? event.status_code
         : undefined
-  const reason =
-    event.type === "error" &&
-    event.error === undefined &&
-    event.response === undefined &&
-    summary === undefined &&
-    status === undefined
-      ? new ProviderInternalReason({ message })
-      : classifyProviderFailure({ message, code, status, rawBody: body })
   return new AIError({
     module: id,
     method: "stream",
-    body,
-    reason,
+    reason: classifyProviderFailure({ message, code, status }),
   })
 }
 
@@ -1169,28 +1047,13 @@ export const step = (state: ParserState, event: Event) => {
         : onOutputTextDone(state, event, event.item_id),
     )
   }
-  if (event.type === "response.refusal.delta" || event.type === "response.refusal.done") {
-    const value = event.type === "response.refusal.delta" ? event.delta : event.refusal
-    if (!event.item_id || typeof value !== "string")
-      return ProviderShared.eventError(state.id, `${event.type} is malformed`)
-    return Effect.succeed(
-      event.type === "response.refusal.delta"
-        ? onOutputTextDelta(state, event, event.item_id)
-        : onOutputTextDone(state, { ...event, text: value }, event.item_id),
-    )
-  }
   if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta") {
     if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
     return Effect.succeed(onReasoningDelta(state, event, event.item_id))
   }
-  if (
-    event.type === "response.reasoning.done" ||
-    event.type === "response.reasoning_summary_text.done" ||
-    event.type === "response.reasoning_summary.done" ||
-    event.type === "response.reasoning_text.done"
-  ) {
+  if (event.type === "response.reasoning.done" || event.type === "response.reasoning_summary_text.done") {
     if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
-    return Effect.succeed(onReasoningDone(state, event, event.item_id))
+    return Effect.succeed(onReasoningDone(state, event))
   }
   if (event.type === "response.reasoning_summary_part.added")
     return event.item_id
@@ -1205,16 +1068,14 @@ export const step = (state: ParserState, event: Event) => {
       return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
     return Effect.succeed(onOutputItemAdded(state, event))
   }
-  if (event.type === "response.function_call_arguments.delta")
-    return event.item_id
-      ? onFunctionCallArgumentsDelta(state, event)
-      : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
+  if (event.type === "response.function_call_arguments.delta") return onFunctionCallArgumentsDelta(state, event)
   if (event.type === "response.output_item.done") {
     if (event.item?.type === "message" && !event.item.id)
       return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
     return onOutputItemDone(state, event)
   }
-  if (event.type === "response.completed" || event.type === "response.incomplete") return onResponseFinish(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 decodeKnownErrorEvent(event).pipe(
@@ -1239,11 +1100,17 @@ export const initial = (request: LLMRequest, extension: Extension = BASE): Parse
   tools: ToolStream.empty<string>(),
   lifecycle: Lifecycle.initial(),
   messageItems: new Set<string>(),
+  messagePhase: (value) => messagePhase(value, extension),
   messagePhases: {},
   reasoningItems: {},
   store: OpenResponsesOptions.resolve(request).store,
 })
 
+const messagePhase = (value: unknown, extension: Extension): MessagePhase | null | undefined => {
+  if (value === "commentary" || value === "final_answer") return value
+  return extension.messagePhase?.(value)
+}
+
 export const protocol = Protocol.make({
   id: ADAPTER,
   body: {

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

@@ -28,7 +28,7 @@ import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { ToolStream } from "./utils/tool-stream.js"
 
 const ADAPTER = "openai-chat"
-const RESERVED_REASONING_FIELDS = new Set(["role", "content", "refusal", "tool_calls"])
+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"
 
@@ -156,9 +156,6 @@ const OpenAIChatUsage = Schema.StructWithRest(
     prompt_tokens: optionalNull(Schema.Number),
     completion_tokens: optionalNull(Schema.Number),
     total_tokens: optionalNull(Schema.Number),
-    // Zai reports cache hits as top-level `cached_tokens`; DeepSeek uses `prompt_cache_hit_tokens`.
-    cached_tokens: optionalNull(Schema.Number),
-    prompt_cache_hit_tokens: optionalNull(Schema.Number),
     prompt_tokens_details: optionalNull(
       Schema.StructWithRest(
         Schema.Struct({
@@ -197,7 +194,6 @@ type OpenAIChatToolCallDelta = Schema.Schema.Type<typeof OpenAIChatToolCallDelta
 const OpenAIChatDelta = Schema.StructWithRest(
   Schema.Struct({
     content: optionalNull(Schema.String),
-    refusal: optionalNull(Schema.String),
     reasoning_content: optionalNull(Schema.String),
     reasoning: optionalNull(Schema.String),
     reasoning_text: optionalNull(Schema.String),
@@ -207,16 +203,11 @@ const OpenAIChatDelta = Schema.StructWithRest(
   [Schema.Record(Schema.String, Schema.Unknown)],
 )
 
-const OpenAIChatChoice = Schema.StructWithRest(
-  Schema.Struct({
-    delta: optionalNull(OpenAIChatDelta),
-    finish_reason: optionalNull(Schema.String),
-    native_finish_reason: optionalNull(Schema.String),
-    // Moonshot streams usage on `choice.usage` instead of top-level `usage`.
-    usage: optionalNull(OpenAIChatUsage),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
+const 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])),
@@ -269,7 +260,7 @@ const lowerTool = (tool: ToolDefinition, inputSchema: JsonSchema, options: Lower
   function: {
     name: tool.name,
     description: tool.description,
-    parameters: inputSchema,
+    parameters: ToolSchemaProjection.openAI(inputSchema),
   },
   cache_control: options.cacheControl?.(tool.cache),
 })
@@ -517,23 +508,11 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
   return messages
 })
 
-// Anthropic via LiteLLM and Amazon Bedrock require `tools` to be present
-// whenever the conversation history contains tool calls/results. Send an
-// explicit empty array when we have history but no active tools.
-const hasToolHistory = (messages: ReadonlyArray<LLMRequest["messages"][number]>) => {
-  for (const message of messages) {
-    if (message.role === "tool") return true
-    if (message.role === "assistant" && message.content.some((part) => part.type === "tool-call")) return true
-  }
-  return false
-}
-
 const lowerOptions = (request: LLMRequest) => {
   const options = OpenAIOptions.resolve(request)
-  const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey)
   return {
     ...(options.store !== undefined ? { store: options.store } : {}),
-    ...(cacheKey ? { prompt_cache_key: cacheKey } : {}),
+    ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
     ...(options.reasoningEffort ? { reasoning_effort: options.reasoningEffort } : {}),
   }
 }
@@ -552,15 +531,12 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   const maxTokensField = request.model.compatibility?.maxTokensField ?? "max_tokens"
-  const hasHistory = hasToolHistory(request.messages)
   return {
     model: request.model.id,
     messages: yield* lowerMessages(request, options),
     tools:
       request.tools.length === 0
-        ? hasHistory
-          ? []
-          : undefined
+        ? undefined
         : request.tools.map((tool) =>
             lowerTool(
               tool,
@@ -604,18 +580,11 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 // total) with a `reasoning_tokens` subset. We pass the inclusive totals
 // through and derive the non-cached breakdown so the `AI.Usage` contract is
 // satisfied on both sides.
-// Providers differ on cache-hit location: OpenAI uses
-// `prompt_tokens_details.cached_tokens`, DeepSeek uses
-// `prompt_cache_hit_tokens`, and Zai uses top-level `cached_tokens`.
 const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
   if (!usage) return undefined
   const input = usage.prompt_tokens ?? undefined
   const output = usage.completion_tokens ?? undefined
-  const cached =
-    (usage.prompt_tokens_details?.cached_tokens ??
-      (usage as { prompt_cache_hit_tokens?: number | null }).prompt_cache_hit_tokens ??
-      (usage as { cached_tokens?: number | null }).cached_tokens ??
-      undefined) as number | undefined
+  const cached = usage.prompt_tokens_details?.cached_tokens ?? undefined
   const cacheWrite = usage.prompt_tokens_details?.cache_write_tokens ?? undefined
   const reasoning = usage.completion_tokens_details?.reasoning_tokens ?? undefined
   const nonCached = ProviderShared.subtractTokens(input, ProviderShared.sumTokens(cached, cacheWrite))
@@ -721,11 +690,8 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
         }),
       })
     const events: LLMEvent[] = []
+    const usage = mapUsage(event.usage) ?? state.usage
     const choice = event.choices?.[0]
-    // Moonshot (and a few other OpenAI-compatible providers) attach usage to
-    // `choice.usage` instead of the top-level `usage` field.
-    const choiceUsage = (choice as unknown as { usage?: OpenAIChatEvent["usage"] })?.usage
-    const usage = mapUsage(event.usage) ?? (choiceUsage ? mapUsage(choiceUsage) : undefined) ?? state.usage
     const rawFinishReason = choice?.finish_reason
     const finishReason =
       rawFinishReason !== undefined && rawFinishReason !== null
@@ -743,7 +709,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     const reasoning = reasoningDelta(delta, state.reasoningField)
     const hasLateContent =
       Boolean(delta?.content) ||
-      Boolean(delta?.refusal) ||
       reasoning !== undefined ||
       (Array.isArray(delta?.reasoning_details) && delta.reasoning_details.length > 0) ||
       toolDeltas.some((tool) => Boolean(tool.id) || Boolean(tool.function?.name) || Boolean(tool.function?.arguments))
@@ -763,7 +728,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     else if (
       reasoningDetailsObserved &&
       !lifecycle.reasoning.has("reasoning-0") &&
-      (Boolean(delta?.content) || Boolean(delta?.refusal) || toolDeltas.length > 0)
+      (Boolean(delta?.content) || toolDeltas.length > 0)
     )
       lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata)
     const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0")
@@ -778,16 +743,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
       lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
     }
 
-    if (delta?.refusal) {
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined),
-      )
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.refusal)
-    }
-
     // Compatible providers may omit indexes. Prefer durable identity, then use
     // batch position for parallel deltas or the latest call for sparse chunks.
     for (const [position, tool] of toolDeltas.entries()) {

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

@@ -110,7 +110,7 @@ export const model = (input: ModelInput) => {
       const multipartImages = yield* Effect.forEach(sourceImages, (image) => {
         if (image.type === "bytes") return Effect.succeed({ data: image.data, mediaType: image.mediaType })
         if (image.type === "url") return ImageInputs.decodeDataUrl(image.url, ADAPTER)
-        return Effect.undefined
+        return Effect.succeed(undefined)
       })
       const multipartMask =
         mask === undefined

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

@@ -4,7 +4,7 @@ import { Effect, Option, Schema } from "effect"
 import * as ProviderShared from "./shared.js"
 import { OpenResponses } from "./open-responses.js"
 
-const PROTOCOL = "open-responses.websocket.v1"
+const PROTOCOL = "openai-responses.websocket.v1"
 const VERSION = 1
 const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)
 
@@ -161,4 +161,4 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
   }
 }
 
-export const OpenResponsesContinuation = { driver } as const
+export const OpenAIResponsesChannel = { driver } as const

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

@@ -5,13 +5,14 @@ import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { HttpTransport } from "../route/transport/index.js"
-import { LLMRequest, type JsonSchema, type ToolDefinition } from "../schema/index.js"
+import { LLMEvent, LLMRequest, type JsonSchema, type ToolDefinition } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { optionalArray, ProviderShared } from "./shared.js"
+import { Lifecycle } from "./utils/lifecycle.js"
 import { OpenAIImage } from "./utils/openai-image.js"
-import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { OpenResponsesChannel } from "./open-responses-channel.js"
+import { OpenAIResponsesChannel } from "./openai-responses-channel.js"
 
 const ADAPTER = "openai-responses"
 const NAME = "OpenAI Responses"
@@ -39,8 +40,18 @@ const OpenAIResponsesToolChoice = Schema.Union([
   Schema.Struct({ type: Schema.tag("image_generation") }),
 ])
 
+const OpenAIResponsesInputItem = Schema.Union([
+  Schema.Struct({
+    role: Schema.tag("assistant"),
+    content: Schema.Array(Schema.Struct({ type: Schema.tag("output_text"), text: Schema.String })),
+    phase: Schema.optionalKey(Schema.NullOr(OpenResponses.MessagePhase)),
+  }),
+  OpenResponses.InputItem,
+])
+
 const OpenAIResponsesCoreFields = {
   ...OpenResponses.coreFields,
+  input: Schema.Array(OpenAIResponsesInputItem),
   tools: optionalArray(OpenAIResponsesTools),
   tool_choice: Schema.optional(OpenAIResponsesToolChoice),
 }
@@ -51,27 +62,18 @@ const OpenAIResponsesBody = Schema.Struct({
 })
 export type OpenAIResponsesBody = Schema.Schema.Type<typeof OpenAIResponsesBody>
 
-// Replayed items are paired with stored server state by id, so a foreign or
-// synthetic token can fail request validation even when `call_id` pairing is
-// intact. Only resend ids in each item kind's own grammar; hosted tool
-// references keep generic validation because every hosted tool mints its own
-// prefix. The same allowlist approach codex uses before resending history
-// (codex-rs core/src/client.rs, `prepare_response_items_for_request`).
-const ITEM_ID_PREFIXES: Record<OpenResponses.ItemKind, ReadonlyArray<string>> = {
-  message: ["msg_"],
-  reasoning: ["rs_"],
-  "function-call": ["fc_"],
-  // Every hosted tool mints its own id prefix, so references keep generic
-  // validation only.
-  reference: [],
-}
-
 const extension = {
   id: ADAPTER,
   name: NAME,
-  acceptsItemID: (kind: OpenResponses.ItemKind, id: string) => {
-    const prefixes = ITEM_ID_PREFIXES[kind]
-    return prefixes.length === 0 || prefixes.some((prefix) => id.startsWith(prefix))
+  messagePhase: (value: unknown) => (value === null ? null : undefined),
+  lowerMedia: ({ part, media, request }) => {
+    if (request.model.provider !== "xai" || media.mime !== "application/pdf") return undefined
+    return {
+      type: "input_file",
+      filename: part.filename ?? "document.pdf",
+      file_data: media.base64,
+      mime_type: media.mime,
+    }
   },
 } satisfies OpenResponses.Extension
 
@@ -124,7 +126,46 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
   } satisfies OpenAIResponsesBody
 })
 
-const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item: ResponsesHostedTools.Item) {
+type HostedToolData = OpenResponses.StreamItem & {
+  readonly id: string
+  readonly status?: string
+  readonly action?: unknown
+  readonly queries?: unknown
+  readonly results?: unknown
+  readonly code?: string
+  readonly container_id?: string
+  readonly outputs?: unknown
+  readonly server_label?: string
+  readonly output?: unknown
+  readonly result?: string
+  readonly output_format?: "png" | "jpeg" | "webp"
+  readonly error?: unknown
+}
+
+const HOSTED_TOOLS = {
+  web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
+  web_search_preview_call: { name: "web_search_preview", input: (item) => item.action ?? {} },
+  file_search_call: { name: "file_search", input: (item) => ({ queries: item.queries ?? [] }) },
+  code_interpreter_call: {
+    name: "code_interpreter",
+    input: (item) => ({ code: item.code, container_id: item.container_id }),
+  },
+  computer_use_call: { name: "computer_use", input: (item) => item.action ?? {} },
+  image_generation_call: { name: "image_generation", input: () => ({}) },
+  mcp_call: {
+    name: "mcp",
+    input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
+  },
+  local_shell_call: { name: "local_shell", input: (item) => item.action ?? {} },
+} as const satisfies Record<string, { readonly name: string; readonly input: (item: HostedToolData) => unknown }>
+
+type HostedToolType = keyof typeof HOSTED_TOOLS
+type HostedToolItem = HostedToolData & { readonly type: HostedToolType }
+
+const isHostedToolItem = (item: OpenResponses.StreamItem): item is HostedToolItem =>
+  item.type in HOSTED_TOOLS && typeof item.id === "string" && item.id.length > 0
+
+const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item: HostedToolItem) {
   const isError = item.error !== undefined && item.error !== null
   if (item.type === "image_generation_call" && item.result) {
     yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(
@@ -145,29 +186,44 @@ const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function*
   return isError ? { type: "error" as const, value: item.error } : { type: "json" as const, value: item }
 })
 
-const HOSTED_TOOLS = {
-  web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
-  web_search_preview_call: { name: "web_search_preview", input: (item) => item.action ?? {} },
-  file_search_call: { name: "file_search", input: (item) => ({ queries: item.queries ?? [] }) },
-  code_interpreter_call: {
-    name: "code_interpreter",
-    input: (item) => ({ code: item.code, container_id: item.container_id }),
-  },
-  computer_call: { name: "computer_use", input: (item) => item.action ?? {} },
-  image_generation_call: { name: "image_generation", input: () => ({}), result: hostedToolResult },
-  mcp_call: {
-    name: "mcp",
-    input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
-  },
-} as const satisfies ResponsesHostedTools.Definitions
+const onHostedToolDone = Effect.fn("OpenAIResponses.onHostedToolDone")(function* (
+  state: OpenResponses.ParserState,
+  item: HostedToolItem,
+) {
+  const tool = HOSTED_TOOLS[item.type]
+  const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id })
+  const events: LLMEvent[] = []
+  const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
+  events.push(
+    LLMEvent.toolCall({
+      id: item.id,
+      name: tool.name,
+      input: tool.input(item),
+      providerExecuted: true,
+      providerMetadata,
+    }),
+    LLMEvent.toolResult({
+      id: item.id,
+      name: tool.name,
+      result: yield* hostedToolResult(item),
+      providerExecuted: true,
+      providerMetadata,
+    }),
+  )
+  return [{ ...state, lifecycle }, events] satisfies OpenResponses.StepResult
+})
 
 const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
   if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")
     return event.item_id
       ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
       : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
-  if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
-    return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
+  if (event.type === "response.reasoning_text.done" || event.type === "response.reasoning_summary.done")
+    return event.item_id
+      ? Effect.succeed(OpenResponses.onReasoningDone(state, event))
+      : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
+  if (event.type === "response.output_item.done" && event.item && isHostedToolItem(event.item))
+    return onHostedToolDone(state, event.item)
   return OpenResponses.step(state, event)
 }
 
@@ -189,12 +245,12 @@ const endpoint = Endpoint.path<OpenAIResponsesBody>(PATH, { baseURL: DEFAULT_BAS
 const auth = Auth.none
 
 export const httpTransport = HttpTransport.sseJson.with<OpenAIResponsesBody>()
-export const channelTransport = OpenResponsesChannel.transport<OpenAIResponsesBody>
-export const transport = channelTransport({
+export const transport = OpenResponsesChannel.transport<OpenAIResponsesBody>({
   id: ADAPTER,
   name: NAME,
   rotateAfterMs: WEBSOCKET_ROTATE_AFTER_MS,
   headers: (headers) => Headers.set(headers, "openai-beta", headers["openai-beta"] ?? WEBSOCKET_PROTOCOL_HEADER),
+  driver: (input) => OpenAIResponsesChannel.driver({ id: ADAPTER, name: NAME, ...input }),
 })
 
 export const route = Route.make({

packages/ai/src/protocols/shared.ts

@@ -24,17 +24,6 @@ export const JsonObject = Schema.Record(Schema.String, Schema.Unknown)
 export const optionalArray = <const S extends Schema.Top>(schema: S) => Schema.optional(Schema.Array(schema))
 export const optionalNull = <const S extends Schema.Top>(schema: S) => Schema.optional(Schema.NullOr(schema))
 
-export const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64
-
-// OpenAI limits `prompt_cache_key` to 64 chars; DeepSeek and Zai inherit the same
-// limit via their OpenAI-compatible APIs. Clamp with unicode-aware slicing.
-export const clampPromptCacheKey = (key: string | undefined): string | undefined => {
-  if (key === undefined) return undefined
-  const chars = Array.from(key)
-  if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH) return key
-  return chars.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH).join("")
-}
-
 /**
  * Streaming tool-call accumulator. Adapters that build a tool call across
  * multiple `tool-input-delta` chunks store the partial JSON input string here
@@ -208,28 +197,19 @@ export const errorText = (error: unknown) => {
 
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty / `[DONE]`
- * keep-alive events so the protocol event schema sees one JSON string per
- * element. The SSE channel emits a
+ * decoder, and drops empty / `[DONE]` keep-alive events so the protocol event
+ * schema sees one JSON string per element. The SSE channel emits a
  * `Retry` control event on its error channel; we drop it here (we don't
  * implement client-driven retries). Decoder failures become provider output
  * errors so the public error channel stays `AIError`.
  */
-export const sseFraming = (
-  bytes: Stream.Stream<Uint8Array, AIError>,
-  events?: ReadonlySet<string>,
-): Stream.Stream<string, AIError> =>
+export const sseFraming = (bytes: Stream.Stream<Uint8Array, AIError>): Stream.Stream<string, AIError> =>
   bytes.pipe(
     Stream.decodeText(),
     Stream.pipeThroughChannel(Sse.decode()),
     Stream.catchTag("Retry", () => Stream.empty),
     Stream.catchTag("SseError", (error) => Stream.fail(eventError("sse", error.message))),
-    Stream.filter(
-      (event) =>
-        (events === undefined || events.has(event.event)) &&
-        event.data.length > 0 &&
-        (event.data !== "[DONE]" || (events !== undefined && event.event !== "message")),
-    ),
+    Stream.filter((event) => event.data.length > 0 && event.data !== "[DONE]"),
     Stream.map((event) => event.data),
   )
 

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

@@ -16,7 +16,7 @@ export const decodeDataUrl = (
   url: string,
   module: string,
 ): Effect.Effect<{ readonly mediaType: string; readonly data: Uint8Array } | undefined, AIError> => {
-  if (!url.startsWith("data:")) return Effect.undefined
+  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(

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

@@ -21,15 +21,9 @@ export const textStart = (state: State, events: LLMEvent[], id: string, provider
   return { ...stepped, text: new Set([...stepped.text, id]) }
 }
 
-export const textDelta = (
-  state: State,
-  events: LLMEvent[],
-  id: string,
-  text: string,
-  providerMetadata?: ProviderMetadata,
-): State => {
+export const textDelta = (state: State, events: LLMEvent[], id: string, text: string): State => {
   const started = textStart(state, events, id)
-  events.push(LLMEvent.textDelta({ id, text, providerMetadata }))
+  events.push(LLMEvent.textDelta({ id, text }))
   return started
 }
 

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

@@ -28,11 +28,7 @@ export const ResponseIncludables = [
 export type ResponseIncludable = (typeof ResponseIncludables)[number] | (string & {})
 
 export const ServiceTiers = ["auto", "default", "flex", "priority"] as const
-export type ServiceTier = (typeof ServiceTiers)[number] | (string & {})
-export const ServiceTier = Schema.declare<ServiceTier>(
-  (value): value is ServiceTier => typeof value === "string",
-  { title: "ServiceTier" },
-)
+export type ServiceTier = (typeof ServiceTiers)[number]
 
 export const Truncations = ["auto", "disabled"] as const
 export type Truncation = (typeof Truncations)[number]
@@ -42,7 +38,7 @@ export const ResponseIncludableSchema = Schema.declare<ResponseIncludable>(
   (value): value is ResponseIncludable => typeof value === "string",
   { title: "ResponseIncludable" },
 )
-export const ServiceTierSchema = ServiceTier
+export const ServiceTierSchema = Schema.Literals(ServiceTiers)
 export const TruncationSchema = Schema.Literals(Truncations)
 
 export const AllowedTools = Schema.Struct({
@@ -51,17 +47,9 @@ export const AllowedTools = Schema.Struct({
 })
 export type AllowedTools = typeof AllowedTools.Type
 
-export const StreamOptions = Schema.Struct({
-  includeObfuscation: Schema.optional(Schema.Boolean),
-})
-
 export const Options = Schema.Struct({
   instructions: Schema.optional(Schema.String),
   store: Schema.optional(Schema.Boolean),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  safetyIdentifier: Schema.optional(Schema.String),
-  streamOptions: Schema.optional(StreamOptions),
-  topLogprobs: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 20 }))),
   reasoningEffort: Schema.optional(ReasoningEffort),
   reasoningSummary: Schema.optional(Schema.Literals(["auto", "concise", "detailed"])),
   include: Schema.optional(Schema.Array(ResponseIncludableSchema)),

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

@@ -9,8 +9,8 @@ export type OpenAITextVerbosity = OpenResponsesOptions.TextVerbosity
 // in lockstep with `openai-node/src/resources/responses/responses.ts`.
 export const OpenAIResponseIncludables = OpenResponsesOptions.ResponseIncludables
 export type OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludable
-export const OpenAIServiceTiers = [...OpenResponsesOptions.ServiceTiers, "scale"] as const
-export type OpenAIServiceTier = (typeof OpenAIServiceTiers)[number] | (string & {})
+export const OpenAIServiceTiers = OpenResponsesOptions.ServiceTiers
+export type OpenAIServiceTier = OpenResponsesOptions.ServiceTier
 
 export const OpenAIReasoningEffort = OpenResponsesOptions.ReasoningEffort
 export const OpenAITextVerbosity = OpenResponsesOptions.TextVerbosity

packages/ai/src/protocols/utils/responses-hosted-tools.ts

@@ -1,70 +0,0 @@
-import { Effect } from "effect"
-import { LLMEvent, type AIError, type ToolResultPart } from "../../schema/index.js"
-import { OpenResponses } from "../open-responses.js"
-import { Lifecycle } from "./lifecycle.js"
-
-export type Item = OpenResponses.StreamItem & {
-  readonly id: string
-  readonly status?: string
-  readonly action?: unknown
-  readonly queries?: unknown
-  readonly results?: unknown
-  readonly code?: string
-  readonly container_id?: string
-  readonly outputs?: unknown
-  readonly server_label?: string
-  readonly output?: unknown
-  readonly result?: string
-  readonly output_format?: "png" | "jpeg" | "webp"
-  readonly error?: unknown
-}
-
-export interface Definition {
-  readonly name: string
-  readonly input: (item: Item) => unknown
-  readonly result?: (item: Item) => Effect.Effect<ToolResultPart["result"], AIError>
-}
-
-export type Definitions = Readonly<Record<string, Definition>>
-
-export const isItem = <Tools extends Definitions>(item: OpenResponses.StreamItem, tools: Tools): item is Item =>
-  item.type in tools && typeof item.id === "string" && item.id.length > 0
-
-export const onDone: (
-  state: OpenResponses.ParserState,
-  item: Item,
-  tools: Definitions,
-) => Effect.Effect<OpenResponses.StepResult, AIError> = Effect.fn("ResponsesHostedTools.onDone")(function* (
-  state,
-  item,
-  tools,
-) {
-  const tool = tools[item.type]
-  if (!tool) return [state, []] satisfies OpenResponses.StepResult
-  const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id })
-  const events: LLMEvent[] = []
-  const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-  events.push(
-    LLMEvent.toolCall({
-      id: item.id,
-      name: tool.name,
-      input: tool.input(item),
-      providerExecuted: true,
-      providerMetadata,
-    }),
-    LLMEvent.toolResult({
-      id: item.id,
-      name: tool.name,
-      result: tool.result
-        ? yield* tool.result(item)
-        : item.error !== undefined && item.error !== null
-          ? { type: "error", value: item.error }
-          : { type: "json", value: item },
-      providerExecuted: true,
-      providerMetadata,
-    }),
-  )
-  return [{ ...state, lifecycle }, events] satisfies OpenResponses.StepResult
-})
-
-export * as ResponsesHostedTools from "./responses-hosted-tools.js"

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

@@ -2,6 +2,20 @@ import type { JsonSchema, LanguageModelToolSchemaCompatibility } from "../../sch
 import { isRecord } from "../../utils/record.js"
 import { GeminiToolSchema } from "./gemini-tool-schema.js"
 
+const removeNullSchemas = (value: unknown): unknown => {
+  if (Array.isArray(value)) return value.map(removeNullSchemas)
+  if (!isRecord(value)) return value
+  const fields = Object.fromEntries(
+    Object.entries(value)
+      .filter(([key]) => key !== "anyOf")
+      .map(([key, field]) => [key, removeNullSchemas(field)]),
+  )
+  if (!Array.isArray(value.anyOf)) return fields
+  const variants = value.anyOf.filter((variant) => !isRecord(variant) || variant.type !== "null").map(removeNullSchemas)
+  if (variants.length === 1 && isRecord(variants[0])) return { ...fields, ...variants[0] }
+  return { ...fields, anyOf: variants }
+}
+
 const tupleItemsSchema = (items: ReadonlyArray<unknown>) => {
   const projected = items.map(moonshotNode)
   if (projected.length === 0) return {}
@@ -31,7 +45,24 @@ const moonshot = (schema: JsonSchema): JsonSchema => {
   return isRecord(projected) ? projected : {}
 }
 
-const openAI = (schema: JsonSchema): JsonSchema => schema
+const openAI = (schema: JsonSchema): JsonSchema => {
+  const variants = Array.isArray(schema.anyOf) ? schema.anyOf.filter(isRecord) : []
+  const flattened =
+    variants.length === 0
+      ? { ...schema, type: "object" }
+      : {
+          ...Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "anyOf")),
+          type: "object",
+          properties: variants.reduce(
+            (properties, variant) => ({ ...(isRecord(variant.properties) ? variant.properties : {}), ...properties }),
+            {},
+          ),
+          additionalProperties: false,
+        }
+  const normalized = removeNullSchemas(flattened)
+  return isRecord(normalized) ? normalized : { type: "object" }
+}
+
 const responses = openAI
 
 const gemini = (schema: JsonSchema): JsonSchema => GeminiToolSchema.convert(schema) ?? {}

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

@@ -1,47 +0,0 @@
-import { Protocol } from "../route/protocol.js"
-import { OpenResponses } from "./open-responses.js"
-import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
-
-const ADAPTER = "xai-responses"
-const NAME = "xAI Responses"
-
-const extension = {
-  id: ADAPTER,
-  name: NAME,
-} satisfies OpenResponses.Extension
-
-const HOSTED_TOOLS = {
-  web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
-  x_search_call: { name: "x_search", input: (item) => item.action ?? {} },
-  file_search_call: { name: "file_search", input: (item) => ({ queries: item.queries ?? [] }) },
-  code_interpreter_call: {
-    name: "code_interpreter",
-    input: (item) => ({ code: item.code, container_id: item.container_id }),
-  },
-  image_generation_call: { name: "image_generation", input: () => ({}) },
-  mcp_call: {
-    name: "mcp",
-    input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
-  },
-} as const satisfies ResponsesHostedTools.Definitions
-
-// Grok speaks the standard Responses reasoning dialect (`reasoning_summary_text.*`,
-// handled by the baseline); only its hosted tool vocabulary differs.
-const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
-  if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
-    return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
-  return OpenResponses.step(state, event)
-}
-
-export const protocol = Protocol.make({
-  id: ADAPTER,
-  body: OpenResponses.protocol.body,
-  stream: {
-    event: OpenResponses.protocol.stream.event,
-    initial: (request) => OpenResponses.initial(request, extension),
-    step,
-    terminal: OpenResponses.terminal,
-  },
-})
-
-export * as XAIResponses from "./xai-responses.js"

packages/ai/src/provider-error.ts

@@ -74,15 +74,11 @@ const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error"
 const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i
 const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded/i
 const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i
-const NETWORK_ERROR_TEXT = /network[-_\s]error/i
 
 export interface ProviderFailure {
   readonly message: string
   readonly status?: number | undefined
   readonly code?: string | undefined
-  // Raw wire payload, scanned for failure signals (codes, overflow phrases)
-  // that the summary message does not carry. Not shown to users.
-  readonly rawBody?: string | undefined
   readonly retryAfterMs?: number | undefined
   readonly rateLimit?: HttpRateLimitDetails | undefined
   readonly http?: HttpContext | undefined
@@ -92,13 +88,11 @@ export interface ProviderFailure {
 // Keep HTTP failures and provider-reported stream failures on one typed path so
 // session retry policy never needs provider-specific string matching.
 export function classifyProviderFailure(input: ProviderFailure): AIError["reason"] {
-  const body = input.http?.body ?? input.rawBody ?? ""
+  const body = input.http?.body ?? ""
   const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message)]
     .filter((code): code is string => code !== undefined)
     .map((code) => code.toLowerCase())
-  // Scan the raw payload too so signals missing from the summary message
-  // (e.g. overflow phrases nested in a JSON error body) still classify.
-  const text = [input.message, body].filter((value) => value.length > 0).join("\n")
+  const text = body || input.message
   const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http }
   const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500)
 
@@ -133,7 +127,6 @@ export function classifyProviderFailure(input: ProviderFailure): AIError["reason
       retryAfterMs: input.retryAfterMs,
       rateLimit: input.rateLimit,
     })
-  if (NETWORK_ERROR_TEXT.test(text)) return new ProviderInternalReason({ ...common, status: input.status })
   if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
     return new ProviderInternalReason({
       ...common,

packages/ai/src/provider-package.ts

@@ -1,16 +1,62 @@
+import { Auth } from "./route/auth.js"
+import type { AuthOverride, RequiredApiKeyAuth } from "./route/auth-options.js"
 import type { LanguageModel, ProviderOptions } from "./schema/index.js"
 
-export interface Settings extends Readonly<Record<string, unknown>> {
-  readonly baseURL?: string
+export interface Settings {}
+
+export type Credential =
+  | {
+      readonly type: "key"
+      readonly value: string
+      readonly configuration?: Readonly<Record<string, unknown>>
+    }
+  | {
+      readonly type: "oauth"
+      readonly accessToken: string
+    }
+
+export interface Defaults {
   readonly headers?: Readonly<Record<string, string>>
   readonly body?: Readonly<Record<string, unknown>>
+  readonly limits?: {
+    readonly context: number
+    readonly input?: number
+    readonly output: number
+  }
 }
 
+export interface ModelInput<ProviderSettings extends Settings = Settings> {
+  readonly id: string
+  readonly settings: ProviderSettings
+  readonly credential?: Credential
+  readonly defaults: Defaults
+}
+
+export const routeDefaults = (input: Defaults) => ({
+  headers: input.headers,
+  http: input.body === undefined ? undefined : { body: input.body },
+  limits: input.limits,
+})
+
+export const bearerCredentialValue = (input: Credential) => (input.type === "key" ? input.value : input.accessToken)
+
+export const bearerAuthOption = (input: Credential): AuthOverride => ({
+  auth: Auth.bearer(bearerCredentialValue(input)),
+})
+
+export const apiKeyOrBearerAuthOption = (
+  input: Credential,
+  competingKeyHeader: string,
+): RequiredApiKeyAuth | AuthOverride =>
+  input.type === "key"
+    ? { apiKey: input.value }
+    : { auth: Auth.remove(competingKeyHeader).andThen(Auth.bearer(input.accessToken)) }
+
 export interface Definition<
   ProviderSettings extends Settings = Settings,
   Options extends ProviderOptions = ProviderOptions,
 > {
-  readonly model: (modelID: string, settings: ProviderSettings) => LanguageModel<Options>
+  readonly model: (input: ModelInput<ProviderSettings>) => LanguageModel<Options>
 }
 
 export * as ProviderPackage from "./provider-package.js"

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

@@ -1,6 +1,6 @@
 import { Auth } from "../route/auth.js"
 import type { Route as RouteDef, RouteDefaultsInput } from "../route/client.js"
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
 import { OpenAIResponses } from "../protocols/openai-responses.js"
 import { BedrockAuth, type Credentials } from "../protocols/utils/bedrock-auth.js"
@@ -79,28 +79,27 @@ export const configure = (input: Config = {}) => {
 
 export const provider = configure()
 
-const config = (settings: Settings): Config => {
-  if (settings.auth === "bearer" && settings.apiKey === undefined)
+const config = (input: ProviderPackage.ModelInput<Settings>): Config => {
+  if (!input.credential && input.settings.auth === "bearer" && input.settings.apiKey === undefined)
     throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey")
-  if (settings.auth === "sigv4" && settings.apiKey !== undefined)
+  if (!input.credential && input.settings.auth === "sigv4" && input.settings.apiKey !== undefined)
     throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey")
   return {
-    apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
-    baseURL: settings.baseURL,
-    credentials: settings.credentials,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-    region: settings.region,
+    ...ProviderPackage.routeDefaults(input.defaults),
+    apiKey: input.credential
+      ? ProviderPackage.bearerCredentialValue(input.credential)
+      : input.settings.auth === "sigv4"
+        ? undefined
+        : input.settings.apiKey,
+    baseURL: input.settings.baseURL,
+    credentials: input.settings.credentials,
+    providerOptions: input.settings.providerOptions,
+    region: input.settings.region,
   }
 }
 
-export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => configure(config(settings)).chat(modelID)
-export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => configure(config(settings)).responses(modelID)
+export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
+  configure(config(input)).chat(input.id)
+export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
+  configure(config(input)).responses(input.id)
 export const model = chatModel

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

@@ -1,6 +1,6 @@
 import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import * as BedrockConverse from "../protocols/bedrock-converse.js"
 import type { BedrockCredentials } from "../protocols/bedrock-converse.js"
@@ -50,18 +50,21 @@ export const configure = (input: Config = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
-  if (settings.auth === "bearer" && settings.apiKey === undefined)
+export const model: ProviderPackage.Definition<Settings>["model"] = (input) => {
+  if (!input.credential && input.settings.auth === "bearer" && input.settings.apiKey === undefined)
     throw new Error("Amazon Bedrock bearer auth requires apiKey")
-  if (settings.auth === "sigv4" && settings.apiKey !== undefined)
+  if (!input.credential && input.settings.auth === "sigv4" && input.settings.apiKey !== undefined)
     throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey")
   return configure({
-    apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
-    baseURL: settings.baseURL,
-    credentials: settings.credentials,
-    generation: settings.topP === undefined ? undefined : { topP: settings.topP },
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    region: settings.region,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    apiKey: input.credential
+      ? ProviderPackage.bearerCredentialValue(input.credential)
+      : input.settings.auth === "sigv4"
+        ? undefined
+        : input.settings.apiKey,
+    baseURL: input.settings.baseURL,
+    credentials: input.settings.credentials,
+    generation: input.settings.topP === undefined ? undefined : { topP: input.settings.topP },
+    region: input.settings.region,
+  }).model(input.id)
 }

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

@@ -1,4 +1,4 @@
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
@@ -32,7 +32,9 @@ export const routes = [AnthropicMessages.route]
 
 const auth = (input: ProviderAuthOption<"optional">) => {
   if ("auth" in input && input.auth) return input.auth
-  return Auth.optional("apiKey" in input ? input.apiKey : undefined, "apiKey").pipe(Auth.header("x-api-key"))
+  return Auth.remove("authorization").andThen(
+    Auth.optional("apiKey" in input ? input.apiKey : undefined, "apiKey").pipe(Auth.header("x-api-key")),
+  )
 }
 
 export const configure = (input: Config) => {
@@ -57,20 +59,20 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => {
-  if (settings.apiKey !== undefined && settings.authToken !== undefined)
+export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (input) => {
+  if (!input.credential && input.settings.apiKey !== undefined && input.settings.authToken !== undefined)
     throw new Error("Anthropic-compatible apiKey cannot be combined with authToken")
   return configure({
-    ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    provider: settings.provider,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    ...(input.credential
+      ? ProviderPackage.apiKeyOrBearerAuthOption(input.credential, "x-api-key")
+      : input.settings.authToken === undefined
+        ? { apiKey: input.settings.apiKey }
+        : { auth: Auth.bearer(input.settings.authToken) }),
+    baseURL: input.settings.baseURL,
+    provider: input.settings.provider,
+    providerOptions: input.settings.providerOptions,
+  }).model(input.id)
 }
 
 export * as AnthropicCompatible from "./anthropic-compatible.js"

packages/ai/src/providers/anthropic.ts

@@ -1,7 +1,7 @@
 import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { AnthropicCompatible } from "./anthropic-compatible.js"
@@ -31,9 +31,11 @@ export type Settings = ProviderPackage.Settings &
 
 const auth = (options: ProviderAuthOption<"optional">) => {
   if ("auth" in options && options.auth) return options.auth
-  return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
-    .orElse(Auth.config("ANTHROPIC_API_KEY"))
-    .pipe(Auth.header("x-api-key"))
+  return Auth.remove("authorization").andThen(
+    Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
+      .orElse(Auth.config("ANTHROPIC_API_KEY"))
+      .pipe(Auth.header("x-api-key")),
+  )
 }
 
 export const configure = (input: Config = {}) => {
@@ -52,17 +54,17 @@ export const configure = (input: Config = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => {
-  if (settings.apiKey !== undefined && settings.authToken !== undefined)
+export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (input) => {
+  if (!input.credential && input.settings.apiKey !== undefined && input.settings.authToken !== undefined)
     throw new Error("Anthropic apiKey cannot be combined with authToken")
   return configure({
-    ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    ...(input.credential
+      ? ProviderPackage.apiKeyOrBearerAuthOption(input.credential, "x-api-key")
+      : input.settings.authToken === undefined
+        ? { apiKey: input.settings.apiKey }
+        : { auth: Auth.bearer(input.settings.authToken) }),
+    baseURL: input.settings.baseURL,
+    providerOptions: input.settings.providerOptions,
+  }).model(input.id)
 }

packages/ai/src/providers/azure.ts

@@ -1,8 +1,7 @@
-import { Headers } from "effect/unstable/http"
 import { Auth } from "../route/auth.js"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
 import type { Route as RouteDef, RouteDefaultsInput } from "../route/client.js"
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import * as OpenAIResponses from "../protocols/openai-responses.js"
@@ -11,7 +10,6 @@ import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-opt
 
 export const id = ProviderID.make("azure")
 const routeAuth = Auth.remove("authorization")
-const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 55 * 60 * 1000
 
 // Azure needs the customer's resource URL; supply either `resourceName`
 // (helper builds the URL) or `baseURL` directly.
@@ -42,30 +40,6 @@ const responsesRoute = OpenAIResponses.route.with({
   id: "azure-openai-responses",
   provider: id,
   auth: routeAuth,
-  transport: OpenAIResponses.channelTransport({
-    id: "azure-openai-responses",
-    name: "Azure OpenAI Responses",
-    rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
-    enabled: (value) => {
-      const url = new URL(value)
-      return (
-        url.protocol === "https:" &&
-        url.hostname.endsWith(".openai.azure.com") &&
-        url.pathname.endsWith("/openai/v1/responses") &&
-        url.searchParams.get("api-version") === "v1"
-      )
-    },
-    url: (value) => {
-      const url = new URL(value)
-      url.searchParams.delete("api-version")
-      return url.toString()
-    },
-    headers: (headers) => {
-      const apiKey = headers["api-key"]
-      if (!apiKey) return headers
-      return Headers.remove(Headers.set(headers, "authorization", `Bearer ${apiKey}`), "api-key")
-    },
-  }),
 })
 
 const chatRoute = OpenAIChat.route.with({
@@ -146,27 +120,29 @@ export const provider = {
   configure,
 }
 
-const config = (settings: Settings): Config => {
+const config = (input: ProviderPackage.ModelInput<Settings>): Config => {
+  const settings = input.settings
+  const configuration = input.credential?.type === "key" ? input.credential.configuration : undefined
+  const baseURL = settings.baseURL ?? (typeof configuration?.baseURL === "string" ? configuration.baseURL : undefined)
+  const resourceName =
+    settings.resourceName ?? (typeof configuration?.resourceName === "string" ? configuration.resourceName : undefined)
   const common = {
-    apiKey: settings.apiKey,
+    ...ProviderPackage.routeDefaults(input.defaults),
+    ...(input.credential
+      ? ProviderPackage.apiKeyOrBearerAuthOption(input.credential, "api-key")
+      : { apiKey: settings.apiKey }),
     apiVersion: settings.apiVersion,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
     providerOptions: settings.providerOptions,
     queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
     useDeploymentBasedUrls: settings.useDeploymentBasedUrls,
   }
-  if (settings.baseURL !== undefined) return { ...common, baseURL: settings.baseURL }
-  if (settings.resourceName !== undefined) return { ...common, resourceName: settings.resourceName }
+  if (baseURL !== undefined) return { ...common, baseURL }
+  if (resourceName !== undefined) return { ...common, resourceName }
   throw new Error("Azure requires resourceName or baseURL")
 }
 
-export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => configure(config(settings)).responses(modelID)
-export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => configure(config(settings)).chat(modelID)
+export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
+  configure(config(input)).responses(input.id)
+export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
+  configure(config(input)).chat(input.id)
 export const model = responsesModel

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

@@ -1,4 +1,4 @@
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
 import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
@@ -68,15 +68,15 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) => {
+  if (input.credential?.type === "key" || (!input.credential && input.settings.apiKey !== undefined))
+    throw new Error("Google Vertex Chat does not support API keys")
   return configure({
-    accessToken: settings.accessToken,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    accessToken: input.credential?.type === "oauth" ? input.credential.accessToken : input.settings.accessToken,
+    baseURL: input.settings.baseURL,
+    location: input.settings.location,
+    project: input.settings.project,
+    providerOptions: input.settings.providerOptions,
+  }).model(input.id)
 }

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

@@ -1,9 +1,10 @@
 import { Effect, Schema, Struct } from "effect"
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
 import { Protocol } from "../route/protocol.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
@@ -13,7 +14,6 @@ export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInp
 export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput
 
 const VERSION = "vertex-2023-10-16" as const
-const HEADER_VERSION = "2023-06-01" as const
 
 export const id = ProviderID.make("google-vertex")
 
@@ -57,8 +57,7 @@ const route = Route.make({
   }),
   endpoint: Endpoint.path(({ request }) => `/${request.model.id}:streamRawPredict`),
   auth: Auth.none,
-  framing: AnthropicMessages.framing,
-  headers: () => ({ "anthropic-version": HEADER_VERSION }),
+  framing: Framing.sse,
 })
 
 export const routes = [route]
@@ -101,18 +100,15 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Messages does not support API keys")
+export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (input) => {
+  if (input.credential?.type === "key" || (!input.credential && input.settings.apiKey !== undefined))
+    throw new Error("Google Vertex Messages does not support API keys")
   return configure({
-    accessToken: settings.accessToken,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    accessToken: input.credential?.type === "oauth" ? input.credential.accessToken : input.settings.accessToken,
+    baseURL: input.settings.baseURL,
+    location: input.settings.location,
+    project: input.settings.project,
+    providerOptions: input.settings.providerOptions,
+  }).model(input.id)
 }

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

@@ -1,4 +1,4 @@
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses.js"
 import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
@@ -70,18 +70,15 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Responses does not support API keys")
+export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (input) => {
+  if (input.credential?.type === "key" || (!input.credential && input.settings.apiKey !== undefined))
+    throw new Error("Google Vertex Responses does not support API keys")
   return configure({
-    accessToken: settings.accessToken,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    accessToken: input.credential?.type === "oauth" ? input.credential.accessToken : input.settings.accessToken,
+    baseURL: input.settings.baseURL,
+    location: input.settings.location,
+    project: input.settings.project,
+    providerOptions: input.settings.providerOptions,
+  }).model(input.id)
 }

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

@@ -69,9 +69,8 @@ const adc = (project?: string) => {
 export const oauth = (input: OAuthOptions, project?: string) => {
   if (input.accessToken !== undefined && input.auth !== undefined)
     throw new Error("Google Vertex accessToken cannot be combined with auth")
-  if (input.auth) return input.auth
-  if (input.accessToken !== undefined) return Auth.bearer(input.accessToken)
-  return adc(project)
+  const auth = input.auth ?? (input.accessToken !== undefined ? Auth.bearer(input.accessToken) : adc(project))
+  return Auth.remove("x-goog-api-key").andThen(auth)
 }
 
 export * as GoogleVertexShared from "./google-vertex-shared.js"

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

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { Gemini } from "../protocols/gemini.js"
 import { ProviderShared } from "../protocols/shared.js"
 import { Auth } from "../route/auth.js"
@@ -38,23 +38,13 @@ export type Settings = ProviderPackage.Settings &
 
 const fromRequest = Effect.fn("GoogleVertex.fromRequest")(function* (request: LLMRequest) {
   const body = yield* Gemini.protocol.body.from(request)
-  // Vertex's native REST schema rejects `id` on FunctionCall/FunctionResponse parts with HTTP 400,
-  // unlike AI Studio, so history minted there cannot be lowered verbatim.
-  const contents = body.contents.map((content) => ({
-    ...content,
-    parts: (content.parts ?? []).map((part) => {
-      if ("functionCall" in part) return { ...part, functionCall: { ...part.functionCall, id: undefined } }
-      if ("functionResponse" in part) return { ...part, functionResponse: { ...part.functionResponse, id: undefined } }
-      return part
-    }),
-  }))
   const value = request.providerOptions?.labels
   const labels = ProviderShared.isRecord(value)
     ? Object.fromEntries(
         Object.entries(value).filter((entry): entry is [string, string] => typeof entry[1] === "string"),
       )
     : undefined
-  return { ...body, contents, labels }
+  return { ...body, labels }
 })
 
 const protocol = {
@@ -104,7 +94,10 @@ const configuredRoute = (input: Config, modelID: string | ModelID) => {
   return route.with({
     ...rest,
     endpoint: { baseURL: endpoint },
-    auth: apiKey === undefined ? GoogleVertexShared.oauth(input, project) : Auth.header("x-goog-api-key", apiKey),
+    auth:
+      apiKey === undefined
+        ? GoogleVertexShared.oauth(input, project)
+        : Auth.remove("authorization").andThen(Auth.header("x-goog-api-key", apiKey)),
   })
 }
 
@@ -121,16 +114,21 @@ export const provider = {
   id,
   configure,
 }
-export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"] = (modelID, settings) => {
-  if (settings.apiKey !== undefined && settings.accessToken !== undefined)
+export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"] = (input) => {
+  if (!input.credential && input.settings.apiKey !== undefined && input.settings.accessToken !== undefined)
     throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth")
   return configure({
-    ...(settings.apiKey === undefined ? { accessToken: settings.accessToken } : { apiKey: settings.apiKey }),
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    location: settings.location,
-    project: settings.project,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    ...(input.credential
+      ? input.credential.type === "key"
+        ? { apiKey: input.credential.value }
+        : { accessToken: input.credential.accessToken }
+      : input.settings.apiKey === undefined
+        ? { accessToken: input.settings.accessToken }
+        : { apiKey: input.settings.apiKey }),
+    baseURL: input.settings.baseURL,
+    location: input.settings.location,
+    project: input.settings.project,
+    providerOptions: input.settings.providerOptions,
+  }).model(input.id)
 }

packages/ai/src/providers/google.ts

@@ -1,7 +1,7 @@
 import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { HttpOptions, ProviderID, mergeHttpOptions, type ModelID } from "../schema/index.js"
 import { Gemini } from "../protocols/gemini.js"
 import { GoogleImages } from "../protocols/google-images.js"
@@ -28,9 +28,11 @@ export interface Settings extends ProviderPackage.Settings {
 
 const auth = (options: ProviderAuthOption<"optional">) => {
   if ("auth" in options && options.auth) return options.auth
-  return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
-    .orElse(Auth.config("GOOGLE_GENERATIVE_AI_API_KEY"))
-    .pipe(Auth.header("x-goog-api-key"))
+  return Auth.remove("authorization").andThen(
+    Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
+      .orElse(Auth.config("GOOGLE_GENERATIVE_AI_API_KEY"))
+      .pipe(Auth.header("x-goog-api-key")),
+  )
 }
 
 const configuredRoute = (input: Config) => {
@@ -57,13 +59,14 @@ export const configure = (input: Config = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (input) =>
   configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    ...(input.credential
+      ? ProviderPackage.apiKeyOrBearerAuthOption(input.credential, "x-goog-api-key")
+      : { apiKey: input.settings.apiKey }),
+    baseURL: input.settings.baseURL,
+    providerOptions: input.settings.providerOptions,
+  }).model(input.id)
 
 export const image = provider.image

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

@@ -1,4 +1,4 @@
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import type { RouteDefaultsInput } from "../route/client.js"
@@ -46,15 +46,11 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
+export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (input) =>
   configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    provider: settings.provider,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    ...(input.credential ? ProviderPackage.bearerAuthOption(input.credential) : { apiKey: input.settings.apiKey }),
+    baseURL: input.settings.baseURL,
+    provider: input.settings.provider,
+    providerOptions: input.settings.providerOptions,
+  }).model(input.id)

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

@@ -2,7 +2,7 @@ import { ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
 import type { RouteDefaultsInput } from "../route/client.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { profiles, type OpenAICompatibleProfile } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
@@ -68,15 +68,14 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
   configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers === undefined ? undefined : { ...settings.headers },
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    provider: settings.provider,
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    ...(input.credential ? ProviderPackage.bearerAuthOption(input.credential) : { apiKey: input.settings.apiKey }),
+    baseURL: input.settings.baseURL,
+    provider: input.settings.provider,
+    providerOptions: input.settings.providerOptions,
+  }).model(input.id)
 
 export const baseten = define(profiles.baseten)
 export const cerebras = define(profiles.cerebras)

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

@@ -1,41 +1,21 @@
 import { mergeProviderOptions, type ProviderOptions } from "../schema/index.js"
-import type { OpenAIServiceTier } from "../protocols/utils/openai-options.js"
+import type { OpenResponsesOptionsInput } from "./open-responses-options.js"
 import type { Options } from "../protocols/utils/open-responses-options.js"
 
 export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options.js"
 
-export type OpenAIOptionsInput = Omit<Options, "serviceTier"> & {
-  readonly serviceTier?: OpenAIServiceTier
-  readonly [key: string]: unknown
-}
+export type OpenAIOptionsInput = OpenResponsesOptionsInput
+export type OpenAIConfigOptions = Options
 
 export type OpenAIProviderOptionsInput = OpenAIOptionsInput
 
-const definedEntries = (input: Record<string, unknown>) =>
-  Object.entries(input).filter((entry) => entry[1] !== undefined)
-
-const openAIProviderOptions = (options: OpenAIOptionsInput | undefined): ProviderOptions | undefined => {
-  const result = Object.fromEntries(
-    definedEntries({
-      store: options?.store,
-      reasoningEffort: options?.reasoningEffort,
-      reasoningSummary: options?.reasoningSummary,
-      include: options?.include,
-      textVerbosity: options?.textVerbosity,
-      serviceTier: options?.serviceTier,
-    }),
-  )
-  if (Object.keys(result).length === 0) return undefined
-  return result
-}
-
 export const gpt5DefaultOptions = (
   modelID: string,
   options: { readonly textVerbosity?: boolean } = {},
 ): ProviderOptions | undefined => {
   const id = modelID.toLowerCase()
   if (!id.includes("gpt-5") || id.includes("gpt-5-chat") || id.includes("gpt-5-pro")) return undefined
-  return openAIProviderOptions({
+  return {
     reasoningEffort: "medium",
     reasoningSummary: "auto",
     // GPT-5 reasoning models are configured stateless (`store: false`) by
@@ -48,14 +28,13 @@ export const gpt5DefaultOptions = (
       options.textVerbosity === true && id.includes("gpt-5.") && !id.includes("codex") && !id.includes("-chat")
         ? "low"
         : undefined,
-  })
+  }
 }
 
 export const openAIDefaultOptions = (
   modelID: string,
   options: { readonly textVerbosity?: boolean } = {},
-): ProviderOptions | undefined =>
-  mergeProviderOptions(openAIProviderOptions({ store: false }), gpt5DefaultOptions(modelID, options))
+): ProviderOptions | undefined => mergeProviderOptions({ store: false }, gpt5DefaultOptions(modelID, options))
 
 export const withOpenAIOptions = <Options extends { readonly providerOptions?: OpenAIProviderOptionsInput }>(
   modelID: string,

packages/ai/src/providers/openai.ts

@@ -1,10 +1,10 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import type { Route, RouteDefaultsInput } from "../route/client.js"
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import * as OpenAIResponses from "../protocols/openai-responses.js"
-import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"
+import { withOpenAIOptions, type OpenAIConfigOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"
 import { OpenAIImages, type OpenAIImageString } from "../protocols/openai-images.js"
 
 export type { OpenAIOptionsInput, OpenAIResponseIncludable } from "./openai-options.js"
@@ -17,11 +17,11 @@ export const routes = [OpenAIResponses.route, OpenAIChat.route]
 // This provider facade wraps the lower-level Responses and Chat model factories
 // with OpenAI-specific conveniences: typed options, API-key sugar, env fallback,
 // and default option normalization.
-export type Config = RouteDefaultsInput &
+export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
+  OpenAIConfigOptions &
   ProviderAuthOption<"optional"> & {
     readonly baseURL?: string
     readonly queryParams?: Record<string, string>
-    readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
 export interface ImageGenerationOptions {
@@ -57,13 +57,12 @@ export const imageGeneration = (options: ImageGenerationOptions = {}) =>
     },
   })
 
-export interface Settings extends ProviderPackage.Settings {
+export interface Settings extends ProviderPackage.Settings, OpenAIConfigOptions {
   readonly apiKey?: string
   readonly baseURL?: string
   readonly organization?: string
   readonly project?: string
   readonly queryParams?: Readonly<Record<string, string>>
-  readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "OPENAI_API_KEY")
@@ -73,6 +72,39 @@ const defaults = (input: Config) => {
   return rest
 }
 
+const splitConfigOptions = <Input extends OpenAIConfigOptions>(input: Input) => {
+  const {
+    instructions,
+    store,
+    reasoningEffort,
+    reasoningSummary,
+    include,
+    textVerbosity,
+    serviceTier,
+    truncation,
+    allowedTools,
+    maxToolCalls,
+    parallelToolCalls,
+    ...rest
+  } = input
+  return {
+    options: {
+      instructions,
+      store,
+      reasoningEffort,
+      reasoningSummary,
+      include,
+      textVerbosity,
+      serviceTier,
+      truncation,
+      allowedTools,
+      maxToolCalls,
+      parallelToolCalls,
+    },
+    rest,
+  }
+}
+
 const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Config) =>
   route.with({
     auth: auth(input),
@@ -82,7 +114,8 @@ const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Co
 export const configure = (input: Config = {}) => {
   const responsesRoute = configuredRoute(OpenAIResponses.route, input)
   const chatRoute = configuredRoute(OpenAIChat.route, input)
-  const modelDefaults = defaults(input)
+  const split = splitConfigOptions(defaults(input))
+  const modelDefaults = { ...split.rest, providerOptions: split.options }
   const responses = (id: string | ModelID) =>
     responsesRoute
       .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
@@ -113,30 +146,30 @@ export const configure = (input: Config = {}) => {
 
 export const provider = configure()
 
-const config = (settings: Settings): Config => {
+const config = (input: ProviderPackage.ModelInput<Settings>): Config => {
+  const settings = input.settings
+  const options = splitConfigOptions(settings).options
   const headers = {
     ...(settings.organization === undefined ? {} : { "OpenAI-Organization": settings.organization }),
     ...(settings.project === undefined ? {} : { "OpenAI-Project": settings.project }),
-    ...settings.headers,
+    ...input.defaults.headers,
   }
   return {
-    apiKey: settings.apiKey,
+    ...ProviderPackage.routeDefaults(input.defaults),
+    ...(input.credential ? ProviderPackage.bearerAuthOption(input.credential) : { apiKey: settings.apiKey }),
     baseURL: settings.baseURL,
     headers: Object.keys(headers).length === 0 ? undefined : headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
     queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
+    ...options,
   }
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
-  return configure(config(settings)).responses(modelID)
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) => {
+  return configure(config(input)).responses(input.id)
 }
 
-export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) => configure(config(settings)).chat(modelID)
+export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
+  configure(config(input)).chat(input.id)
 export const responses = provider.responses
 export const chat = provider.chat
 export const image = provider.image

packages/ai/src/providers/openrouter.ts

@@ -5,11 +5,11 @@ import { Framing } from "../route/framing.js"
 import { Protocol } from "../route/protocol.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { ProviderID, type CacheHint, type ModelID } from "../schema/index.js"
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import { newBreakpoints, ttlBucket } from "../protocols/utils/cache.js"
-import { isRecord, ProviderShared } from "../protocols/shared.js"
+import { isRecord } from "../protocols/shared.js"
 
 export const profile = OpenAICompatibleProfiles.profiles.openrouter
 export const id = ProviderID.make(profile.provider)
@@ -115,12 +115,11 @@ export const protocol = Protocol.make({
               reasoning_details: reasoningDetails,
             }
           })
-          const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey)
           return {
             ...body,
             messages,
             ...bodyOptions(request.providerOptions),
-            ...(cacheKey ? { prompt_cache_key: cacheKey } : {}),
+            ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
           } as OpenRouterBody
         }),
       ),
@@ -192,14 +191,10 @@ export const configure = (input: LanguageModelOptions = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptionsInput>["model"] = (
-  modelID,
-  settings,
-) =>
+export const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptionsInput>["model"] = (input) =>
   configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    ...(input.credential ? ProviderPackage.bearerAuthOption(input.credential) : { apiKey: input.settings.apiKey }),
+    baseURL: input.settings.baseURL,
+    providerOptions: input.settings.providerOptions,
+  }).model(input.id)

packages/ai/src/providers/xai.ts

@@ -5,11 +5,10 @@ import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
-import { OpenResponsesChannel } from "../protocols/open-responses-channel.js"
-import { XAIResponses } from "../protocols/xai-responses.js"
+import * as OpenAIResponses from "../protocols/openai-responses.js"
 import { XAIImages } from "../protocols/xai-images.js"
 import type { OpenAIOptionsInput } from "./openai-options.js"
-import type { ProviderPackage } from "../provider-package.js"
+import { ProviderPackage } from "../provider-package.js"
 
 export const id = ProviderID.make("xai")
 
@@ -29,19 +28,13 @@ export interface Settings extends ProviderPackage.Settings {
 
 export type { XAIImageOptions } from "../protocols/xai-images.js"
 
-const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000
-
 const responsesRoute = Route.make({
   id: "openai-responses",
   provider: id,
   providerMetadataKey: "xai",
-  protocol: XAIResponses.protocol,
+  protocol: OpenAIResponses.protocol,
   endpoint: Endpoint.path("/responses", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
-  transport: OpenResponsesChannel.transport({
-    id: "openai-responses",
-    name: "xAI Responses",
-    rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
-  }),
+  transport: OpenAIResponses.httpTransport,
   defaults: { providerOptions: { store: false } },
 })
 
@@ -102,14 +95,13 @@ export const configure = (input: LanguageModelOptions = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"] = (input) =>
   configure({
-    apiKey: settings.apiKey,
-    baseURL: settings.baseURL,
-    headers: settings.headers,
-    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
-    providerOptions: settings.providerOptions,
-  }).model(modelID)
+    ...ProviderPackage.routeDefaults(input.defaults),
+    ...(input.credential ? ProviderPackage.bearerAuthOption(input.credential) : { apiKey: input.settings.apiKey }),
+    baseURL: input.settings.baseURL,
+    providerOptions: input.settings.providerOptions,
+  }).model(input.id)
 export const responses = provider.responses
 export const chat = provider.chat
 export const image = provider.image

packages/ai/src/route/client.ts

@@ -16,6 +16,7 @@ import {
   LLMRequest,
   LLMResponse,
   LanguageModel,
+  LanguageModelLimits,
   LLMEvent,
   InvalidProviderOutputReason,
   ProviderID,
@@ -73,6 +74,7 @@ export type RouteRoutedLanguageModelInput = Omit<LanguageModel.Input, "route">
 
 export interface RouteDefaults {
   readonly headers?: Record<string, string>
+  readonly limits?: LanguageModelLimits
   readonly generation?: GenerationOptions
   readonly providerOptions?: ProviderOptions
   readonly http?: HttpOptions
@@ -80,6 +82,7 @@ export interface RouteDefaults {
 
 export interface RouteDefaultsInput {
   readonly headers?: Record<string, string>
+  readonly limits?: LanguageModelLimits.Input
   readonly generation?: GenerationOptions.Input
   readonly providerOptions?: ProviderOptions
   readonly http?: HttpOptions.Input
@@ -116,6 +119,7 @@ const mergeRouteDefaults = (base: RouteDefaults | undefined, patch: RouteDefault
     ...base,
     ...patch,
     headers,
+    limits: patch.limits === undefined ? base?.limits : LanguageModelLimits.make(patch.limits),
     generation: mergeGenerationOptions(generationOptions(base?.generation), generationOptions(patch.generation)),
     providerOptions: mergeProviderOptions(base?.providerOptions, patch.providerOptions),
     http: mergeHttpOptions(

packages/ai/src/route/framing.ts

@@ -24,10 +24,4 @@ export interface Definition<Frame> {
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export const sse: Definition<string> = { id: "sse", frame: ProviderShared.sseFraming }
 
-/** SSE framing restricted to protocol-recognized event names. */
-export const sseEvents = (events: ReadonlySet<string>): Definition<string> => ({
-  id: "sse",
-  frame: (bytes) => ProviderShared.sseFraming(bytes, events),
-})
-
 export * as Framing from "./framing.js"

packages/ai/src/schema/errors.ts

@@ -153,9 +153,6 @@ export class AIError extends Schema.TaggedError<AIError>()("AI.Error", {
   module: Schema.String,
   method: Schema.String,
   reason: AIErrorReason,
-  // Raw provider payload as a string, so classified failures never lose the
-  // original error detail even when the pretty message is a summary.
-  body: Schema.optional(Schema.String),
 }) {
   override readonly cause = this.reason
 

packages/ai/src/schema/messages.ts

@@ -51,7 +51,6 @@ export const MediaPart = Schema.Struct({
   mediaType: Schema.String,
   data: Schema.Union([Schema.String, Schema.Uint8Array]),
   filename: Schema.optional(Schema.String),
-  cache: Schema.optional(CacheHint),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 }).annotate({ identifier: "LLM.Content.Media" })
 export type MediaPart = Schema.Schema.Type<typeof MediaPart>
@@ -256,7 +255,6 @@ export namespace ToolDefinition {
 export class ToolChoice extends Schema.Class<ToolChoice>("LLM.ToolChoice")({
   type: Schema.Literals(["auto", "none", "required", "tool"]),
   name: Schema.optional(Schema.String),
-  disableParallelToolUse: Schema.optional(Schema.Boolean),
 }) {}
 
 export namespace ToolChoice {

packages/ai/src/schema/options.ts

@@ -114,7 +114,22 @@ export const mergeGenerationOptions = (...items: ReadonlyArray<GenerationOptions
   return Object.values(result).some((value) => value !== undefined) ? result : undefined
 }
 
+export class LanguageModelLimits extends Schema.Class<LanguageModelLimits>("LLM.LanguageModelLimits")({
+  context: Schema.optional(Schema.Number),
+  input: Schema.optional(Schema.Number),
+  output: Schema.optional(Schema.Number),
+}) {}
+
+export namespace LanguageModelLimits {
+  export type Input = LanguageModelLimits | ConstructorParameters<typeof LanguageModelLimits>[0]
+
+  /** Normalize model limit input into the canonical `LanguageModelLimits` class. */
+  export const make = (input: Input | undefined) =>
+    input instanceof LanguageModelLimits ? input : new LanguageModelLimits(input ?? {})
+}
+
 export class LanguageModelDefaults extends Schema.Class<LanguageModelDefaults>("LLM.LanguageModelDefaults")({
+  limits: Schema.optional(LanguageModelLimits),
   generation: Schema.optional(GenerationOptions),
   providerOptions: Schema.optional(ProviderOptions),
   http: Schema.optional(HttpOptions),
@@ -124,6 +139,7 @@ export namespace LanguageModelDefaults {
   export type Input =
     | LanguageModelDefaults
     | {
+        readonly limits?: LanguageModelLimits.Input
         readonly generation?: GenerationOptions.Input
         readonly providerOptions?: ProviderOptions
         readonly http?: HttpOptions.Input
@@ -133,6 +149,7 @@ export namespace LanguageModelDefaults {
   export const make = (input: Input) => {
     if (input instanceof LanguageModelDefaults) return input
     return new LanguageModelDefaults({
+      limits: input.limits === undefined ? undefined : LanguageModelLimits.make(input.limits),
       generation: input.generation === undefined ? undefined : GenerationOptions.make(input.generation),
       providerOptions: input.providerOptions,
       http: input.http === undefined ? undefined : HttpOptions.make(input.http),

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

@@ -81,8 +81,22 @@ OpenAI.configure({
 }).responses("gpt-4.1-mini")
 OpenAI.configure({
   generation: { maxTokens: 100 },
-  providerOptions: { store: false },
+  store: false,
 }).responses("gpt-4.1-mini")
+OpenAI.model({
+  id: "gpt-5",
+  settings: {},
+  credential: { type: "key", value: "sk-test" },
+  defaults: { headers: { "x-test": "value" } },
+})
+OpenAI.model({
+  id: "gpt-5",
+  settings: {
+    // @ts-expect-error Common request defaults belong under input.defaults.
+    headers: { "x-test": "value" },
+  },
+  defaults: {},
+})
 
 // @ts-expect-error OpenAI model selectors only accept model ids.
 OpenAI.configure({ apiKey: "sk-test" }).responses("gpt-4.1-mini", {})
@@ -97,7 +111,7 @@ OpenAI.configure({ bogus: true })
 OpenAI.configure({ generation: { maxTokens: "many" } })
 
 // @ts-expect-error provider-native options remain typed.
-OpenAI.configure({ providerOptions: { store: "false" } })
+OpenAI.configure({ 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") })
@@ -145,8 +159,12 @@ Anthropic.configure({
 }).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" })
+Anthropic.model({
+  id: "claude-sonnet-4-6",
+  // @ts-expect-error Anthropic package settings accept only one auth source.
+  settings: { apiKey: "anthropic-key", authToken: "anthropic-token" },
+  defaults: {},
+})
 // @ts-expect-error Enabled Anthropic thinking requires a token budget.
 Anthropic.configure({ providerOptions: { thinking: { type: "enabled" } } })
 // @ts-expect-error Anthropic thinking budgets must be numbers.
@@ -162,11 +180,15 @@ AnthropicCompatible.configure({
 AnthropicCompatible.configure({ apiKey: "messages-key" })
 // @ts-expect-error Anthropic-compatible model selectors only accept model ids.
 AnthropicCompatible.configure({ baseURL: "https://messages.example.com/v1" }).model("compatible-model", {})
-// @ts-expect-error Anthropic-compatible package settings accept only one auth source.
-AnthropicCompatible.model("compatible-model", {
-  apiKey: "messages-key",
-  authToken: "messages-token",
-  baseURL: "https://messages.example.com/v1",
+AnthropicCompatible.model({
+  id: "compatible-model",
+  // @ts-expect-error Anthropic-compatible package settings accept only one auth source.
+  settings: {
+    apiKey: "messages-key",
+    authToken: "messages-token",
+    baseURL: "https://messages.example.com/v1",
+  },
+  defaults: {},
 })
 
 Google.configure({ apiKey: "google-key" }).model("gemini-2.5-flash")
@@ -189,15 +211,23 @@ GoogleVertex.configure({ auth: Auth.bearer("vertex-token"), project: "project" }
 GoogleVertex.configure({ apiKey: "vertex-key" }).model("gemini-3.5-flash", {})
 // @ts-expect-error Vertex Gemini config accepts only one auth source.
 GoogleVertex.configure({ accessToken: "vertex-token", apiKey: "vertex-key", project: "project" })
-// @ts-expect-error Vertex Gemini package settings accept only one auth source.
-GoogleVertex.model("gemini-3.5-flash", { accessToken: "vertex-token", apiKey: "vertex-key", project: "project" })
+GoogleVertex.model({
+  id: "gemini-3.5-flash",
+  // @ts-expect-error Vertex Gemini package settings accept only one auth source.
+  settings: { accessToken: "vertex-token", apiKey: "vertex-key", project: "project" },
+  defaults: {},
+})
 
 GoogleVertexChat.configure({ accessToken: "vertex-token", project: "project" }).model("deepseek-ai/deepseek-v3.2-maas")
 GoogleVertexChat.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model(
   "deepseek-ai/deepseek-v3.2-maas",
 )
-// @ts-expect-error Vertex Chat package settings do not accept API keys.
-GoogleVertexChat.model("deepseek-ai/deepseek-v3.2-maas", { apiKey: "vertex-key", project: "project" })
+GoogleVertexChat.model({
+  id: "deepseek-ai/deepseek-v3.2-maas",
+  // @ts-expect-error Vertex Chat package settings do not accept API keys.
+  settings: { apiKey: "vertex-key", project: "project" },
+  defaults: {},
+})
 GoogleVertexChat.configure({ accessToken: "vertex-token", project: "project" }).model(
   "deepseek-ai/deepseek-v3.2-maas",
   // @ts-expect-error Vertex Chat model selectors only accept model ids.
@@ -214,8 +244,12 @@ GoogleVertexResponses.configure({ accessToken: "vertex-token", project: "project
 GoogleVertexResponses.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model(
   "xai/grok-4.20-reasoning",
 )
-// @ts-expect-error Vertex Responses package settings do not accept API keys.
-GoogleVertexResponses.model("xai/grok-4.20-reasoning", { apiKey: "vertex-key", project: "project" })
+GoogleVertexResponses.model({
+  id: "xai/grok-4.20-reasoning",
+  // @ts-expect-error Vertex Responses package settings do not accept API keys.
+  settings: { apiKey: "vertex-key", project: "project" },
+  defaults: {},
+})
 GoogleVertexResponses.configure({ accessToken: "vertex-token", project: "project" }).model(
   "xai/grok-4.20-reasoning",
   // @ts-expect-error Vertex Responses model selectors only accept model ids.
@@ -233,8 +267,12 @@ GoogleVertexMessages.configure({
   project: "project",
   providerOptions: { thinking: { type: "adaptive", display: "omitted" }, effort: "low" },
 }).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.model({
+  id: "claude-sonnet-4-6",
+  // @ts-expect-error Vertex Messages package settings do not accept API keys.
+  settings: { apiKey: "vertex-key", project: "project" },
+  defaults: {},
+})
 GoogleVertexMessages.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model("claude-sonnet-4-6")
 GoogleVertexMessages.configure({ accessToken: "vertex-token", project: "project" }).model(
   "claude-sonnet-4-6",

packages/ai/test/compile.test.ts

@@ -270,20 +270,21 @@ describe("request option precedence", () => {
     ),
   )
 
-  it.effect("uses the Anthropic default before call maxTokens", () =>
+  it.effect("uses model output limits after route limits and before call maxTokens", () =>
     Effect.gen(function* () {
       const route = AnthropicMessages.route.with({
         endpoint: { baseURL: "https://api.anthropic.test/v1/" },
         auth: Auth.header("x-api-key", "test"),
+        limits: { output: 128 },
       })
-      const model = route.model({ id: "claude-sonnet-4-5" })
+      const model = route.model({ id: "claude-sonnet-4-5", defaults: { limits: { output: 64 } } })
       const withoutMaxTokens = yield* compileRequest(LLM.request({ model, prompt: "Say hello.", cache: "none" }))
       const withMaxTokens = yield* compileRequest(
-        LLM.request({ model, prompt: "Say hello.", cache: "none", generation: { maxTokens: 8_000 } }),
+        LLM.request({ model, prompt: "Say hello.", cache: "none", generation: { maxTokens: 32 } }),
       )
 
-      expect(withoutMaxTokens.body.max_tokens).toBe(32_000)
-      expect(withMaxTokens.body.max_tokens).toBe(8_000)
+      expect(withoutMaxTokens.body.max_tokens).toBe(64)
+      expect(withMaxTokens.body.max_tokens).toBe(32)
     }),
   )
 })

packages/ai/test/fixtures/recordings/azure/chat-streams-text.json

@@ -1,31 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:azure",
-      "provider:azure"
-    ],
-    "name": "azure/chat-streams-text",
-    "recordedAt": "2026-08-23T17:21:53.198Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://aiden-azury-group.openai.azure.com/openai/v1/chat/completions?api-version=v1",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"gpt-5.6-luna\",\"messages\":[{\"role\":\"user\",\"content\":\"Reply with exactly one word: hello\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"store\":false,\"reasoning_effort\":\"medium\"}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "data: {\"choices\":[],\"created\":0,\"id\":\"\",\"model\":\"\",\"object\":\"\",\"prompt_filter_results\":[{\"prompt_index\":0,\"content_filter_results\":{}}]}\n\ndata: {\"choices\":[{\"content_filter_results\":{},\"delta\":{\"content\":\"\",\"refusal\":null,\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0,\"logprobs\":null}],\"created\":1787505712,\"id\":\"chatcmpl-EG6BEiYSfrcTSI2WX8PqNzERZDcPc\",\"model\":\"gpt-5.6-luna-2026-07-09\",\"obfuscation\":\"Mxr\",\"object\":\"chat.completion.chunk\",\"service_tier\":\"default\",\"system_fingerprint\":null,\"usage\":null}\n\ndata: {\"choices\":[{\"content_filter_results\":{},\"delta\":{\"content\":\"hello\"},\"finish_reason\":null,\"index\":0,\"logprobs\":null}],\"created\":1787505712,\"id\":\"chatcmpl-EG6BEiYSfrcTSI2WX8PqNzERZDcPc\",\"model\":\"gpt-5.6-luna-2026-07-09\",\"obfuscation\":\"\",\"object\":\"chat.completion.chunk\",\"service_tier\":\"default\",\"system_fingerprint\":null,\"usage\":null}\n\ndata: {\"choices\":[{\"content_filter_results\":{},\"delta\":{},\"finish_reason\":\"stop\",\"index\":0,\"logprobs\":null}],\"created\":1787505712,\"id\":\"chatcmpl-EG6BEiYSfrcTSI2WX8PqNzERZDcPc\",\"model\":\"gpt-5.6-luna-2026-07-09\",\"obfuscation\":\"WyZa5AY1CaCeFdS\",\"object\":\"chat.completion.chunk\",\"service_tier\":\"default\",\"system_fingerprint\":null,\"usage\":null}\n\ndata: {\"choices\":[],\"created\":1787505712,\"id\":\"chatcmpl-EG6BEiYSfrcTSI2WX8PqNzERZDcPc\",\"latency_checkpoint\":{\"engine_tbt_ms\":20,\"engine_ttft_ms\":106,\"engine_ttlt_ms\":206,\"pre_inference_ms\":89,\"service_tbt_ms\":20,\"service_ttft_ms\":480,\"service_ttlt_ms\":576,\"total_duration_ms\":491,\"user_visible_ttft_ms\":391},\"model\":\"gpt-5.6-luna-2026-07-09\",\"obfuscation\":\"6\",\"object\":\"chat.completion.chunk\",\"service_tier\":\"default\",\"system_fingerprint\":null,\"usage\":{\"completion_tokens\":5,\"completion_tokens_details\":{\"accepted_prediction_tokens\":0,\"audio_tokens\":0,\"reasoning_tokens\":0,\"rejected_prediction_tokens\":0},\"prompt_tokens\":13,\"prompt_tokens_details\":{\"audio_tokens\":0,\"cache_write_tokens\":0,\"cached_tokens\":0},\"total_tokens\":18}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/google-vertex/calls-a-tool.json

@@ -1,32 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:google-vertex",
-      "provider:google-vertex",
-      "protocol:gemini"
-    ],
-    "name": "google-vertex/calls-a-tool",
-    "recordedAt": "2026-08-23T17:21:51.036Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://aiplatform.googleapis.com/v1/publishers/google/models/gemini-3.5-flash:streamGenerateContent?alt=sse",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"What is the weather in Paris? Use the lookup_weather tool.\"}]}],\"tools\":[{\"functionDeclarations\":[{\"name\":\"lookup_weather\",\"description\":\"Look up the current weather for a city\",\"parameters\":{\"required\":[\"city\"],\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}}}}]}]}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"functionCall\": {\"name\": \"lookup_weather\",\"args\": {\"city\": \"Paris\"},\"id\": \"call_425130\"},\"thoughtSignature\": \"AY89a1+1fXnLgYhHMuN3Ak6LBhT6PcrYOW7iPav4LfsacvG/Z6l1yJ+AsU7vWhFj/JyPIbsJJQ+GjohM9sCIZ6nqUOIg3reo/7osmrCvFrVHedTHQcwiPzoz2Kp3gb+uWjFAXxk1EX4IRAKcu0ox1W/Z9PpuZvHkTerGO2a82e02N6MAF1YhhtbXFvSdqLRih2Os68rdOk5/Bcld7ol8qUgeyIZ3CtI3OJ5jwRcD8LjvK33A7ZFzH5Bxp/peUmXvqnu5iNhnGBxZaJy/vupCtxRZxjaS+ojG0/UhyrnRiKIpbzQ0FBkxePPn8GCX/LOe2y3GUc98co8lN8OOuCd9ZmEdx5AjHmQkPO9fAV9SxG6Bda6SDWVL8o/Uz3WSQYoUEfAdoajEWIBvcisoeCJjb7zgmRRZ9VQSPl3RXj5LFRvX8jn0YKV1CahYbc24jA==\"}]}}],\"usageMetadata\": {\"trafficType\": \"ON_DEMAND\"},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:50.308576Z\",\"responseId\": \"LiyLauDqErCErb8Pj8aWkAs\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"\"}]},\"finishReason\": \"STOP\"}],\"usageMetadata\": {\"promptTokenCount\": 39,\"candidatesTokenCount\": 16,\"totalTokenCount\": 102,\"trafficType\": \"ON_DEMAND\",\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 39}],\"candidatesTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 16}],\"thoughtsTokenCount\": 47},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:50.308576Z\",\"responseId\": \"LiyLauDqErCErb8Pj8aWkAs\"}\r\n\r\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/google-vertex/continues-after-a-tool-result.json

@@ -1,32 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:google-vertex",
-      "provider:google-vertex",
-      "protocol:gemini"
-    ],
-    "name": "google-vertex/continues-after-a-tool-result",
-    "recordedAt": "2026-08-23T17:21:51.853Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://aiplatform.googleapis.com/v1/publishers/google/models/gemini-3.5-flash:streamGenerateContent?alt=sse",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"What is the weather in Paris?\"}]},{\"role\":\"model\",\"parts\":[{\"functionCall\":{\"name\":\"lookup_weather\",\"args\":{\"city\":\"Paris\"}},\"thoughtSignature\":\"skip_thought_signature_validator\"}]},{\"role\":\"user\",\"parts\":[{\"functionResponse\":{\"name\":\"lookup_weather\",\"response\":{\"name\":\"lookup_weather\",\"content\":\"18C, light rain\"}}}]}],\"tools\":[{\"functionDeclarations\":[{\"name\":\"lookup_weather\",\"description\":\"Look up the current weather for a city\",\"parameters\":{\"required\":[\"city\"],\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}}}}]}]}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"The weather in Paris is currently 18°C with light rain.\"}]}}],\"usageMetadata\": {\"trafficType\": \"ON_DEMAND\"},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:51.220919Z\",\"responseId\": \"LyyLave9DbWnrb8P1IjLmQQ\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"\",\"thoughtSignature\": \"AY89a197c+fpHJftPtcufnqMAyoRQKVEQK+KeG+RVHVx2wKil3L4jP4YWvfVbcuOFr2jio4Kre/hCrDANAoMFSvaZrdaPeo1b5bXQSmJKMH03yM5M6q6ME6JiBvXym143U4exIde4UbOh2tMeyXMvB3aWxcavIHd78g5G5QPLreo6A3LO5871cYYVeRwteY+/zbEdqfaAq1hlk6WYpWkNljYpjMyKwr15YC8rFLh3HYayS9tTN++GGrk/reZn6C3OEPlzPou/pXRATzcEAGVl/TW\"}]},\"finishReason\": \"STOP\"}],\"usageMetadata\": {\"promptTokenCount\": 59,\"candidatesTokenCount\": 15,\"totalTokenCount\": 98,\"trafficType\": \"ON_DEMAND\",\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 59}],\"candidatesTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 15}],\"thoughtsTokenCount\": 24},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:51.220919Z\",\"responseId\": \"LyyLave9DbWnrb8P1IjLmQQ\"}\r\n\r\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/google-vertex/streams-text.json

@@ -1,32 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:google-vertex",
-      "provider:google-vertex",
-      "protocol:gemini"
-    ],
-    "name": "google-vertex/streams-text",
-    "recordedAt": "2026-08-23T17:21:50.112Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://aiplatform.googleapis.com/v1/publishers/google/models/gemini-3.5-flash:streamGenerateContent?alt=sse",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"Reply with exactly one word: hello\"}]}]}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"Hello\"}]}}],\"usageMetadata\": {\"trafficType\": \"ON_DEMAND\"},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:48.528714Z\",\"responseId\": \"LCyLasqiIO6crb8P1sDboQc\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"\",\"thoughtSignature\": \"AY89a1+BGsRqlGpfT0psLB4jeTkT5rDV2HFOlrRuF7aVxDOjqNVUku6t4azeSnxpd+msHWuwXj4RS+7gmVlzVs+JNi8uj+iZWTBCi71vSh9kdK9ed/sHv9J7uL9ZWSOcgbhX/hxdXaUp5yVbQzHFXPjR9A/IkEkHV8VKarDZVFE1T1uASia74lkmyBeZZz+DQmRsLwbUHzFUKlF3qnk/SliLo21ZgASd7itlALQ0PBLJZwgeI3g7tDscDSE18hnB11Fky8q7MLd3HY16zbDvHBEMb18pmmPelPI01KdrCIwMSou/01/u5jiSUCc3pFksZawUj3tAHocHSC3ZKAQQQuUXGe5tm61C2E40/NANBeePc1S4HYE6Yo/vtX6tE02LDky5IQWX09H6+DZ7fpopP5nCUfcKPHa3hVjYquWYYMtZgXO4ZpxfVd3lt1VUDuJNN3BMMCZapjBoJZFPXPJ5t/yg9Rnd791+msGH77b4wztz1vtsPrT9oV9g6SDo9ZUH6BaOcbK7fw8FaXcGw+55malEwQy6zpRLGecooBu70p6RwhaAUyKIMX49y+F2hkNxQxDeBUNckJnu6n4w+KLyjP+bR0gqPJbGjVfteHm+QujqjJdBBT/m1u9kPo1nIbzdEs/PIADBdbuV7TkD/HoRFKpLnNmM2no8ioTtFEjKBDz4ippGi15r8pGgA6wIb/1HAvOGh+PVERdGcbelVTgfONwBqjQ7B1wmEizCfyYuMIskfwjxDGayfKlpDxrnNeogtEct9u5/DjEKlURlg9MtmW1B9P8BXYJ+7SCiRJWwW6bzB+5C+MLCnETl/mljDizoJMHK8DKIhI4oxBsrWXEuoHFwEwGIeOZq0BofH2Jz/l6+KIboV/zd581Kk0zPg/rlI6acfjUEtXtbF+t0+jzoJN7006x4i2tqXeJZ+4e5yisSArEsfJ0YzNWoJtBHG9V9/euDcEP3+jsr98efaQaQbLMPvT/Hb7CYQ7ChhGfcGxQ=\"}]},\"finishReason\": \"STOP\"}],\"usageMetadata\": {\"promptTokenCount\": 7,\"candidatesTokenCount\": 1,\"totalTokenCount\": 150,\"trafficType\": \"ON_DEMAND\",\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 7}],\"candidatesTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 1}],\"thoughtsTokenCount\": 142},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:48.528714Z\",\"responseId\": \"LCyLasqiIO6crb8P1sDboQc\"}\r\n\r\n"
-      }
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/openai-responses-websocket/continues-a-tool-call-over-one-socket.json

@@ -1,100 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "openai",
-    "protocol": "openai-responses",
-    "transport": "websocket",
-    "model": "gpt-5.5",
-    "tags": [
-      "prefix:openai-responses-websocket",
-      "provider:openai",
-      "protocol:openai-responses",
-      "transport:websocket",
-      "tool",
-      "continuation"
-    ],
-    "name": "openai-responses-websocket/continues-a-tool-call-over-one-socket",
-    "recordedAt": "2026-08-20T00:00:00.000Z"
-  },
-  "interactions": [
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 0,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Call get_weather once, then reply exactly: Paris is sunny.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":50,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_tool_1\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"function_call\",\"id\":\"fc_ws_weather\",\"call_id\":\"call_ws_weather\",\"name\":\"get_weather\",\"arguments\":\"\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.function_call_arguments.delta\",\"item_id\":\"fc_ws_weather\",\"delta\":\"{\\\"city\\\":\\\"Paris\\\"}\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"function_call\",\"id\":\"fc_ws_weather\",\"call_id\":\"call_ws_weather\",\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_tool_1\"}}"
-        },
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"function_call_output\",\"call_id\":\"call_ws_weather\",\"output\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":50,\"previous_response_id\":\"resp_ws_tool_1\",\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_tool_2\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_tool_2\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_tool_2\",\"delta\":\"Paris is sunny.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_tool_2\",\"text\":\"Paris is sunny.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_tool_2\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Paris is sunny.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_tool_2\"}}"
-        }
-      ]
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/openai-responses-websocket/reconstructs-full-context-after-reconnect.json

@@ -1,119 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "openai",
-    "protocol": "openai-responses",
-    "transport": "websocket",
-    "model": "gpt-5.5",
-    "tags": [
-      "prefix:openai-responses-websocket",
-      "provider:openai",
-      "protocol:openai-responses",
-      "transport:websocket",
-      "reconnect",
-      "full-context"
-    ],
-    "name": "openai-responses-websocket/reconstructs-full-context-after-reconnect",
-    "recordedAt": "2026-08-20T00:00:00.000Z"
-  },
-  "interactions": [
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 0,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Alpha.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_reconnect_1\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_1\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_reconnect_1\",\"delta\":\"Alpha.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_reconnect_1\",\"text\":\"Alpha.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Alpha.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_reconnect_1\"}}"
-        }
-      ]
-    },
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 1,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Alpha.\"}]},{\"type\":\"message\",\"id\":\"msg_ws_reconnect_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Alpha.\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Beta.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_reconnect_2\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_2\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_reconnect_2\",\"delta\":\"Beta.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_reconnect_2\",\"text\":\"Beta.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_2\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Beta.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_reconnect_2\"}}"
-        }
-      ]
-    }
-  ]
-}

packages/ai/test/fixtures/recordings/openai-responses-websocket/recovers-from-explicit-continuation-rejection.json

@@ -1,129 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "openai",
-    "protocol": "openai-responses",
-    "transport": "websocket",
-    "model": "gpt-5.5",
-    "tags": [
-      "prefix:openai-responses-websocket",
-      "provider:openai",
-      "protocol:openai-responses",
-      "transport:websocket",
-      "continuation",
-      "recovery"
-    ],
-    "name": "openai-responses-websocket/recovers-from-explicit-continuation-rejection",
-    "recordedAt": "2026-08-20T00:00:00.000Z"
-  },
-  "interactions": [
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 0,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Ready.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_rejection_1\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_1\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_rejection_1\",\"delta\":\"Ready.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_rejection_1\",\"text\":\"Ready.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Ready.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_rejection_1\"}}"
-        }
-      ]
-    },
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 1,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Recovered.\"}]}],\"store\":false,\"max_output_tokens\":30,\"previous_response_id\":\"resp_ws_rejection_1\",\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"error\",\"error\":{\"code\":\"previous_response_not_found\",\"message\":\"Previous response not found\"}}"
-        },
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Ready.\"}]},{\"type\":\"message\",\"id\":\"msg_ws_rejection_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Ready.\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Recovered.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_rejection_2\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_2\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_rejection_2\",\"delta\":\"Recovered.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_rejection_2\",\"text\":\"Recovered.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_2\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Recovered.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_rejection_2\"}}"
-        }
-      ]
-    }
-  ]
-}

packages/ai/test/lib/sse.ts

@@ -10,9 +10,6 @@ export const sseEvents = (...chunks: ReadonlyArray<unknown>): string =>
 
 const formatChunk = (chunk: unknown) => `data: ${typeof chunk === "string" ? chunk : JSON.stringify(chunk)}\n\n`
 
-export const sseNamedEvent = (event: string, data: unknown): string =>
-  `event: ${event}\ndata: ${typeof data === "string" ? data : JSON.stringify(data)}`
-
 /**
  * Build an SSE body from already-serialized strings (used when the chunk shape
  * itself is part of what's being tested, e.g. malformed chunks).

packages/ai/test/llm.test.ts

@@ -121,6 +121,7 @@ describe("llm constructors", () => {
     const model = chatRoute.model({
       id: "kimi-k2",
       defaults: {
+        limits: { context: 128_000, output: 8_192 },
         generation: { maxTokens: 1_024, stop: ["END"] },
         providerOptions: { parallelToolCalls: false },
         http: { body: { extra_body: true } },
@@ -129,6 +130,7 @@ describe("llm constructors", () => {
     })
     const request = LLM.request({ model, prompt: "Say hello." })
 
+    expect(request.model.defaults?.limits).toEqual({ context: 128_000, output: 8_192 })
     expect(request.model.defaults?.generation).toEqual({ maxTokens: 1_024, stop: ["END"] })
     expect(request.model.defaults?.providerOptions).toEqual({ parallelToolCalls: false })
     expect(request.model.defaults?.http).toEqual({ body: { extra_body: true } })

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

@@ -82,14 +82,6 @@ describe("provider error classification", () => {
     ])
   })
 
-  test("classifies network error text as provider internal", () => {
-    expect(
-      ["network error", "network-error", "network_error"].map(
-        (message) => classifyProviderFailure({ message })._tag,
-      ),
-    ).toEqual(["ProviderInternal", "ProviderInternal", "ProviderInternal"])
-  })
-
   test("classifies nested provider codes when a top-level code is also present", () => {
     expect(
       [
@@ -106,20 +98,3 @@ describe("provider error classification", () => {
     expect(classifyProviderFailure({ message: "not-json" })._tag).toBe("UnknownProvider")
   })
 })
-
-describe("provider error rawBody classification", () => {
-  test("classifies overflow signals buried in the raw payload when the summary is vague", () => {
-    const reason = classifyProviderFailure({
-      message: "Request failed",
-      rawBody: '{"error":{"message":"This model\'s maximum context length is 40960 tokens"}}',
-    })
-    expect(reason._tag).toBe("InvalidRequest")
-    expect(reason).toMatchObject({ classification: "context-overflow" })
-  })
-
-  test("extracts nested codes from the raw payload", () => {
-    expect(
-      classifyProviderFailure({ message: "Request failed", rawBody: '{"error":{"code":"insufficient_quota"}}' })._tag,
-    ).toBe("QuotaExceeded")
-  })
-})

packages/ai/test/provider-options/google-vertex-chat.types.ts

@@ -4,4 +4,10 @@ import { GoogleVertexChat } from "../../src/providers.js"
 const model = GoogleVertexChat.configure({ accessToken: "test", project: "project" }).model("gemini")
 
 LLM.request({ model, prompt: "Hello", providerOptions: { serviceTier: "priority" } })
-LLM.request({ model, prompt: "Hello", providerOptions: { serviceTier: "future-tier" } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Vertex OpenAI-compatible service tiers use the OpenAI union.
+  providerOptions: { serviceTier: "premium" },
+})

packages/ai/test/provider-options/openai.types.ts

@@ -8,8 +8,6 @@ LLM.request({ model: selected, prompt: "Hello", providerOptions: { reasoningEffo
 LLM.request({ model: selected, prompt: "Hello", providerOptions: { reasoningEffort: "experimental" } })
 LLM.request({ model: selected, prompt: "Hello", providerOptions: { textVerbosity: "low" } })
 LLM.request({ model: selected, prompt: "Hello", providerOptions: { textVerbosity: "verbose" } })
-LLM.request({ model: selected, prompt: "Hello", providerOptions: { serviceTier: "scale" } })
-LLM.request({ model: selected, prompt: "Hello", providerOptions: { serviceTier: "future-tier" } })
 LLM.request({ model: chat, prompt: "Hello", providerOptions: { reasoningEffort: "max" } })
 LLM.request({ model: chat, prompt: "Hello", providerOptions: { reasoningEffort: "experimental" } })
 

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

@@ -1,6 +1,72 @@
 import { describe, expect, test } from "bun:test"
+import { ConfigProvider, Effect } from "effect"
+import { Headers } from "effect/unstable/http"
+import { LLM, ProviderPackage } from "@opencode-ai/ai"
 import { model } from "@opencode-ai/ai/providers/openai"
 
+const packageInput = <Input extends Record<string, unknown>>(id: string, input: Input) => {
+  const { headers, body, limits, ...settings } = input
+  return { id, settings, defaults: { headers, body, limits } }
+}
+
+const authHeaders = (
+  selected: ReturnType<typeof model>,
+  headers: Record<string, string> = {},
+  env: Record<string, string> = {},
+) =>
+  Effect.runPromise(
+    selected.route.auth
+      .apply({
+        request: LLM.request({ model: selected, prompt: "hello" }),
+        method: "POST",
+        url: "https://example.test/v1",
+        body: "{}",
+        headers: Headers.fromInput(headers),
+      })
+      .pipe(Effect.provide(ConfigProvider.layer(ConfigProvider.fromEnv({ env })))),
+  )
+
+const applyAuth = (
+  option: ReturnType<typeof ProviderPackage.bearerAuthOption>,
+  headers: Record<string, string> = {},
+) => {
+  const selected = model(packageInput("gpt-5", { apiKey: "fixture" }))
+  return Effect.runPromise(
+    option.auth.apply({
+      request: LLM.request({ model: selected, prompt: "hello" }),
+      method: "POST",
+      url: "https://example.test/v1",
+      body: "{}",
+      headers: Headers.fromInput(headers),
+    }),
+  )
+}
+
+describe("provider package credential lowering", () => {
+  test("intentionally renders keys and OAuth credentials as bearer auth", async () => {
+    const key = await applyAuth(ProviderPackage.bearerAuthOption({ type: "key", value: "provider-key" }))
+    const oauth = await applyAuth(ProviderPackage.bearerAuthOption({ type: "oauth", accessToken: "provider-token" }))
+
+    expect(key.authorization).toBe("Bearer provider-key")
+    expect(oauth.authorization).toBe("Bearer provider-token")
+  })
+
+  test("keeps key-header credentials configurable and removes stale keys for OAuth", async () => {
+    expect(ProviderPackage.apiKeyOrBearerAuthOption({ type: "key", value: "provider-key" }, "x-api-key")).toEqual({
+      apiKey: "provider-key",
+    })
+    const oauth = ProviderPackage.apiKeyOrBearerAuthOption(
+      { type: "oauth", accessToken: "provider-token" },
+      "x-api-key",
+    )
+    if (!("auth" in oauth)) throw new Error("Expected OAuth credential to lower to auth")
+    const headers = await applyAuth(oauth, { "x-api-key": "stale" })
+
+    expect(headers.authorization).toBe("Bearer provider-token")
+    expect(headers["x-api-key"]).toBeUndefined()
+  })
+})
+
 describe("provider package entrypoints", () => {
   test("semantic API aliases expose the same contract", async () => {
     const modules = await Promise.all([
@@ -43,49 +109,177 @@ describe("provider package entrypoints", () => {
       baseURL: "https://provider.example.test/v1",
       headers: { "x-application": "opencode" },
       body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
     }
-    const openrouter = OpenRouter.model("anthropic/claude-sonnet-4", {
-      ...settings,
-      providerOptions: { usage: true },
-    })
-    const xai = XAI.model("grok-4", {
-      ...settings,
-      providerOptions: { reasoningEffort: "high" },
-    })
+    const openrouter = OpenRouter.model(
+      packageInput("anthropic/claude-sonnet-4", {
+        ...settings,
+        providerOptions: { usage: true },
+      }),
+    )
+    const xai = XAI.model(
+      packageInput("grok-4", {
+        ...settings,
+        providerOptions: { reasoningEffort: "high" },
+      }),
+    )
 
     for (const selected of [openrouter, xai]) {
       expect(selected.route.endpoint.baseURL).toBe(settings.baseURL)
       expect(selected.route.defaults.headers).toEqual(settings.headers)
       expect(selected.route.defaults.http?.body).toEqual(settings.body)
+      expect(selected.route.defaults.limits).toEqual(settings.limits)
     }
     expect(openrouter.route.defaults.providerOptions).toEqual({ usage: true })
     expect(xai.route.defaults.providerOptions).toMatchObject({ reasoningEffort: "high", store: false })
   })
 
   test("maps package settings onto the executable model", () => {
-    const selected = model("gpt-5", {
-      apiKey: "fixture",
-      baseURL: "https://api.openai.test/v1",
-      headers: { "x-application": "opencode" },
-      body: { service_tier: "priority" },
-      unrelatedInheritedSetting: true,
-    })
+    const selected = model(
+      packageInput("gpt-5", {
+        apiKey: "fixture",
+        baseURL: "https://api.openai.test/v1",
+        headers: { "x-application": "opencode" },
+        body: { service_tier: "priority" },
+        limits: { context: 200_000, output: 64_000 },
+        reasoningEffort: "high",
+        unrelatedInheritedSetting: true,
+      }),
+    )
 
     expect(selected.route.id).toBe("openai-responses")
     expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
     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({
+      store: false,
+      reasoningEffort: "high",
+      reasoningSummary: "auto",
+      include: ["reasoning.encrypted_content"],
+    })
+  })
+
+  test("lets provider packages interpret resolved credentials", async () => {
+    const Anthropic = await import("@opencode-ai/ai/providers/anthropic")
+    const Azure = await import("@opencode-ai/ai/providers/azure")
+    const Google = await import("@opencode-ai/ai/providers/google")
+    const GoogleVertex = await import("@opencode-ai/ai/providers/google-vertex")
+    const GoogleVertexChat = await import("@opencode-ai/ai/providers/google-vertex/chat")
+    const openai = model({
+      id: "gpt-5",
+      settings: {},
+      credential: { type: "oauth", accessToken: "openai-token" },
+      defaults: {},
+    })
+    const anthropicKey = Anthropic.model({
+      id: "claude-sonnet-4-6",
+      settings: {},
+      credential: { type: "key", value: "anthropic-key" },
+      defaults: {},
+    })
+    const anthropicOAuth = Anthropic.model({
+      id: "claude-sonnet-4-6",
+      settings: {},
+      credential: { type: "oauth", accessToken: "anthropic-token" },
+      defaults: {},
+    })
+    const anthropicEmptyKey = Anthropic.model({
+      id: "claude-sonnet-4-6",
+      settings: {},
+      credential: { type: "key", value: "" },
+      defaults: {},
+    })
+    const azureKey = Azure.model({
+      id: "deployment",
+      settings: { resourceName: "opencode-test" },
+      credential: { type: "key", value: "azure-key" },
+      defaults: {},
+    })
+    const azureOAuth = Azure.model({
+      id: "deployment",
+      settings: { resourceName: "opencode-test" },
+      credential: { type: "oauth", accessToken: "azure-token" },
+      defaults: {},
+    })
+    const googleKey = Google.model({
+      id: "gemini-2.5-flash",
+      settings: {},
+      credential: { type: "key", value: "google-key" },
+      defaults: {},
+    })
+    const googleOAuth = Google.model({
+      id: "gemini-2.5-flash",
+      settings: {},
+      credential: { type: "oauth", accessToken: "google-token" },
+      defaults: {},
+    })
+    const vertexKey = GoogleVertex.model({
+      id: "gemini-3.5-flash",
+      settings: {},
+      credential: { type: "key", value: "vertex-key" },
+      defaults: {},
+    })
+    const vertexOAuth = GoogleVertex.model({
+      id: "gemini-3.5-flash",
+      settings: { project: "vertex-project" },
+      credential: { type: "oauth", accessToken: "vertex-token" },
+      defaults: {},
+    })
+    const vertexChatOAuth = GoogleVertexChat.model({
+      id: "deepseek-ai/deepseek-v3.2-maas",
+      settings: { apiKey: "configured-key", project: "vertex-project" },
+      credential: { type: "oauth", accessToken: "vertex-chat-token" },
+      defaults: {},
+    })
+
+    expect((await authHeaders(openai)).authorization).toBe("Bearer openai-token")
+    const anthropicKeyHeaders = await authHeaders(anthropicKey, { authorization: "Bearer stale" })
+    const anthropicOAuthHeaders = await authHeaders(anthropicOAuth, { "x-api-key": "stale" })
+    const anthropicEmptyKeyHeaders = await authHeaders(
+      anthropicEmptyKey,
+      { authorization: "Bearer stale" },
+      { ANTHROPIC_API_KEY: "environment-key" },
+    )
+    const azureKeyHeaders = await authHeaders(azureKey, { authorization: "Bearer stale" })
+    const azureOAuthHeaders = await authHeaders(azureOAuth, { "api-key": "stale" })
+    const googleKeyHeaders = await authHeaders(googleKey, { authorization: "Bearer stale" })
+    const googleOAuthHeaders = await authHeaders(googleOAuth, { "x-goog-api-key": "stale" })
+    const vertexKeyHeaders = await authHeaders(vertexKey, { authorization: "Bearer stale" })
+    const vertexOAuthHeaders = await authHeaders(vertexOAuth, { "x-goog-api-key": "stale" })
+    expect(anthropicKeyHeaders["x-api-key"]).toBe("anthropic-key")
+    expect(anthropicKeyHeaders.authorization).toBeUndefined()
+    expect(anthropicOAuthHeaders.authorization).toBe("Bearer anthropic-token")
+    expect(anthropicOAuthHeaders["x-api-key"]).toBeUndefined()
+    expect(anthropicEmptyKeyHeaders["x-api-key"]).toBe("environment-key")
+    expect(anthropicEmptyKeyHeaders.authorization).toBeUndefined()
+    expect(azureKeyHeaders["api-key"]).toBe("azure-key")
+    expect(azureKeyHeaders.authorization).toBeUndefined()
+    expect(azureOAuthHeaders.authorization).toBe("Bearer azure-token")
+    expect(azureOAuthHeaders["api-key"]).toBeUndefined()
+    expect(googleKeyHeaders["x-goog-api-key"]).toBe("google-key")
+    expect(googleKeyHeaders.authorization).toBeUndefined()
+    expect(googleOAuthHeaders.authorization).toBe("Bearer google-token")
+    expect(googleOAuthHeaders["x-goog-api-key"]).toBeUndefined()
+    expect(vertexKeyHeaders["x-goog-api-key"]).toBe("vertex-key")
+    expect(vertexKeyHeaders.authorization).toBeUndefined()
+    expect(vertexOAuthHeaders.authorization).toBe("Bearer vertex-token")
+    expect(vertexOAuthHeaders["x-goog-api-key"]).toBeUndefined()
+    expect((await authHeaders(vertexChatOAuth)).authorization).toBe("Bearer vertex-chat-token")
   })
 
   test("maps OpenAI-compatible Responses settings onto the executable model", async () => {
     const OpenAICompatibleResponses = await import("@opencode-ai/ai/providers/openai-compatible/responses")
-    const selected = OpenAICompatibleResponses.model("custom-model", {
-      apiKey: "fixture",
-      baseURL: "https://responses.example.test/v1",
-      provider: "example",
-      headers: { "x-application": "opencode" },
-      body: { service_tier: "priority" },
-      providerOptions: { reasoningEffort: "low", store: true },
-    })
+    const selected = OpenAICompatibleResponses.model(
+      packageInput("custom-model", {
+        apiKey: "fixture",
+        baseURL: "https://responses.example.test/v1",
+        provider: "example",
+        headers: { "x-application": "opencode" },
+        body: { service_tier: "priority" },
+        limits: { context: 200_000, output: 64_000 },
+        providerOptions: { reasoningEffort: "low", store: true },
+      }),
+    )
 
     expect(String(selected.provider)).toBe("example")
     expect(selected.route.id).toBe("openai-compatible-responses")
@@ -95,19 +289,23 @@ describe("provider package entrypoints", () => {
     })
     expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
     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({ reasoningEffort: "low", store: true })
   })
 
   test("maps Anthropic-compatible settings onto the executable model", async () => {
     const AnthropicCompatible = await import("@opencode-ai/ai/providers/anthropic-compatible")
-    const selected = AnthropicCompatible.model("compatible-model", {
-      apiKey: "fixture",
-      baseURL: "https://messages.example.test/v1",
-      provider: "example",
-      headers: { "x-application": "opencode" },
-      body: { metadata: { user_id: "user_1" } },
-      providerOptions: { effort: "low" },
-    })
+    const selected = AnthropicCompatible.model(
+      packageInput("compatible-model", {
+        apiKey: "fixture",
+        baseURL: "https://messages.example.test/v1",
+        provider: "example",
+        headers: { "x-application": "opencode" },
+        body: { metadata: { user_id: "user_1" } },
+        limits: { context: 200_000, output: 64_000 },
+        providerOptions: { effort: "low" },
+      }),
+    )
 
     expect(String(selected.provider)).toBe("example")
     expect(selected.route.id).toBe("anthropic-messages")
@@ -117,15 +315,18 @@ 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({ 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: { thinking: { type: "adaptive" } },
-    })
+    const selected = Anthropic.model(
+      packageInput("claude-sonnet-4-6", {
+        apiKey: "fixture",
+        providerOptions: { thinking: { type: "adaptive" } },
+      }),
+    )
 
     expect(selected.route.defaults.providerOptions).toEqual({ thinking: { type: "adaptive" } })
   })
@@ -133,7 +334,7 @@ describe("provider package entrypoints", () => {
   test("requires an Anthropic-compatible base URL at runtime", async () => {
     const AnthropicCompatible = await import("@opencode-ai/ai/providers/anthropic-compatible")
     expect(() =>
-      Reflect.apply(AnthropicCompatible.model, undefined, ["compatible-model", { apiKey: "fixture" }]),
+      Reflect.apply(AnthropicCompatible.model, undefined, [packageInput("compatible-model", { apiKey: "fixture" })]),
     ).toThrow("Anthropic-compatible providers require a baseURL")
   })
 
@@ -142,25 +343,28 @@ describe("provider package entrypoints", () => {
     const AnthropicCompatible = await import("@opencode-ai/ai/providers/anthropic-compatible")
     expect(() =>
       Reflect.apply(AnthropicCompatible.model, undefined, [
-        "compatible-model",
-        {
+        packageInput("compatible-model", {
           apiKey: "fixture",
           authToken: "token",
           baseURL: "https://messages.example.test/v1",
-        },
+        }),
       ]),
     ).toThrow("Anthropic-compatible apiKey cannot be combined with authToken")
     expect(() =>
-      Reflect.apply(Anthropic.model, undefined, ["claude-sonnet-4-6", { apiKey: "fixture", authToken: "token" }]),
+      Reflect.apply(Anthropic.model, undefined, [
+        packageInput("claude-sonnet-4-6", { apiKey: "fixture", authToken: "token" }),
+      ]),
     ).toThrow("Anthropic apiKey cannot be combined with authToken")
   })
 
   test("maps legacy OpenAI organization and project settings to headers", () => {
-    const selected = model("gpt-5", {
-      apiKey: "fixture",
-      organization: "org_123",
-      project: "proj_123",
-    })
+    const selected = model(
+      packageInput("gpt-5", {
+        apiKey: "fixture",
+        organization: "org_123",
+        project: "proj_123",
+      }),
+    )
 
     expect(selected.route.defaults.headers).toMatchObject({
       "OpenAI-Organization": "org_123",
@@ -177,31 +381,37 @@ describe("provider package entrypoints", () => {
       resourceName: "opencode-test",
       headers: { "x-application": "opencode" },
       body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
     }
 
-    const responses = AzureResponses.model("deployment", settings)
-    const chat = AzureChat.model("deployment", settings)
+    const responses = AzureResponses.model(packageInput("deployment", settings))
+    const chat = AzureChat.model(packageInput("deployment", settings))
 
-    expect(Azure.model("deployment", settings).route.id).toBe("azure-openai-responses")
+    expect(Azure.model(packageInput("deployment", settings)).route.id).toBe("azure-openai-responses")
     expect(responses.route.id).toBe("azure-openai-responses")
     expect(responses.route.endpoint.baseURL).toBe("https://opencode-test.openai.azure.com/openai/v1")
     expect(responses.route.defaults.headers).toEqual({ "x-application": "opencode" })
     expect(responses.route.defaults.http?.body).toEqual({ service_tier: "priority" })
+    expect(responses.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
     expect(chat.route.id).toBe("azure-openai-chat")
   })
 
   test("constructs Azure deployment URLs and preserves custom gateway URLs", async () => {
     const Azure = await import("@opencode-ai/ai/providers/azure")
-    const deployment = Azure.model("custom-deployment", {
-      apiKey: "fixture",
-      resourceName: "opencode-test",
-      apiVersion: "2025-01-01-preview",
-      useDeploymentBasedUrls: true,
-    })
-    const gateway = Azure.model("gateway-model", {
-      apiKey: "fixture",
-      baseURL: "https://gateway.example/azure/",
-    })
+    const deployment = Azure.model(
+      packageInput("custom-deployment", {
+        apiKey: "fixture",
+        resourceName: "opencode-test",
+        apiVersion: "2025-01-01-preview",
+        useDeploymentBasedUrls: true,
+      }),
+    )
+    const gateway = Azure.model(
+      packageInput("gateway-model", {
+        apiKey: "fixture",
+        baseURL: "https://gateway.example/azure/",
+      }),
+    )
 
     expect(deployment.route.endpoint).toMatchObject({
       baseURL: "https://opencode-test.openai.azure.com/openai/deployments/custom-deployment",
@@ -213,18 +423,22 @@ describe("provider package entrypoints", () => {
 
   test("maps Google package settings onto the Gemini model", async () => {
     const Google = await import("@opencode-ai/ai/providers/google")
-    const selected = Google.model("gemini-2.5-flash", {
-      apiKey: "fixture",
-      baseURL: "https://generativelanguage.test/v1beta",
-      headers: { "x-application": "opencode" },
-      body: { safetySettings: [] },
-      providerOptions: { thinkingConfig: { thinkingBudget: 1_024 } },
-    })
+    const selected = Google.model(
+      packageInput("gemini-2.5-flash", {
+        apiKey: "fixture",
+        baseURL: "https://generativelanguage.test/v1beta",
+        headers: { "x-application": "opencode" },
+        body: { safetySettings: [] },
+        limits: { context: 1_000_000, output: 65_536 },
+        providerOptions: { thinkingConfig: { thinkingBudget: 1_024 } },
+      }),
+    )
 
     expect(selected.route.id).toBe("gemini")
     expect(selected.route.endpoint.baseURL).toBe("https://generativelanguage.test/v1beta")
     expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
     expect(selected.route.defaults.http?.body).toEqual({ safetySettings: [] })
+    expect(selected.route.defaults.limits).toEqual({ context: 1_000_000, output: 65_536 })
     expect(selected.route.defaults.providerOptions).toEqual({ thinkingConfig: { thinkingBudget: 1_024 } })
   })
 
@@ -234,26 +448,35 @@ describe("provider package entrypoints", () => {
     const GoogleVertexChat = await import("@opencode-ai/ai/providers/google-vertex/chat")
     const GoogleVertexResponses = await import("@opencode-ai/ai/providers/google-vertex/responses")
     const GoogleVertexMessages = await import("@opencode-ai/ai/providers/google-vertex/messages")
-    const gemini = GoogleVertex.model("gemini-3.5-flash", {
-      apiKey: "fixture",
-      headers: { "x-application": "opencode" },
-      body: { safetySettings: [] },
-    })
-    const messages = GoogleVertexMessages.model("claude-sonnet-4-6", {
-      accessToken: "fixture",
-      location: "global",
-      project: "vertex-project",
-    })
-    const chat = GoogleVertexChat.model("deepseek-ai/deepseek-v3.2-maas", {
-      accessToken: "fixture",
-      location: "global",
-      project: "vertex-project",
-    })
-    const responses = GoogleVertexResponses.model("xai/grok-4.20-reasoning", {
-      accessToken: "fixture",
-      location: "global",
-      project: "vertex-project",
-    })
+    const gemini = GoogleVertex.model(
+      packageInput("gemini-3.5-flash", {
+        apiKey: "fixture",
+        headers: { "x-application": "opencode" },
+        body: { safetySettings: [] },
+        limits: { context: 1_000_000, output: 65_536 },
+      }),
+    )
+    const messages = GoogleVertexMessages.model(
+      packageInput("claude-sonnet-4-6", {
+        accessToken: "fixture",
+        location: "global",
+        project: "vertex-project",
+      }),
+    )
+    const chat = GoogleVertexChat.model(
+      packageInput("deepseek-ai/deepseek-v3.2-maas", {
+        accessToken: "fixture",
+        location: "global",
+        project: "vertex-project",
+      }),
+    )
+    const responses = GoogleVertexResponses.model(
+      packageInput("xai/grok-4.20-reasoning", {
+        accessToken: "fixture",
+        location: "global",
+        project: "vertex-project",
+      }),
+    )
 
     expect(GoogleVertexGemini.model).toBe(GoogleVertex.model)
     expect(gemini.route.id).toBe("google-vertex-gemini")
@@ -261,12 +484,15 @@ describe("provider package entrypoints", () => {
     expect(gemini.route.endpoint.baseURL).toBe("https://aiplatform.googleapis.com/v1/publishers/google")
     expect(gemini.route.defaults.headers).toEqual({ "x-application": "opencode" })
     expect(gemini.route.defaults.http?.body).toEqual({ safetySettings: [] })
+    expect(gemini.route.defaults.limits).toEqual({ context: 1_000_000, output: 65_536 })
     expect(
-      GoogleVertex.model("gemini-3.5-flash", {
-        accessToken: "fixture",
-        location: "eu",
-        project: "vertex-project",
-      }).route.endpoint.baseURL,
+      GoogleVertex.model(
+        packageInput("gemini-3.5-flash", {
+          accessToken: "fixture",
+          location: "eu",
+          project: "vertex-project",
+        }),
+      ).route.endpoint.baseURL,
     ).toBe("https://aiplatform.eu.rep.googleapis.com/v1beta1/projects/vertex-project/locations/eu/publishers/google")
     expect(messages.route.id).toBe("google-vertex-messages")
     expect(messages.route.protocol).toBe("anthropic-messages")
@@ -296,8 +522,11 @@ describe("provider package entrypoints", () => {
     const Providers = await import("@opencode-ai/ai/providers")
     expect(() =>
       Reflect.apply(GoogleVertex.model, undefined, [
-        "gemini-3.5-flash",
-        { accessToken: "token", apiKey: "fixture", project: "vertex-project" },
+        packageInput("gemini-3.5-flash", {
+          accessToken: "token",
+          apiKey: "fixture",
+          project: "vertex-project",
+        }),
       ]),
     ).toThrow("Google Vertex apiKey cannot be combined with accessToken or auth")
     const configured = Reflect.apply(GoogleVertex.configure, undefined, [
@@ -306,8 +535,7 @@ describe("provider package entrypoints", () => {
     expect(() => configured.model("gemini-3.5-flash")).toThrow("Google Vertex accessToken cannot be combined with auth")
     expect(() =>
       Reflect.apply(GoogleVertexMessages.model, undefined, [
-        "claude-sonnet-4-6",
-        { apiKey: "fixture", project: "vertex-project" },
+        packageInput("claude-sonnet-4-6", { apiKey: "fixture", project: "vertex-project" }),
       ]),
     ).toThrow("Google Vertex Messages does not support API keys")
     expect(() =>
@@ -317,8 +545,7 @@ describe("provider package entrypoints", () => {
     ).toThrow("Google Vertex Messages does not support API keys")
     expect(() =>
       Reflect.apply(GoogleVertexChat.model, undefined, [
-        "deepseek-ai/deepseek-v3.2-maas",
-        { apiKey: "fixture", project: "vertex-project" },
+        packageInput("deepseek-ai/deepseek-v3.2-maas", { apiKey: "fixture", project: "vertex-project" }),
       ]),
     ).toThrow("Google Vertex Chat does not support API keys")
     expect(() =>
@@ -328,8 +555,7 @@ describe("provider package entrypoints", () => {
     ).toThrow("Google Vertex Chat does not support API keys")
     expect(() =>
       Reflect.apply(GoogleVertexResponses.model, undefined, [
-        "xai/grok-4.20-reasoning",
-        { apiKey: "fixture", project: "vertex-project" },
+        packageInput("xai/grok-4.20-reasoning", { apiKey: "fixture", project: "vertex-project" }),
       ]),
     ).toThrow("Google Vertex Responses does not support API keys")
     expect(() =>

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

@@ -8,7 +8,7 @@ import * as AnthropicMessages from "../../src/protocols/anthropic-messages.js"
 import { continuationRequest, nativeAnthropicMessagesContinuation } from "../continuation-scenarios.js"
 import { it } from "../lib/effect.js"
 import { dynamicResponse, fixedResponse } from "../lib/http.js"
-import { sseEvents, sseNamedEvent, sseRaw } from "../lib/sse.js"
+import { sseEvents } from "../lib/sse.js"
 
 const model = AnthropicMessages.route
   .with({ endpoint: { baseURL: "https://api.anthropic.test/v1/" }, auth: Auth.header("x-api-key", "test") })
@@ -322,34 +322,11 @@ describe("Anthropic Messages route", () => {
           { role: "user", content: [{ type: "tool_result", tool_use_id: "call_1", content: '{"forecast":"sunny"}' }] },
         ],
         stream: true,
-        max_tokens: 32_000,
+        max_tokens: 4096,
       })
     }),
   )
 
-  it.effect("scrubs outbound tool call IDs without truncating them", () =>
-    Effect.gen(function* () {
-      const id = `functions.lookup:1|${"x".repeat(64)}`
-      const scrubbed = `functions_lookup_1_${"x".repeat(64)}`
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id, name: "lookup", input: {} })]),
-            Message.tool({ id, name: "lookup", result: "done" }),
-          ],
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.messages).toMatchObject([
-        { role: "assistant", content: [{ type: "tool_use", id: scrubbed, name: "lookup", input: {} }] },
-        { role: "user", content: [{ type: "tool_result", tool_use_id: scrubbed }] },
-      ])
-      expect(scrubbed.length).toBeGreaterThan(64)
-    }),
-  )
-
   it.effect("batches parallel tool results into one Anthropic user message", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -663,60 +640,7 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("ignores unknown named SSE events", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseRaw(
-              sseNamedEvent("message_start", {
-                type: "message_start",
-                message: { usage: { input_tokens: 5 } },
-              }),
-              sseNamedEvent("proxy.stats", "not json"),
-              sseNamedEvent("content_block_start", {
-                type: "content_block_start",
-                index: 0,
-                content_block: { type: "text", text: "" },
-              }),
-              sseNamedEvent("content_block_delta", {
-                type: "content_block_delta",
-                index: 0,
-                delta: { type: "text_delta", text: "Hello" },
-              }),
-              sseNamedEvent("content_block_stop", { type: "content_block_stop", index: 0 }),
-              sseNamedEvent("message_delta", {
-                type: "message_delta",
-                delta: { stop_reason: "end_turn" },
-                usage: { output_tokens: 1 },
-              }),
-              sseNamedEvent("message_stop", { type: "message_stop" }),
-              sseNamedEvent("proxy.done", "still not json"),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([{ type: "text", text: "Hello" }])
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: "end_turn" })
-    }),
-  )
-
-  it.effect("rejects malformed recognized SSE events", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(fixedResponse(sseRaw(sseNamedEvent("message_start", "[DONE]")))),
-        Effect.flip,
-      )
-
-      expect(error.reason).toMatchObject({
-        _tag: "InvalidProviderOutput",
-        message: "Invalid anthropic/anthropic-messages stream event",
-      })
-    }),
-  )
-
-  it.effect("maps nullable input tokens and preserves unknown Anthropic usage fields", () =>
+  it.effect("maps thinking tokens and preserves unknown Anthropic usage fields", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(request).pipe(
         Effect.provide(
@@ -739,7 +663,6 @@ describe("Anthropic Messages route", () => {
                 type: "message_delta",
                 delta: { stop_reason: "end_turn" },
                 usage: {
-                  input_tokens: null,
                   output_tokens: 8,
                   server_tool_use: { web_search_requests: 2, terminal_counter: 3 },
                   output_tokens_details: { terminal_detail: "preserved" },
@@ -759,7 +682,7 @@ describe("Anthropic Messages route", () => {
         totalTokens: 15,
         providerMetadata: {
           anthropic: {
-            input_tokens: null,
+            input_tokens: 5,
             cache_read_input_tokens: 2,
             service_tier: "standard",
             cache_creation: { ephemeral_5m_input_tokens: 1 },
@@ -1416,14 +1339,14 @@ describe("Anthropic Messages route", () => {
             Message.assistant([
               {
                 type: "tool-call",
-                id: "srvtoolu.abc",
+                id: "srvtoolu_abc",
                 name: "web_search",
                 input: { query: "effect 4" },
                 providerExecuted: true,
               },
               {
                 type: "tool-result",
-                id: "srvtoolu.abc",
+                id: "srvtoolu_abc",
                 name: "web_search",
                 result: { type: "json", value: [{ url: "https://example.com" }] },
                 providerExecuted: true,

packages/ai/test/provider/azure.recorded.test.ts

@@ -1,93 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM, Message, ToolDefinition, ToolCallPart } from "../../src/index.js"
-import { Azure } from "../../src/providers.js"
-import { LLMClient } from "../../src/route.js"
-import { recordedTests } from "../recorded-test.js"
-
-const resourceName = process.env.AZURE_OPENAI_RESOURCE_NAME ?? "aiden-azury-group"
-
-const chatModel = Azure.configure({
-  resourceName,
-  apiKey: process.env.AZURE_OPENAI_API_KEY ?? "fixture",
-}).chat("gpt-5.6-luna")
-
-const responsesModel = Azure.configure({
-  resourceName,
-  apiKey: process.env.AZURE_OPENAI_API_KEY ?? "fixture",
-}).responses("gpt-5.6-luna")
-
-const lookupWeather = ToolDefinition.make({
-  name: "lookup_weather",
-  description: "Look up the current weather for a city",
-  inputSchema: { type: "object", properties: { city: { type: "string" } }, required: ["city"] },
-})
-
-const recorded = recordedTests({
-  prefix: "azure",
-  provider: "azure",
-  requires: ["AZURE_OPENAI_API_KEY"],
-})
-
-describe("Azure OpenAI recorded", () => {
-  recorded.effect("chat streams text", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({ model: chatModel, prompt: "Reply with exactly one word: hello" }),
-      )
-
-      expect(response.text.toLowerCase()).toContain("hello")
-    }),
-  )
-
-  recorded.effect("responses streams text", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({ model: responsesModel, prompt: "Reply with exactly one word: bonjour" }),
-      )
-
-      expect(response.text.toLowerCase()).toContain("bonjour")
-    }),
-  )
-
-  recorded.effect("responses calls a tool", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          model: responsesModel,
-          prompt: "What is the weather in Paris? Use the lookup_weather tool.",
-          tools: [lookupWeather],
-        }),
-      )
-
-      const call = response.toolCalls.find((part) => part.name === "lookup_weather")
-      expect(call).toBeDefined()
-      expect(call?.input).toMatchObject({ city: "Paris" })
-    }),
-  )
-
-  recorded.effect("responses continues after a tool result", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          model: responsesModel,
-          messages: [
-            Message.user("What is the weather in Paris?"),
-            Message.assistant([
-              ToolCallPart.make({ id: "call_paris_1", name: "lookup_weather", input: { city: "Paris" } }),
-            ]),
-            Message.tool({
-              id: "call_paris_1",
-              name: "lookup_weather",
-              result: "18C, light rain",
-              resultType: "text",
-            }),
-          ],
-          tools: [lookupWeather],
-        }),
-      )
-
-      expect(response.text.length).toBeGreaterThan(0)
-    }),
-  )
-})

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

@@ -139,190 +139,6 @@ describe("Gemini route", () => {
     }),
   )
 
-  it.effect("keeps system updates separate from function responses", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } })]),
-            Message.tool({ id: "call_1", name: "lookup", result: "done", resultType: "text" }),
-            Message.system("Update."),
-            Message.system("Later update."),
-          ],
-        }),
-      )
-
-      expect(prepared.body.contents).toEqual([
-        {
-          role: "model",
-          parts: [{ functionCall: { name: "lookup", args: { query: "weather" } } }],
-        },
-        {
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                name: "lookup",
-                response: { name: "lookup", content: "done" },
-              },
-            },
-          ],
-        },
-        {
-          role: "user",
-          parts: [
-            { text: "<system-update>\nUpdate.\n</system-update>" },
-            { text: "<system-update>\nLater update.\n</system-update>" },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("merges parallel tool results into one function-response turn", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([
-              ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } }),
-              ToolCallPart.make({ id: "call_2", name: "lookup", input: { query: "time" } }),
-            ]),
-            Message.tool({ id: "call_1", name: "lookup", result: "sunny", resultType: "text" }),
-            Message.tool({ id: "call_2", name: "lookup", result: "noon", resultType: "text" }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.contents).toEqual([
-        {
-          role: "model",
-          parts: [
-            { functionCall: { name: "lookup", args: { query: "weather" } } },
-            { functionCall: { name: "lookup", args: { query: "time" } } },
-          ],
-        },
-        {
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                name: "lookup",
-                response: { name: "lookup", content: "sunny" },
-              },
-            },
-            {
-              functionResponse: {
-                name: "lookup",
-                response: { name: "lookup", content: "noon" },
-              },
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("lowers function call ids for gemini 3 models", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: gemini3,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } })]),
-            Message.tool({ id: "call_1", name: "lookup", result: "done", resultType: "text" }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.contents).toEqual([
-        {
-          role: "model",
-          parts: [
-            {
-              functionCall: { id: "call_1", name: "lookup", args: { query: "weather" } },
-              thoughtSignature: "skip_thought_signature_validator",
-            },
-          ],
-        },
-        {
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                id: "call_1",
-                name: "lookup",
-                response: { name: "lookup", content: "done" },
-              },
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("omits function call ids entirely for pre-gemini-3 models", () =>
-    Effect.gen(function* () {
-      const messages = [
-        Message.assistant([ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } })]),
-        Message.tool({ id: "call_1", name: "lookup", result: "done", resultType: "text" }),
-      ]
-      const legacy = yield* compileRequest(LLM.request({ model, messages }))
-      const older = yield* compileRequest(
-        LLM.request({
-          model: Gemini.route
-            .with({
-              endpoint: { baseURL: "https://generativelanguage.test/v1beta/" },
-              auth: Auth.header("x-goog-api-key", "test"),
-            })
-            .model({ id: "gemini-1.5-flash" }),
-          messages,
-        }),
-      )
-
-      expect(legacy.body.contents).toEqual([
-        { role: "model", parts: [{ functionCall: { name: "lookup", args: { query: "weather" } } }] },
-        {
-          role: "user",
-          parts: [{ functionResponse: { name: "lookup", response: { name: "lookup", content: "done" } } }],
-        },
-      ])
-      expect(JSON.stringify(legacy.body.contents)).not.toContain('"id"')
-      expect(JSON.stringify(older.body.contents)).not.toContain('"id"')
-    }),
-  )
-
-  it.effect("includes function call ids for non-gemini model ids", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: Gemini.route
-            .with({
-              endpoint: { baseURL: "https://generativelanguage.test/v1beta/" },
-              auth: Auth.header("x-goog-api-key", "test"),
-            })
-            .model({ id: "gemma-3-27b-it" }),
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } })]),
-            Message.tool({ id: "call_1", name: "lookup", result: "done", resultType: "text" }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.contents).toEqual([
-        { role: "model", parts: [{ functionCall: { id: "call_1", name: "lookup", args: { query: "weather" } } }] },
-        {
-          role: "user",
-          parts: [
-            { functionResponse: { id: "call_1", name: "lookup", response: { name: "lookup", content: "done" } } },
-          ],
-        },
-      ])
-    }),
-  )
-
   it.effect("prepares multimodal user input and tool history", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -423,18 +239,14 @@ 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=" } },
+                ],
               },
             },
           ],
         },
-        {
-          role: "user",
-          parts: [
-            { text: "Attached media from tool result:" },
-            { inlineData: { mimeType: "image/png", data: "AAECAw==" } },
-            { inlineData: { mimeType: "application/pdf", data: "JVBERi0xLjQ=" } },
-          ],
-        },
       ])
       expect(JSON.stringify(prepared.body.contents)).not.toContain('"content":"AAECAw=="')
     }),
@@ -467,164 +279,11 @@ describe("Gemini route", () => {
               functionResponse: {
                 name: "read",
                 response: { name: "read", content: "" },
+                parts: [{ inlineData: { mimeType: "image/jpeg", data: "/9j/" } }],
               },
             },
           ],
         },
-        {
-          role: "user",
-          parts: [
-            { text: "Attached media from tool result:" },
-            { inlineData: { mimeType: "image/jpeg", data: "/9j/" } },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("nests media inside function responses for gemini 3", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: gemini3,
-          messages: [
-            Message.assistant([
-              ToolCallPart.make({
-                id: "call_image",
-                name: "read",
-                input: { path: "pixel.png" },
-                providerMetadata: { google: { thoughtSignature: "sig_1" } },
-              }),
-            ]),
-            Message.tool({
-              id: "call_image",
-              name: "read",
-              result: {
-                type: "content",
-                value: [
-                  { type: "text", text: "Image read successfully" },
-                  { type: "file", uri: "data:image/png;base64,AAECAw==", mime: "image/png", name: "pixel.png" },
-                ],
-              },
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.contents).toEqual([
-        {
-          role: "model",
-          parts: [
-            { functionCall: { id: "call_image", name: "read", args: { path: "pixel.png" } }, thoughtSignature: "sig_1" },
-          ],
-        },
-        {
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                id: "call_image",
-                name: "read",
-                response: { name: "read", content: "Image read successfully" },
-                parts: [{ inlineData: { mimeType: "image/png", data: "AAECAw==" } }],
-              },
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("flushes pending media before system update text", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "shot", input: {} })]),
-            Message.tool({
-              id: "call_1",
-              name: "shot",
-              result: {
-                type: "content",
-                value: [{ type: "file", uri: "data:image/png;base64,AAEC", mime: "image/png" }],
-              },
-            }),
-            Message.system("Update."),
-          ],
-        }),
-      )
-
-      expect(prepared.body.contents).toEqual([
-        { role: "model", parts: [{ functionCall: { name: "shot", args: {} } }] },
-        {
-          role: "user",
-          parts: [{ functionResponse: { name: "shot", response: { name: "shot", content: "" } } }],
-        },
-        {
-          role: "user",
-          parts: [
-            { text: "Attached media from tool result:" },
-            { inlineData: { mimeType: "image/png", data: "AAEC" } },
-            { text: "<system-update>\nUpdate.\n</system-update>" },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("collects legacy tool media into one turn after merged responses", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([
-              ToolCallPart.make({ id: "call_1", name: "shot", input: {} }),
-              ToolCallPart.make({ id: "call_2", name: "shot", input: {} }),
-            ]),
-            Message.tool({
-              id: "call_1",
-              name: "shot",
-              result: {
-                type: "content",
-                value: [{ type: "file", uri: "data:image/png;base64,AAEC", mime: "image/png" }],
-              },
-            }),
-            Message.tool({
-              id: "call_2",
-              name: "shot",
-              result: {
-                type: "content",
-                value: [{ type: "text", text: "no image here" }],
-              },
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.contents).toEqual([
-        {
-          role: "model",
-          parts: [
-            { functionCall: { name: "shot", args: {} } },
-            { functionCall: { name: "shot", args: {} } },
-          ],
-        },
-        {
-          role: "user",
-          parts: [
-            { functionResponse: { name: "shot", response: { name: "shot", content: "" } } },
-            { functionResponse: { name: "shot", response: { name: "shot", content: "no image here" } } },
-          ],
-        },
-        {
-          role: "user",
-          parts: [
-            { text: "Attached media from tool result:" },
-            { inlineData: { mimeType: "image/png", data: "AAEC" } },
-          ],
-        },
       ])
     }),
   )
@@ -946,8 +605,8 @@ describe("Gemini route", () => {
         providerMetadata: { google: { thoughtSignature: "thought_sig" } },
       })
       expect(toolCall).toMatchObject({
-        id: "provider_call",
-        providerMetadata: { google: { thoughtSignature: "tool_sig" } },
+        id: "tool_0",
+        providerMetadata: { google: { functionCallId: "provider_call", thoughtSignature: "tool_sig" } },
       })
       expect(response.events.findIndex((event) => event.type === "reasoning-end")).toBeLessThan(
         response.events.findIndex((event) => event.type === "tool-call"),
@@ -955,22 +614,23 @@ describe("Gemini route", () => {
 
       const prepared = yield* compileRequest(
         LLM.request({
-          model: gemini3,
+          model,
           messages: [
             Message.assistant([
               { type: "reasoning", text: "thinking", providerMetadata: reasoningEnd?.providerMetadata },
               ToolCallPart.make({
-                id: "provider_call",
+                id: "tool_0",
                 name: "lookup",
                 input: { query: "weather" },
                 providerMetadata: toolCall?.providerMetadata,
               }),
             ]),
             Message.tool({
-              id: "provider_call",
+              id: "tool_0",
               name: "lookup",
               result: "done",
               resultType: "text",
+              providerMetadata: toolCall?.providerMetadata,
             }),
           ],
         }),
@@ -1002,61 +662,6 @@ describe("Gemini route", () => {
     }),
   )
 
-  it.effect("preserves thoughtSignature on visible text parts", () =>
-    Effect.gen(function* () {
-      const body = sseEvents({
-        candidates: [
-          {
-            content: { role: "model", parts: [{ text: "All done.", thoughtSignature: "text_sig" }] },
-            finishReason: "STOP",
-          },
-        ],
-      })
-      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
-      const delta = response.events.find((event) => event.type === "text-delta")
-      expect(delta).toMatchObject({
-        id: "text-0",
-        text: "All done.",
-        providerMetadata: { google: { thoughtSignature: "text_sig" } },
-      })
-
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [Message.assistant([{ type: "text", text: "All done.", providerMetadata: delta?.providerMetadata }])],
-        }),
-      )
-      expect(prepared.body.contents).toEqual([
-        { role: "model", parts: [{ text: "All done.", thoughtSignature: "text_sig" }] },
-      ])
-    }),
-  )
-
-  it.effect("flushes a trailing empty signed text part at block close", () =>
-    Effect.gen(function* () {
-      const body = sseEvents({
-        candidates: [
-          {
-            content: {
-              role: "model",
-              parts: [{ text: "Working." }, { text: "", thoughtSignature: "tail_sig" }],
-            },
-            finishReason: "STOP",
-          },
-        ],
-      })
-      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
-      const delta = response.events.find((event) => event.type === "text-delta")
-      const end = response.events.find((event) => event.type === "text-end")
-
-      expect(delta).toMatchObject({ id: "text-0", text: "Working.", providerMetadata: undefined })
-      expect(end).toMatchObject({
-        id: "text-0",
-        providerMetadata: { google: { thoughtSignature: "tail_sig" } },
-      })
-    }),
-  )
-
   it.effect("replays unsigned Gemini 3 tool calls with the validator bypass sentinel", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -1074,7 +679,7 @@ describe("Gemini route", () => {
           role: "model",
           parts: [
             {
-              functionCall: { id: "tool_0", name: "lookup", args: { query: "weather" } },
+              functionCall: { id: undefined, name: "lookup", args: { query: "weather" } },
               thoughtSignature: "skip_thought_signature_validator",
             },
           ],
@@ -1084,7 +689,7 @@ describe("Gemini route", () => {
           parts: [
             {
               functionResponse: {
-                id: "tool_0",
+                id: undefined,
                 name: "lookup",
                 response: { name: "lookup", content: "done" },
               },
@@ -1120,15 +725,15 @@ describe("Gemini route", () => {
           role: "model",
           parts: [
             {
-              functionCall: { id: "tool_0", name: "lookup", args: { query: "weather" } },
+              functionCall: { id: undefined, name: "lookup", args: { query: "weather" } },
               thoughtSignature: "parallel_signature",
             },
             {
-              functionCall: { id: "tool_1", name: "lookup", args: { query: "news" } },
+              functionCall: { id: undefined, name: "lookup", args: { query: "news" } },
               thoughtSignature: undefined,
             },
             {
-              functionCall: { id: "tool_2", name: "lookup", args: { query: "sports" } },
+              functionCall: { id: undefined, name: "lookup", args: { query: "sports" } },
               thoughtSignature: undefined,
             },
           ],
@@ -1156,11 +761,11 @@ describe("Gemini route", () => {
           role: "model",
           parts: [
             {
-              functionCall: { id: "tool_0", name: "lookup", args: { query: "weather" } },
+              functionCall: { id: undefined, name: "lookup", args: { query: "weather" } },
               thoughtSignature: "skip_thought_signature_validator",
             },
             {
-              functionCall: { id: "tool_1", name: "lookup", args: { query: "news" } },
+              functionCall: { id: undefined, name: "lookup", args: { query: "news" } },
               thoughtSignature: "skip_thought_signature_validator",
             },
           ],
@@ -1198,17 +803,21 @@ describe("Gemini route", () => {
         providerMetadata: { google: { promptTokenCount: 5, candidatesTokenCount: 1 } },
       })
 
-      expect(response.toolCalls[0].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
-      expect(response.toolCalls[0]).toMatchObject({
-        type: "tool-call",
-        name: "lookup",
-        input: { query: "weather" },
-      })
+      expect(response.toolCalls).toEqual([
+        {
+          type: "tool-call",
+          id: "tool_0",
+          name: "lookup",
+          input: { query: "weather" },
+          providerExecuted: undefined,
+          providerMetadata: undefined,
+        },
+      ])
       expect(response.events).toEqual([
         { type: "step-start", index: 0 },
         {
           type: "tool-call",
-          id: response.toolCalls[0].id,
+          id: "tool_0",
           name: "lookup",
           input: { query: "weather" },
           providerExecuted: undefined,
@@ -1251,8 +860,7 @@ describe("Gemini route", () => {
         ),
       )
 
-      expect(response.toolCalls[0].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
-      expect(response.toolCalls).toMatchObject([{ type: "tool-call", name: "ping", input: {} }])
+      expect(response.toolCalls).toEqual([{ type: "tool-call", id: "tool_0", name: "ping", input: {} }])
     }),
   )
 
@@ -1292,7 +900,7 @@ describe("Gemini route", () => {
             content: {
               role: "model",
               parts: [
-                { functionCall: { id: "call_0", name: "lookup", args: { query: "weather" } } },
+                { functionCall: { id: "tool_0", name: "lookup", args: { query: "weather" } } },
                 { functionCall: { name: "lookup", args: { query: "news" } } },
               ],
             },
@@ -1306,19 +914,16 @@ describe("Gemini route", () => {
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
 
-      expect(response.toolCalls[0]).toMatchObject({
-        type: "tool-call",
-        id: "call_0",
-        name: "lookup",
-        input: { query: "weather" },
-      })
-      expect(response.toolCalls[1]).toMatchObject({
-        type: "tool-call",
-        name: "lookup",
-        input: { query: "news" },
-      })
-      expect(response.toolCalls[1].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
-      expect(response.toolCalls[0].id).not.toBe(response.toolCalls[1].id)
+      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_1", name: "lookup", input: { query: "news" } },
+      ])
       expect(response.events.at(-1)).toMatchObject({
         type: "finish",
         reason: { normalized: "tool-calls", raw: "STOP" },
@@ -1326,62 +931,6 @@ describe("Gemini route", () => {
     }),
   )
 
-  it.effect("replaces repeated supplier ids with fresh fallback ids", () =>
-    Effect.gen(function* () {
-      const body = sseEvents({
-        candidates: [
-          {
-            content: {
-              role: "model",
-              parts: [
-                { functionCall: { id: "dup_call", name: "lookup", args: { query: "weather" } } },
-                { functionCall: { id: "dup_call", name: "lookup", args: { query: "news" } } },
-              ],
-            },
-            finishReason: "STOP",
-          },
-        ],
-      })
-      const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
-        }),
-      ).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.toolCalls[0]).toMatchObject({
-        id: "dup_call",
-        providerMetadata: undefined,
-      })
-      expect(response.toolCalls[1].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
-      expect(response.toolCalls[1].id).not.toBe(response.toolCalls[0].id)
-    }),
-  )
-
-  it.effect("assigns distinct unique fallback ids across separate requests", () =>
-    Effect.gen(function* () {
-      const body = sseEvents({
-        candidates: [
-          {
-            content: {
-              role: "model",
-              parts: [{ functionCall: { name: "lookup", args: { query: "weather" } } }],
-            },
-            finishReason: "STOP",
-          },
-        ],
-      })
-      const req = LLMRequest.update(request, {
-        tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
-      })
-      const first = yield* LLMClient.generate(req).pipe(Effect.provide(fixedResponse(body)))
-      const second = yield* LLMClient.generate(req).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(first.toolCalls[0].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
-      expect(second.toolCalls[0].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
-      expect(first.toolCalls[0].id).not.toBe(second.toolCalls[0].id)
-    }),
-  )
-
   it.effect("maps length and content-filter finish reasons", () =>
     Effect.gen(function* () {
       const length = yield* LLMClient.generate(request).pipe(
@@ -1492,73 +1041,6 @@ describe("Gemini route", () => {
     }),
   )
 
-  it.effect("survives explicit null usage counts", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { candidates: [{ content: { role: "model", parts: [{ text: "Hi" }] } }] },
-              { usageMetadata: { promptTokenCount: null, candidatesTokenCount: 5 } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("Hi")
-      expect(response.usage).toMatchObject({ outputTokens: 5, totalTokens: 5 })
-      expect(response.usage?.inputTokens).toBeUndefined()
-      expect(response.usage?.nonCachedInputTokens).toBeUndefined()
-      expect(response.usage?.cacheReadInputTokens).toBeUndefined()
-      expect(response.usage?.reasoningTokens).toBeUndefined()
-    }),
-  )
-
-  it.effect("survives null candidates, content, parts, and finish reason", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { candidates: null },
-              { candidates: [{ content: { role: "model", parts: null } }] },
-              { candidates: [{ content: null, finishReason: null }] },
-              {
-                candidates: [
-                  { content: { role: "model", parts: [{ text: "Hello" }] }, finishReason: "STOP" as const },
-                ],
-              },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("Hello")
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: "STOP" })
-    }),
-  )
-
-  it.effect("treats a null thought flag on a text part as visible output", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents({
-              candidates: [
-                { content: { role: "model", parts: [{ text: "Visible", thought: null }] }, finishReason: "STOP" },
-              ],
-            }),
-          ),
-        ),
-      )
-      const reasoningStart = response.events.find((event) => event.type === "reasoning-start")
-
-      expect(reasoningStart).toBeUndefined()
-      expect(response.reasoning ?? "").toBe("")
-      expect(response.text).toBe("Visible")
-    }),
-  )
-
   it.effect("fails invalid stream events", () =>
     Effect.gen(function* () {
       const error = yield* LLMClient.generate(request).pipe(

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

@@ -1,77 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-
-import { LLM, Message, ToolDefinition, ToolCallPart } from "../../src/index.js"
-import { GoogleVertex } from "../../src/providers.js"
-import { LLMClient } from "../../src/route.js"
-import { recordedTests } from "../recorded-test.js"
-
-const model = GoogleVertex.configure({
-  apiKey: process.env.GOOGLE_VERTEX_API_KEY ?? "fixture",
-}).model("gemini-3.5-flash")
-
-const lookupWeather = ToolDefinition.make({
-  name: "lookup_weather",
-  description: "Look up the current weather for a city",
-  inputSchema: { type: "object", properties: { city: { type: "string" } }, required: ["city"] },
-})
-
-const recorded = recordedTests({
-  prefix: "google-vertex",
-  provider: "google-vertex",
-  protocol: "gemini",
-  requires: ["GOOGLE_VERTEX_API_KEY"],
-})
-
-describe("Google Vertex Gemini recorded", () => {
-  recorded.effect("streams text", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({ model, prompt: "Reply with exactly one word: hello" }),
-      )
-
-      expect(response.text.toLowerCase()).toContain("hello")
-    }),
-  )
-
-  recorded.effect("calls a tool", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          model,
-          prompt: "What is the weather in Paris? Use the lookup_weather tool.",
-          tools: [lookupWeather],
-        }),
-      )
-
-      const call = response.toolCalls.find((part) => part.name === "lookup_weather")
-      expect(call).toBeDefined()
-      expect(call?.input).toMatchObject({ city: "Paris" })
-    }),
-  )
-
-  recorded.effect("continues after a tool result", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          model,
-          messages: [
-            Message.user("What is the weather in Paris?"),
-            Message.assistant([
-              ToolCallPart.make({ id: "call_paris_1", name: "lookup_weather", input: { city: "Paris" } }),
-            ]),
-            Message.tool({
-              id: "call_paris_1",
-              name: "lookup_weather",
-              result: "18C, light rain",
-              resultType: "text",
-            }),
-          ],
-          tools: [lookupWeather],
-        }),
-      )
-
-      expect(response.text.length).toBeGreaterThan(0)
-    }),
-  )
-})

packages/ai/test/provider/google-vertex.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
-import { LLM, Message, ToolCallPart } from "../../src/index.js"
+import { LLM } from "../../src/index.js"
 import { GoogleVertex, GoogleVertexChat, GoogleVertexMessages, GoogleVertexResponses } from "../../src/providers.js"
 import { LLMClient } from "../../src/route.js"
 import { compileRequest } from "../../src/route/client.js"
@@ -75,53 +75,6 @@ describe("Google Vertex providers", () => {
     }),
   )
 
-  it.effect("strips function call ids Vertex does not accept from lowered bodies", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: GoogleVertex.configure({
-            accessToken: "vertex-token",
-            project: "vertex-project",
-          }).model("gemini-3.5-flash"),
-          messages: [
-            Message.assistant([
-              ToolCallPart.make({
-                id: "call_1",
-                name: "lookup",
-                input: { query: "weather" },
-                providerMetadata: { google: { functionCallId: "provider_call_1" } },
-              }),
-            ]),
-            Message.tool({
-              id: "call_1",
-              name: "lookup",
-              result: "sunny",
-              resultType: "text",
-              providerMetadata: { google: { functionCallId: "provider_call_1" } },
-            }),
-          ],
-        }),
-      )
-
-      expect(JSON.stringify(prepared.body.contents)).not.toContain('"id"')
-      expect(prepared.body.contents).toMatchObject([
-        { role: "model", parts: [{ functionCall: { id: undefined, name: "lookup", args: { query: "weather" } } }] },
-        {
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                id: undefined,
-                name: "lookup",
-                response: { name: "lookup", content: "sunny" },
-              },
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
   it.effect("projects Anthropic Messages onto the Vertex raw-predict API", () =>
     Effect.gen(function* () {
       const model = GoogleVertexMessages.configure({
@@ -143,7 +96,7 @@ describe("Google Vertex providers", () => {
                 "https://aiplatform.eu.rep.googleapis.com/v1/projects/vertex-project/locations/eu/publishers/anthropic/models/claude-sonnet-4-6:streamRawPredict",
               )
               expect(request.headers.get("authorization")).toBe("Bearer vertex-token")
-              expect(request.headers.get("anthropic-version")).toBe("2023-06-01")
+              expect(request.headers.get("anthropic-version")).toBeNull()
               const body = yield* Effect.promise(() => request.json())
               expect(body).toMatchObject({
                 anthropic_version: "vertex-2023-10-16",
@@ -237,7 +190,6 @@ describe("Google Vertex providers", () => {
               })
               return input.respond(
                 sseEvents(
-                  { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
                   { type: "response.output_text.delta", item_id: "msg_1", delta: "Hello." },
                   { type: "response.completed", response: { id: "resp_1" } },
                 ),

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

@@ -342,7 +342,6 @@ describe("OpenAI Chat route", () => {
           },
           { role: "tool", tool_call_id: "call_1", content: encodeJson({ forecast: "sunny" }) },
         ],
-        tools: [],
         stream: true,
         stream_options: { include_usage: true },
       })
@@ -665,74 +664,6 @@ describe("OpenAI Chat route", () => {
     }),
   )
 
-  it.effect("preserves streamed refusals as ordinary assistant text", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              deltaChunk({ role: "assistant", refusal: "I can't" }),
-              deltaChunk({ refusal: " help with that." }),
-              deltaChunk({}, "stop"),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("I can't help with that.")
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: "stop" })
-      expect(response.message.content).toEqual([{ type: "text", text: "I can't help with that." }])
-
-      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
-      expect(replay.body.messages).toEqual([{ role: "assistant", content: "I can't help with that." }])
-    }),
-  )
-
-  it.effect("orders metadata-only reasoning before refusal output", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning_details: [] } }] },
-              deltaChunk({ refusal: "I can't help with that." }),
-              deltaChunk({}, "stop"),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        { type: "reasoning", text: "", providerMetadata: { openai: { reasoningDetails: [] } } },
-        {
-          type: "text",
-          text: "I can't help with that.",
-        },
-      ])
-    }),
-  )
-
-  it.effect("joins content and refusal deltas into ordinary assistant text", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              deltaChunk({ refusal: "No." }),
-              deltaChunk({ content: " Alternative." }),
-              deltaChunk({ refusal: " Still no." }),
-              deltaChunk({}, "stop"),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("No. Alternative. Still no.")
-      expect(response.events.filter(LLMEvent.is.textStart).map((event) => event.id)).toEqual(["text-0"])
-      expect(response.events.filter(LLMEvent.is.textEnd).map((event) => event.id)).toEqual(["text-0"])
-    }),
-  )
-
   it.effect("parses and replays OpenAI-compatible reasoning fields", () =>
     Effect.gen(function* () {
       const fields = ["reasoning_content", "reasoning", "reasoning_text"] as const

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

@@ -73,46 +73,7 @@ describe("Open Responses-compatible route", () => {
       expect(prepared.body.input).toEqual([
         { role: "user", content: [{ type: "input_text", text: "Before." }] },
         { role: "developer", content: "Operator update." },
-        { type: "message", role: "assistant", content: [{ type: "output_text", text: "After." }] },
-      ])
-    }),
-  )
-
-  it.effect("uses data URLs for embedded PDF messages and tool results", () =>
-    Effect.gen(function* () {
-      const model = configure({
-        apiKey: "test-key",
-        baseURL: "https://responses.example.test/v1",
-        provider: "example",
-      }).model("example-model")
-      const pdf = "data:application/pdf;base64,JVBERi0xLjQ="
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.user([{ type: "media", mediaType: "application/pdf", data: pdf, filename: "input.pdf" }]),
-            Message.assistant({ type: "tool-call", id: "call_1", name: "read", input: {} }),
-            Message.tool({
-              id: "call_1",
-              name: "read",
-              resultType: "content",
-              result: [{ type: "file", uri: pdf, mime: "application/pdf", name: "result.pdf" }],
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.input).toEqual([
-        {
-          role: "user",
-          content: [{ type: "input_file", filename: "input.pdf", file_data: pdf }],
-        },
-        { type: "function_call", call_id: "call_1", name: "read", arguments: "{}" },
-        {
-          type: "function_call_output",
-          call_id: "call_1",
-          output: [{ type: "input_file", filename: "result.pdf", file_data: pdf }],
-        },
+        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
       ])
     }),
   )
@@ -132,79 +93,7 @@ describe("Open Responses-compatible route", () => {
     }),
   )
 
-  it.effect("keeps foreign item id grammars but drops malformed ids", () =>
-    Effect.gen(function* () {
-      const model = configure({
-        apiKey: "test-key",
-        baseURL: "https://responses.example.test/v1",
-      }).model("example-model")
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([
-              // The baseline does not enforce a provider id grammar, so a
-              // non-OpenAI but well-formed token is resent as-is.
-              { type: "text", text: "Kept.", providerMetadata: { openresponses: { itemId: "history_1" } } },
-              // Shape violations are dropped even without a grammar policy.
-              {
-                type: "text",
-                text: "Dropped.",
-                providerMetadata: { openresponses: { itemId: `m${"a".repeat(64)}` } },
-              },
-            ]),
-          ],
-        }),
-      )
-
-      expect(prepared.body.input).toEqual([
-        {
-          type: "message",
-          id: "history_1",
-          role: "assistant",
-          content: [{ type: "output_text", text: "Kept." }],
-        },
-        {
-          type: "message",
-          role: "assistant",
-          content: [{ type: "output_text", text: "Dropped." }],
-        },
-      ])
-    }),
-  )
-
-  it.effect("reconciles raw reasoning finals without streamed deltas", () =>
-    Effect.gen(function* () {
-      const model = configure({
-        apiKey: "test-key",
-        baseURL: "https://responses.example.test/v1",
-      }).model("example-model")
-      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Think it through." })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.added",
-                item: { type: "reasoning", id: "rs_raw", encrypted_content: null },
-              },
-              // Raw reasoning finals carry no summary index; they reconcile
-              // into the item's first block.
-              { type: "response.reasoning.done", item_id: "rs_raw", text: "Raw chain of thought." },
-              {
-                type: "response.output_item.done",
-                item: { type: "reasoning", id: "rs_raw", encrypted_content: "raw-state" },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("Raw chain of thought.")
-    }),
-  )
-
-  it.effect("preserves nullable phases in the forgiving Open Responses baseline", () =>
+  it.effect("omits OpenAI-only nullable phases from the Open Responses baseline", () =>
     Effect.gen(function* () {
       const model = configure({
         apiKey: "test-key",
@@ -224,74 +113,11 @@ describe("Open Responses-compatible route", () => {
       )
 
       expect(prepared.body).toMatchObject({
-        input: [
-          {
-            type: "message",
-            role: "assistant",
-            content: [{ type: "output_text", text: "Unclassified." }],
-            phase: null,
-          },
-        ],
+        input: [{ role: "assistant", content: [{ type: "output_text", text: "Unclassified." }] }],
       })
     }),
   )
 
-  it.effect("preserves standard refusal content as ordinary assistant text", () =>
-    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: "Unsafe request" })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.added",
-                output_index: 0,
-                item: { type: "message", id: "msg_refusal", content: [] },
-              },
-              {
-                type: "response.refusal.done",
-                item_id: "msg_refusal",
-                refusal: "I can't help with that.",
-              },
-              {
-                type: "response.output_item.done",
-                output_index: 0,
-                item: {
-                  type: "message",
-                  id: "msg_refusal",
-                  content: [{ type: "refusal", refusal: "I can't help with that." }],
-                },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        {
-          type: "text",
-          text: "I can't help with that.",
-          providerMetadata: { openresponses: { itemId: "msg_refusal" } },
-        },
-      ])
-
-      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
-      expect(prepared.body.input).toEqual([
-        {
-          type: "message",
-          id: "msg_refusal",
-          role: "assistant",
-          content: [{ type: "output_text", text: "I can't help with that." }],
-        },
-      ])
-    }),
-  )
-
   it.effect("reads standard Open Responses options", () =>
     Effect.gen(function* () {
       const model = configure({
@@ -300,12 +126,7 @@ describe("Open Responses-compatible route", () => {
         providerOptions: {
           reasoningEffort: "low",
           store: true,
-          metadata: { environment: "test" },
-          safetyIdentifier: "user_123",
-          streamOptions: { includeObfuscation: false },
-          topLogprobs: 3,
           truncation: "auto",
-          serviceTier: "provider-tier",
           allowedTools: { toolNames: ["lookup"] },
           maxToolCalls: 2,
           parallelToolCalls: false,
@@ -315,7 +136,6 @@ describe("Open Responses-compatible route", () => {
         LLM.request({
           model,
           prompt: "Think.",
-          generation: { presencePenalty: 0.2, frequencyPenalty: -0.1 },
           tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
         }),
       )
@@ -323,14 +143,7 @@ describe("Open Responses-compatible route", () => {
       expect(prepared.body).toMatchObject({
         reasoning: { effort: "low" },
         store: true,
-        metadata: { environment: "test" },
-        safety_identifier: "user_123",
-        stream_options: { include_obfuscation: false },
-        top_logprobs: 3,
-        presence_penalty: 0.2,
-        frequency_penalty: -0.1,
         truncation: "auto",
-        service_tier: "provider-tier",
         tool_choice: {
           type: "allowed_tools",
           mode: "auto",

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

@@ -1,216 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Stream } from "effect"
-import { Socket } from "effect/unstable/socket"
-import { LLM, LLMRequest, Message, ToolRuntime } from "../../src/index.js"
-import {
-  LLMClient,
-  WebSocketTransport,
-  type ChannelCheckpoint,
-  type ChannelObservation,
-  type WebSocketChannelExchange,
-  type WebSocketChannelExecutor,
-  type WebSocketConnection,
-} from "../../src/route.js"
-import { configure } from "../../src/providers/openai.js"
-import { decodeJson } from "../../src/protocols/shared.js"
-import { weatherRuntimeTool, weatherTool, weatherToolName } from "../recorded-scenarios.js"
-import { recordedTests } from "../recorded-test.js"
-
-const model = configure({ apiKey: process.env.OPENAI_API_KEY ?? "fixture" }).responses("gpt-5.5")
-const recorded = recordedTests({
-  prefix: "openai-responses-websocket",
-  provider: "openai",
-  protocol: "openai-responses",
-  requires: ["OPENAI_API_KEY"],
-  tags: ["transport:websocket"],
-  metadata: { transport: "websocket", model: model.id },
-})
-
-const observationFrame = (observation: ChannelObservation) => {
-  if (observation.type === "frame" || observation.type === "completed" || observation.type === "incomplete")
-    return Effect.succeed(observation.frame)
-  return Effect.fail(observation.error)
-}
-
-const terminal = (observation: ChannelObservation) => observation.type !== "frame"
-
-// This deliberately models only sequential test traffic. Core owns production connection pooling and recovery.
-const makeChannel = Effect.gen(function* () {
-  const constructor = yield* Socket.WebSocketConstructor
-  let connection: WebSocketConnection | undefined
-  let checkpoint: ChannelCheckpoint | undefined
-  let pending: ChannelCheckpoint | undefined
-  let opens = 0
-  const sent: unknown[] = []
-
-  const close = Effect.suspend(() => {
-    const current = connection
-    connection = undefined
-    return current ? current.close : Effect.void
-  })
-  yield* Effect.addFinalizer(() => close)
-
-  const executor: WebSocketChannelExecutor = {
-    execute: (exchange: WebSocketChannelExchange) =>
-      Effect.gen(function* () {
-        if (!connection) {
-          connection = yield* WebSocketTransport.open(exchange.connect).pipe(
-            Effect.provideService(Socket.WebSocketConstructor, constructor),
-          )
-          opens += 1
-        }
-        const current = connection
-        const create = yield* exchange.driver.create(checkpoint)
-        if (create.mode === "full") checkpoint = undefined
-        pending = undefined
-        sent.push(decodeJson(create.message))
-        yield* current.sendText(create.message)
-        const decoder = new TextDecoder()
-        return {
-          frames: current.messages.pipe(
-            Stream.map((message) => WebSocketTransport.messageText(message, decoder)),
-            Stream.mapEffect((frame) => exchange.driver.observe(create, frame)),
-            Stream.tap((observation) =>
-              Effect.sync(() => {
-                if (!terminal(observation)) return
-                pending = observation.type === "completed" ? observation.checkpoint : undefined
-                if (observation.type !== "completed") checkpoint = undefined
-              }),
-            ),
-            Stream.takeUntil(terminal),
-            Stream.mapEffect(observationFrame),
-          ),
-          complete: Effect.sync(() => {
-            checkpoint = pending
-            pending = undefined
-          }),
-        }
-      }),
-  }
-
-  return {
-    executor,
-    sent,
-    opens: () => opens,
-    reconnect: (preserveCheckpoint = false) =>
-      close.pipe(
-        Effect.andThen(
-          Effect.sync(() => {
-            pending = undefined
-            if (!preserveCheckpoint) checkpoint = undefined
-          }),
-        ),
-      ),
-  }
-})
-
-describe("OpenAI Responses WebSocket recorded", () => {
-  recorded.effect.with("continues a tool call over one socket", { tags: ["tool", "continuation"] }, () =>
-    Effect.gen(function* () {
-      const channel = yield* makeChannel
-      const request = LLM.request({
-        id: "recorded_openai_responses_websocket_tool",
-        model,
-        system: "Call get_weather once, then reply exactly: Paris is sunny.",
-        prompt: "What is the weather in Paris?",
-        tools: [weatherTool],
-        generation: { maxTokens: 50 },
-        cache: "none",
-      })
-      const first = yield* LLMClient.generate(request, { webSocket: channel.executor })
-      const call = first.toolCalls[0]
-      if (!call) yield* Effect.die("Expected get_weather tool call")
-      const result = yield* ToolRuntime.dispatch({ [weatherToolName]: weatherRuntimeTool }, call)
-      const second = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          messages: [
-            ...request.messages,
-            first.message,
-            Message.tool({ id: call.id, name: call.name, result: result.result }),
-          ],
-        }),
-        { webSocket: channel.executor },
-      )
-
-      expect(second.text).toBe("Paris is sunny.")
-      expect(channel.opens()).toBe(1)
-      expect(channel.sent).toHaveLength(2)
-      expect(channel.sent[1]).toMatchObject({
-        previous_response_id: expect.any(String),
-        input: [{ type: "function_call_output", call_id: call.id, output: expect.any(String) }],
-      })
-    }),
-  )
-
-  recorded.effect.with("reconstructs full context after reconnect", { tags: ["reconnect", "full-context"] }, () =>
-    Effect.gen(function* () {
-      const channel = yield* makeChannel
-      const request = LLM.request({
-        id: "recorded_openai_responses_websocket_reconnect",
-        model,
-        system: "Follow the user's exact reply instruction.",
-        prompt: "Reply exactly: Alpha.",
-        generation: { maxTokens: 30 },
-        cache: "none",
-      })
-      const first = yield* LLMClient.generate(request, { webSocket: channel.executor })
-      yield* channel.reconnect()
-      const second = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          messages: [...request.messages, first.message, Message.user("Reply exactly: Beta.")],
-        }),
-        { webSocket: channel.executor },
-      )
-
-      expect(first.text).toBe("Alpha.")
-      expect(second.text).toBe("Beta.")
-      expect(channel.opens()).toBe(2)
-      expect(channel.sent[1]).not.toHaveProperty("previous_response_id")
-      expect(channel.sent[1]).toMatchObject({
-        input: [
-          { role: "system", content: "Follow the user's exact reply instruction." },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Alpha." }] },
-          { role: "assistant", content: [{ type: "output_text", text: "Alpha." }] },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Beta." }] },
-        ],
-      })
-    }),
-  )
-
-  recorded.effect.with("recovers from explicit continuation rejection", { tags: ["continuation", "recovery"] }, () =>
-    Effect.gen(function* () {
-      const channel = yield* makeChannel
-      const request = LLM.request({
-        id: "recorded_openai_responses_websocket_rejection",
-        model,
-        system: "Follow the user's exact reply instruction.",
-        prompt: "Reply exactly: Ready.",
-        generation: { maxTokens: 30 },
-        cache: "none",
-      })
-      const first = yield* LLMClient.generate(request, { webSocket: channel.executor })
-      const continuation = LLMRequest.update(request, {
-        messages: [...request.messages, first.message, Message.user("Reply exactly: Recovered.")],
-      })
-      yield* channel.reconnect(true)
-      const rejected = yield* LLMClient.generate(continuation, { webSocket: channel.executor }).pipe(Effect.flip)
-      const recovered = yield* LLMClient.generate(continuation, { webSocket: channel.executor })
-
-      expect(rejected).toMatchObject({
-        reason: { _tag: "Transport", delivery: "rejected", recovery: "retry-full" },
-      })
-      expect(recovered.text).toBe("Recovered.")
-      expect(channel.opens()).toBe(2)
-      expect(channel.sent[1]).toHaveProperty("previous_response_id", expect.any(String))
-      expect(channel.sent[2]).not.toHaveProperty("previous_response_id")
-      expect(channel.sent[2]).toMatchObject({
-        input: [
-          { role: "system", content: "Follow the user's exact reply instruction." },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Ready." }] },
-          { role: "assistant", content: [{ type: "output_text", text: "Ready." }] },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Recovered." }] },
-        ],
-      })
-    }),
-  )
-})

packages/ai/test/provider/pdf.recorded.test.ts

@@ -64,7 +64,7 @@ const targets: ReadonlyArray<{
     id: "xai",
     name: "xAI Grok 4.5",
     provider: "xai",
-    protocol: "xai-responses",
+    protocol: "openai-responses",
     requires: "XAI_API_KEY",
     filename: "verification.pdf",
     maxTokens: 40,

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

@@ -1,86 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM, LLMEvent } from "../../src/index.js"
-import { XAI } from "../../src/providers.js"
-import { OpenResponses } from "../../src/protocols/open-responses.js"
-import { OpenAIResponses } from "../../src/protocols/openai-responses.js"
-import { XAIResponses } from "../../src/protocols/xai-responses.js"
-import { LLMClient } from "../../src/route.js"
-import { compileRequest } from "../../src/route/client.js"
-import { it } from "../lib/effect.js"
-import { fixedResponse } from "../lib/http.js"
-import { sseEvents } from "../lib/sse.js"
-
-const model = XAI.configure({ apiKey: "test", baseURL: "https://api.x.ai/v1" }).responses("grok-4.6")
-
-describe("xAI Responses route", () => {
-  it.effect("extends the Open Responses baseline directly", () =>
-    Effect.gen(function* () {
-      expect(XAIResponses.protocol.body).toBe(OpenResponses.protocol.body)
-      expect(XAIResponses.protocol.body).not.toBe(OpenAIResponses.protocol.body)
-
-      const prepared = yield* compileRequest(LLM.request({ model, prompt: "Hello" }))
-      expect(prepared.protocol).toBe("xai-responses")
-    }),
-  )
-
-  it.effect("parses xAI reasoning summaries", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Think" })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.added",
-                item: { type: "reasoning", id: "reasoning_1" },
-              },
-              // Grok streams reasoning with the standard summary event name.
-              {
-                type: "response.reasoning_summary_text.delta",
-                item_id: "reasoning_1",
-                summary_index: 0,
-                delta: "Considering.",
-              },
-              {
-                type: "response.output_item.done",
-                item: { type: "reasoning", id: "reasoning_1", encrypted_content: "opaque" },
-              },
-              { type: "response.completed", response: { id: "response_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content.find((part) => part.type === "reasoning")).toMatchObject({
-        type: "reasoning",
-        text: "Considering.",
-        providerMetadata: { xai: { itemId: "reasoning_1", reasoningEncryptedContent: "opaque" } },
-      })
-    }),
-  )
-
-  it.effect("parses xAI hosted tool items", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Search X" })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.done",
-                item: { type: "x_search_call", id: "x_search_1", status: "completed", action: { query: "news" } },
-              },
-              { type: "response.completed", response: { id: "response_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.events.find(LLMEvent.is.toolCall)).toMatchObject({
-        id: "x_search_1",
-        name: "x_search",
-        input: { query: "news" },
-        providerExecuted: true,
-      })
-    }),
-  )
-})