fix(ai): keep OpenAI image output settings and Z.ai URL expiry (#51380 )

fix(ai): harden OpenAI transcription stream parsing (#51378 )
fix(ai): tighten media error consistency (#51374 )
2026-09-25 18:17:35 +00:00 · 2026-09-25 22:51:46 +05:30 · 2026-09-25 22:51:22 +05:30 · 2026-09-25 22:46:04 +05:30 · 2026-09-25 22:37:20 +05:30 · 2026-09-25 22:36:02 +05:30
218 changed files with 6922 additions and 2041 deletions
@@ -597,8 +597,8 @@
      },
      "peerDependencies": {
        "@opencode/theme": "workspace:*",
-        "@opentui/core": ">=0.5.10",
-        "@opentui/solid": ">=0.5.10",
+        "@opentui/core": ">=0.5.12",
+        "@opentui/solid": ">=0.5.12",
        "solid-js": ">=1.9.0",
      },
      "optionalPeers": [
@@ -1114,9 +1114,9 @@
    "@npmcli/arborist": "9.4.0",
    "@octokit/rest": "22.0.0",
    "@openauthjs/openauth": "0.0.0-20250322224806",
-    "@opentui/core": "0.5.10",
-    "@opentui/keymap": "0.5.10",
-    "@opentui/solid": "0.5.10",
+    "@opentui/core": "0.5.12",
+    "@opentui/keymap": "0.5.12",
+    "@opentui/solid": "0.5.12",
    "@pierre/diffs": "1.2.10",
    "@playwright/test": "1.59.1",
    "@sentry/solid": "10.71.0",
@@ -2252,27 +2252,27 @@

    "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.43.0", "", {}, "sha512-eSYWTm620tTk45EKSedaUL8MFYI8hW164hIXsgIHyxu3VobUB3fFCu5t0hQby6OoWRPsG1KkKUG2M5UadiLiVg=="],

-    "@opentui/core": ["@opentui/core@0.5.10", "", { "dependencies": { "bun-ffi-structs": "0.3.1", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.5.10", "@opentui/core-darwin-x64": "0.5.10", "@opentui/core-linux-arm64": "0.5.10", "@opentui/core-linux-arm64-musl": "0.5.10", "@opentui/core-linux-x64": "0.5.10", "@opentui/core-linux-x64-musl": "0.5.10", "@opentui/core-win32-arm64": "0.5.10", "@opentui/core-win32-x64": "0.5.10" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-C3a2UbmefeAjIxAgm4BqjuSxKT4oqutfvYFwVvUgMxmGRHkNbBc/s7sukV0JgwcxFcV3uMFrXxo+E+BQtvuOiw=="],
+    "@opentui/core": ["@opentui/core@0.5.12", "", { "dependencies": { "bun-ffi-structs": "0.3.1", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.5.12", "@opentui/core-darwin-x64": "0.5.12", "@opentui/core-linux-arm64": "0.5.12", "@opentui/core-linux-arm64-musl": "0.5.12", "@opentui/core-linux-x64": "0.5.12", "@opentui/core-linux-x64-musl": "0.5.12", "@opentui/core-win32-arm64": "0.5.12", "@opentui/core-win32-x64": "0.5.12" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-ZXBE5gmvdovmV8zJQrOQf6E44v1tJRDEgrM2MYhEglzgXZ+smIUp95O8zeRYGsuIzQIiMPMgQqKtTJuzvAb7BQ=="],

-    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.5.10", "", { "os": "darwin", "cpu": "arm64" }, "sha512-Vyb+nTbhab8ZcRy5gg1loEEGwRcIbjAeVRIBfHBcbFDqmITBOg7x2gqJ+x/TnoOy4uwMhCmICUN2wiyREw3r1Q=="],
+    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.5.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-YdVnP0tAyerBNl0mIcmQEOotPeZzW1VnSXKBl5cyZ5e6nDd2Y+ui/8eRPpn1oqcamf1NCnzS4ohMgejOvna8Zg=="],

-    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.5.10", "", { "os": "darwin", "cpu": "x64" }, "sha512-tTFLcM7Oj1gTyhm/bUdAt3C6grZdCxPk6+/g2azcZBUlI3/62LwbeRS6HbQKFFmm+1fUmX8cq6kWrtul885mVg=="],
+    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.5.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-uRrQJdHmLUSj3PV23QPi3WSimYTTxcXnVouxF6U4xMXlOv4N3SxnHfVwMRQkPqbGOfvVWHeLE6FdK4C+ubU0sQ=="],

-    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.5.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-ncJXcgudhBf2GdJyF3xVQN/Ec+1F7GOL+pRrURmgBYSj2v1w6EyoDQFAACtPTK2c3R38W6fvZwL4JSLlm4EFXQ=="],
+    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.5.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-XeKhuIaEtgipvuPHbl4qPOBj+Ut+2zObmsxMVM1jDcjz/FatG9PGeGQPx1G1SnvH2AgpT4K+eCu7DUF0+yIqoQ=="],

-    "@opentui/core-linux-arm64-musl": ["@opentui/core-linux-arm64-musl@0.5.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-dGMphDKexSdeYqwl0wgoFBP88Ta/cdi1Zc1mk29/ENkSCGz+74zlCHgqTHRNGLmI8W5TfuUtCyktQH11/Z+TBQ=="],
+    "@opentui/core-linux-arm64-musl": ["@opentui/core-linux-arm64-musl@0.5.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-VZ2sNMw1d/r1SLPjUbOP9LKscKz1CQjID8adTL6gG8Lrrq+mYcIUxutyB+P/eG0J/7oRZLPR6OMt7dUOap6RTg=="],

-    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.5.10", "", { "os": "linux", "cpu": "x64" }, "sha512-5qtYaOgwVycZD1GaGshTRsi0rXPAmVExO03N1JQaHu+NYxK/vXSOc7Bu4QW0sPXx3Sp0SpzpP+FHjXABfoK66g=="],
+    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.5.12", "", { "os": "linux", "cpu": "x64" }, "sha512-eZiCjEzwbb6qClPPfk32Nha9xmr9obt69Xj0+9SKsXxWLBKkjQEGOMRoh/R9ObaQF4aq8If1xV3VEY0sD9W9vg=="],

-    "@opentui/core-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.5.10", "", { "os": "linux", "cpu": "x64" }, "sha512-Oj4H9hApuvuTKPWxh4SoZAgGJorR7vbvnrZA/cAkSMAk2VGSoHRRcqeXQbcH8IcdjVZ0KFpv8Zkl/D5Ye+2mew=="],
+    "@opentui/core-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.5.12", "", { "os": "linux", "cpu": "x64" }, "sha512-WWW0hVBoSYZ3D6AgZ4u2Y5/u/IyIq2pDb+4yI3WgJ70Wyt6ofHy+6kRGRgbXFn1p+rPInAHjCXD2v6C7iEKSrA=="],

-    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.5.10", "", { "os": "win32", "cpu": "arm64" }, "sha512-A9VhgvTxQoUdZ+8LmUumEng1sQNbj9QQQT3NYG9mSxI54qTANi7vOWNSphMiY6RMVsr22pgm6nUvSSvJXv7Jog=="],
+    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.5.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-aLbm6870Ybls6CYL4zMOCImTBPLZHZMUXJFGqMI44lIWxitkAtT6zg5lYA4oRqFRzzryDclxr29+hDgT3p3Blw=="],

-    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.5.10", "", { "os": "win32", "cpu": "x64" }, "sha512-u3KHa7kEeWrmKVDRJYpxSGO+g5E9cMGlrmTsPN3GVPHUmQMiREUawLXUvsU8+IHaQnqG3Q5nuE1yf4fPBzS+Qw=="],
+    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.5.12", "", { "os": "win32", "cpu": "x64" }, "sha512-KTwtwpfd2zF9opVh3SyRJYDd1o3Xv4XL8OZb8Zi+CqWUel6Y2IDCiVivCv8fGJt3J7wOIXXtuZI9ZUkLyKJCiQ=="],

-    "@opentui/keymap": ["@opentui/keymap@0.5.10", "", { "dependencies": { "@opentui/core": "0.5.10" }, "peerDependencies": { "@opentui/react": "0.5.10", "@opentui/solid": "0.5.10", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-8vDJF+ltXscSnLEv3rgCa4m7PcoYZeUT9BngugpFCmVoNevbaRtYijjdfiUuLmXfT61lO5QbR6nEhn2RZMK8ow=="],
+    "@opentui/keymap": ["@opentui/keymap@0.5.12", "", { "dependencies": { "@opentui/core": "0.5.12" }, "peerDependencies": { "@opentui/react": "0.5.12", "@opentui/solid": "0.5.12", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-yWPvJjRhJTRoRSUucQq9Ua8ZW7n/2YQ/j6JxWq5Qekm4WuFiTplEkebR/Aj2/xA8tX68NOE5qv1LrY0Jk3NLNQ=="],

-    "@opentui/solid": ["@opentui/solid@0.5.10", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.5.10", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.12", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.12" } }, "sha512-KrmMIsHiKBHOABTC0brOwqWm+sGq1ZX2sGCAx6WgtBbE3STMup9n8TAy/6gUYhwcjC9zugT53ytfSVwCwVWZUg=="],
+    "@opentui/solid": ["@opentui/solid@0.5.12", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.5.12", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.12", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.12" } }, "sha512-hAiVlVMtT7AkHGblKwcW1YAuXtxkSy1XSf/RRc4j3IlG3mTNX0bhJdnGOo3Xw14EqeZMp41Mcp5WzHAzMm/DzA=="],

    "@oslojs/asn1": ["@oslojs/asn1@1.0.0", "", { "dependencies": { "@oslojs/binary": "1.0.0" } }, "sha512-zw/wn0sj0j0QKbIXfIlnEcTviaCzYOY3V5rAyjR6YtOByFtJiT574+8p9Wlach0lZH9fddD4yb9laEAIl4vXQA=="],

@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-+Clo0VPDdruHSoBNvV/wKAM8iR6HJPtB00oa8yl9ujU=",
-    "aarch64-linux": "sha256-4wU5v36GTXjwyt5ls4FH+5G43Ujd+dKVSJR21w3lhbA=",
-    "aarch64-darwin": "sha256-pThjoD6baddQ6biy7k1ByXwGwLAeWe/+w0tcYmt1uWs=",
-    "x86_64-darwin": "sha256-bCBl63CqBiqilb+YdaOLBYYZx/yf47c1aqgDOkgdegg="
+    "x86_64-linux": "sha256-aQQQhaUlAhpfqzH0vNi0IJ1cg7FQHIKYzxeq5d8PZoU=",
+    "aarch64-linux": "sha256-r9aDFu3UYmudmmYPhzCrpFvQlaejXc8V1IzLtG3jZPc=",
+    "aarch64-darwin": "sha256-B0m41LelD7d61vPHGIZZSO/cU7gbjHDJHt6oxNRRM8Q=",
+    "x86_64-darwin": "sha256-9TWJsyI3Y6BMomtGSgqA1th9LpxpqP4F5Tl/GyexVYw="
  }
 }
@@ -52,9 +52,9 @@
      "@octokit/rest": "22.0.0",
      "@hono/standard-validator": "0.2.0",
      "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.10",
-      "@opentui/keymap": "0.5.10",
-      "@opentui/solid": "0.5.10",
+      "@opentui/core": "0.5.12",
+      "@opentui/keymap": "0.5.12",
+      "@opentui/solid": "0.5.12",
      "@tanstack/solid-virtual": "3.13.37",
      "@shikijs/stream": "4.4.3",
      "@standard-schema/spec": "1.1.0",
@@ -10,11 +10,11 @@

 ## Conventions

-Per-type constructors live on the type, not as top-level re-exports. Use `Message.system(...)`, `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `Message.media(...)`, `LanguageModel.make(...)`, `ToolDefinition.make(...)`, `ToolCallPart.make(...)`, `ToolResultPart.make(...)`, `ToolChoice.make(...)`, `ToolChoice.named(...)`, `SystemPart.make(...)`, and `GenerationOptions.make(...)` directly. The top-level `LLM` namespace is reserved for request-shaped call APIs: `LLM.request`, `LLM.generate`, `LLM.stream`, and `LLM.generateObject`. Use `LLMRequest.update(...)` when deriving canonical request data; do not add a duplicate `LLM.updateRequest(...)` path. Two ways to construct the same thing is one too many.
+Per-type constructors live on the type, not as top-level re-exports. Use `Message.system(...)`, `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `Message.media(...)`, `LanguageModel.make(...)`, `ToolDefinition.make(...)`, `ToolCallPart.make(...)`, `ToolResultPart.make(...)`, `ToolChoice.make(...)`, `ToolChoice.named(...)`, `SystemPart.make(...)`, and `GenerationOptions.make(...)` directly. The top-level `LLM` namespace is reserved for request-shaped call APIs: `LLM.request`, `LLM.generate`, `LLM.stream`, and `LLM.generateObject`. `LLM.generate`/`LLM.stream` and Promise `ai.llm.generate`/`ai.llm.stream` accept ergonomic input or an `LLMRequest`; both paths use the same canonical request. Core still builds, logs, replays, and updates that durable `LLMRequest` boundary. Use `LLMRequest.update(...)` when deriving canonical request data; do not add a duplicate `LLM.updateRequest(...)` path.

-Modality namespaces mirror `LLM` exactly: `Image.request`, `Image.generate`, `Image.stream` (later `Video`, `Speech`, `Transcription`). Common request fields (`images`, `mask`, `n`, `size`, `aspectRatio`, `seed`, `format`) lower natively or fail with a typed `AIError`; provider-native controls always live under `providerOptions`, never under a modality-specific `options` key.
+Modality namespaces mirror `LLM` exactly: `Image.request`, `Image.generate`, `Image.stream`, and the same for `Video`, `Speech`, and `Transcription`. Common request fields (`images`, `mask`, `n`, `size`, `aspectRatio`, `seed`, `format`) lower natively or fail with a typed `AIError`; provider-native controls always live under `providerOptions`, never under a modality-specific `options` key.

-Media payloads are always `Media.Asset` (`src/media.ts`). Construct them with `Media.bytes`, `Media.base64`, `Media.url`, `Media.ref`, `Media.fromDataUrl`, or `Media.file`; never introduce a parallel `data: string | Uint8Array` shape. `MediaPart.media`, `ImageRequest.images`/`mask`, `ImageResponse.images`, and the `media` `LLMEvent` all share it. Protocols branch on `asset.source.type` and `asset.kind` and use `ProviderShared.inlineMedia` / `requireInlineMedia` / `mediaUrl` / `MediaInput.refID` rather than re-deriving base64 or URL handling.
+Media payloads are always `Media.Asset` (`src/media.ts`). Construct them with `Media.bytes`, `Media.base64`, `Media.url`, `Media.ref`, `Media.fromDataUrl`, or `Media.file`; never introduce a parallel `data: string | Uint8Array` shape. `MediaPart.media`, `ImageRequest.images`/`mask`, `ImageResponse.images`, and the `media` `LLMEvent` all share it. Protocols branch on `asset.source.type` and `asset.kind` and use `ProviderShared.requireInlineMedia` / `inlineRequired` / `mediaUrl` / `mediaReference` and `MediaInput.inlineBytes` / `refID` rather than re-deriving base64 or URL handling.

 `schema/messages.ts → media.ts → route/executor-service.ts` is an accepted runtime dependency from the schema layer on the executor service tag: `Media.Asset.bytes()` must be able to download `url` sources, and the tag lives in that leaf module precisely so the schema barrel never imports the executor implementation (which imports the schema barrel back). Do not move the tag into `route/executor.ts` or import `route/executor.ts` from `src/schema/*` or `src/media.ts`.

@@ -98,11 +98,11 @@ When a provider supports multiple physical transports, selection remains executi

 Media does not fit the SSE-frames-to-event-state-machine LLM route. `MediaRoute.inline(...)` / `queued(...)` / `stream(...)` (`src/route/media.ts`) compose a `MediaProtocol` kind with `Endpoint` and `Auth` and own the transport plumbing: `http` option merging, URL/query rendering, auth headers, JSON vs multipart encoding, and handing the response back to the protocol. `MediaProtocol.inline` (`src/route/media-protocol.ts`) is `body.from(request)` plus `response.decode(response, context)`; each protocol declares `const route = MediaProtocol.identity({ id, name, provider })` once and decodes through `route.decodeJson` / `route.text` / `route.decodeStarted` so decode failures retain the raw body and HTTP context, raising `route.unsupported(operation, message)` for requests it cannot lower, and passes `route` as the first argument to `MediaProtocol.inline` / `queued` / `stream`. `Generation` (`src/generation.ts`) is the provider-neutral handle for a queued generation over a `GenerationRoute` (`status`, `result`, `cancel`). Image protocol files follow the same section order as LLM protocols and declare unsupported common fields once through the protocol's `unsupported` list.

-`MediaProtocol.queued` is the submit-then-poll kind every video route uses: `start` (body + decode into `{ token, snapshot }`), `status`, `result`, and optional `cancel`, each addressed by a route-owned `token` whose `Schema.Codec` makes it serializable. `MediaRoute.inline` and `MediaRoute.queued` compose the two kinds with `Endpoint` and `Auth`; the queued route decodes the token once at the boundary (`start` output or `resume` input) and closes over it in a token-free `GenerationRoute` (`status`/`result`/`cancel` are plain Effects), so `Generation` never sees the token's shape and only carries the encoded JSON for persistence. Polls reuse the route's auth and deployment headers plus the request's `http` overlay after `start`, and resolve relative paths against the route base URL (provider-issued absolute URLs such as fal's `status_url` pass through). `result` is always its own GET even when the provider returns output inside the status document, so `Generation.await` behaves the same after `start` and after `resume`. `PollContext.auth` carries only what `Auth` added or changed so protocols can hand download credentials to output assets as transient `Media.Asset.headers` (Veo) — never part of `source` or JSON. Status strings map through a per-protocol `STATUS` table via `MediaProtocol.status`; terminal generations without output fail through `output.ended` / `output.contentPolicy` with the provider document on `reason.body`. `GenerationAwaitOptions` (`AwaitOptions` in `src/generation.ts`, `{ poll?: Poll }`) is the one options type for `await`, `events`, `Video.generate`, and `Video.stream`.
+`MediaProtocol.queued` is the submit-then-poll kind every video route uses: `start` (body + decode into `{ token, snapshot }`), `status`, `result`, and optional `cancel` (with `activeOnly` when the provider's cancel endpoint deletes finished work, as Runway's does: the route refreshes status first and skips terminal generations), each addressed by a route-owned `token` whose `Schema.Codec` makes it serializable. `MediaRoute.inline` and `MediaRoute.queued` compose the two kinds with `Endpoint` and `Auth`; the queued route decodes the token once at the boundary (`start` output or `resume` input) and closes over it in a token-free `GenerationRoute` (`status`/`result`/`cancel` are plain Effects), so `Generation` never sees the token's shape and only carries the encoded JSON for persistence. Polls reuse the route's auth and deployment headers plus the request's `http` overlay after `start`, and resolve relative paths against the route base URL (provider-issued absolute URLs such as fal's `status_url` pass through). `result` is always its own GET even when the provider returns output inside the status document, so `Generation.await` behaves the same after `start` and after `resume`. `PollContext.auth` carries only what `Auth` added or changed so protocols can hand download credentials to output assets as transient `Media.Asset.headers` (Veo) — never part of `source` or JSON. Status strings map through a per-protocol `STATUS` table via `MediaProtocol.status`; terminal generations without output fail through `output.ended` / `output.contentPolicy` with the provider document on `reason.body`. `GenerationAwaitOptions` (`AwaitOptions` in `src/generation.ts`, `{ poll?: Poll }`) is the one options type for `await`, `events`, `Video.generate`, and `Video.stream`.

 `MediaProtocol.stream` is the incremental kind every speech route uses, with the same discipline as LLM protocols. `MediaRoute.stream` submits the caller's request as `MediaProtocol.Addressed<Request>` (`{ ...request, mode }`, `mode: "generate" | "stream"`), so one provider stays one protocol: `body.from`, the endpoint path, and `frames` read `request.mode` to pick the body, path, and framing. `frames(bytes, context)` returns frames — `Framing.sse`, `Framing.lines`, `Framing.document` (a single-document response shaped like a streamed record), or the raw `bytes` for chunked audio. `initial()` is fresh per-response parser state; `step` folds each frame into it and emits modality events; `finish(state, context)` runs once after the last frame with the request, body, and observed `http` (header-only usage lives there) and emits exactly one terminal event or fails with `route.incomplete()`. Keep parser state to real accumulators and derive anything the request or body determines in `finish`. `generate` runs the same stream and folds it with the modality's `collect`. Request-derived URL parameters go on the body's `query` (array values repeat the parameter), applied before route and caller `http.query`. Decode frames with `route.decodeFrame` and raise stream-time failures with `route.frameError` (the frame stays on `reason.body`); protocols never thread HTTP context, because the route fills `reason.http` on stream errors that lack it. Speech protocols share `protocols/utils/speech-stream.ts` for deltas, timestamps, voice ids, PCM and container descriptions, and the terminal asset.

-Transcription uses all three kinds (OpenAI and Gemini stream, Deepgram is inline, AssemblyAI is queued): every route carries its `kind` and `TranscriptionClient` dispatches on it. `ImageRoute` is the same union; both clients dispatch through `MediaRoute.dispatch` and models compose through `composeAnyRoute`, and fal queue protocols come from `protocols/utils/fal-queue.ts`. Bodies are `json`, `multipart`, or `binary` (a raw upload), and a queued protocol that must upload media before submitting implements `start.prepare` (`MediaProtocol.Prepare`; AssemblyAI `/v2/upload`).
+Every modality route is the inline | stream | queued union (transcription uses all three: OpenAI and Gemini stream, Deepgram is inline, AssemblyAI is queued), every client is `MediaClient.make(Service, { modality, responseEvents })` (`src/media-client.ts`), which dispatches on the route's `kind`, and every model composes through `composeRoute`. fal queue protocols come from `protocols/utils/fal-queue.ts`, bodies are `json`, `multipart`, or `binary` (a raw upload), and a queued protocol that must upload media before submitting implements `start.prepare` (`MediaProtocol.Prepare`; AssemblyAI `/v2/upload`).

 ### URL Construction

@@ -112,7 +112,7 @@ For providers where the URL is derived from typed inputs (Azure resource name, B

 ### Provider Facades

-Provider-facing APIs are configured facades over route values. Endpoint/auth/resource/API-version setup happens before model selection, and model selectors accept only a model or deployment id. Media models use per-modality selectors on the same facade (`openai.image(id)`, later `.video` / `.speech` / `.transcription`) that mirror `openai.responses(id)`; the one-word overlap with the request namespace is accepted over a second construction path:
+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. Media models use per-modality selectors on the same facade (`openai.image(id)`, `.speech(id)`, `.transcription(id)`, `google.video(id)`) that mirror `openai.responses(id)`; the one-word overlap with the request namespace is accepted over a second construction path:

 ```ts
 const openai = OpenAI.configure({ apiKey, baseURL })
@@ -275,6 +275,7 @@ Use this order for every protocol module:
 ### Rules

 - Keep protocol files focused on the protocol. Move provider-specific projection, signing, media normalization, or other bulky transformations into `src/protocols/utils/*`.
+- Send `tool.inputSchema` as given. `prepareRequest` applies the tool schema rules (`ToolSchemaProjection.tools`) once per request, including tools in namespaces. A protocol whose API needs a model family's rules for every model declares `sanitizer` instead of transforming schemas itself.
 - Use `Effect.fn("Provider.fromRequest")` for request body construction entrypoints. Use `Effect.fn(...)` for event handlers that yield effects; keep purely synchronous handlers as plain functions returning a `StepResult` that the dispatcher lifts via `Effect.succeed(...)`.
 - Parser state owns terminal information. The state machine records finish reason, usage, and pending tool calls; emit one terminal `finish` event (or `provider-error`) for each completed response. If a provider splits reason and usage across events, merge them in parser state before flushing.
 - Emit exactly one terminal `finish` event for a completed response, normally after a matching `step-finish`. Use `stream.terminal` to stop reading when the provider has a completion sentinel; use `stream.onHalt` when the final event must be flushed after the framed stream ends.
@@ -9,15 +9,13 @@ import { OpenAI } from "@opencode/ai/providers"

 const openai = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY })

-const request = LLM.request({
-  model: openai.responses("gpt-4o-mini"), // `.chat(...)` selects the Chat Completions API instead
-  system: "You are concise.",
-  prompt: "Say hello in one short sentence.",
-  generation: { maxTokens: 40 },
-})
-
 const program = Effect.gen(function* () {
-  const response = yield* LLM.generate(request)
+  const response = yield* LLM.generate({
+    model: openai.responses("gpt-4o-mini"), // `.chat(...)` selects the Chat Completions API instead
+    system: "You are concise.",
+    prompt: "Say hello in one short sentence.",
+    generation: { maxTokens: 40 },
+  })
  console.log(response.text)
 })

@@ -25,7 +23,8 @@ const program = Effect.gen(function* () {
 await Effect.runPromise(program.pipe(Effect.provide(AIClient.layer)))
 ```

-Run `LLM.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses,
+Run `LLM.stream(...)` instead of `generate` when you want incremental `LLMEvent`s. Both accept input or a prebuilt
+`LLM.request(...)`. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses,
 Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.

 The same configured facade names image, video, speech, and transcription models. `Image.generate` resolves the
@@ -72,10 +71,11 @@ helpers; `ai.file` and `ai.write` load `node:fs/promises` on first use, so no Ef
 import { AI } from "@opencode/ai/promise"

 const ai = AI.make()
-const text = await ai.llm.generate({ model: openai.responses("gpt-4o-mini"), prompt: "Say hello." })
+const input = { model: openai.responses("gpt-4o-mini"), prompt: "Say hello." }
+const text = await ai.llm.generate(input)
 const generated = await ai.image.generate({ model: openai.image("gpt-image-2"), prompt: "A lighthouse" })
 await ai.write(generated.image, "./lighthouse.png") // also ai.file(path), ai.bytes(asset), ai.base64(asset), ai.materialize(asset)
-for await (const event of ai.llm.stream({ model: openai.responses("gpt-4o-mini"), prompt: "Stream hello." })) {
+for await (const event of ai.llm.stream(ai.llm.request(input))) {
  // LLMEvent
 }
 await ai.dispose()
@@ -475,18 +475,18 @@ const program = Effect.gen(function* () {
 Common fields are portable in shape, not in support. Unsupported fields fail with a typed `AIError` before any network
 call rather than being dropped, so check this table before swapping only the `model`:

-| Provider              | `n` | `size`    | `aspectRatio` | `seed` | `format` | `images`                  | `mask`              |
-| --------------------- | --- | --------- | ------------- | ------ | -------- | ------------------------- | ------------------- |
-| OpenAI                | ✓¹  | ✓         | ✗             | ✗      | ✓        | ✓                         | ✓                   |
-| Google (Gemini)       | 1   | ✗         | ✓             | ✓      | ✗        | ✓ (no public URLs)        | ✗                   |
-| xAI                   | ✓   | ✗         | ✓             | ✗      | ✗        | ✓                         | ✗                   |
-| Z.ai                  | ✗   | ✓         | ✗             | ✗      | ✗        | ✗                         | ✗                   |
-| Meta                  | ✓   | ✓ (hint)  | ✗             | ✗      | ✓        | ✓                         | ✗                   |
-| Black Forest Labs     | 1   | per model | per model     | ✓      | ✓        | per model (1–8)           | `flux-pro-1.0-fill` |
-| fal                   | ✓   | per model | per model     | ✓      | ✓        | 1 (several on `/edit`)    | ✓                   |
-| Replicate             | ✗   | ✗         | ✗             | ✗      | ✗        | ✗ (use `providerOptions`) | ✗                   |
-| Stability `image`     | 1   | ✗         | ✓             | ✓      | ✓        | 1 (not on `core`)         | ✗                   |
-| Stability `upscale()` | ✗   | ✗         | ✗             | ✓      | ✓        | exactly 1 (required)      | ✗                   |
+| Provider              | `n` | `size`    | `aspectRatio` | `seed` | `format` | `images`                         | `mask`              |
+| --------------------- | --- | --------- | ------------- | ------ | -------- | -------------------------------- | ------------------- |
+| OpenAI                | ✓¹  | ✓         | ✗             | ✗      | ✓        | ✓                                | ✓                   |
+| Google (Gemini)       | 1   | ✗         | ✓             | ✓      | ✗        | ✓ (no public URLs)               | ✗                   |
+| xAI                   | ✓   | ✗         | ✓             | ✗      | ✗        | ✓                                | ✗                   |
+| Z.ai                  | ✗   | ✓         | ✗             | ✗      | ✗        | ✗                                | ✗                   |
+| Meta                  | ✓   | ✓ (hint)  | ✗             | ✗      | ✓        | ✓                                | ✗                   |
+| Black Forest Labs     | 1   | per model | per model     | ✓      | ✓        | per model (1–8)                  | `flux-pro-1.0-fill` |
+| fal                   | ✓   | per model | per model     | ✓      | ✓        | 1 (several on `/edit`, `/multi`) | ✓                   |
+| Replicate             | ✗   | ✗         | ✗             | ✗      | ✗        | ✗ (use `providerOptions`)        | ✗                   |
+| Stability `image`     | 1   | ✗         | ✓             | ✓      | ✓        | 1 (not on `core`)                | ✗                   |
+| Stability `upscale()` | ✗   | ✗         | ✗             | ✓      | ✓        | exactly 1 (required)             | ✗                   |

 ✓ lowers natively; ✗ fails whenever the field is set (including `n: 1`); `1` means `n > 1` fails. ¹ `Image.stream` on OpenAI generates one image. fal
 rejects `size` and `aspectRatio` together; which one a fal or BFL model takes depends on the model.
@@ -621,8 +621,7 @@ persist the bytes promptly if they must remain available.
 ### Partial images

 OpenAI's GPT image models stream previews. `Image.stream` sends `stream: true` with `partialImages` (0–3, default 2)
-and emits `image-partial` events before each final `image`; `Image.generate` keeps the plain JSON request.
-`dall-e-*` models do not stream and fail typed:
+and emits `image-partial` events before each final `image`; `Image.generate` keeps the plain JSON request:

 ```ts
 import { Stream } from "effect"
@@ -699,7 +698,7 @@ const program = Effect.gen(function* () {
 })
 ```

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

 ## Video generation

@@ -840,9 +839,10 @@ Provider notes:
 - **OpenAI** streams over SSE (`stream_format: "sse"`), which is also the only place it reports token usage; `tts-1`
  and `tts-1-hd` do not support SSE and stream the raw audio body instead. `pcm` is 24 kHz 16-bit mono. `language`
  and `timestamps` are not supported.
- **Gemini TTS** returns raw 16-bit PCM only (`audio/L16;codec=pcm;rate=24000`), so any `format` other than `pcm`
-  fails typed; wrap the samples yourself. Style is directed in the text, so `instructions` and `speed` fail typed.
-  Only `gemini-3.1-flash-tts-preview` and later support streaming. Two-speaker audio goes through
+- **Gemini TTS** returns the provider's default output: WAV for Gemini 3.8 TTS `generate`, raw 16-bit PCM
+  (`audio/L16;codec=pcm;rate=24000`) otherwise. `pcm` is the only explicit `format` it accepts, and it fails typed on
+  Gemini 3.8 `generate`; the route never wraps PCM as WAV. Style is directed in the text, so `instructions` and
+  `speed` fail typed. Only `gemini-3.1-flash-tts-preview` and later support streaming. Two-speaker audio goes through
  `providerOptions.speechConfig.multiSpeakerVoiceConfig`.
 - **ElevenLabs** requires `voice` (the path voice id) and authenticates with `xi-api-key`. `format` maps to the
  `output_format` query parameter (`mp3_44100_128`, `pcm_24000`, `wav_24000`, `opus_48000_64`);
@@ -936,7 +936,7 @@ const transcript = await generation.await({ poll: { interval: 3_000 } })
 ## Public API

 - **`LLM.request({...})`** — build a provider-neutral `LLMRequest`. Accepts ergonomic inputs (`system: string`, `prompt: string`) that normalize into the canonical Schema classes.
- **`LLM.generate` / `LLM.stream`** — re-exported from `LLMClient` for one-import use.
+- **`LLM.generate` / `LLM.stream`** — run direct input or an `LLMRequest` through `LLMClient` for one-import use.
 - **`Message.user(...)` / `Message.assistant(...)` / `Message.tool(...)`** — message constructors from the canonical schema model.
 - **`LanguageModel.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model.
 - **`LLMEvent.is.*`** — typed guards (`is.textDelta`, `is.toolCall`, `is.finish`, …) for filtering streams.
@@ -944,6 +944,7 @@ const transcript = await generation.await({ poll: { interval: 3_000 } })
 - **`ImageClient`** — Effect service and layer for image execution, parallel to `LLMClient`.
 - **`Media`** — the shared asset type (`Media.Asset`, `Media.Source`) and constructors used by messages, tool results, and media requests.
 - **`Generation`** — provider-neutral handle for an in-flight media generation (`await`, `refresh`, `cancel`, `events`) used by queued media routes.
+- **`Video.request` / `generate` / `stream` / `start` / `resume`** — queued video generation through a provider-neutral request; `VideoClient` is its Effect service and layer.
 - **`Speech.request` / `Speech.generate` / `Speech.stream`** — text-to-speech through a provider-neutral request; `SpeechClient` is its Effect service and layer.
 - **`Transcription.request` / `generate` / `stream` / `start` / `resume`** — speech-to-text over inline, streaming, and queued routes; `TranscriptionClient` is its Effect service and layer.
 - **`AIClient.layer` / `AIClient.layerWith(executor)`** — every modality client plus the request executor in one layer.
@@ -1,6 +1,7 @@
 # Media generation in `@opencode/ai` — public API direction

-Status: phases 1–4 implemented (through Image queued routes and partial images); phase 5 proposal.
+Status: phases 1–4 implemented (through Image queued routes and partial images; ElevenLabs Scribe transcription
+pending); phase 5 proposal.

 ## Goal

@@ -40,7 +41,7 @@ The design below is derived from a survey of the raw provider APIs (OpenAI, Gemi

 ### Model selection

-A model value is built as `OpenAI.configure({ apiKey }).responses("gpt-5")` or `.image("gpt-image-2")`: `configure` fixes credentials, endpoint, and defaults; the selector fixes which of the provider's APIs to hit and binds the typed `providerOptions` generic. Media follows the same shape with one selector per modality — `openai.image(id)` today, `.video(id)` / `.speech(id)` / `.transcription(id)` as those modalities land — mirroring `openai.responses(id)`. `Image.request` accepts `ImageModel` only, exactly as `LLM.request` accepts `LanguageModel`.
+A model value is built as `OpenAI.configure({ apiKey }).responses("gpt-5")` or `.image("gpt-image-2")`: `configure` fixes credentials, endpoint, and defaults; the selector fixes which of the provider's APIs to hit and binds the typed `providerOptions` generic. Media follows the same shape with one selector per modality — `.image(id)`, `.video(id)`, `.speech(id)`, `.transcription(id)` on the facades that offer each — mirroring `openai.responses(id)`. `Image.request` accepts `ImageModel` only, exactly as `LLM.request` accepts `LanguageModel`.

 ```ts
 import { OpenAI, Google } from "@opencode/ai/providers"
@@ -135,12 +136,12 @@ Effect.gen(function* () {
 })
 ```

-`size` and `aspectRatio` are not interchangeable; each route rejects fields it cannot lower — see the README's Image
-portability matrix.
+`size` and `aspectRatio` are not interchangeable; each route rejects fields it cannot lower — see the portability table
+in the README's Image generation section.

 Editing is not a separate function; `images`/`mask` on the request select the edit path in the route (OpenAI `/images/edits`, Gemini multimodal parts, xAI `/images/edits`). Routes that cannot honor `mask` fail with `Unsupported`.

-`ImageRoute` is the inline | stream | queued union, dispatched on `route.kind`. `Image.stream` on a streaming route emits `image-partial` previews before each `image`; on a queued route it emits `generation-queued` / `generation-progress` observations, then the result's `image` and `finish` events.
+`ImageRoute` is the inline | stream | queued union, dispatched on `route.kind`, like every modality route. `Image.stream` on a streaming route emits `image-partial` previews before each `image`; on a queued route it emits `generation-queued` / `generation-progress` observations, then the result's `image` and `finish` events.

 #### Video

@@ -166,8 +167,8 @@ Effect.gen(function* () {

  // Simple: wait for it.
  const response = yield* Video.generate(request, { poll: { interval: "10 seconds", timeout: "10 minutes" } })
-  response.video                                     // Media.Asset: url with expiresAt (+ transient `headers` for Veo downloads)
-  response.usage                                     // credits on Runway; the other three report none
+  response.video                                     // Media.Asset: url (expiresAt on Veo and Runway; transient `headers` for Veo downloads)
+  response.usage                                     // credits on Runway; the other three report none (xAI's usage.cost_in_usd_ticks is not decoded)
  response.notices                                   // Veo raiMediaFilteredReasons → filtered, xAI respect_moderation → moderated
  yield* response.video.materialize()                // pull bytes before the URL expires

@@ -175,7 +176,7 @@ Effect.gen(function* () {
  const generation = yield* Video.start(request)     // Generation<VideoResponse>
  generation.id; generation.status; generation.progress; generation.position; generation.token
  yield* generation.await({ poll })                  // VideoResponse
-  yield* generation.cancel()                         // fal PUT cancel_url, Runway DELETE /tasks/{id}; no-op for Veo and xAI
+  yield* generation.cancel()                         // fal PUT cancel_url, Runway DELETE /tasks/{id}; Veo and xAI succeed without a request

  // Resume from another process. The token is validated against the route's codec and refreshed once. It carries no
  // route identity, so persist the provider and model ID alongside it: `resume` needs the model.
@@ -188,10 +189,11 @@ Effect.gen(function* () {

 Tokens are route-owned JSON: Veo `{ operation }`, xAI `{ requestID }`, Runway `{ taskID }`, fal
 `{ requestID, statusURL, responseURL, cancelURL }` (fal's follow-up URLs are authoritative and absolute). Common-field
-lowering per provider: Veo takes inline media only and rejects `audio: false` and `n > 1`; xAI rejects `seed` and
-`negativePrompt` and routes a `video` input to edits or (`providerOptions.mode: "extend"`) extensions; fal rejects
-`durationSeconds`, `references`, and `frames.last` because the field names and enums differ per model; Runway passes
-`aspectRatio` through as its pixel `ratio` and rejects `n`.
+lowering per provider: Veo takes inline media only, rejects `audio: false` and `n > 1`, and requires `frames.first`
+when `frames.last` is set; xAI rejects `n`, `seed`, and `negativePrompt` and routes a `video` input to edits or
+(`providerOptions.mode: "extend"`) extensions; fal rejects `n`, plus `durationSeconds`, `references`, and `frames.last`
+because the field names and enums differ per model; Runway passes `aspectRatio` through as its pixel `ratio` and
+rejects `n`.

 Deferred: `Video.complete(model, token, webhook)` (finish from a webhook payload without polling) and provider poll
 hints (none of the four providers emit one). Later providers: Luma, Kling, MiniMax, Replicate.
@@ -215,7 +217,7 @@ const request = Speech.request({
 })

 const response = yield* Speech.generate(request)   // SpeechResponse: audio: Media.Asset, timestamps?, usage?, providerMetadata?
-yield* Speech.stream(request)                      // Stream<SpeechEvent>: audio-delta { chunk } | timestamps { items } | finish { audio, usage? }
+yield* Speech.stream(request)                      // Stream<SpeechEvent>: generation-queued | generation-progress | audio-delta { chunk } | timestamps { items } | finish { audio, usage? }
 ```

 Execution is `MediaProtocol.stream` for every provider: one request whose body is framed and folded by a `step`
@@ -241,10 +243,12 @@ name→id resolution. Multi-speaker (Gemini `speechConfig.multiSpeakerVoiceConfi
 `opus_48000_64`, Cartesia `{ container, encoding, sample_rate }`, Deepgram `encoding`+`container`) and declares the
 asset's media type rather than sniffing, because headerless PCM can look like an MPEG frame sync. Headerless PCM
 always carries `info.encoding`, `info.sampleRate`, and `info.channels`; its media type is the provider's declaration
-(Gemini `audio/L16;codec=pcm;rate=24000`, Deepgram's `content-type`) or `audio/pcm`. Gemini returns PCM only, so any
-other `format` is rejected rather than wrapped as WAV by the route. Every `format` value a route cannot produce (unknown
-to it, a container on Cartesia SSE, WAV on an ElevenLabs stream, anything but PCM on Gemini) fails the same way as an
-unsupported field: `UnsupportedOperation` with `operation: "media.format"`.
+(Gemini `audio/L16;codec=pcm;rate=24000`, Deepgram's `content-type`) or `audio/pcm`. Gemini's asset follows the
+provider's declared type: WAV for Gemini 3.8 TTS `generate`, headerless PCM otherwise. The route never wraps PCM as WAV,
+so `pcm` is the only explicit `format` it accepts, and not on Gemini 3.8 `generate`. Every `format` value a route cannot
+produce (unknown to it, a container on Cartesia SSE, WAV on an ElevenLabs stream, anything but `pcm` on Gemini, `pcm` on
+Gemini 3.8 `generate`) fails the same way as an unsupported field: `UnsupportedOperation` with
+`operation: "media.format"`.

 **Timestamps.** `timestamps: true` on the request asks for alignment. ElevenLabs selects the `with-timestamps`
 endpoints (character-level, NDJSON when streaming); Cartesia sets `add_timestamps` on `/tts/sse` (word-level; a
@@ -277,7 +281,7 @@ const request = Transcription.request({
  language: "en",                                  // provider-native passthrough
  timestamps: "segment",                           // none | segment | word
  diarize: true,
-  speakers: 2,                                     // expected count, hint only (AssemblyAI)
+  speakers: 2,                                     // exact speaker count (AssemblyAI only)
  providerOptions: { known_speaker_names: ["agent"] },
 })

@@ -291,10 +295,11 @@ yield* Transcription.resume(model, token)
 Transcription is the first modality whose providers span all three protocol kinds, and it needed no fourth kind.
 Every `MediaRoute` now carries its `kind`; `TranscriptionRoute` is the union of the inline, stream, and queued routes;
 `TranscriptionModel.fromRoute` is overloaded per protocol kind (arity picks the overload: `<Options>`,
-`<Options, Frame, State>`, `<Options, Token>`) and composes through `MediaRoute.inline` / `stream` / `queued`; and
-`TranscriptionClient` dispatches on `route.kind`. `generate` on a queued route is `start` then `await`; `stream` on an
-inline route is the response as a single `finish`, and on a queued route it is the status observations followed by
-`finish`. `start` / `resume` on a non-queued route fail with `UnsupportedOperation` (`transcription.start`). The
+`<Options, Frame, State>`, `<Options, Token>`) and composes through the shared `composeRoute` (`src/media-model.ts`),
+which picks `MediaRoute.inline` / `stream` / `queued`; and `TranscriptionClient`, like every modality client, is
+`MediaClient.make` (`src/media-client.ts`), which dispatches on `route.kind`. `generate` on a queued route is `start`
+then `await`; `stream` on an inline route is the response as a single `finish`, and on a queued route it is the status
+observations followed by `finish`. `start` / `resume` on a non-queued route fail with `UnsupportedOperation` (`transcription.start`). The
 `finish` event carries the whole transcript (text, segments, words, language, duration, usage), so the stream route's
 `collect` is just "take `finish`".

@@ -309,11 +314,12 @@ Settled rules:
  word offsets, so segment timestamps and diarization also request word offsets there.
 - **Diarization.** `diarize` means segments (and words, where the provider labels them) carry `speaker`. Labels are
  provider-native strings — OpenAI `A` or a known speaker name, Deepgram `0`, Gemini `spk:0`, AssemblyAI `A` — with no
-  cross-provider speaker model. `speakers` is a hint; only AssemblyAI (`speakers_expected`) accepts it.
+  cross-provider speaker model. `speakers` is the exact number of speakers to label, which AssemblyAI (`speakers_expected`, the only route that
+  accepts it) treats as a constraint rather than a hint.
 - **Language** is passed through (`language`, OpenAI `gpt-transcribe` `languages[]`, Gemini `languageCodes`,
  AssemblyAI `language_code`). `response.language` is the provider's own value, lowercased but not normalized: an
-  ISO code on most routes, `english` from whisper-1, `en_us` from AssemblyAI. Deepgram and AssemblyAI assume English
-  unless asked to detect, so a missing `language` enables their detection.
+  ISO code on most routes (AssemblyAI's detection returns `en`), `english` from whisper-1. Deepgram and AssemblyAI
+  assume English unless asked to detect, so a missing `language` enables their detection.
 - **Gemini** requires a transcribe model; other model ids fail with `UnsupportedOperation` before the call, because
  general models ignore `audioTranscriptionConfig` and answer conversationally. Streamed chunks carry whole speaker
  turns (one part per turn), which join with a space.
@@ -323,7 +329,7 @@ Settled rules:

 | Provider | Kind | Audio input | `timestamps` | `diarize` | Unsupported | Usage |
 |---|---|---|---|---|---|---|
-| OpenAI | stream (`stream: true` in `stream` mode) | multipart `file` (inline only) | `whisper-1` (`verbose_json`); diarize model: `segment` | `gpt-4o-transcribe-diarize` (`diarized_json`) | `speakers`; `prompt` on the diarize model; streaming on `whisper-1` | `tokens` or `seconds` |
+| OpenAI | stream (`stream: true` in `stream` mode; `whisper-1` ignores `stream`, so it emits only `finish`) | multipart `file` (inline only) | `whisper-1` (`verbose_json`); diarize model: `segment` | `gpt-4o-transcribe-diarize` (`diarized_json`) | `speakers`; `prompt` on the diarize model | `tokens` or `seconds` |
 | Gemini | stream (`generateContent` / `streamGenerateContent`) | `inlineData` or Gemini Files `fileData` | `audioTranscriptionConfig.wordTimestamp` | `audioTranscriptionConfig.diarization` | `prompt`, `speakers` | `tokens` |
 | Deepgram | inline | raw body, or JSON `{ url }` | words always; `segment` → `utterances` | `diarize_model=latest` + `utterances` | `prompt`, `speakers` | `seconds` (`metadata.duration`) |
 | AssemblyAI | queued (upload → submit → poll) | `/v2/upload` then `audio_url`, or a URL | words always; `segment` → `speaker_labels` | `speaker_labels` | — | `seconds` (`audio_duration`) |
@@ -353,7 +359,7 @@ GenerationAwaitOptions = { poll?: Poll }
 Poll = { interval?: Duration; timeout?: Duration }
 ```

-`Generation` is not video-specific. Image routes on BFL, fal, and Replicate are queued; `Image.start` exists for them. A route declares itself `inline` or `queued`; `generate` on a queued route is `start` then `await`.
+`Generation` is not video-specific. Image routes on BFL, fal, Replicate, and Stability `upscale()` are queued; `Image.start` exists for them. A route declares itself `inline` or `queued`; `generate` on a queued route is `start` then `await`.

 ### Usage

@@ -389,7 +395,8 @@ for await (const event of generation.events({ poll: { interval: 10_000 } })) {
 const video = await generation.await({ poll: { interval: 10_000 }, signal })
 const resumed = await ai.video.resume(model, JSON.parse(saved)) // persist provider + model ID with the token

-const text = await ai.llm.generate({ model, prompt })
+const request = ai.llm.request({ model, prompt })
+const text = await ai.llm.generate(request)
 for await (const event of ai.llm.stream(request)) { … }

 await ai.dispose()
@@ -399,14 +406,15 @@ Streams become `AsyncIterable` via `Stream.toAsyncIterable`. `AIError` is thrown

 ### Providers

-Existing facades gain per-modality selectors; the modality routes each facade provides:
+Existing facades gain per-modality selectors; the modality routes each facade provides (*italics* are not
+implemented):

 | Facade | llm | image | video | speech | transcription | other |
 |---|---|---|---|---|---|---|
-| `OpenAI` | responses (default), chat | Images API (stream) | Sora (deprecated 2026-09-24) | ✓ | ✓ | |
+| `OpenAI` | responses (default), chat | Images API (stream) | *Sora skipped (decision 8)* | ✓ | ✓ | |
 | `Google` | Gemini | Gemini-native | Veo | Gemini TTS | `gemini-3.5-transcribe` | |
 | `XAI` | ✓ | ✓ | ✓ | | | |
-| `ElevenLabs` | | | | ✓ | Scribe | soundEffect, music |
+| `ElevenLabs` | | | | ✓ | *Scribe (pending)* | *soundEffect, music (phase 5)* |
 | `Cartesia` | | | | ✓ | | |
 | `Deepgram` | | | | Aura | ✓ | |
 | `Fal` | | ✓ (queued) | ✓ | | | |
@@ -415,11 +423,11 @@ Existing facades gain per-modality selectors; the modality routes each facade pr
 | `Replicate` | | ✓ (queued) | | | | |
 | `Stability` | | `image` (inline), `upscale()` (queued) | | | | |
 | `Runway` | | | ✓ | | | |
-| `Luma`, `Kling`, `MiniMax` | | per provider | | | | |
+| `Luma`, `Kling`, `MiniMax` | | *deferred* | *deferred* | | | |

 New facades follow the existing one-file-per-provider rule. The facade selector is the public path for media models; modality-specific package entrypoints (for example `@opencode/ai/providers/openai/images`) are deferred until Core has a modality-aware model resolver.

-`ImageModel<Options>` gives typed `providerOptions` per model; `VideoModel`, `SpeechModel`, and `TranscriptionModel` follow the same generic. They share an internal `MediaModel` base class (ids, route, `http` overlays) that is not part of the public exports; `Generation` and the promise client work with the concrete modality models.
+`ImageModel<Options>` gives typed `providerOptions` per model; `VideoModel`, `SpeechModel`, and `TranscriptionModel` follow the same generic. As with `LanguageModel`, the route type does not carry `Options`, so `ImageModel<OpenAIImageOptions>` is an `ImageModel` and client methods take plain `ImageRequestFor`. They share an internal `MediaModel` base class (ids, route, `http` overlays) that is not part of the public exports; `Generation` and the promise client work with the concrete modality models.

 ### Routes and protocols

@@ -53,6 +53,8 @@ export type Event = Observation | { readonly type: "generation-finished"; readon

 const TERMINAL: ReadonlySet<Status> = new Set(["completed", "failed", "cancelled", "expired"])

+export const isTerminal = (status: Status) => TERMINAL.has(status)
+
 export class Generation<Response> {
  readonly id: string
  readonly status: Status
@@ -81,7 +83,7 @@ export class Generation<Response> {
  }

  get terminal() {
-    return TERMINAL.has(this.status)
+    return isTerminal(this.status)
  }

  refresh(): Effect.Effect<Generation<Response>, AIError> {
@@ -109,9 +111,10 @@ export class Generation<Response> {
  }

  /**
-   * Status observations as a stream, ending after the first terminal observation. Each poll is bounded by the time
-   * remaining until `poll.timeout`, so a hung status request fails the stream instead of stalling it. (`Stream.interruptWhen`
-   * would express this directly but deadlocks under `TestClock` when the source completes while the timer sleeps.)
+   * Status observations as a stream, ending after the first terminal observation. Each poll and each sleep between polls
+   * is bounded by the time remaining until `poll.timeout`, so a hung status request or a long interval fails the stream at
+   * the deadline instead of stalling it. (`Stream.interruptWhen` would express this directly but deadlocks under
+   * `TestClock` when the source completes while the timer sleeps.)
   */
  events(options?: AwaitOptions): Stream.Stream<Event, AIError> {
    if (this.terminal) return Stream.make(this.event())
@@ -120,17 +123,26 @@ export class Generation<Response> {
      Clock.currentTimeMillis.pipe(
        Effect.map((start) => {
          const deadline = start + Duration.toMillis(timeout)
+          // Fail before polling once the deadline has passed: a fast status request could otherwise win the zero-budget
+          // race and schedule another zero-delay poll.
          const refresh = Clock.currentTimeMillis.pipe(
            Effect.flatMap((now) =>
-              this.refresh().pipe(
-                Effect.timeoutOrElse({
-                  duration: Duration.millis(Math.max(0, deadline - now)),
-                  orElse: () => this.timeoutError(timeout),
-                }),
-              ),
+              now >= deadline
+                ? this.timeoutError(timeout)
+                : this.refresh().pipe(
+                    Effect.timeoutOrElse({
+                      duration: Duration.millis(deadline - now),
+                      orElse: () => this.timeoutError(timeout),
+                    }),
+                  ),
            ),
          )
-          return Stream.fromEffectSchedule(refresh, this.schedule(options?.poll)).pipe(
+          const schedule = this.schedule(options?.poll).pipe(
+            Schedule.modifyDelay((meta) =>
+              Effect.succeed(Duration.min(meta.duration, Duration.millis(Math.max(0, deadline - meta.now)))),
+            ),
+          )
+          return Stream.fromEffectSchedule(refresh, schedule).pipe(
            Stream.takeUntil((generation) => generation.terminal),
            Stream.map((generation) => generation.event()),
          )
@@ -1,99 +1,30 @@
-import { Context, Effect, Layer, Stream } from "effect"
-import type { AwaitOptions, Generation } from "./generation.js"
-import { RequestExecutor } from "./route/executor.js"
-import { MediaRoute } from "./route/media.js"
-import type { AIError } from "./schema/index.js"
+import { Context } from "effect"
+import { MediaClient } from "./media-client.js"
 import {
-  responseEvents,
+  ImageOutputEvent,
+  ImageFinishEvent,
  type ImageEvent,
-  type ImageModel,
-  type ImageOptions,
  type ImageRequestFor,
  type ImageResponse,
 } from "./image.js"

-export interface Interface {
-  readonly generate: <Options extends ImageOptions>(
-    request: ImageRequestFor<Options>,
-    options?: AwaitOptions,
-  ) => Effect.Effect<ImageResponse, AIError>
-  readonly stream: <Options extends ImageOptions>(
-    request: ImageRequestFor<Options>,
-    options?: AwaitOptions,
-  ) => Stream.Stream<ImageEvent, AIError>
-  readonly start: <Options extends ImageOptions>(
-    request: ImageRequestFor<Options>,
-  ) => Effect.Effect<Generation<ImageResponse>, AIError>
-  readonly resume: <Options extends ImageOptions>(
-    model: ImageModel<Options>,
-    token: unknown,
-  ) => Effect.Effect<Generation<ImageResponse>, AIError>
-}
+export type Interface = MediaClient.Interface<ImageRequestFor, ImageEvent, ImageResponse>

 export class ImageClientService extends Context.Service<ImageClientService, Interface>()("@opencode/ImageClient") {}
 export const Service = ImageClientService
 export type Service = ImageClientService

-export const generate = <Options extends ImageOptions>(
-  request: ImageRequestFor<Options>,
-  options?: AwaitOptions,
-): Effect.Effect<ImageResponse, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.generate(request, options)
-  })
-
-export const stream = <Options extends ImageOptions>(
-  request: ImageRequestFor<Options>,
-  options?: AwaitOptions,
-): Stream.Stream<ImageEvent, AIError, Service> =>
-  Stream.unwrap(
-    Effect.gen(function* () {
-      const client = yield* Service
-      return client.stream(request, options)
-    }),
-  )
-
-export const start = <Options extends ImageOptions>(
-  request: ImageRequestFor<Options>,
-): Effect.Effect<Generation<ImageResponse>, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.start(request)
-  })
-
-export const resume = <Options extends ImageOptions>(
-  model: ImageModel<Options>,
-  token: unknown,
-): Effect.Effect<Generation<ImageResponse>, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.resume(model, token)
-  })
-
-export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service
-    const dispatch = MediaRoute.dispatch<ImageEvent, ImageResponse>({
-      modality: "image",
-      execute: executor.execute,
-      responseEvents,
-    })
-    return Service.of({
-      start: (request) => dispatch.start(request.model.route, request),
-      resume: (model, token) => dispatch.resume(model.route, model, token),
-      generate: (request, options) => dispatch.generate(request.model.route, request, options),
-      stream: (request, options) => dispatch.stream(request.model.route, request, options),
-    })
-  }),
-)
-
 export const ImageClient = {
  Service,
-  layer,
-  generate,
-  stream,
-  start,
-  resume,
+  ...MediaClient.make(Service, {
+    modality: "image",
+    responseEvents: (response: ImageResponse) => [
+      ...response.images.map((image, index) => ImageOutputEvent.make({ index, image })),
+      ImageFinishEvent.make({
+        usage: response.usage,
+        notices: response.notices,
+        providerMetadata: response.providerMetadata,
+      }),
+    ],
+  }),
 } as const
@@ -1,9 +1,8 @@
 import { Effect, Schema, Stream } from "effect"
 import { Generation, ProgressEvent, QueuedEvent, type AwaitOptions } from "./generation.js"
 import { Media } from "./media.js"
-import { MediaModel, composeAnyRoute, tryRequest } from "./media-model.js"
+import { MediaModel, composeRoute, tryRequest } from "./media-model.js"
 import { MediaRoute } from "./route/media.js"
-import type { MediaProtocol } from "./route/media-protocol.js"
 import { AIError, HttpOptions, MediaUsage, ProviderMetadata, type OpenString } from "./schema/index.js"
 import { ImageClient, Service } from "./image-client.js"

@@ -11,75 +10,39 @@ import { ImageClient, Service } from "./image-client.js"
 // Model
 // ---------------------------------------------------------------------------

-export type ImageOptions = Record<string, unknown>
+export type ImageOptions = MediaModel.Options

-export type ImageRoute<Options extends ImageOptions = ImageOptions> = MediaRoute.AnyRoute<
-  ImageRequestFor<Options>,
-  ImageEvent,
-  ImageResponse
->
+export type ImageRoute = MediaRoute.AnyRoute<ImageRequestFor, ImageEvent, ImageResponse>

-export class ImageModel<Options extends ImageOptions = ImageOptions> extends MediaModel<ImageRoute<Options>, Options> {
+export class ImageModel<Options extends ImageOptions = ImageOptions> extends MediaModel<ImageRoute, Options> {
  declare protected readonly _ImageModel: void

-  static make<Options extends ImageOptions = ImageOptions>(input: MediaModel.Input<ImageRoute<Options>>) {
-    return new ImageModel<Options>(input)
-  }
-
  /** The number of type arguments selects the kind: `<Options>`, `<Options, Frame, State>`, or `<Options, Token>`. */
  static fromRoute<Options extends ImageOptions>(
-    route: ImageModel.InlineRouteInput<Options>,
+    route: MediaModel.InlineRouteInput<ImageRequestFor<Options>, ImageResponse>,
    input: MediaRoute.ModelInput,
  ): ImageModel<Options>
  static fromRoute<Options extends ImageOptions, Frame, State>(
-    route: ImageModel.StreamRouteInput<Options, Frame, State>,
+    route: MediaModel.StreamRouteInput<ImageRequestFor<Options>, ImageEvent, Frame, State>,
    input: MediaRoute.ModelInput,
  ): ImageModel<Options>
  static fromRoute<Options extends ImageOptions, Token>(
-    route: ImageModel.QueuedRouteInput<Options, Token>,
+    route: MediaModel.QueuedRouteInput<ImageRequestFor<Options>, ImageResponse, Token>,
    input: MediaRoute.ModelInput,
  ): ImageModel<Options>
  static fromRoute<Options extends ImageOptions, Frame, State, Token>(
-    route: ImageModel.RouteInput<Options, Frame, State, Token>,
+    route: MediaModel.AnyRouteInput<ImageRequestFor<Options>, ImageEvent, ImageResponse, Frame, State, Token>,
    input: MediaRoute.ModelInput,
  ) {
    return new ImageModel<Options>({
      id: input.id,
      provider: route.protocol.provider,
      http: input.http,
-      route: composeAnyRoute(route, input, collectResponse),
+      route: composeRoute(route, input, collectResponse) as ImageRoute,
    })
  }
 }

-export namespace ImageModel {
-  export type InlineRouteInput<Options extends ImageOptions = ImageOptions> = MediaModel.RouteInput<
-    ImageRequestFor<Options>,
-    MediaProtocol.Inline<ImageRequestFor<Options>, ImageResponse>
-  >
-
-  export type StreamRouteInput<
-    Options extends ImageOptions = ImageOptions,
-    Frame = unknown,
-    State = unknown,
-  > = MediaModel.RouteInput<
-    MediaProtocol.Addressed<ImageRequestFor<Options>>,
-    MediaProtocol.Streamed<ImageRequestFor<Options>, ImageEvent, Frame, State>
-  >
-
-  export type QueuedRouteInput<Options extends ImageOptions = ImageOptions, Token = unknown> = MediaModel.RouteInput<
-    ImageRequestFor<Options>,
-    MediaProtocol.Queued<ImageRequestFor<Options>, ImageResponse, Token>
-  >
-
-  export type RouteInput<
-    Options extends ImageOptions = ImageOptions,
-    Frame = unknown,
-    State = unknown,
-    Token = unknown,
-  > = MediaModel.AnyRouteInput<ImageRequestFor<Options>, ImageEvent, ImageResponse, Frame, State, Token>
-}
-
 export const ImageModelSchema = Schema.declare((value): value is ImageModel => value instanceof ImageModel, {
  expected: "Image.Model",
 })
@@ -190,15 +153,6 @@ export const ImageEvent = Object.assign(imageEventTagged, {
 })
 export type ImageEvent = Schema.Schema.Type<typeof imageEventTagged>

-export const responseEvents = (response: ImageResponse): ReadonlyArray<ImageEvent> => [
-  ...response.images.map((image, index) => ImageOutputEvent.make({ index, image })),
-  ImageFinishEvent.make({
-    usage: response.usage,
-    notices: response.notices,
-    providerMetadata: response.providerMetadata,
-  }),
-]
-
 const collectResponse = (events: ReadonlyArray<ImageEvent>): Effect.Effect<ImageResponse> => {
  const finish = events.find(ImageEvent.is.finish)
  // Every image protocol's `finish` emits the terminal event or fails, so a completed stream always has one.
@@ -232,36 +186,31 @@ export function request(input: ImageRequest | ImageRequestInput) {
 const requestEffect = (input: ImageRequest | ImageRequestInput) => tryRequest(() => request(input))

 export function generate<const Model extends ImageModel>(
-  input: ImageRequestInput<Model>,
+  input: ImageRequest | ImageRequestInput<Model>,
  options?: AwaitOptions,
 ): Effect.Effect<ImageResponse, AIError, Service>
-export function generate(input: ImageRequest, options?: AwaitOptions): Effect.Effect<ImageResponse, AIError, Service>
 export function generate(input: ImageRequest | ImageRequestInput, options?: AwaitOptions) {
  return requestEffect(input).pipe(Effect.flatMap((request) => ImageClient.generate(request, options)))
 }

 export function stream<const Model extends ImageModel>(
-  input: ImageRequestInput<Model>,
+  input: ImageRequest | ImageRequestInput<Model>,
  options?: AwaitOptions,
 ): Stream.Stream<ImageEvent, AIError, Service>
-export function stream(input: ImageRequest, options?: AwaitOptions): Stream.Stream<ImageEvent, AIError, Service>
 export function stream(input: ImageRequest | ImageRequestInput, options?: AwaitOptions) {
  return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => ImageClient.stream(request, options))))
 }

 /** Inline and streaming routes fail with `UnsupportedOperation`. */
 export function start<const Model extends ImageModel>(
-  input: ImageRequestInput<Model>,
+  input: ImageRequest | ImageRequestInput<Model>,
 ): Effect.Effect<Generation<ImageResponse>, AIError, Service>
-export function start(input: ImageRequest): Effect.Effect<Generation<ImageResponse>, AIError, Service>
 export function start(input: ImageRequest | ImageRequestInput) {
  return requestEffect(input).pipe(Effect.flatMap((request) => ImageClient.start(request)))
 }

-export const resume = <Options extends ImageOptions>(
-  model: ImageModel<Options>,
-  token: unknown,
-): Effect.Effect<Generation<ImageResponse>, AIError, Service> => ImageClient.resume(model, token)
+export const resume = (model: ImageModel, token: unknown): Effect.Effect<Generation<ImageResponse>, AIError, Service> =>
+  ImageClient.resume(model, token)

 export const Image = {
  request,
@@ -1,5 +1,6 @@
-import { Effect, JsonSchema, Schema } from "effect"
-import { LLMClient, Service } from "./route/client.js"
+import { Effect, JsonSchema, Schema, Stream } from "effect"
+import { tryRequest } from "./media-model.js"
+import { LLMClient, Service, type StreamOptions } from "./route/client.js"
 import {
  GenerationOptions,
  HttpOptions,
@@ -35,9 +36,26 @@ export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageM
  readonly http?: HttpOptions.Input
 }

-export const generate = LLMClient.generate
+export function generate<const Model extends LanguageModel>(
+  input: RequestInput<Model>,
+  options?: StreamOptions,
+): Effect.Effect<LLMResponse, AIError, Service>
+export function generate(input: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service>
+export function generate(input: RequestInput | LLMRequest, options?: StreamOptions) {
+  return requestEffect(input).pipe(Effect.flatMap((request) => LLMClient.generate(request, options)))
+}

-export const stream = LLMClient.stream
+export function stream<const Model extends LanguageModel>(
+  input: RequestInput<Model>,
+  options?: StreamOptions,
+): Stream.Stream<LLMEvent, AIError, Service>
+export function stream(input: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service>
+export function stream(input: RequestInput | LLMRequest, options?: StreamOptions) {
+  return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => LLMClient.stream(request, options))))
+}
+
+const requestEffect = (input: RequestInput | LLMRequest) =>
+  input instanceof LLMRequest ? Effect.succeed(input) : tryRequest(() => request(input))

 export const request = <const SelectedLanguageModel extends LanguageModel>(
  input: RequestInput<SelectedLanguageModel>,
@@ -0,0 +1,77 @@
+import { type Context, Effect, Layer, Stream } from "effect"
+import { resultEvents, type AwaitOptions, type Generation, type Observation } from "./generation.js"
+import { RequestExecutor } from "./route/executor.js"
+import type { MediaRoute } from "./route/media.js"
+import { AIError, UnsupportedOperationError } from "./schema/index.js"
+
+/** A media request whose model carries the route that executes it. */
+export interface RoutedRequest<Self extends MediaRoute.MediaRequest, Event, Response> extends MediaRoute.MediaRequest {
+  readonly model: MediaRoute.MediaRequest["model"] & { readonly route: MediaRoute.AnyRoute<Self, Event, Response> }
+}
+
+/** `start` and `resume` fail with `UnsupportedOperation` on inline and stream routes. */
+export interface Interface<Req extends RoutedRequest<Req, Event, Response>, Event, Response> {
+  readonly generate: (request: Req, options?: AwaitOptions) => Effect.Effect<Response, AIError>
+  readonly stream: (request: Req, options?: AwaitOptions) => Stream.Stream<Event | Observation, AIError>
+  readonly start: (request: Req) => Effect.Effect<Generation<Response>, AIError>
+  readonly resume: (model: Req["model"], token: unknown) => Effect.Effect<Generation<Response>, AIError>
+}
+
+/** One modality's layer and service accessors, dispatching each request on its route's `kind`. */
+export const make = <Self, Req extends RoutedRequest<Req, Event, Response>, Event, Response>(
+  service: Context.Service<Self, Interface<Req, Event, Response>>,
+  input: {
+    readonly modality: string
+    /** A completed response expanded into the streaming event shape. */
+    readonly responseEvents: (response: Response) => ReadonlyArray<Event>
+  },
+) => ({
+  layer: Layer.effect(
+    service,
+    Effect.gen(function* () {
+      const executor = yield* RequestExecutor.Service
+      const notQueued = (route: MediaRoute.AnyRoute<Req, Event, Response>, operation: string) =>
+        new AIError({
+          reason: new UnsupportedOperationError({
+            operation: `${input.modality}.${operation}`,
+            provider: route.provider,
+            route: route.id,
+            message: `${route.provider}/${route.id} is not a queued route; use generate or stream`,
+          }),
+        })
+      const start = (request: Req) => {
+        const route = request.model.route
+        if (route.kind !== "queued") return Effect.fail(notQueued(route, "start"))
+        return route.start(request, executor.execute)
+      }
+      return service.of({
+        start,
+        resume: (model, token) => {
+          if (model.route.kind !== "queued") return Effect.fail(notQueued(model.route, "resume"))
+          return model.route.resume(model, token, executor.execute)
+        },
+        generate: (request, options) => {
+          const route = request.model.route
+          if (route.kind !== "queued") return route.generate(request, executor.execute)
+          return start(request).pipe(Effect.flatMap((generation) => generation.await(options)))
+        },
+        stream: (request, options) => {
+          const route = request.model.route
+          if (route.kind === "stream") return route.stream(request, executor.execute)
+          if (route.kind === "queued")
+            return Stream.unwrap(
+              start(request).pipe(Effect.map((generation) => resultEvents(generation, input.responseEvents, options))),
+            )
+          return Stream.fromIterableEffect(Effect.map(route.generate(request, executor.execute), input.responseEvents))
+        },
+      })
+    }),
+  ),
+  generate: (request: Req, options?: AwaitOptions) => service.use((client) => client.generate(request, options)),
+  stream: (request: Req, options?: AwaitOptions) =>
+    Stream.unwrap(service.useSync((client) => client.stream(request, options))),
+  start: (request: Req) => service.use((client) => client.start(request)),
+  resume: (model: Req["model"], token: unknown) => service.use((client) => client.resume(model, token)),
+})
+
+export * as MediaClient from "./media-client.js"
@@ -6,11 +6,13 @@ import { AIError, HttpOptions, InvalidRequestError, ModelID, ProviderID } from "

 /**
 * What every media model carries: ids, the configured route, and deployment `http` overlays. Modality classes
- * (`ImageModel`, `VideoModel`, `SpeechModel`) extend it with their route type and a nominal marker so one cannot stand
- * in for the other in requests.
+ * (`ImageModel`, `VideoModel`, `SpeechModel`, `TranscriptionModel`) extend it with their route type and a nominal
+ * marker so one cannot stand in for the other in requests.
 */
 export class MediaModel<Route, Options> {
-  declare protected readonly _Options: (options: Options) => Options
+  // As with `LanguageModel`, the route type is erased over `Options`; `fromRoute` and the constructor trust that the
+  // route accepts every request this model's `Options` admit.
+  declare protected readonly _Options: Options
  readonly id: ModelID
  readonly provider: ProviderID
  readonly route: Route
@@ -25,6 +27,8 @@ export class MediaModel<Route, Options> {
 }

 export namespace MediaModel {
+  export type Options = Record<string, unknown>
+
  export interface Input<Route> {
    readonly id: string | ModelID
    readonly provider: string | ProviderID
@@ -41,48 +45,56 @@ export namespace MediaModel {
    readonly headers?: Record<string, string>
  }

+  export type InlineRouteInput<Request extends MediaRoute.MediaRequest, Response> = RouteInput<
+    Request,
+    MediaProtocol.Inline<Request, Response>
+  >
+
+  export type StreamRouteInput<Request extends MediaRoute.MediaRequest, Event, Frame, State> = RouteInput<
+    MediaProtocol.Addressed<Request>,
+    MediaProtocol.Streamed<Request, Event, Frame, State>
+  >
+
+  export type QueuedRouteInput<Request extends MediaRoute.MediaRequest, Response, Token> = RouteInput<
+    Request,
+    MediaProtocol.Queued<Request, Response, Token>
+  >
+
  export type AnyRouteInput<Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token> =
-    | RouteInput<Request, MediaProtocol.Inline<Request, Response>>
-    | RouteInput<MediaProtocol.Addressed<Request>, MediaProtocol.Streamed<Request, Event, Frame, State>>
-    | RouteInput<Request, MediaProtocol.Queued<Request, Response, Token>>
+    | InlineRouteInput<Request, Response>
+    | StreamRouteInput<Request, Event, Frame, State>
+    | QueuedRouteInput<Request, Response, Token>
 }

 /** Compose a protocol route input with one deployment through `MediaRoute.inline`, `queued`, or `stream`. */
-export const composeRoute = <Request extends MediaRoute.MediaRequest, Protocol, Route>(
-  compose: (input: MediaRoute.Composition<Request> & { readonly protocol: Protocol }) => Route,
-  route: MediaModel.RouteInput<Request, Protocol>,
-  input: MediaRoute.ModelInput,
-): Route =>
-  compose({
-    protocol: route.protocol,
-    endpoint: Endpoint.path(route.path, { baseURL: input.baseURL ?? route.baseURL }),
-    auth: input.auth,
-    headers:
-      route.headers === undefined && input.headers === undefined ? undefined : { ...route.headers, ...input.headers },
-  })
-
-export const composeAnyRoute = <Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token>(
+export const composeRoute = <Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token>(
  route: MediaModel.AnyRouteInput<Request, Event, Response, Frame, State, Token>,
  input: MediaRoute.ModelInput,
  collect: (events: ReadonlyArray<Event>) => Effect.Effect<Response, AIError>,
 ): MediaRoute.AnyRoute<Request, Event, Response> => {
-  if (isStreamInput(route))
-    return composeRoute((composition) => MediaRoute.stream({ ...composition, collect }), route, input)
-  if (isQueuedInput(route)) return composeRoute(MediaRoute.queued, route, input)
-  return composeRoute(MediaRoute.inline, route, input)
+  if (isStreamInput(route)) return MediaRoute.stream({ ...composition(route, input), collect })
+  if (isQueuedInput(route)) return MediaRoute.queued(composition(route, input))
+  return MediaRoute.inline(composition(route, input))
 }

+const composition = <Request extends MediaRoute.MediaRequest, Protocol>(
+  route: MediaModel.RouteInput<Request, Protocol>,
+  input: MediaRoute.ModelInput,
+): MediaRoute.Composition<Request> & { readonly protocol: Protocol } => ({
+  protocol: route.protocol,
+  endpoint: Endpoint.path(route.path, { baseURL: input.baseURL ?? route.baseURL }),
+  auth: input.auth,
+  headers:
+    route.headers === undefined && input.headers === undefined ? undefined : { ...route.headers, ...input.headers },
+})
+
 const isStreamInput = <Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token>(
  route: MediaModel.AnyRouteInput<Request, Event, Response, Frame, State, Token>,
-): route is MediaModel.RouteInput<
-  MediaProtocol.Addressed<Request>,
-  MediaProtocol.Streamed<Request, Event, Frame, State>
-> => route.protocol.kind === "stream"
+): route is MediaModel.StreamRouteInput<Request, Event, Frame, State> => route.protocol.kind === "stream"

 const isQueuedInput = <Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token>(
  route: MediaModel.AnyRouteInput<Request, Event, Response, Frame, State, Token>,
-): route is MediaModel.RouteInput<Request, MediaProtocol.Queued<Request, Response, Token>> =>
-  route.protocol.kind === "queued"
+): route is MediaModel.QueuedRouteInput<Request, Response, Token> => route.protocol.kind === "queued"

 /** Lift a synchronous Schema-class constructor into a typed `InvalidRequest` failure. */
 export const tryRequest = <A>(make: () => A): Effect.Effect<A, AIError> =>
@@ -1,23 +1,22 @@
 import { Effect, Layer, ManagedRuntime, Stream } from "effect"
 import { AIClient } from "./ai-client.js"
 import type { AwaitOptions, Event, Generation, Snapshot } from "./generation.js"
-import { Image, ImageModel, ImageRequest, type ImageOptions, type ImageRequestInput } from "./image.js"
+import { Image, type ImageModel, type ImageRequest, type ImageRequestInput } from "./image.js"
 import { LLM } from "./index.js"
 import { Media } from "./media.js"
 import { tryRequest } from "./media-model.js"
 import { RequestExecutor } from "./route/executor.js"
 import { AIError, InvalidRequestError, LanguageModel, LLMRequest } from "./schema/index.js"
 import type { RequestInput } from "./llm.js"
-import { Speech, SpeechModel, SpeechRequest, type SpeechRequestInput } from "./speech.js"
+import { Speech, type SpeechModel, type SpeechRequest, type SpeechRequestInput } from "./speech.js"
 import {
  Transcription,
-  TranscriptionModel,
-  TranscriptionRequest,
-  type TranscriptionOptions,
+  type TranscriptionModel,
+  type TranscriptionRequest,
  type TranscriptionRequestInput,
 } from "./transcription.js"
 import { fileMediaType } from "./utils/media-type.js"
-import { Video, VideoModel, VideoRequest, type VideoOptions, type VideoRequestInput } from "./video.js"
+import { Video, type VideoModel, type VideoRequest, type VideoRequestInput } from "./video.js"

 /**
 * Promise-first entrypoint for scripts and non-Effect callers. One `ManagedRuntime` hosts the LLM, image, video, speech,
@@ -93,17 +92,8 @@ export const make = (options: Options = {}) => {
    cancel: (options) => run(generation.cancel(), options),
  })

-  // The typed `generate`/`stream` overloads take a concrete input or a request, not the union; normalize once here.
  const llmRequest = (input: RequestInput | LLMRequest) =>
    input instanceof LLMRequest ? Effect.succeed(input) : tryRequest(() => LLM.request(input))
-  const imageRequest = (input: ImageRequestInput | ImageRequest) =>
-    input instanceof ImageRequest ? input : Image.request(input)
-  const videoRequest = (input: VideoRequestInput | VideoRequest) =>
-    input instanceof VideoRequest ? input : Video.request(input)
-  const speechRequest = (input: SpeechRequestInput | SpeechRequest) =>
-    input instanceof SpeechRequest ? input : Speech.request(input)
-  const transcriptionRequest = (input: TranscriptionRequestInput | TranscriptionRequest) =>
-    input instanceof TranscriptionRequest ? input : Transcription.request(input)

  return {
    run,
@@ -155,61 +145,58 @@ export const make = (options: Options = {}) => {
      generate: <const Model extends ImageModel>(
        input: ImageRequestInput<Model> | ImageRequest,
        options?: AwaitOptions & RunOptions,
-      ) => run(Image.generate(imageRequest(input), { poll: options?.poll }), options),
+      ) => run(Image.generate(input, { poll: options?.poll }), options),
      stream: <const Model extends ImageModel>(
        input: ImageRequestInput<Model> | ImageRequest,
        options?: AwaitOptions & RunOptions,
-      ) => iterate(Image.stream(imageRequest(input), { poll: options?.poll }), options),
+      ) => iterate(Image.stream(input, { poll: options?.poll }), options),
      start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) =>
-        run(Image.start(imageRequest(input)), options).then(handle),
-      resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown, options?: RunOptions) =>
+        run(Image.start(input), options).then(handle),
+      resume: (model: ImageModel, token: unknown, options?: RunOptions) =>
        run(Image.resume(model, token), options).then(handle),
    },
    video: {
      request: Video.request,
      start: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: RunOptions) =>
-        run(Video.start(videoRequest(input)), options).then(handle),
+        run(Video.start(input), options).then(handle),
      generate: <const Model extends VideoModel>(
        input: VideoRequestInput<Model> | VideoRequest,
        options?: AwaitOptions & RunOptions,
-      ) => run(Video.generate(videoRequest(input), { poll: options?.poll }), options),
-      resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown, options?: RunOptions) =>
+      ) => run(Video.generate(input, { poll: options?.poll }), options),
+      resume: (model: VideoModel, token: unknown, options?: RunOptions) =>
        run(Video.resume(model, token), options).then(handle),
      stream: <const Model extends VideoModel>(
        input: VideoRequestInput<Model> | VideoRequest,
        options?: AwaitOptions & RunOptions,
-      ) => iterate(Video.stream(videoRequest(input), { poll: options?.poll }), options),
+      ) => iterate(Video.stream(input, { poll: options?.poll }), options),
    },
    speech: {
      request: Speech.request,
      generate: <const Model extends SpeechModel>(
        input: SpeechRequestInput<Model> | SpeechRequest,
        options?: RunOptions,
-      ) => run(Speech.generate(speechRequest(input)), options),
+      ) => run(Speech.generate(input), options),
      stream: <const Model extends SpeechModel>(
        input: SpeechRequestInput<Model> | SpeechRequest,
        options?: RunOptions,
-      ) => iterate(Speech.stream(speechRequest(input)), options),
+      ) => iterate(Speech.stream(input), options),
    },
    transcription: {
      request: Transcription.request,
      generate: <const Model extends TranscriptionModel>(
        input: TranscriptionRequestInput<Model> | TranscriptionRequest,
        options?: AwaitOptions & RunOptions,
-      ) => run(Transcription.generate(transcriptionRequest(input), { poll: options?.poll }), options),
+      ) => run(Transcription.generate(input, { poll: options?.poll }), options),
      stream: <const Model extends TranscriptionModel>(
        input: TranscriptionRequestInput<Model> | TranscriptionRequest,
        options?: AwaitOptions & RunOptions,
-      ) => iterate(Transcription.stream(transcriptionRequest(input), { poll: options?.poll }), options),
+      ) => iterate(Transcription.stream(input, { poll: options?.poll }), options),
      start: <const Model extends TranscriptionModel>(
        input: TranscriptionRequestInput<Model> | TranscriptionRequest,
        options?: RunOptions,
-      ) => run(Transcription.start(transcriptionRequest(input)), options).then(handle),
-      resume: <Options extends TranscriptionOptions>(
-        model: TranscriptionModel<Options>,
-        token: unknown,
-        options?: RunOptions,
-      ) => run(Transcription.resume(model, token), options).then(handle),
+      ) => run(Transcription.start(input), options).then(handle),
+      resume: (model: TranscriptionModel, token: unknown, options?: RunOptions) =>
+        run(Transcription.resume(model, token), options).then(handle),
    },
    dispose: () => runtime.dispose(),
  }
@@ -70,7 +70,11 @@ export const protocol = Protocol.make({
      return {
        ...(yield* OpenAIChat.protocol.body.from(req)),
        enable_thinking: opts.enableThinking,
-        thinking_budget: opts.thinkingBudget,
+        // Alibaba also rejects an explicit budget that is not below `max_completion_tokens`.
+        thinking_budget:
+          opts.thinkingBudget === undefined
+            ? undefined
+            : ProviderShared.fitThinkingBudget(opts.thinkingBudget, req.generation?.maxTokens),
        preserve_thinking: opts.preserveThinking,
        clear_thinking: opts.clearThinking,
        thinking: opts.thinking,
@@ -26,18 +26,21 @@ export const protocol = Protocol.make({
    from: Effect.fn("AlibabaMessages.fromRequest")(function* (req) {
      const opts = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(req.providerOptions ?? {})
      // Model Studio accepts enabled thinking without Anthropic's mandatory token budget.
+      const body = yield* AnthropicMessages.protocol.body.from(
+        LLMRequest.update(req, {
+          providerOptions: { ...req.providerOptions, thinking: undefined },
+        }),
+      )
+      const budget = opts.thinking?.budgetTokens ?? opts.thinking?.budget_tokens
      return {
-        ...(yield* AnthropicMessages.protocol.body.from(
-          LLMRequest.update(req, {
-            providerOptions: { ...req.providerOptions, thinking: undefined },
-          }),
-        )),
+        ...body,
        thinking:
          opts.thinking === undefined
            ? undefined
            : {
                type: opts.thinking.type,
-                budget_tokens: opts.thinking.budgetTokens ?? opts.thinking.budget_tokens,
+                budget_tokens:
+                  budget === undefined ? undefined : ProviderShared.fitThinkingBudget(budget, body.max_tokens),
              },
      }
    }),
@@ -18,7 +18,6 @@ import {
  type CacheHint,
  type FinishReasonDetails,
  type FinishReason,
-  type JsonSchema,
  type MediaPart,
  type ProviderMetadata,
  type ProviderOptions,
@@ -31,13 +30,13 @@ import { classifyProviderFailure } from "../provider-error.js"
 import { effortUpdate, resolveEffortUpdates } from "../effort-updates.js"
 import * as Cache from "./utils/cache.js"
 import { Lifecycle } from "./utils/lifecycle.js"
-import { ToolSchemaProjection } from "./utils/tool-schema.js"
 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 MIN_THINKING_BUDGET = 1_024
 const DEFAULT_EFFORT = "high"

 const SSE_EVENTS = new Set([
@@ -524,10 +523,10 @@ const redactedDataFromMetadata = (metadata: ProviderMetadata | undefined, key: s
  return typeof provider.redactedData === "string" ? provider.redactedData : undefined
 }

-const lowerTool = (breakpoints: Cache.Breakpoints, tool: ToolDefinition, inputSchema: JsonSchema): AnthropicTool => ({
+const lowerTool = (breakpoints: Cache.Breakpoints, tool: ToolDefinition): AnthropicTool => ({
  name: tool.name,
  description: tool.description,
-  input_schema: inputSchema,
+  input_schema: tool.inputSchema,
  cache_control: cacheControl(breakpoints, tool.cache),
 })

@@ -1027,6 +1026,15 @@ const applyThinkingBindingDefault = (model: LLMRequest["model"], thinking: Anthr
  }
 }

+// Anthropic also requires an explicit thinking budget below `max_tokens` and at or above its minimum.
+const fitThinking = (thinking: AnthropicThinking | undefined, maxTokens: number) =>
+  thinking?.type === "enabled"
+    ? {
+        ...thinking,
+        budget_tokens: ProviderShared.fitThinkingBudget(thinking.budget_tokens, maxTokens, MIN_THINKING_BUDGET),
+      }
+    : thinking
+
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) {
  const options = yield* decodeOptions(request.providerOptions ?? {})
  const management = options.contextManagement
@@ -1039,12 +1047,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
  // over-mark we keep their tool hints and shed the message-tail ones first.
  const breakpoints = Cache.newBreakpoints(ANTHROPIC_BREAKPOINT_CAP)
  const flattened = ProviderShared.flattenToolRequest(updates.request)
-  const tools =
-    flattened.tools.length === 0
-      ? undefined
-      : flattened.tools.map((tool) =>
-          lowerTool(breakpoints, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model)),
-        )
+  const tools = flattened.tools.length === 0 ? undefined : flattened.tools.map((tool) => lowerTool(breakpoints, tool))
  // Anthropic rejects tool_choice when tools are absent; "none" is only meaningful with tools present.
  const toolChoice = tools === undefined || !request.toolChoice ? undefined : yield* lowerToolChoice(request.toolChoice)
  const systemParts = request.system.filter((part) => part.text.length > 0)
@@ -1064,6 +1067,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
  }
  const output_config =
    updates.effort === undefined && format === undefined ? undefined : { effort: updates.effort, format }
+  const maxTokens = generation?.maxTokens ?? DEFAULT_MAX_TOKENS
  const body = {
    model: request.model.id,
    system,
@@ -1071,12 +1075,12 @@ 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: maxTokens,
    temperature: generation?.temperature,
    top_p: generation?.topP,
    top_k: generation?.topK,
    stop_sequences: generation?.stop,
-    thinking: applyThinkingBindingDefault(request.model, options.thinking),
+    thinking: applyThinkingBindingDefault(request.model, fitThinking(options.thinking, maxTokens)),
    output_config,
    // top-level passthrough per SDK MessageCreateParamsBase:4638,4643,4649,4654,4670
    cache_control: options.cache_control ?? options.cacheControl,
@@ -110,8 +110,11 @@ const fromRequest = Effect.fn("AssemblyAITranscription.fromRequest")(function* (
        language_code: request.language,
        language_detection: request.language === undefined ? true : undefined,
        prompt: request.prompt,
-        // Turn-level `utterances`, the only segments AssemblyAI returns, require speaker labels.
-        speaker_labels: request.diarize === true || request.timestamps === "segment" ? true : undefined,
+        // Turn-level `utterances`, the only segments AssemblyAI returns, and `speakers_expected` require speaker labels.
+        speaker_labels:
+          request.diarize === true || request.timestamps === "segment" || request.speakers !== undefined
+            ? true
+            : undefined,
        speakers_expected: request.speakers,
      },
      request.providerOptions,
@@ -155,8 +158,7 @@ const decodeResult = Effect.fn("AssemblyAITranscription.decodeResult")(function*
  const error = transcript.error ?? undefined
  if (status === "failed")
    return yield* output.ended("failed", `${route.name} transcription failed${error === undefined ? "" : `: ${error}`}`)
-  if (status !== "completed")
-    return yield* output.invalid(`${route.name} transcript ${context.token.transcriptID} has not finished`)
+  if (status !== "completed") return yield* output.pending(context.token.transcriptID)
  const duration = transcript.audio_duration ?? undefined
  return new TranscriptionResponse({
    text: transcript.text ?? "",
@@ -9,7 +9,6 @@ import {
  type CacheHint,
  type FinishReason,
  type FinishReasonDetails,
-  type JsonSchema,
  type LLMRequest,
  type LanguageModel,
  type ProviderMetadata,
@@ -26,7 +25,6 @@ import { BedrockCache } from "./utils/bedrock-cache.js"
 import { BedrockMedia } from "./utils/bedrock-media.js"
 import { Lifecycle } from "./utils/lifecycle.js"
 import { MistralToolID } from "./utils/mistral-tool-id.js"
-import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { ToolStream } from "./utils/tool-stream.js"
 import { concatBytes } from "../utils/bytes.js"

@@ -221,22 +219,18 @@ type BedrockEvent = Schema.Schema.Type<typeof BedrockEvent>
 // =============================================================================
 // Request Lowering
 // =============================================================================
-const lowerToolSpec = (tool: ToolDefinition, inputSchema: JsonSchema): BedrockToolSpec => ({
+const lowerToolSpec = (tool: ToolDefinition): BedrockToolSpec => ({
  toolSpec: {
    name: tool.name,
    ...(tool.description.trim().length > 0 ? { description: tool.description } : {}),
-    inputSchema: { json: inputSchema },
+    inputSchema: { json: tool.inputSchema },
  },
 })

-const lowerTools = (
-  model: LanguageModel,
-  breakpoints: BedrockCache.Breakpoints,
-  tools: ReadonlyArray<ToolDefinition>,
-): BedrockTool[] => {
+const lowerTools = (breakpoints: BedrockCache.Breakpoints, tools: ReadonlyArray<ToolDefinition>): BedrockTool[] => {
  const result: BedrockTool[] = []
  for (const tool of tools) {
-    result.push(lowerToolSpec(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, model)))
+    result.push(lowerToolSpec(tool))
    const cachePoint = BedrockCache.block(breakpoints, tool.cache)
    if (cachePoint) result.push(cachePoint)
  }
@@ -441,19 +435,39 @@ const isHighReasoningEffort = Schema.is(
  }),
 )

+const Options = Schema.Struct({
+  thinking: Schema.optional(Schema.Struct({ type: Schema.Literal("enabled"), budgetTokens: Schema.Number })),
+})
+export type OptionsInput = typeof Options.Type
+const decodeOptions = ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))
+// Claude on Bedrock requires the thinking budget below `maxTokens`, with a minimum of 1,024.
+const MIN_THINKING_BUDGET = 1_024
+
 const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request: LLMRequest) {
  const toolChoice = request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined
  const flattened = ProviderShared.flattenToolRequest(request)
  const generation = request.generation
+  const options = yield* decodeOptions(request.providerOptions ?? {})
  const maxTokens =
    isNova2(request.model) && isHighReasoningEffort(request.http?.body) ? undefined : generation?.maxTokens
+  const thinking =
+    options.thinking === undefined
+      ? undefined
+      : {
+          type: "enabled",
+          budget_tokens: ProviderShared.fitThinkingBudget(
+            options.thinking.budgetTokens,
+            maxTokens,
+            MIN_THINKING_BUDGET,
+          ),
+        }
  // Bedrock-Claude shares Anthropic's 4-breakpoint cap. Spend the budget in
  // tools → system → messages order to favour the highest-impact prefixes.
  const breakpoints = BedrockCache.breakpoints(request.model.id)
  const toolConfig = (() => {
    if (flattened.tools.length === 0) return undefined
    return {
-      tools: lowerTools(request.model, breakpoints, flattened.tools),
+      tools: lowerTools(breakpoints, flattened.tools),
      // Converse has no native "none". Keep definitions stable for prompt
      // caching and omit only the unsupported choice.
      toolChoice,
@@ -487,9 +501,15 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request:
    system,
    inferenceConfig,
    toolConfig,
-    // Converse's base inferenceConfig has no topK; Anthropic/Nova accept it
-    // as a model-specific field, so it goes through additionalModelRequestFields.
-    additionalModelRequestFields: generation?.topK === undefined ? undefined : { top_k: generation.topK },
+    // Converse's base inferenceConfig has no topK or thinking; Anthropic/Nova accept them
+    // as model-specific fields, so they go through additionalModelRequestFields.
+    additionalModelRequestFields:
+      generation?.topK === undefined && thinking === undefined
+        ? undefined
+        : {
+            ...(generation?.topK === undefined ? {} : { top_k: generation.topK }),
+            ...(thinking === undefined ? {} : { thinking }),
+          },
  }
 })

@@ -31,13 +31,21 @@ export type Request = ImageRequestFor<BlackForestLabsImageOptions>
 // 2. Token and response schemas
 // ---------------------------------------------------------------------------

-/** Regional clusters answer on different hosts, so the returned `polling_url` is followed verbatim. */
-export const Token = Schema.Struct({ id: Schema.String, pollingURL: Schema.String })
+/**
+ * Regional clusters answer on different hosts, so the returned `polling_url` is followed verbatim. BFL reports the
+ * credit cost on submit, so it rides on the token; it is optional so tokens persisted before it existed still decode.
+ */
+export const Token = Schema.Struct({
+  id: Schema.String,
+  pollingURL: Schema.String,
+  cost: Schema.optionalKey(Schema.Number),
+})
 export type Token = Schema.Schema.Type<typeof Token>

 const StartResponse = Schema.Struct({
  id: Schema.String,
  polling_url: Schema.String,
+  cost: optionalNull(Schema.Number),
 })

 const Result = Schema.Struct({
@@ -145,7 +153,11 @@ const fromRequest = Effect.fn("BlackForestLabsImages.fromRequest")(function* (re
 // ---------------------------------------------------------------------------

 const decodeStart = route.decodeStarted(StartResponse, (value) => ({
-  token: { id: value.id, pollingURL: value.polling_url },
+  token: {
+    id: value.id,
+    pollingURL: value.polling_url,
+    ...(value.cost === undefined || value.cost === null ? {} : { cost: value.cost }),
+  },
  snapshot: { id: value.id, status: "queued" },
 }))

@@ -169,14 +181,16 @@ const decodeResult = Effect.fn("BlackForestLabsImages.decodeResult")(function* (
  if (isModerated(document.status)) return yield* output.contentPolicy(`${route.name} moderated the generation`)
  if (status === "failed" || status === "expired")
    return yield* output.ended(status, `${route.name} generation ${context.token.id} ended with ${document.status}`)
-  if (status !== "completed" || document.result === undefined || document.result === null)
+  if (status !== "completed") return yield* output.pending(context.token.id)
+  if (document.result === undefined || document.result === null)
    return yield* output.invalid(`${route.name} generation ${context.token.id} has no result`)
  const { sample, seed, prompt, ...rest } = document.result
+  // A settled `cost` on the result supersedes the submit-time cost carried on the token.
+  const cost = document.cost ?? context.token.cost
  return new ImageResponse({
    // `sample` is a signed URL that expires 10 minutes after the result is ready, so it is downloaded now.
    images: [yield* context.materialize(Media.url(sample))],
-    usage:
-      document.cost === undefined || document.cost === null ? undefined : { type: "credits", credits: document.cost },
+    usage: cost === undefined ? undefined : { type: "credits", credits: cost },
    providerMetadata: {
      bfl: { id: context.token.id, seed: seed ?? undefined, prompt: prompt ?? undefined, ...rest },
    },
@@ -67,6 +67,9 @@ const queryParameters = (request: Request) => {
 }

 const fromRequest = Effect.fn("DeepgramSpeech.fromRequest")(function* (request: Request) {
+  // Not in `unsupported`: that list would also reject `timestamps: false`, which asks for nothing.
+  if (request.timestamps === true)
+    return yield* route.unsupported("media.timestamps", `${route.name} does not return timestamps`)
  if (
    request.format !== undefined &&
    FORMATS[request.format] === undefined &&
@@ -117,7 +120,7 @@ const finish = (state: State, context: MediaProtocol.ResponseContext<Request>) =
 // ---------------------------------------------------------------------------

 export const protocol = MediaProtocol.stream<Request, SpeechEvent, Uint8Array, State>(route, {
-  unsupported: ["voice", "language", "instructions", "timestamps"],
+  unsupported: ["voice", "language", "instructions"],
  body: { from: fromRequest },
  frames: (bytes) => bytes,
  initial: () => ({ chunks: [] }),
@@ -49,7 +49,7 @@ const QueueResult = Schema.StructWithRest(
 // ---------------------------------------------------------------------------

 const sizing = (model: string) => {
-  if (/^fal-ai\/(nano-banana|flux-pro\/v1\.1-ultra)/.test(model)) return "aspect_ratio"
+  if (/^fal-ai\/(nano-banana|flux-pro\/(v1\.1-ultra|kontext))/.test(model)) return "aspect_ratio"
  if (model.startsWith("fal-ai/flux")) return "image_size"
  return undefined
 }
@@ -63,20 +63,24 @@ const validate = (request: Request) => {
    return Effect.fail(route.unsupported("media.size", `${id} sizes by aspectRatio`))
  if (request.aspectRatio !== undefined && field === "image_size")
    return Effect.fail(route.unsupported("media.aspectRatio", `${id} sizes by size (image_size)`))
-  if ((request.images?.length ?? 0) > 1 && !isEdit(id))
+  if ((request.images?.length ?? 0) > 1 && !takesImageList(id))
    return Effect.fail(
-      route.unsupported("media.images", `${id} takes one image_url; use an /edit endpoint for several images`),
+      route.unsupported(
+        "media.images",
+        `${id} takes one image_url; use an /edit or /multi endpoint for several images`,
+      ),
    )
  return Effect.void
 }

-// `/edit` endpoints take an `image_urls` list; image-to-image, fill, and Ultra take one `image_url` (beside `mask_url`).
-const isEdit = (model: string) => model.endsWith("/edit")
+// `/edit` and `/multi` (Kontext) endpoints take an `image_urls` list; image-to-image, fill, and Ultra take one
+// `image_url` (beside `mask_url`).
+const takesImageList = (model: string) => model.endsWith("/edit") || model.endsWith("/multi")

 const fromRequest = Effect.fn("FalImages.fromRequest")(function* (request: Request) {
  yield* validate(request)
  const images = yield* Effect.forEach(request.images ?? [], (image) => FalQueue.mediaUrl(image, route.name))
-  const edit = isEdit(request.model.id)
+  const list = takesImageList(request.model.id)
  return MediaProtocol.json(
    mergeJsonRecords(
      {
@@ -86,8 +90,8 @@ const fromRequest = Effect.fn("FalImages.fromRequest")(function* (request: Reque
        image_size: request.size === undefined ? undefined : MediaInput.dimensions(request.size),
        aspect_ratio: request.aspectRatio,
        output_format: request.format,
-        image_urls: edit && images.length > 0 ? images : undefined,
-        image_url: edit ? undefined : images[0],
+        image_urls: list && images.length > 0 ? images : undefined,
+        image_url: list ? undefined : images[0],
        mask_url: request.mask === undefined ? undefined : yield* FalQueue.mediaUrl(request.mask, route.name),
      },
      request.providerOptions,
@@ -112,12 +116,14 @@ const decodeResult = Effect.fn("FalImages.decodeResult")(function* (
  // With the safety checker on, flagged images come back blacked out rather than omitted.
  const flagged = (has_nsfw_concepts ?? []).flatMap((value, index) => (value ? [index] : []))
  return new ImageResponse({
-    images: images.map((image) =>
-      Media.url(image.url, {
-        mediaType: image.content_type ?? undefined,
-        info: { width: image.width ?? undefined, height: image.height ?? undefined },
-      }),
-    ),
+    images: images.map((image) => {
+      const info = { width: image.width ?? undefined, height: image.height ?? undefined }
+      // `sync_mode: true` returns data URIs instead of hosted URLs.
+      return (
+        Media.parseDataUrl(image.url, { info }) ??
+        Media.url(image.url, { mediaType: image.content_type ?? undefined, info })
+      )
+    }),
    notices:
      flagged.length === 0
        ? undefined
@@ -11,7 +11,6 @@ import {
  Usage,
  type FinishReason,
  type LLMRequest,
-  type LanguageModel,
  type MediaPart,
  type ProviderMetadata,
  type ProviderOptions,
@@ -24,11 +23,12 @@ import { Media } from "../media.js"
 import { JsonObject, knownString, lenient, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { GeminiGenerateContent } from "./utils/gemini-generate-content.js"
 import { Lifecycle } from "./utils/lifecycle.js"
-import { ToolSchemaProjection } from "./utils/tool-schema.js"

 const ADAPTER = "gemini"
 // Google documents this sentinel for replaying Gemini 3 function calls after their original signature was lost.
 const SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator"
+// Gemini 2.5 rejects a budget under the model's minimum: 512 on Flash-Lite, the highest, and 128 on Pro.
+const MIN_THINKING_BUDGET = 512
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"

 // Gemini 3 rejects replayed function calls without a thought signature. Google's SDKs avoid that in normal chats by
@@ -268,12 +268,11 @@ interface ParserState {
 // =============================================================================
 // Request Lowering
 // =============================================================================
-// Tool schemas go in `parametersJsonSchema`, which accepts standard JSON Schema. Gemini's schema
-// rules are this API's default, including for tuned endpoints whose IDs do not name Gemini.
-const lowerTool = (tool: ToolDefinition, model: LanguageModel) => ({
+// Tool schemas go in `parametersJsonSchema`, which accepts standard JSON Schema.
+const lowerTool = (tool: ToolDefinition) => ({
  name: tool.name,
  description: tool.description,
-  parametersJsonSchema: ToolSchemaProjection.modelCompatibility(tool.inputSchema, model, "gemini"),
+  parametersJsonSchema: tool.inputSchema,
 })

 const lowerToolConfig = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
@@ -452,10 +451,22 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
    presencePenalty: generation?.presencePenalty,
    seed: generation?.seed,
    stopSequences: generation?.stop,
+    // Gemini accepts a budget above `maxOutputTokens`, but thinking then leaves the answer empty.
    thinkingConfig:
      options.thinkingConfig === undefined
        ? undefined
-        : { ...options.thinkingConfig, includeThoughts: options.thinkingConfig.includeThoughts ?? true },
+        : {
+            ...options.thinkingConfig,
+            includeThoughts: options.thinkingConfig.includeThoughts ?? true,
+            thinkingBudget:
+              options.thinkingConfig.thinkingBudget === undefined
+                ? undefined
+                : ProviderShared.fitThinkingBudget(
+                    options.thinkingConfig.thinkingBudget,
+                    generation?.maxTokens,
+                    MIN_THINKING_BUDGET,
+                  ),
+          },
  }

  return {
@@ -468,7 +479,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
    tools: hasTools
      ? [
          {
-            functionDeclarations: flattened.tools.map((tool) => lowerTool(tool, request.model)),
+            functionDeclarations: flattened.tools.map(lowerTool),
          },
        ]
      : undefined,
@@ -804,6 +815,8 @@ export const protocol = Protocol.make({
    schema: GeminiBody,
    from: fromRequest,
  },
+  // Gemini's schema rules are this API's default, including for tuned endpoints whose IDs do not name Gemini.
+  sanitizer: "gemini",
  stream: {
    event: Protocol.jsonEvent(GeminiEvent),
    initial: (request) => ({
@@ -101,7 +101,7 @@ const generationConfig = (request: Request) => {
 const fromRequest = Effect.fn("GoogleImages.fromRequest")(function* (request: Request) {
  if (request.n !== undefined && request.n > 1)
    return yield* route.unsupported(
-      "image.n",
+      "media.n",
      `${route.name} generates one image per request; call it once per image instead of n=${request.n}`,
    )
  const parts = yield* Effect.forEach(request.images ?? [], (image) =>
@@ -56,10 +56,18 @@ interface State extends SpeechStream.Audio, GeminiGenerateContent.Metadata {
 // ---------------------------------------------------------------------------

 const fromRequest = Effect.fn("GoogleSpeech.fromRequest")(function* (request: MediaProtocol.Addressed<Request>) {
+  // Not in `unsupported`: that list would also reject `timestamps: false`, which asks for nothing.
+  if (request.timestamps === true)
+    return yield* route.unsupported("media.timestamps", `${route.name} does not return timestamps`)
+  if (request.format === "pcm" && request.mode === "generate" && /^gemini-3\.8-.*-tts(?:-|$)/.test(request.model.id))
+    return yield* route.unsupported(
+      "media.format",
+      `${route.name} returns WAV by default for Gemini 3.8 TTS unary requests; omit the format to accept it`,
+    )
  if (request.format !== undefined && request.format !== "pcm")
    return yield* route.unsupported(
      "media.format",
-      `${route.name} only returns raw PCM; request format "pcm" or omit it, then wrap the samples yourself`,
+      `${route.name} only accepts raw PCM as an explicit format; omit it to accept the provider's default output`,
    )
  const voiceName = SpeechStream.voiceID(request.voice)
  return MediaProtocol.json(
@@ -97,10 +105,18 @@ const step = Effect.fn("GoogleSpeech.step")(function* (state: State, frame: stri
  return [next, audio.flatMap((part) => SpeechStream.delta(next, part.data)[1])] as const
 })

-const finish = (state: State) => {
+const finish = (state: State, context: MediaProtocol.ResponseContext<Request>) => {
  const sampleRate = SpeechStream.sampleRate(state.mimeType) ?? DEFAULT_SAMPLE_RATE
+  const output =
+    state.mimeType?.split(";")[0]?.toLowerCase() === "audio/wav"
+      ? SpeechStream.container("wav", sampleRate)
+      : SpeechStream.pcm("pcm_s16le", sampleRate, state.mimeType ?? `audio/L16;codec=pcm;rate=${sampleRate}`)
+  if (context.request.format === "pcm" && output.info.format !== "pcm")
+    return Effect.fail(
+      route.frameError(`Google Speech returned ${output.info.format} instead of the requested raw PCM`),
+    )
  return SpeechStream.finish(route, state, {
-    ...SpeechStream.pcm("pcm_s16le", sampleRate, state.mimeType ?? `audio/L16;codec=pcm;rate=${sampleRate}`),
+    ...output,
    usage: GeminiGenerateContent.usage(state.usage),
    providerMetadata: GeminiGenerateContent.providerMetadata(state),
    detail: state.finishReason === undefined ? undefined : `finish reason: ${state.finishReason}`,
@@ -112,7 +128,7 @@ const finish = (state: State) => {
 // ---------------------------------------------------------------------------

 export const protocol = MediaProtocol.stream<Request, SpeechEvent, string, State>(route, {
-  unsupported: ["instructions", "speed", "timestamps"],
+  unsupported: ["instructions", "speed"],
  body: { from: fromRequest },
  frames: (bytes, context) => GeminiGenerateContent.frames(bytes, context.request.mode),
  initial: () => ({ chunks: [] }),
@@ -149,8 +149,7 @@ const decodeResult = Effect.fn("GoogleVideo.decodeResult")(function* (
  const output = yield* decodeOperation(response)
  const operation = output.value
  const status = statusOf(operation)
-  if (status === "running")
-    return yield* output.invalid(`${route.name} operation ${context.token.operation} has not finished`)
+  if (status === "running") return yield* output.pending(context.token.operation)
  if (status === "failed")
    return yield* output.ended(
      "failed",
@@ -5,7 +5,6 @@ import { LLMEvent, LLMRequest, Message, ToolResultPart } from "../schema/index.j
 import { OpenResponses } from "./open-responses.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
-import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { detectMediaType } from "../utils/media-type.js"

 const ADAPTER = "meta-responses"
@@ -103,12 +102,7 @@ const fromRequest = Effect.fn("MetaResponses.fromRequest")(function* (request: L
        ? undefined
        : yield* Effect.forEach(projected.tools, (tool) =>
            Effect.gen(function* () {
-              if (tool.native === undefined)
-                return yield* OpenResponses.lowerTool(
-                  NAME,
-                  tool,
-                  ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model),
-                )
+              if (tool.native === undefined) return yield* OpenResponses.lowerTool(NAME, tool)
              return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(NativeTool))(tool.native.meta)
            }),
          ),
@@ -13,7 +13,6 @@ import {
  UnknownProviderError,
  Usage,
  type FinishReasonDetails,
-  type JsonSchema,
  type LLMRequest,
  type MediaPart,
  type ToolCallPart,
@@ -23,7 +22,6 @@ import { classifyProviderFailure } from "../provider-error.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { Lifecycle } from "./utils/lifecycle.js"
 import { MistralToolID } from "./utils/mistral-tool-id.js"
-import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { ToolStream } from "./utils/tool-stream.js"

 const ADAPTER = "mistral-chat"
@@ -368,9 +366,9 @@ const lowerMessages = Effect.fn("MistralChat.lowerMessages")(function* (request:
  return messages
 })

-const lowerTool = (tool: ToolDefinition, inputSchema: JsonSchema): MistralTool => ({
+const lowerTool = (tool: ToolDefinition): MistralTool => ({
  type: "function",
-  function: { name: tool.name, description: tool.description, parameters: inputSchema, strict: false },
+  function: { name: tool.name, description: tool.description, parameters: tool.inputSchema, strict: false },
 })

 export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (request: LLMRequest) {
@@ -396,12 +394,7 @@ export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (reque
  return {
    model: request.model.id,
    messages: yield* lowerMessages(flattened.request),
-    tools:
-      flattened.tools.length > 0
-        ? flattened.tools.map((tool) =>
-            lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model)),
-          )
-        : undefined,
+    tools: flattened.tools.length > 0 ? flattened.tools.map(lowerTool) : undefined,
    tool_choice: toolChoice,
    stream: true as const,
    max_tokens: request.generation?.maxTokens,
@@ -8,7 +8,6 @@ import {
  ProviderInternalError,
  Usage,
  type FinishReason,
-  type JsonSchema,
  type LLMRequest,
  type MediaPart,
  type ProviderMetadata,
@@ -24,7 +23,6 @@ import { classifyProviderFailure } from "../provider-error.js"
 import { effortUpdate } from "../effort-updates.js"
 import { OpenResponsesOptions } from "./utils/open-responses-options.js"
 import { Lifecycle } from "./utils/lifecycle.js"
-import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { ToolStream } from "./utils/tool-stream.js"

 const ADAPTER = "open-responses"
@@ -443,23 +441,24 @@ interface ReasoningStreamItem {
 // =============================================================================
 // Request Lowering
 // =============================================================================
-export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (
-  protocolName: string,
-  tool: ToolDefinition,
-  inputSchema: JsonSchema,
-) {
+export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protocolName: string, tool: ToolDefinition) {
  if (tool.native !== undefined)
    return yield* ProviderShared.invalidRequest(`${protocolName} does not support provider-native tool ${tool.name}`)
  return {
    type: "function" as const,
    name: tool.name,
    description: tool.description,
-    parameters: inputSchema,
+    parameters: tool.inputSchema,
    // The common tool definition does not currently express Responses strict-schema policy.
    strict: false,
  }
 })

+export const lowerTools = (tools: ReadonlyArray<ToolDefinition>, adapter: ProviderAdapter) =>
+  Effect.forEach(tools, (tool) =>
+    tool.native !== undefined && adapter.nativeTool ? adapter.nativeTool(tool.native) : lowerTool(adapter.name, tool),
+  )
+
 export const lowerToolChoice = (protocolName: string, toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
  ProviderShared.matchToolChoice(protocolName, toolChoice, {
    auto: () => "auto" as const,
@@ -821,14 +820,7 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
  return {
    ...(yield* lowerConversation(projected.request, adapter)),
    ...lowerGeneration(request),
-    tools:
-      projected.tools.length === 0
-        ? undefined
-        : yield* Effect.forEach(projected.tools, (tool) =>
-            tool.native !== undefined && adapter.nativeTool
-              ? adapter.nativeTool(tool.native)
-              : lowerTool(adapter.name, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model)),
-          ),
+    tools: projected.tools.length === 0 ? undefined : yield* lowerTools(projected.tools, adapter),
    tool_choice:
      allowedToolChoice(request) ??
      (request.toolChoice ? yield* lowerToolChoice(adapter.name, request.toolChoice) : undefined),
@@ -17,7 +17,6 @@ import {
  type FinishReason,
  type FinishReasonDetails,
  type CacheHint,
-  type JsonSchema,
  type LLMRequest,
  type MediaPart,
  type ReasoningPart,
@@ -29,7 +28,6 @@ import { classifyProviderFailure } from "../provider-error.js"
 import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { OpenAIOptions } from "./utils/openai-options.js"
 import { Lifecycle } from "./utils/lifecycle.js"
-import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { ToolStream } from "./utils/tool-stream.js"

 const ADAPTER = "openai-chat"
@@ -330,17 +328,12 @@ interface LoweringOptions {
  readonly toolCallID?: (id: string) => string
 }

-const lowerTool = (
-  tool: ToolDefinition,
-  inputSchema: JsonSchema,
-  options: LoweringOptions,
-  supportsStrictMode: boolean,
-): OpenAIChatTool => ({
+const lowerTool = (tool: ToolDefinition, options: LoweringOptions, supportsStrictMode: boolean): OpenAIChatTool => ({
  type: "function",
  function: {
    name: tool.name,
    description: tool.description,
-    parameters: inputSchema,
+    parameters: tool.inputSchema,
    ...(supportsStrictMode ? { strict: false } : {}),
  },
  cache_control: options.cacheControl?.(tool.cache),
@@ -825,14 +818,7 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
        ? hasHistory
          ? []
          : undefined
-        : flattened.tools.map((tool) =>
-            lowerTool(
-              tool,
-              ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model),
-              options,
-              supportsStrictMode,
-            ),
-          ),
+        : flattened.tools.map((tool) => lowerTool(tool, options, supportsStrictMode)),
    tool_choice: hasActiveTools && request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
    stream: true as const,
    ...(supportsUsageInStreaming ? { stream_options: { include_usage: true } } : {}),
@@ -48,15 +48,17 @@ const Usage = Schema.Struct({
  output_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 })

-const OpenAIImageResponse = Schema.Struct({
-  data: Schema.Array(
-    Schema.Struct({
-      b64_json: Schema.optional(Schema.String),
-      url: Schema.optional(Schema.String),
-      revised_prompt: Schema.optional(Schema.String),
-    }),
-  ),
+/** What the provider actually rendered; it can differ from the request when `auto` or a default applied. */
+const Settings = {
  output_format: Schema.optional(Schema.String),
+  size: Schema.optional(Schema.String),
+  quality: Schema.optional(Schema.String),
+  background: Schema.optional(Schema.String),
+}
+
+const OpenAIImageResponse = Schema.Struct({
+  data: Schema.Array(Schema.Struct({ b64_json: Schema.String })),
+  ...Settings,
  usage: Schema.optional(Usage),
 })

@@ -69,11 +71,13 @@ const StreamEvent = Schema.Union([
    type: Schema.Literals(["image_generation.partial_image", "image_edit.partial_image"]),
    b64_json: Schema.String,
    partial_image_index: Schema.Number,
+    ...Settings,
    output_format: Schema.String,
  }),
  Schema.Struct({
    type: Schema.Literals(["image_generation.completed", "image_edit.completed"]),
    b64_json: Schema.String,
+    ...Settings,
    output_format: Schema.String,
    usage: Schema.optional(Usage),
  }),
@@ -92,6 +96,9 @@ type Frame = string | { readonly document: string; readonly requested: string |
 interface State {
  readonly completed: number
  readonly format?: string
+  readonly size?: string
+  readonly quality?: string
+  readonly background?: string
  readonly usage?: MediaUsage
 }

@@ -110,10 +117,6 @@ const nativeOptions = (options: OpenAIImageOptions | undefined) => {

 const streamOptions = (request: MediaProtocol.Addressed<Request>) => {
  if (request.mode !== "stream") return Effect.succeed(undefined)
-  if (request.model.id.startsWith("dall-e"))
-    return Effect.fail(
-      route.unsupported("media.stream", `${request.model.id} does not stream; use Image.generate or a GPT image model`),
-    )
  if (request.n !== undefined && request.n > 1)
    return Effect.fail(
      route.unsupported("media.n", `${route.name} streams one image; use Image.generate for n=${request.n}`),
@@ -194,21 +197,34 @@ const usage = (value: Schema.Schema.Type<typeof Usage> | undefined): MediaUsage
        details: { openai: value },
      }

-const eventImage = (frame: string, label: string, data: string, format: string) =>
+/** `size` echoes the rendered `WIDTHxHEIGHT`; `auto` or any other value leaves the dimensions unknown. */
+const info = (format: string, size: string | undefined): Media.Info => {
+  const match = size?.match(/^(\d+)x(\d+)$/)
+  return match ? { format, width: Number(match[1]), height: Number(match[2]) } : { format }
+}
+
+const eventImage = (frame: string, label: string, data: string, format: string, size: string | undefined) =>
  MediaInput.decodedAsset((message, cause) => route.frameError(message, frame, cause), label, data, `image/${format}`, {
-    info: { format },
+    info: info(format, size),
  })

 const onEvent = Effect.fn("OpenAIImages.onEvent")(function* (state: State, frame: string) {
  const event = yield* decodeEvent(frame)
  const format = event.output_format
  if ("partial_image_index" in event) {
-    const image = yield* eventImage(frame, `${route.name} partial image`, event.b64_json, format)
+    const image = yield* eventImage(frame, `${route.name} partial image`, event.b64_json, format, event.size)
    return [state, [ImagePartialEvent.make({ index: event.partial_image_index, image })]] as const
  }
-  const image = yield* eventImage(frame, `${route.name} result ${state.completed}`, event.b64_json, format)
+  const image = yield* eventImage(frame, `${route.name} result ${state.completed}`, event.b64_json, format, event.size)
  return [
-    { ...state, completed: state.completed + 1, format, usage: usage(event.usage) },
+    {
+      completed: state.completed + 1,
+      format,
+      size: event.size,
+      quality: event.quality,
+      background: event.background,
+      usage: usage(event.usage),
+    },
    [ImageOutputEvent.make({ index: state.completed, image })],
  ] as const
 })
@@ -219,16 +235,20 @@ const onDocument = Effect.fn("OpenAIImages.onDocument")(function* (frame: Exclud
    Effect.mapError((cause) => invalid(`${route.name} returned an invalid response`, cause)),
  )
  const format = decoded.output_format ?? frame.requested ?? "png"
-  const mediaType = `image/${format}`
  const images = yield* Effect.forEach(decoded.data, (item, index) =>
-    MediaInput.imageOutput(invalid, `${route.name} result ${index}`, item, mediaType, {
-      info: { format },
-      providerMetadata:
-        item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
+    MediaInput.decodedAsset(invalid, `${route.name} result ${index}`, item.b64_json, `image/${format}`, {
+      info: info(format, decoded.size),
    }),
  )
  if (images.length === 0) return yield* invalid(`${route.name} returned no images`)
-  const state: State = { completed: images.length, format, usage: usage(decoded.usage) }
+  const state: State = {
+    completed: images.length,
+    format,
+    size: decoded.size,
+    quality: decoded.quality,
+    background: decoded.background,
+    usage: usage(decoded.usage),
+  }
  return [state, images.map((image, index) => ImageOutputEvent.make({ index, image }))] as const
 })

@@ -237,7 +257,17 @@ const step = (state: State, frame: Frame) => (typeof frame === "string" ? onEven
 const finish = (state: State) => {
  if (state.completed === 0) return Effect.fail(route.incomplete())
  return Effect.succeed([
-    ImageFinishEvent.make({ usage: state.usage, providerMetadata: { openai: { outputFormat: state.format } } }),
+    ImageFinishEvent.make({
+      usage: state.usage,
+      providerMetadata: {
+        openai: {
+          outputFormat: state.format,
+          size: state.size,
+          quality: state.quality,
+          background: state.background,
+        },
+      },
+    }),
  ])
 }

@@ -5,20 +5,12 @@ 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,
-  mergeJsonRecords,
-  type JsonSchema,
-  type LanguageModel,
-  type ToolDefinition,
-  type ToolEntry,
-} from "../schema/index.js"
+import { LLMRequest, type ToolDefinition, type ToolEntry } from "../schema/index.js"
 import { resolveEffortUpdates } from "../effort-updates.js"
 import { OpenResponses } from "./open-responses.js"
 import { OpenResponsesOptions } from "./utils/open-responses-options.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
-import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { OpenResponsesChannel } from "./open-responses-channel.js"
 import { ResponsesCompaction } from "./utils/responses-compaction.js"
 import { ResponsesCheckpoint } from "./utils/responses-checkpoint.js"
@@ -143,11 +135,6 @@ export const CompactionTrigger = Schema.Struct({ type: Schema.Literal("compactio
 const CheckpointBody = Schema.Struct({
  ...OpenAIResponsesBody.fields,
  input: Schema.Array(Schema.Union([OpenAIResponsesInputItem, CompactionTrigger])),
-  store: Schema.Literal(false),
-  prompt_cache_retention: optionalNull(Schema.String),
-  prompt_cache_options: optionalNull(
-    Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) }),
-  ),
 })

 const adapter = {
@@ -156,12 +143,14 @@ const adapter = {
  restoreHostedToolItem: (item: unknown) => (Schema.is(OpenAIResponsesHostedToolItem)(item) ? item : undefined),
 } satisfies OpenResponses.ProviderAdapter

-// Only GPT-6 Astra accepts `configuration_update`, and never alongside automatic `context_management` compaction.
+// GPT-6 Astra, Sol, and Luna accept `configuration_update` only in standard mode (not `reasoning.mode: "pro"` or
+// `-pro` slugs), and never alongside automatic `context_management` compaction.
 const supportsEffortUpdates = (request: LLMRequest) => {
  if (request.providerOptions?.contextManagement !== undefined) return false
+  if (Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(request.http?.body?.reasoning)) return false
  const override = request.model.compatibility?.supportsEffortUpdates
  if (override !== undefined) return override
-  return /(?:^|\/)gpt-6-astra$/i.test(request.model.id)
+  return /(?:^|\/)gpt-6-(?:astra|sol|luna)$/i.test(request.model.id)
 }

 const nativeImageToolInput = (tool: ToolDefinition) => {
@@ -174,20 +163,19 @@ const nativeImageTool = (tool: ToolDefinition) => {
  return Schema.is(OpenAIResponsesImageGenerationTool)(native) ? native : undefined
 }

-const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool: ToolDefinition, inputSchema: JsonSchema) {
+const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool: ToolDefinition) {
  const native = nativeImageToolInput(tool)
  if (native !== undefined) {
    if (Schema.is(OpenAIResponsesImageGenerationTool)(native)) return native
    return yield* ProviderShared.invalidRequest("OpenAI Responses image generation tool options are invalid")
  }
-  return yield* OpenResponses.lowerTool(NAME, tool, inputSchema)
+  return yield* OpenResponses.lowerTool(NAME, tool)
 })

 // Native namespaces hold only function tools, so deeper levels flatten into
 // the leaf names the same way non-native protocols flatten the whole tree.
-const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (tool: ToolEntry, model: LanguageModel) {
-  if (tool.type === "tool")
-    return yield* lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, model))
+const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (tool: ToolEntry) {
+  if (tool.type === "tool") return yield* lowerTool(tool)
  // OpenAI requires a namespace description; fall back to a generic one so a
  // missing description never blocks the request.
  return {
@@ -195,11 +183,13 @@ const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (to
    name: tool.name,
    description: tool.description ?? `Tools in the ${tool.name} namespace.`,
    tools: yield* Effect.forEach(ProviderShared.flattenTools(tool.tools), (leaf) =>
-      OpenResponses.lowerTool(NAME, leaf, ToolSchemaProjection.modelCompatibility(leaf.inputSchema, model)),
+      OpenResponses.lowerTool(NAME, leaf),
    ),
  }
 })

+const lowerTools = (request: LLMRequest) => Effect.forEach(request.tools, lowerToolEntry)
+
 const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolEntry>) =>
  ProviderShared.matchToolChoice(NAME, toolChoice, {
    auto: () => "auto" as const,
@@ -223,10 +213,7 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
    ...(yield* OpenResponses.lowerConversation(updates.request, adapter)),
    ...OpenResponses.lowerGeneration(request, { ...options, reasoningEffort: updates.effort }),
    context_management: management?.map((edit) => ({ type: edit.type, compact_threshold: edit.compactThreshold })),
-    tools:
-      request.tools.length === 0
-        ? undefined
-        : yield* Effect.forEach(request.tools, (tool) => lowerToolEntry(tool, request.model)),
+    tools: request.tools.length === 0 ? undefined : yield* lowerTools(request),
    tool_choice:
      request.tools.length === 0
        ? undefined
@@ -238,7 +225,6 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
 const checkpointBody = {
  schema: CheckpointBody,
  from: Effect.fn("OpenAIResponses.checkpointBody")(function* (request: LLMRequest) {
-    const native = yield* fromRequest(LLMRequest.update(request, { toolChoice: undefined }))
    const overlay = request.http?.body
    // Complete history is required for stateless replay and SSE recovery. Raw input overrides bypass that contract.
    if (
@@ -249,18 +235,13 @@ const checkpointBody = {
      return yield* ProviderShared.invalidRequest(
        "Trigger compaction requires complete canonical history, not an input or continuation override",
      )
-    return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(CheckpointBody))({
-      ...mergeJsonRecords(native, overlay),
-      input: [...native.input, { type: "compaction_trigger" }],
-      stream: true,
-      store: false,
-      parallel_tool_calls: true,
-      tool_choice: undefined,
-      context_management: undefined,
-      text: undefined,
-      max_output_tokens: undefined,
-      max_tool_calls: undefined,
-    })
+    if (overlay?.stream !== undefined && overlay.stream !== true)
+      return yield* ProviderShared.invalidRequest("Trigger compaction requires a streamed response")
+    const native = yield* fromRequest(request)
+    return {
+      ...native,
+      input: [...native.input, { type: "compaction_trigger" as const }],
+    }
  }),
 }

@@ -342,7 +323,10 @@ export const transport = channelTransport({
 })

 export const route = Route.make({
-  compact: { endpoint: ResponsesCompaction.make(adapter), trigger: ResponsesCheckpoint.make(checkpointBody) },
+  compact: {
+    endpoint: ResponsesCompaction.make(adapter, lowerTools),
+    trigger: ResponsesCheckpoint.make(checkpointBody),
+  },
  id: ADAPTER,
  provider: "openai",
  providerMetadataKey: "openai",
@@ -61,6 +61,9 @@ interface State extends SpeechStream.Audio {
 const supportsSse = (model: string) => !/^tts-1(-hd)?(-|$)/.test(model)

 const fromRequest = Effect.fn("OpenAISpeech.fromRequest")(function* (request: MediaProtocol.Addressed<Request>) {
+  // Not in `unsupported`: that list would also reject `timestamps: false`, which asks for nothing.
+  if (request.timestamps === true)
+    return yield* route.unsupported("media.timestamps", `${route.name} does not return timestamps`)
  return MediaProtocol.json(
    mergeJsonRecords(
      {
@@ -121,7 +124,7 @@ const finish = (state: State, context: MediaProtocol.ResponseContext<Request>) =
 // ---------------------------------------------------------------------------

 export const protocol = MediaProtocol.stream<Request, SpeechEvent, string | Uint8Array, State>(route, {
-  unsupported: ["language", "timestamps"],
+  unsupported: ["language"],
  body: { from: fromRequest },
  frames: (bytes, context) => (isSse(context.body) ? Framing.sse.frame(bytes) : bytes),
  initial: () => ({ chunks: [], done: false }),
@@ -1,8 +1,9 @@
 import { Effect, Schema, Stream } from "effect"
+import { classifyProviderFailure } from "../provider-error.js"
 import { Framing } from "../route/framing.js"
 import { MediaProtocol } from "../route/media-protocol.js"
 import { MediaRoute } from "../route/media.js"
-import { mergeJsonRecords, type MediaUsage } from "../schema/index.js"
+import { AIError, mergeJsonRecords, type MediaUsage } from "../schema/index.js"
 import {
  TranscriptionFinishEvent,
  TranscriptionModel,
@@ -59,6 +60,9 @@ const Usage = Schema.Union([
    input_tokens: Schema.optional(Schema.Number),
    output_tokens: Schema.optional(Schema.Number),
    total_tokens: Schema.optional(Schema.Number),
+    input_token_details: Schema.optional(
+      Schema.Struct({ audio_tokens: Schema.optional(Schema.Number), text_tokens: Schema.optional(Schema.Number) }),
+    ),
  }),
  Schema.Struct({ type: Schema.Literal("duration"), seconds: Schema.Number }),
 ])
@@ -75,14 +79,23 @@ const transcriptFields = {
  usage: Schema.optional(Usage),
 }

+/** OpenAI may add stream event types; frames outside `EVENT_TYPES` are ignored. */
+const EventType = Schema.Struct({ type: Schema.String })
 const Event = Schema.Union([
  Schema.Struct({ type: Schema.Literal("transcript.text.delta"), delta: Schema.String }),
  Schema.Struct({ type: Schema.Literal("transcript.text.segment"), ...Segment.fields }),
  Schema.Struct({ type: Schema.Literal("transcript.text.done"), ...transcriptFields }),
+  Schema.Struct({
+    type: Schema.Literal("error"),
+    message: Schema.optional(Schema.String),
+    error: Schema.optional(Schema.Struct({ message: Schema.optional(Schema.String) })),
+  }),
 ])
+const EVENT_TYPES = new Set(["transcript.text.delta", "transcript.text.segment", "transcript.text.done", "error"])
 const Transcript = Schema.Struct(transcriptFields)
 type Transcript = Schema.Schema.Type<typeof Transcript>

+const decodeEventType = route.decodeFrame(EventType)
 const decodeEvent = route.decodeFrame(Event)
 const decodeTranscript = route.decodeFrame(Transcript)

@@ -118,10 +131,12 @@ const capabilities = (model: string): Capabilities => {
  return TRANSCRIBE
 }

+/** whisper-1 ignores `stream`, so its `stream` mode sends a plain request and emits only `finish`. */
+const streamsEvents = (request: MediaProtocol.Addressed<Request>) =>
+  request.mode === "stream" && capabilities(request.model.id).stream
+
 const validate = (request: MediaProtocol.Addressed<Request>, model: Capabilities) => {
  const id = request.model.id
-  if (request.mode === "stream" && !model.stream)
-    return Effect.fail(route.unsupported("media.stream", `${id} does not stream; use Transcription.generate`))
  if (request.diarize === true && !model.diarize)
    return Effect.fail(route.unsupported("media.diarize", `${id} does not diarize; use gpt-4o-transcribe-diarize`))
  if (request.prompt !== undefined && model.diarize)
@@ -173,7 +188,7 @@ const fromRequest = Effect.fn("OpenAITranscription.fromRequest")(function* (requ
      timestamp_granularities: responseFormat === "verbose_json" ? [request.timestamps] : undefined,
      // Diarizing audio longer than 30 seconds requires a chunking strategy.
      chunking_strategy: model.diarize ? "auto" : undefined,
-      stream: request.mode === "stream" ? true : undefined,
+      stream: streamsEvents(request) ? true : undefined,
    },
    {
      overlay: mergeJsonRecords(request.providerOptions, request.http?.body),
@@ -196,7 +211,15 @@ const segment = (value: Schema.Schema.Type<typeof Segment>): TranscriptionSegmen
 })

 const onEvent = Effect.fn("OpenAITranscription.onEvent")(function* (state: State, frame: string) {
+  if (!EVENT_TYPES.has((yield* decodeEventType(frame)).type)) return [state, []] as const
  const event = yield* decodeEvent(frame)
+  if (event.type === "error")
+    return yield* new AIError({
+      reason: classifyProviderFailure({
+        message: `${route.name} stream failed: ${event.message ?? event.error?.message ?? "unknown error"}`,
+        rawBody: frame,
+      }),
+    })
  if (event.type === "transcript.text.done") return [{ ...state, transcript: event }, []] as const
  if (event.type === "transcript.text.delta")
    return [state, event.delta.length === 0 ? [] : [TranscriptionTextDeltaEvent.make({ delta: event.delta })]] as const
@@ -246,7 +269,7 @@ export const protocol = MediaProtocol.stream<Request, TranscriptionEvent, Frame,
  unsupported: ["speakers"],
  body: { from: fromRequest },
  frames: (bytes, context) =>
-    context.request.mode === "stream"
+    streamsEvents(context.request)
      ? Framing.sse.frame(bytes)
      : Framing.document.frame(bytes).pipe(Stream.map((document) => ({ document }))),
  initial: () => ({ segments: [] }),
@@ -132,8 +132,7 @@ const decodeResult = Effect.fn("ReplicateImages.decodeResult")(function* (
      status,
      `${route.name} prediction ${context.token.id} ${prediction.status}${typeof prediction.error === "string" ? `: ${prediction.error}` : ""}`,
    )
-  if (status !== "completed")
-    return yield* output.invalid(`${route.name} prediction ${context.token.id} has not finished`)
+  if (status !== "completed") return yield* output.pending(context.token.id)
  if (prediction.data_removed === true)
    return yield* output.ended("expired", `${route.name} removed the output of prediction ${context.token.id}`)
  if (!isOutput(prediction.output))
@@ -141,8 +141,7 @@ const decodeResult = Effect.fn("RunwayVideo.decodeResult")(function* (
  }
  if (status === "cancelled")
    return yield* output.ended("cancelled", `${route.name} task ${context.token.taskID} was cancelled`)
-  if (status !== "completed")
-    return yield* output.invalid(`${route.name} task ${context.token.taskID} has not finished`)
+  if (status !== "completed") return yield* output.pending(context.token.taskID)
  const urls = task.output ?? []
  if (urls.length === 0) return yield* output.invalid(`${route.name} task succeeded without any output`)
  return new VideoResponse({
@@ -171,7 +170,7 @@ export const protocol = MediaProtocol.queued<Request, VideoResponse, Token>(rout
  start: { body: { from: fromRequest }, decode: decodeStart },
  status: { path: taskPath, decode: decodeStatus },
  result: { path: taskPath, decode: decodeResult },
-  cancel: { method: "DELETE", path: taskPath },
+  cancel: { method: "DELETE", path: taskPath, activeOnly: true },
 })

 const startPath = (request: Request) => {
@@ -110,6 +110,14 @@ export const sumTokens = (...values: ReadonlyArray<number | undefined>): number
  return values.reduce((acc: number, value) => acc + (value ?? 0), 0)
 }

+/**
+ * Caps an explicit thinking budget at half the output limit. Thinking counts against the output limit, so a budget
+ * near it leaves the answer, a tool call, or a summary without room. Smaller budgets, special values such as `-1` and
+ * `0`, and requests without an output limit pass through unchanged.
+ */
+export const fitThinkingBudget = (budget: number, maxTokens: number | undefined, minimum = 1) =>
+  maxTokens === undefined || budget <= maxTokens / 2 ? budget : Math.max(minimum, Math.floor(maxTokens / 2))
+
 export const eventError = (route: string, message: string, body?: string, cause?: unknown) =>
  new AIError({
    reason: new InvalidProviderOutputError({ route, message, body, cause }),
@@ -175,7 +175,7 @@ const decodeUpscaleResult = Effect.fn("StabilityImages.decodeUpscaleResult")(fun
 ) {
  if (response.status === 202) {
    const output = yield* upscaleRoute.text(response)
-    return yield* output.invalid(`${upscaleRoute.name} upscale ${context.token.id} has not finished`)
+    return yield* output.pending(context.token.id)
  }
  return yield* decodeUpscaleImage(response)
 })
@@ -1,7 +1,7 @@
 import { Effect, Schema, Stream } from "effect"
 import { Route, type RouteBody, type TriggerCompactOperation } from "../../route/client.js"
 import { Protocol } from "../../route/protocol.js"
-import { CompactionCheckpointResponse, HttpOptions, LLMEvent, LLMRequest } from "../../schema/index.js"
+import { CompactionCheckpointResponse, LLMEvent, LLMRequest } from "../../schema/index.js"
 import { OpenResponses } from "../open-responses.js"
 import { ProviderShared } from "../shared.js"

@@ -109,12 +109,8 @@ export const make = <Body>(body: RouteBody<Body>): TriggerCompactOperation =>
      transport: source.transport,
    })
    const native = yield* body.from(request)
-    // The body builder already applied and validated overlays. Do not let transport reapply them.
-    const preparedRequest = LLMRequest.update(request, {
-      http: request.http === undefined ? undefined : new HttpOptions({ ...request.http, body: undefined }),
-    })
-    const prepared = yield* route.prepareTransport(native, preparedRequest, options)
-    yield* route.streamPrepared(prepared, preparedRequest, { http: executor }, options).pipe(Stream.runDrain)
+    const prepared = yield* route.prepareTransport(native, request, options)
+    yield* route.streamPrepared(prepared, request, { http: executor }, options).pipe(Stream.runDrain)
    if (!result) return yield* ProviderShared.eventError(source.id, "Compaction response ended without a checkpoint")
    return result
  })
@@ -19,12 +19,18 @@ import { OpenResponses } from "../open-responses.js"
 import { JsonObject, optionalNull, ProviderShared } from "../shared.js"
 import { Media } from "../../media.js"

+// /compact has a smaller wire contract than /responses; keep the request controls it accepts.
 const Body = Schema.Struct({
  model: Schema.String,
  input: Schema.Array(Schema.Unknown),
  instructions: optionalNull(Schema.String),
  previous_response_id: optionalNull(Schema.String),
  service_tier: optionalNull(Schema.String),
+  reasoning: Schema.optional(JsonObject),
+  text: Schema.optional(JsonObject),
+  include: OpenResponses.coreFields.include,
+  parallel_tool_calls: OpenResponses.coreFields.parallel_tool_calls,
+  tools: Schema.optional(Schema.Array(JsonObject)),
  prompt_cache_key: optionalNull(Schema.String),
  prompt_cache_retention: optionalNull(Schema.String),
  prompt_cache_options: optionalNull(
@@ -74,17 +80,27 @@ const Response = Schema.Struct({
  usage: Schema.optional(Schema.StructWithRest(OpenResponses.OpenResponsesUsage, [JsonObject])),
 })

-export const make = (adapter: OpenResponses.ProviderAdapter): CompactOperation =>
+export const make = (
+  adapter: OpenResponses.ProviderAdapter,
+  lowerTools: (request: LLMRequest) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, AIError>,
+): CompactOperation =>
  Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
    const route = request.model.route
    // The standalone compaction endpoint rejects histories containing configuration updates.
    const native = yield* OpenResponses.lowerConversation(stripEffortUpdates(request), adapter)
+    const generation = OpenResponses.lowerGeneration(request)
+    const tools = request.tools.length === 0 ? undefined : yield* lowerTools(request)
    const body = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(
      mergeJsonRecords(
        {
          ...native,
-          service_tier: request.providerOptions?.serviceTier,
-          prompt_cache_key: ProviderShared.promptCacheKey(request),
+          service_tier: generation.service_tier,
+          reasoning: generation.reasoning,
+          text: generation.text,
+          include: generation.include,
+          parallel_tool_calls: generation.parallel_tool_calls,
+          tools,
+          prompt_cache_key: generation.prompt_cache_key,
        },
        request.http?.body,
      ),
@@ -1,4 +1,4 @@
-import type { JsonSchema, LanguageModel, LanguageModelSanitizerCompatibility } from "../../schema/index.js"
+import { ToolDefinition, type JsonSchema, type LanguageModel, type LLMRequest } from "../../schema/index.js"
 import { isRecord } from "../../utils/record.js"
 import { GeminiJsonSchema } from "./gemini-json-schema.js"

@@ -70,13 +70,13 @@ const objectRoot = (schema: JsonSchema): JsonSchema => {
 // Otherwise the protocol's own default applies (the Gemini API always uses Gemini's rules), then the
 // model name selects the family's rules so models reached through gateways and OpenAI-compatible
 // endpoints get the same handling.
-const modelCompatibility = (
-  schema: JsonSchema,
-  model: LanguageModel,
-  protocolDefault?: LanguageModelSanitizerCompatibility,
-): JsonSchema => {
+const modelCompatibility = (schema: JsonSchema, model: LanguageModel): JsonSchema => {
  const root = objectRoot(schema)
-  switch (model.compatibility?.sanitizer ?? protocolDefault ?? MODEL_NAMES.find(([name]) => name.test(model.id))?.[1]) {
+  switch (
+    model.compatibility?.sanitizer ??
+    model.route.sanitizer ??
+    MODEL_NAMES.find(([name]) => name.test(model.id))?.[1]
+  ) {
    case "gemini":
      return gemini(root)
    case "moonshot":
@@ -87,10 +87,18 @@ const modelCompatibility = (
  }
 }

+// Applied once to every request before any protocol builds its body, including tools in namespaces.
+const tools = (entries: LLMRequest["tools"], model: LanguageModel): LLMRequest["tools"] =>
+  entries.map((tool) =>
+    tool.type === "tool"
+      ? new ToolDefinition({ ...tool, inputSchema: modelCompatibility(tool.inputSchema, model) })
+      : { ...tool, tools: tools(tool.tools, model) },
+  )
+
 export const ToolSchemaProjection = {
  gemini,
-  modelCompatibility,
  moonshot,
  openAI,
  responses,
+  tools,
 } as const
@@ -101,7 +101,8 @@ const decodeResponse = Effect.fn("XAIImages.decodeResponse")(function* (
  )
  if (images.length === 0) return yield* output.invalid(`${route.name} returned no images`)
  const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined
-  // xAI reports image counts rather than tokens, seconds, or credits; the raw record stays in provider metadata.
+  // xAI reports a USD cost (`cost_in_usd_ticks`) rather than tokens, seconds, or credits; the raw record stays in
+  // provider metadata.
  return new ImageResponse({
    images,
    providerMetadata: usage === undefined ? undefined : { xai: { usage } },
@@ -50,7 +50,8 @@ const fromRequest = Effect.fn("XAIResponses.fromRequest")(function* (request: LL
      operation: "in-band-compaction",
      provider: request.model.provider,
      route: request.model.route.id,
-      message: "xAI requires explicit compaction through LLMClient.compact; automatic context management is not supported",
+      message:
+        "xAI requires explicit compaction through LLMClient.compact; automatic context management is not supported",
    })
  return yield* decodeBody(yield* OpenResponses.fromRequestWithAdapter(request, adapter))
 })
@@ -93,6 +94,8 @@ export const protocol = Protocol.make({
  },
 })

-export const compact = ResponsesCompaction.make(adapter)
+export const compact = ResponsesCompaction.make(adapter, (request) =>
+  OpenResponses.lowerTools(ProviderShared.flattenTools(request.tools), adapter),
+)

 export * as XAIResponses from "./xai-responses.js"
@@ -136,8 +136,7 @@ const decodeResult = Effect.fn("XAIVideo.decodeResult")(function* (
  const output = yield* decodeVideoStatus(response)
  const decoded = output.value
  const status = yield* MediaProtocol.status(STATUS, decoded.status, output)
-  if (status === "running")
-    return yield* output.invalid(`${route.name} request ${context.token.requestID} has not finished`)
+  if (status === "running") return yield* output.pending(context.token.requestID)
  if (status === "failed") {
    const code = decoded.error?.code ?? undefined
    const message = decoded.error?.message ?? undefined
@@ -1,7 +1,6 @@
-import { Effect, Schema } from "effect"
+import { Duration, Effect, Schema } from "effect"
 import type { HttpClientResponse } from "effect/unstable/http"
 import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js"
-import { Media } from "../media.js"
 import { MediaProtocol } from "../route/media-protocol.js"
 import { MediaRoute } from "../route/media.js"
 import { mergeJsonRecords, type OpenString } from "../schema/index.js"
@@ -9,6 +8,7 @@ import { mergeJsonRecords, type OpenString } from "../schema/index.js"
 const route = MediaProtocol.identity({ id: "zai-images", name: "Z.ai Images", provider: "zai" })
 export const DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4"
 export const PATH = "/images/generations"
+const OUTPUT_RETENTION = Duration.days(30)

 // ---------------------------------------------------------------------------
 // 1. Public model input
@@ -76,7 +76,7 @@ const decodeResponse = Effect.fn("ZAIImages.decodeResponse")(function* (
  const filters = decoded.content_filter ?? []
  return new ImageResponse({
    // Z.ai returns only URLs and no content type; the media type resolves when the asset is materialized.
-    images: decoded.data.map((item) => Media.url(item.url)),
+    images: yield* Effect.forEach(decoded.data, (item) => MediaProtocol.expiringUrl(item.url, OUTPUT_RETENTION)),
    // Z.ai reports applied content filters alongside a successful result; surface them instead of dropping them.
    notices:
      filters.length === 0
@@ -80,7 +80,13 @@ const SERVER_CODES = new Set([
  "slow_down",
  "serviceunavailableexception",
 ])
-const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error", "validationexception"])
+// `invalid_request` is the Vercel AI Gateway's code for an upstream request rejection.
+const INVALID_REQUEST_CODES = new Set([
+  "invalid_prompt",
+  "invalid_request",
+  "invalid_request_error",
+  "validationexception",
+])
 // Azure OpenAI reports `content_filter` with `innererror.code` ResponsibleAIPolicyViolation.
 // OpenRouter tags provider failures with a typed `error_type`; its Responses skin also
 // emits `image_content_policy_violation` as the native code.
@@ -31,6 +31,7 @@ export interface Settings extends ProviderPackage.Settings {
  readonly profile?: string
  readonly region?: string
  readonly topP?: number
+  readonly thinking?: BedrockConverse.OptionsInput["thinking"]
 }
 export const routes = [BedrockConverse.route]

@@ -71,6 +72,7 @@ export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, se
    generation: settings.topP === undefined ? undefined : { topP: settings.topP },
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.thinking === undefined ? undefined : { thinking: settings.thinking },
    profile: settings.profile,
    region: settings.region,
  }).model(modelID)
@@ -32,10 +32,7 @@ const openAIProviderOptions = (options: OpenAIOptionsInput | undefined): Provide
  return result
 }

-export const gpt5DefaultOptions = (
-  modelID: string,
-  options: { readonly textVerbosity?: boolean } = {},
-): ProviderOptions | undefined => {
+export const gpt5DefaultOptions = (modelID: string): 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({
@@ -47,27 +44,19 @@ export const gpt5DefaultOptions = (
    // this, callers using the default model facade get reasoning summaries
    // they cannot replay statelessly.
    include: ["reasoning.encrypted_content"],
-    textVerbosity:
-      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))
+export const openAIDefaultOptions = (modelID: string): ProviderOptions | undefined =>
+  mergeProviderOptions(openAIProviderOptions({ store: false }), gpt5DefaultOptions(modelID))

 export const withOpenAIOptions = <Options extends { readonly providerOptions?: OpenAIProviderOptionsInput }>(
  modelID: string,
  options: Options,
-  defaults: { readonly textVerbosity?: boolean } = {},
 ): Omit<Options, "providerOptions"> & { readonly providerOptions?: ProviderOptions } => {
  return {
    ...options,
-    providerOptions: mergeProviderOptions(openAIDefaultOptions(modelID, defaults), options.providerOptions),
+    providerOptions: mergeProviderOptions(openAIDefaultOptions(modelID), options.providerOptions),
  }
 }

@@ -100,7 +100,7 @@ export const configure = (input: Config = {}) => {
  const modelDefaults = defaults(input)
  const responses = (id: string | ModelID) =>
    responsesRoute
-      .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
+      .with(withOpenAIOptions(id, modelDefaults))
      .model<OpenAIProviderOptionsInput>({ id })
  const chat = (id: string | ModelID) =>
    chatRoute.with(withOpenAIOptions(id, modelDefaults)).model<OpenAIProviderOptionsInput>({
@@ -8,7 +8,7 @@ import type { ProviderPackage } from "../provider-package.js"
 import { SystemOne } from "../experimental/system-one.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
 import { newBreakpoints, ttlBucket } from "../protocols/utils/cache.js"
-import { isRecord } from "../protocols/shared.js"
+import { isRecord, ProviderShared } from "../protocols/shared.js"

 export const id = ProviderID.make("openrouter")
 const baseURL = "https://openrouter.ai/api/v1"
@@ -123,7 +123,7 @@ export const protocol = Protocol.make({
          return {
            ...body,
            messages,
-            ...bodyOptions(request.providerOptions),
+            ...bodyOptions(request.providerOptions, request.generation?.maxTokens),
          } as OpenRouterBody
        }),
      ),
@@ -143,7 +143,14 @@ const cacheControl = () => {
  }
 }

-const bodyOptions = (input: unknown) => {
+// OpenRouter forwards `reasoning.max_tokens` as the upstream thinking budget. Upstreams such as Anthropic and Alibaba
+// reject one that is not below the output limit; 1,024 is Anthropic's minimum budget.
+const fitReasoning = (reasoning: Record<string, unknown>, maxTokens: number | undefined) =>
+  typeof reasoning.max_tokens === "number"
+    ? { ...reasoning, max_tokens: ProviderShared.fitThinkingBudget(reasoning.max_tokens, maxTokens, 1_024) }
+    : reasoning
+
+const bodyOptions = (input: unknown, maxTokens: number | undefined) => {
  const openrouter = isRecord(input) ? input : {}
  const { usage, models, provider, plugins, web_search_options, debug, user, reasoning, promptCacheKey, ...options } =
    openrouter
@@ -162,7 +169,7 @@ const bodyOptions = (input: unknown) => {
    ...(isRecord(web_search_options) ? { web_search_options } : {}),
    ...(isRecord(debug) ? { debug } : {}),
    ...(typeof user === "string" ? { user } : {}),
-    ...(isRecord(reasoning) ? { reasoning } : {}),
+    ...(isRecord(reasoning) ? { reasoning: fitReasoning(reasoning, maxTokens) } : {}),
  }
 }

@@ -11,7 +11,8 @@ import { applyEffortUpdates } from "../effort-updates.js"
 import { normalizeToolHistory } from "../tool-history.js"
 import { sanitizeSurrogates } from "../utils/sanitize.js"
 import * as ProviderShared from "../protocols/shared.js"
-import type { ProtocolID, ProviderOptions } from "../schema/index.js"
+import { ToolSchemaProjection } from "../protocols/utils/tool-schema.js"
+import type { LanguageModelSanitizerCompatibility, ProtocolID, ProviderOptions } from "../schema/index.js"
 import {
  AIError,
  CompactionResponse,
@@ -57,6 +58,7 @@ export interface Route<
  readonly defaults: RouteDefaults
  readonly body: RouteBody<Body>
  readonly supportsEffortUpdates?: (request: LLMRequest) => boolean
+  readonly sanitizer?: LanguageModelSanitizerCompatibility
  readonly with: {
    <Next extends CompactionOperations | undefined>(
      patch: RoutePatch<Body, Prepared> & { readonly compact: Next },
@@ -388,6 +390,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
      defaults: routeInput.defaults ?? {},
      body: protocol.body,
      supportsEffortUpdates: protocol.supportsEffortUpdates,
+      sanitizer: protocol.sanitizer,
      with: (patch: RoutePatch<Body, Prepared>) => {
        const { compact, id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch
        return build({
@@ -559,7 +562,9 @@ const prepareRequest = (request: LLMRequest) => {
      tool.type === "tool" ? tool : { ...tool, tools: dedupe(tool.tools) },
    )
  const resolved = applyCachePolicy(
-    applyEffortUpdates(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) })),
+    applyEffortUpdates(
+      LLMRequest.update(sanitized, { tools: ToolSchemaProjection.tools(dedupe(sanitized.tools), sanitized.model) }),
+    ),
  )
  const headers = resolved.model.route.headers?.({ request: resolved })
  return headers === undefined
@@ -137,6 +137,11 @@ export interface Queued<Request, Response, Token> {
  readonly cancel?: {
    readonly method: AuthInput["method"]
    readonly path: (token: Token) => string
+    /**
+     * Fetch a fresh status first and skip the call for terminal generations, for providers whose cancel endpoint
+     * destroys finished work (Runway's `DELETE /v1/tasks/{id}` deletes completed tasks and their outputs).
+     */
+    readonly activeOnly?: boolean
  }
 }

@@ -195,7 +200,8 @@ export const identity = (input: { readonly id: string; readonly name: string; re
  /**
   * Read a text body while retaining the original payload and HTTP context on every downstream error. `invalid` is a
   * malformed provider document; `ended` is a generation that reached a terminal status without output (`failed` is
-   * provider-side, `cancelled`/`expired` mean the result will never exist); `contentPolicy` is a moderated result.
+   * provider-side, `cancelled`/`expired` mean the result will never exist); `pending` is a `result()` read before the
+   * generation finished, which is caller misuse; `contentPolicy` is a moderated result.
   */
  const text = Effect.fn("MediaProtocol.text")(function* (response: HttpClientResponse.HttpClientResponse) {
    const http = context(response)
@@ -224,6 +230,14 @@ export const identity = (input: { readonly id: string; readonly name: string; re
              ? new ProviderInternalError({ message, body, http })
              : new InvalidRequestError({ message, body, http }),
        }),
+      pending: (id: string) =>
+        new AIError({
+          reason: new InvalidRequestError({
+            message: `${input.name} generation ${id} has not finished; await it before reading the result`,
+            body,
+            http,
+          }),
+        }),
      contentPolicy: (message: string) => new AIError({ reason: new ContentPolicyError({ message, body, http }) }),
    }
  })
@@ -285,9 +299,8 @@ export const status = <Table extends Record<string, Status>>(
  raw: string,
  output: Output,
 ): Effect.Effect<Status, AIError> => {
-  const normalized: Status | undefined = table[raw]
-  if (normalized === undefined) return Effect.fail(output.invalid(`Unknown generation status "${raw}"`))
-  return Effect.succeed(normalized)
+  if (!Object.hasOwn(table, raw)) return Effect.fail(output.invalid(`Unknown generation status "${raw}"`))
+  return Effect.succeed(table[raw])
 }

 /** A `url` asset whose provider-declared retention window starts now. */
@@ -5,7 +5,7 @@ import { Endpoint } from "./endpoint.js"
 import { RequestExecutorService, type Interface } from "./executor-service.js"
 import { RequestExecutor } from "./executor.js"
 import { MediaProtocol } from "./media-protocol.js"
-import { Generation, resultEvents, type AwaitOptions, type Observation } from "../generation.js"
+import { Generation, isTerminal } from "../generation.js"
 import type { Media } from "../media.js"
 import {
  AIError,
@@ -52,7 +52,7 @@ export const deployment = (
 // ---------------------------------------------------------------------------

 /** One request, one response. */
-export interface Route<Request extends MediaRequest, Response> {
+export interface InlineRoute<Request extends MediaRequest, Response> {
  readonly kind: "inline"
  readonly id: string
  readonly provider: ProviderID
@@ -86,7 +86,7 @@ export interface StreamRoute<Request extends MediaRequest, Event, Response> {
 }

 export type AnyRoute<Request extends MediaRequest, Event, Response> =
-  | Route<Request, Response>
+  | InlineRoute<Request, Response>
  | StreamRoute<Request, Event, Response>
  | QueuedRoute<Request, Response>

@@ -119,7 +119,7 @@ export interface StreamInput<Request extends MediaRequest, Event, Response, Fram
 */
 export const inline = <Request extends MediaRequest, Response>(
  input: InlineInput<Request, Response>,
-): Route<Request, Response> => {
+): InlineRoute<Request, Response> => {
  const transport = makeTransport(input)
  return {
    kind: "inline",
@@ -164,14 +164,19 @@ export const queued = <Request extends MediaRequest, Response, Token>(
      transport
        .call("GET", operation.path(token), http, execute)
        .pipe(Effect.flatMap((sent) => operation.decode(sent.response, { token, auth: sent.auth, materialize })))
+    const status = poll(protocol.status)
    const cancel = protocol.cancel
+    const send =
+      cancel === undefined
+        ? undefined
+        : transport.call(cancel.method, cancel.path(token), http, execute).pipe(Effect.asVoid)
    return {
-      status: poll(protocol.status),
+      status,
      result: poll(protocol.result),
      cancel:
-        cancel === undefined
-          ? undefined
-          : transport.call(cancel.method, cancel.path(token), http, execute).pipe(Effect.asVoid),
+        send !== undefined && cancel?.activeOnly
+          ? status.pipe(Effect.flatMap((snapshot) => (isTerminal(snapshot.status) ? Effect.void : send)))
+          : send,
    }
  }

@@ -267,59 +272,6 @@ export const stream = <Request extends MediaRequest, Event, Response, Frame, Sta
  }
 }

-export const dispatch = <Event, Response>(input: {
-  readonly modality: string
-  readonly execute: Execute
-  readonly responseEvents: (response: Response) => ReadonlyArray<Event>
-}) => {
-  const notQueued = (route: { readonly provider: ProviderID; readonly id: string }, operation: string) =>
-    new AIError({
-      reason: new UnsupportedOperationError({
-        operation: `${input.modality}.${operation}`,
-        provider: route.provider,
-        route: route.id,
-        message: `${route.provider}/${route.id} is not a queued route; use generate or stream`,
-      }),
-    })
-  const start = <Request extends MediaRequest>(route: AnyRoute<Request, Event, Response>, request: Request) => {
-    if (route.kind !== "queued") return Effect.fail(notQueued(route, "start"))
-    return route.start(request, input.execute)
-  }
-  return {
-    start,
-    resume: <Request extends MediaRequest>(
-      route: AnyRoute<Request, Event, Response>,
-      model: MediaRequest["model"],
-      token: unknown,
-    ) => {
-      if (route.kind !== "queued") return Effect.fail(notQueued(route, "resume"))
-      return route.resume(model, token, input.execute)
-    },
-    generate: <Request extends MediaRequest>(
-      route: AnyRoute<Request, Event, Response>,
-      request: Request,
-      options?: AwaitOptions,
-    ) => {
-      if (route.kind !== "queued") return route.generate(request, input.execute)
-      return start(route, request).pipe(Effect.flatMap((generation) => generation.await(options)))
-    },
-    stream: <Request extends MediaRequest>(
-      route: AnyRoute<Request, Event, Response>,
-      request: Request,
-      options?: AwaitOptions,
-    ): Stream.Stream<Event | Observation, AIError> => {
-      if (route.kind === "stream") return route.stream(request, input.execute)
-      if (route.kind === "queued")
-        return Stream.unwrap(
-          start(route, request).pipe(
-            Effect.map((generation) => resultEvents(generation, input.responseEvents, options)),
-          ),
-        )
-      return Stream.fromIterableEffect(Effect.map(route.generate(request, input.execute), input.responseEvents))
-    },
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Transport plumbing shared by every kind
 // ---------------------------------------------------------------------------
@@ -433,7 +385,11 @@ const encode = (body: MediaProtocol.Body | undefined, headers: Headers.Headers)
  }
 }

-/** Common fields are never silently dropped: a present field the protocol declared unsupported fails typed. */
+/**
+ * Common fields are never silently dropped: a present field the protocol declared unsupported fails typed. `false`
+ * counts as present because some booleans mean something when false (video `audio`); protocols reject opt-in
+ * booleans such as speech `timestamps` with `=== true` in `body.from` instead of listing them.
+ */
 const rejectUnsupported = <Request extends object>(
  route: string,
  provider: ProviderID,
@@ -1,5 +1,5 @@
 import { Schema, type Effect } from "effect"
-import type { AIError, LLMEvent, LLMRequest, ProtocolID } from "../schema/index.js"
+import type { AIError, LanguageModelSanitizerCompatibility, LLMEvent, LLMRequest, ProtocolID } from "../schema/index.js"

 /**
 * The semantic API contract of one model server family.
@@ -43,6 +43,8 @@ export interface Protocol<Body, Frame, Event, State> {
  readonly stream: ProtocolStream<Frame, Event, State>
  /** Whether `body.from` lowers `Message.effort(...)` markers; wrappers around another `body.from` must forward it. */
  readonly supportsEffortUpdates?: (request: LLMRequest) => boolean
+  /** Tool schema sanitizer for every model on this protocol unless the model's compatibility sets one; wrappers around another `body.from` must forward it. */
+  readonly sanitizer?: LanguageModelSanitizerCompatibility
 }

 export interface ProtocolBody<Body> {
@@ -1,53 +1,31 @@
-import { Context, Effect, Layer, Stream } from "effect"
-import { RequestExecutor } from "./route/executor.js"
-import type { AIError } from "./schema/index.js"
-import type { SpeechEvent, SpeechOptions, SpeechRequestFor, SpeechResponse } from "./speech.js"
+import { Context } from "effect"
+import { MediaClient } from "./media-client.js"
+import {
+  SpeechTimestampsEvent,
+  SpeechFinishEvent,
+  type SpeechEvent,
+  type SpeechRequestFor,
+  type SpeechResponse,
+} from "./speech.js"

-export interface Interface {
-  readonly generate: <Options extends SpeechOptions>(
-    request: SpeechRequestFor<Options>,
-  ) => Effect.Effect<SpeechResponse, AIError>
-  readonly stream: <Options extends SpeechOptions>(
-    request: SpeechRequestFor<Options>,
-  ) => Stream.Stream<SpeechEvent, AIError>
-}
+export type Interface = MediaClient.Interface<SpeechRequestFor, SpeechEvent, SpeechResponse>

 export class SpeechClientService extends Context.Service<SpeechClientService, Interface>()("@opencode/SpeechClient") {}
 export const Service = SpeechClientService
 export type Service = SpeechClientService

-export const generate = <Options extends SpeechOptions>(
-  request: SpeechRequestFor<Options>,
-): Effect.Effect<SpeechResponse, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.generate(request)
-  })
-
-export const stream = <Options extends SpeechOptions>(
-  request: SpeechRequestFor<Options>,
-): Stream.Stream<SpeechEvent, AIError, Service> =>
-  Stream.unwrap(
-    Effect.gen(function* () {
-      const client = yield* Service
-      return client.stream(request)
-    }),
-  )
-
-export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service
-    return Service.of({
-      generate: (request) => request.model.route.generate(request, executor.execute),
-      stream: (request) => request.model.route.stream(request, executor.execute),
-    })
-  }),
-)
-
 export const SpeechClient = {
  Service,
-  layer,
-  generate,
-  stream,
+  ...MediaClient.make(Service, {
+    modality: "speech",
+    responseEvents: (response: SpeechResponse) => [
+      ...(response.timestamps === undefined ? [] : [SpeechTimestampsEvent.make({ items: response.timestamps })]),
+      SpeechFinishEvent.make({
+        audio: response.audio,
+        usage: response.usage,
+        notices: response.notices,
+        providerMetadata: response.providerMetadata,
+      }),
+    ],
+  }),
 } as const
@@ -1,8 +1,8 @@
 import { Effect, Schema, Stream } from "effect"
+import { ProgressEvent, QueuedEvent } from "./generation.js"
 import { Media } from "./media.js"
 import { MediaModel, composeRoute, tryRequest } from "./media-model.js"
 import { MediaRoute } from "./route/media.js"
-import type { MediaProtocol } from "./route/media-protocol.js"
 import { AIError, HttpOptions, MediaUsage, ProviderMetadata, type OpenString } from "./schema/index.js"
 import { SpeechClient, Service } from "./speech-client.js"

@@ -10,53 +10,39 @@ import { SpeechClient, Service } from "./speech-client.js"
 // Model
 // ---------------------------------------------------------------------------

-export type SpeechOptions = Record<string, unknown>
+export type SpeechOptions = MediaModel.Options

-export type SpeechRoute<Options extends SpeechOptions = SpeechOptions> = MediaRoute.StreamRoute<
-  SpeechRequestFor<Options>,
-  SpeechEvent,
-  SpeechResponse
->
+export type SpeechRoute = MediaRoute.AnyRoute<SpeechRequestFor, SpeechEvent, SpeechResponse>

-export class SpeechModel<Options extends SpeechOptions = SpeechOptions> extends MediaModel<
-  SpeechRoute<Options>,
-  Options
-> {
+export class SpeechModel<Options extends SpeechOptions = SpeechOptions> extends MediaModel<SpeechRoute, Options> {
  declare protected readonly _SpeechModel: void

-  static make<Options extends SpeechOptions = SpeechOptions>(input: MediaModel.Input<SpeechRoute<Options>>) {
-    return new SpeechModel<Options>(input)
-  }
-
-  /** Compose a streaming speech protocol with its canonical path into a model for one deployment. */
-  static fromRoute<Options extends SpeechOptions = SpeechOptions, Frame = unknown, State = unknown>(
-    route: SpeechModel.RouteInput<Options, Frame, State>,
+  /** The number of type arguments selects the kind: `<Options>`, `<Options, Frame, State>`, or `<Options, Token>`. */
+  static fromRoute<Options extends SpeechOptions>(
+    route: MediaModel.InlineRouteInput<SpeechRequestFor<Options>, SpeechResponse>,
+    input: MediaRoute.ModelInput,
+  ): SpeechModel<Options>
+  static fromRoute<Options extends SpeechOptions, Frame, State>(
+    route: MediaModel.StreamRouteInput<SpeechRequestFor<Options>, SpeechEvent, Frame, State>,
+    input: MediaRoute.ModelInput,
+  ): SpeechModel<Options>
+  static fromRoute<Options extends SpeechOptions, Token>(
+    route: MediaModel.QueuedRouteInput<SpeechRequestFor<Options>, SpeechResponse, Token>,
+    input: MediaRoute.ModelInput,
+  ): SpeechModel<Options>
+  static fromRoute<Options extends SpeechOptions, Frame, State, Token>(
+    route: MediaModel.AnyRouteInput<SpeechRequestFor<Options>, SpeechEvent, SpeechResponse, Frame, State, Token>,
    input: MediaRoute.ModelInput,
  ) {
    return new SpeechModel<Options>({
      id: input.id,
      provider: route.protocol.provider,
      http: input.http,
-      route: composeRoute(
-        (composition) => MediaRoute.stream({ ...composition, collect: collectResponse }),
-        route,
-        input,
-      ),
+      route: composeRoute(route, input, collectResponse) as SpeechRoute,
    })
  }
 }

-export namespace SpeechModel {
-  export type RouteInput<
-    Options extends SpeechOptions = SpeechOptions,
-    Frame = unknown,
-    State = unknown,
-  > = MediaModel.RouteInput<
-    MediaProtocol.Addressed<SpeechRequestFor<Options>>,
-    MediaProtocol.Streamed<SpeechRequestFor<Options>, SpeechEvent, Frame, State>
-  >
-}
-
 export const SpeechModelSchema = Schema.declare((value): value is SpeechModel => value instanceof SpeechModel, {
  expected: "Speech.Model",
 })
@@ -148,11 +134,17 @@ export const SpeechFinishEvent = Schema.Struct({
  providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "Speech.Event.Finish" })

-const speechEventTagged = Schema.Union([SpeechAudioDeltaEvent, SpeechTimestampsEvent, SpeechFinishEvent]).pipe(
-  Schema.toTaggedUnion("type"),
-)
+const speechEventTagged = Schema.Union([
+  QueuedEvent,
+  ProgressEvent,
+  SpeechAudioDeltaEvent,
+  SpeechTimestampsEvent,
+  SpeechFinishEvent,
+]).pipe(Schema.toTaggedUnion("type"))
 export const SpeechEvent = Object.assign(speechEventTagged, {
  is: {
+    generationQueued: speechEventTagged.guards["generation-queued"],
+    generationProgress: speechEventTagged.guards["generation-progress"],
    audioDelta: speechEventTagged.guards["audio-delta"],
    timestamps: speechEventTagged.guards.timestamps,
    finish: speechEventTagged.guards.finish,
@@ -195,17 +187,15 @@ export function request(input: SpeechRequest | SpeechRequestInput) {
 const requestEffect = (input: SpeechRequest | SpeechRequestInput) => tryRequest(() => request(input))

 export function generate<const Model extends SpeechModel>(
-  input: SpeechRequestInput<Model>,
+  input: SpeechRequest | SpeechRequestInput<Model>,
 ): Effect.Effect<SpeechResponse, AIError, Service>
-export function generate(input: SpeechRequest): Effect.Effect<SpeechResponse, AIError, Service>
 export function generate(input: SpeechRequest | SpeechRequestInput) {
  return requestEffect(input).pipe(Effect.flatMap((request) => SpeechClient.generate(request)))
 }

 export function stream<const Model extends SpeechModel>(
-  input: SpeechRequestInput<Model>,
+  input: SpeechRequest | SpeechRequestInput<Model>,
 ): Stream.Stream<SpeechEvent, AIError, Service>
-export function stream(input: SpeechRequest): Stream.Stream<SpeechEvent, AIError, Service>
 export function stream(input: SpeechRequest | SpeechRequestInput) {
  return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => SpeechClient.stream(request))))
 }
@@ -1,34 +1,13 @@
-import { Context, Effect, Layer, Stream } from "effect"
-import type { AwaitOptions, Generation } from "./generation.js"
-import { RequestExecutor } from "./route/executor.js"
-import { MediaRoute } from "./route/media.js"
-import type { AIError } from "./schema/index.js"
+import { Context } from "effect"
+import { MediaClient } from "./media-client.js"
 import {
-  responseEvents,
+  TranscriptionFinishEvent,
  type TranscriptionEvent,
-  type TranscriptionModel,
-  type TranscriptionOptions,
  type TranscriptionRequestFor,
  type TranscriptionResponse,
 } from "./transcription.js"

-export interface Interface {
-  readonly generate: <Options extends TranscriptionOptions>(
-    request: TranscriptionRequestFor<Options>,
-    options?: AwaitOptions,
-  ) => Effect.Effect<TranscriptionResponse, AIError>
-  readonly stream: <Options extends TranscriptionOptions>(
-    request: TranscriptionRequestFor<Options>,
-    options?: AwaitOptions,
-  ) => Stream.Stream<TranscriptionEvent, AIError>
-  readonly start: <Options extends TranscriptionOptions>(
-    request: TranscriptionRequestFor<Options>,
-  ) => Effect.Effect<Generation<TranscriptionResponse>, AIError>
-  readonly resume: <Options extends TranscriptionOptions>(
-    model: TranscriptionModel<Options>,
-    token: unknown,
-  ) => Effect.Effect<Generation<TranscriptionResponse>, AIError>
-}
+export type Interface = MediaClient.Interface<TranscriptionRequestFor, TranscriptionEvent, TranscriptionResponse>

 export class TranscriptionClientService extends Context.Service<TranscriptionClientService, Interface>()(
  "@opencode/TranscriptionClient",
@@ -36,66 +15,10 @@ export class TranscriptionClientService extends Context.Service<TranscriptionCli
 export const Service = TranscriptionClientService
 export type Service = TranscriptionClientService

-export const generate = <Options extends TranscriptionOptions>(
-  request: TranscriptionRequestFor<Options>,
-  options?: AwaitOptions,
-): Effect.Effect<TranscriptionResponse, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.generate(request, options)
-  })
-
-export const stream = <Options extends TranscriptionOptions>(
-  request: TranscriptionRequestFor<Options>,
-  options?: AwaitOptions,
-): Stream.Stream<TranscriptionEvent, AIError, Service> =>
-  Stream.unwrap(
-    Effect.gen(function* () {
-      const client = yield* Service
-      return client.stream(request, options)
-    }),
-  )
-
-export const start = <Options extends TranscriptionOptions>(
-  request: TranscriptionRequestFor<Options>,
-): Effect.Effect<Generation<TranscriptionResponse>, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.start(request)
-  })
-
-export const resume = <Options extends TranscriptionOptions>(
-  model: TranscriptionModel<Options>,
-  token: unknown,
-): Effect.Effect<Generation<TranscriptionResponse>, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.resume(model, token)
-  })
-
-export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service
-    const dispatch = MediaRoute.dispatch<TranscriptionEvent, TranscriptionResponse>({
-      modality: "transcription",
-      execute: executor.execute,
-      responseEvents,
-    })
-    return Service.of({
-      start: (request) => dispatch.start(request.model.route, request),
-      resume: (model, token) => dispatch.resume(model.route, model, token),
-      generate: (request, options) => dispatch.generate(request.model.route, request, options),
-      stream: (request, options) => dispatch.stream(request.model.route, request, options),
-    })
-  }),
-)
-
 export const TranscriptionClient = {
  Service,
-  layer,
-  generate,
-  stream,
-  start,
-  resume,
+  ...MediaClient.make(Service, {
+    modality: "transcription",
+    responseEvents: (response: TranscriptionResponse) => [TranscriptionFinishEvent.make({ ...response })],
+  }),
 } as const
@@ -1,9 +1,8 @@
 import { Effect, Schema, Stream } from "effect"
 import { Generation, ProgressEvent, QueuedEvent, type AwaitOptions } from "./generation.js"
 import { Media } from "./media.js"
-import { MediaModel, composeAnyRoute, tryRequest } from "./media-model.js"
+import { MediaModel, composeRoute, tryRequest } from "./media-model.js"
 import { MediaRoute } from "./route/media.js"
-import type { MediaProtocol } from "./route/media-protocol.js"
 import { AIError, HttpOptions, MediaUsage, ProviderMetadata } from "./schema/index.js"
 import { TranscriptionClient, Service } from "./transcription-client.js"

@@ -11,90 +10,49 @@ import { TranscriptionClient, Service } from "./transcription-client.js"
 // Model
 // ---------------------------------------------------------------------------

-export type TranscriptionOptions = Record<string, unknown>
+export type TranscriptionOptions = MediaModel.Options

-export type TranscriptionRoute<Options extends TranscriptionOptions = TranscriptionOptions> = MediaRoute.AnyRoute<
-  TranscriptionRequestFor<Options>,
-  TranscriptionEvent,
-  TranscriptionResponse
->
+export type TranscriptionRoute = MediaRoute.AnyRoute<TranscriptionRequestFor, TranscriptionEvent, TranscriptionResponse>

 export class TranscriptionModel<Options extends TranscriptionOptions = TranscriptionOptions> extends MediaModel<
-  TranscriptionRoute<Options>,
+  TranscriptionRoute,
  Options
 > {
  declare protected readonly _TranscriptionModel: void

-  static make<Options extends TranscriptionOptions = TranscriptionOptions>(
-    input: MediaModel.Input<TranscriptionRoute<Options>>,
-  ) {
-    return new TranscriptionModel<Options>(input)
-  }
-
  /** The number of type arguments selects the kind: `<Options>`, `<Options, Frame, State>`, or `<Options, Token>`. */
  static fromRoute<Options extends TranscriptionOptions>(
-    route: TranscriptionModel.InlineRouteInput<Options>,
+    route: MediaModel.InlineRouteInput<TranscriptionRequestFor<Options>, TranscriptionResponse>,
    input: MediaRoute.ModelInput,
  ): TranscriptionModel<Options>
  static fromRoute<Options extends TranscriptionOptions, Frame, State>(
-    route: TranscriptionModel.StreamRouteInput<Options, Frame, State>,
+    route: MediaModel.StreamRouteInput<TranscriptionRequestFor<Options>, TranscriptionEvent, Frame, State>,
    input: MediaRoute.ModelInput,
  ): TranscriptionModel<Options>
  static fromRoute<Options extends TranscriptionOptions, Token>(
-    route: TranscriptionModel.QueuedRouteInput<Options, Token>,
+    route: MediaModel.QueuedRouteInput<TranscriptionRequestFor<Options>, TranscriptionResponse, Token>,
    input: MediaRoute.ModelInput,
  ): TranscriptionModel<Options>
  static fromRoute<Options extends TranscriptionOptions, Frame, State, Token>(
-    route: TranscriptionModel.RouteInput<Options, Frame, State, Token>,
+    route: MediaModel.AnyRouteInput<
+      TranscriptionRequestFor<Options>,
+      TranscriptionEvent,
+      TranscriptionResponse,
+      Frame,
+      State,
+      Token
+    >,
    input: MediaRoute.ModelInput,
  ) {
    return new TranscriptionModel<Options>({
      id: input.id,
      provider: route.protocol.provider,
      http: input.http,
-      route: composeAnyRoute(route, input, collectResponse),
+      route: composeRoute(route, input, collectResponse) as TranscriptionRoute,
    })
  }
 }

-export namespace TranscriptionModel {
-  export type InlineRouteInput<Options extends TranscriptionOptions = TranscriptionOptions> = MediaModel.RouteInput<
-    TranscriptionRequestFor<Options>,
-    MediaProtocol.Inline<TranscriptionRequestFor<Options>, TranscriptionResponse>
-  >
-
-  export type StreamRouteInput<
-    Options extends TranscriptionOptions = TranscriptionOptions,
-    Frame = unknown,
-    State = unknown,
-  > = MediaModel.RouteInput<
-    MediaProtocol.Addressed<TranscriptionRequestFor<Options>>,
-    MediaProtocol.Streamed<TranscriptionRequestFor<Options>, TranscriptionEvent, Frame, State>
-  >
-
-  export type QueuedRouteInput<
-    Options extends TranscriptionOptions = TranscriptionOptions,
-    Token = unknown,
-  > = MediaModel.RouteInput<
-    TranscriptionRequestFor<Options>,
-    MediaProtocol.Queued<TranscriptionRequestFor<Options>, TranscriptionResponse, Token>
-  >
-
-  export type RouteInput<
-    Options extends TranscriptionOptions = TranscriptionOptions,
-    Frame = unknown,
-    State = unknown,
-    Token = unknown,
-  > = MediaModel.AnyRouteInput<
-    TranscriptionRequestFor<Options>,
-    TranscriptionEvent,
-    TranscriptionResponse,
-    Frame,
-    State,
-    Token
-  >
-}
-
 export const TranscriptionModelSchema = Schema.declare(
  (value): value is TranscriptionModel => value instanceof TranscriptionModel,
  { expected: "Transcription.Model" },
@@ -212,10 +170,6 @@ export const TranscriptionEvent = Object.assign(transcriptionEventTagged, {
 })
 export type TranscriptionEvent = Schema.Schema.Type<typeof transcriptionEventTagged>

-export const responseEvents = (response: TranscriptionResponse): ReadonlyArray<TranscriptionEvent> => [
-  TranscriptionFinishEvent.make({ ...response }),
-]
-
 const collectResponse = (events: ReadonlyArray<TranscriptionEvent>): Effect.Effect<TranscriptionResponse> => {
  const finish = events.find(TranscriptionEvent.is.finish)
  // Every transcription protocol's `finish` emits the terminal event or fails, so a completed stream always has one.
@@ -243,11 +197,7 @@ export function request(input: TranscriptionRequest | TranscriptionRequestInput)
 const requestEffect = (input: TranscriptionRequest | TranscriptionRequestInput) => tryRequest(() => request(input))

 export function generate<const Model extends TranscriptionModel>(
-  input: TranscriptionRequestInput<Model>,
-  options?: AwaitOptions,
-): Effect.Effect<TranscriptionResponse, AIError, Service>
-export function generate(
-  input: TranscriptionRequest,
+  input: TranscriptionRequest | TranscriptionRequestInput<Model>,
  options?: AwaitOptions,
 ): Effect.Effect<TranscriptionResponse, AIError, Service>
 export function generate(input: TranscriptionRequest | TranscriptionRequestInput, options?: AwaitOptions) {
@@ -255,11 +205,7 @@ export function generate(input: TranscriptionRequest | TranscriptionRequestInput
 }

 export function stream<const Model extends TranscriptionModel>(
-  input: TranscriptionRequestInput<Model>,
-  options?: AwaitOptions,
-): Stream.Stream<TranscriptionEvent, AIError, Service>
-export function stream(
-  input: TranscriptionRequest,
+  input: TranscriptionRequest | TranscriptionRequestInput<Model>,
  options?: AwaitOptions,
 ): Stream.Stream<TranscriptionEvent, AIError, Service>
 export function stream(input: TranscriptionRequest | TranscriptionRequestInput, options?: AwaitOptions) {
@@ -268,15 +214,14 @@ export function stream(input: TranscriptionRequest | TranscriptionRequestInput,

 /** Inline and streaming routes fail with `UnsupportedOperation`. */
 export function start<const Model extends TranscriptionModel>(
-  input: TranscriptionRequestInput<Model>,
+  input: TranscriptionRequest | TranscriptionRequestInput<Model>,
 ): Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>
-export function start(input: TranscriptionRequest): Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>
 export function start(input: TranscriptionRequest | TranscriptionRequestInput) {
  return requestEffect(input).pipe(Effect.flatMap((request) => TranscriptionClient.start(request)))
 }

-export const resume = <Options extends TranscriptionOptions>(
-  model: TranscriptionModel<Options>,
+export const resume = (
+  model: TranscriptionModel,
  token: unknown,
 ): Effect.Effect<Generation<TranscriptionResponse>, AIError, Service> => TranscriptionClient.resume(model, token)

@@ -1,98 +1,30 @@
-import { Context, Effect, Layer, Stream } from "effect"
-import { resultEvents, type AwaitOptions, type Generation } from "./generation.js"
-import { RequestExecutor } from "./route/executor.js"
-import type { AIError } from "./schema/index.js"
+import { Context } from "effect"
+import { MediaClient } from "./media-client.js"
 import {
-  responseEvents,
+  VideoOutputEvent,
+  VideoFinishEvent,
  type VideoEvent,
-  type VideoModel,
-  type VideoOptions,
  type VideoRequestFor,
  type VideoResponse,
 } from "./video.js"

-export interface Interface {
-  readonly start: <Options extends VideoOptions>(
-    request: VideoRequestFor<Options>,
-  ) => Effect.Effect<Generation<VideoResponse>, AIError>
-  readonly resume: <Options extends VideoOptions>(
-    model: VideoModel<Options>,
-    token: unknown,
-  ) => Effect.Effect<Generation<VideoResponse>, AIError>
-  readonly generate: <Options extends VideoOptions>(
-    request: VideoRequestFor<Options>,
-    options?: AwaitOptions,
-  ) => Effect.Effect<VideoResponse, AIError>
-  readonly stream: <Options extends VideoOptions>(
-    request: VideoRequestFor<Options>,
-    options?: AwaitOptions,
-  ) => Stream.Stream<VideoEvent, AIError>
-}
+export type Interface = MediaClient.Interface<VideoRequestFor, VideoEvent, VideoResponse>

 export class VideoClientService extends Context.Service<VideoClientService, Interface>()("@opencode/VideoClient") {}
 export const Service = VideoClientService
 export type Service = VideoClientService

-export const start = <Options extends VideoOptions>(
-  request: VideoRequestFor<Options>,
-): Effect.Effect<Generation<VideoResponse>, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.start(request)
-  })
-
-export const resume = <Options extends VideoOptions>(
-  model: VideoModel<Options>,
-  token: unknown,
-): Effect.Effect<Generation<VideoResponse>, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.resume(model, token)
-  })
-
-export const generate = <Options extends VideoOptions>(
-  request: VideoRequestFor<Options>,
-  options?: AwaitOptions,
-): Effect.Effect<VideoResponse, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.generate(request, options)
-  })
-
-export const stream = <Options extends VideoOptions>(
-  request: VideoRequestFor<Options>,
-  options?: AwaitOptions,
-): Stream.Stream<VideoEvent, AIError, Service> =>
-  Stream.unwrap(
-    Effect.gen(function* () {
-      const client = yield* Service
-      return client.stream(request, options)
-    }),
-  )
-
-export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service
-    const start = <Options extends VideoOptions>(request: VideoRequestFor<Options>) =>
-      request.model.route.start(request, executor.execute)
-    return Service.of({
-      start,
-      resume: (model, token) => model.route.resume(model, token, executor.execute),
-      generate: (request, options) => start(request).pipe(Effect.flatMap((generation) => generation.await(options))),
-      stream: (request, options) =>
-        Stream.unwrap(
-          start(request).pipe(Effect.map((generation) => resultEvents(generation, responseEvents, options))),
-        ),
-    })
-  }),
-)
-
 export const VideoClient = {
  Service,
-  layer,
-  start,
-  resume,
-  generate,
-  stream,
+  ...MediaClient.make(Service, {
+    modality: "video",
+    responseEvents: (response: VideoResponse) => [
+      ...response.videos.map((video, index) => VideoOutputEvent.make({ index, video })),
+      VideoFinishEvent.make({
+        usage: response.usage,
+        notices: response.notices,
+        providerMetadata: response.providerMetadata,
+      }),
+    ],
+  }),
 } as const
@@ -3,7 +3,6 @@ import { Generation, ProgressEvent, QueuedEvent, type AwaitOptions } from "./gen
 import { Media } from "./media.js"
 import { MediaModel, composeRoute, tryRequest } from "./media-model.js"
 import { MediaRoute } from "./route/media.js"
-import type { MediaProtocol } from "./route/media-protocol.js"
 import { AIError, HttpOptions, MediaUsage, ProviderMetadata, type OpenString } from "./schema/index.js"
 import { VideoClient, Service } from "./video-client.js"

@@ -11,41 +10,39 @@ import { VideoClient, Service } from "./video-client.js"
 // Model
 // ---------------------------------------------------------------------------

-export type VideoOptions = Record<string, unknown>
+export type VideoOptions = MediaModel.Options

-export type VideoRoute<Options extends VideoOptions = VideoOptions> = MediaRoute.QueuedRoute<
-  VideoRequestFor<Options>,
-  VideoResponse
->
+export type VideoRoute = MediaRoute.AnyRoute<VideoRequestFor, VideoEvent, VideoResponse>

-export class VideoModel<Options extends VideoOptions = VideoOptions> extends MediaModel<VideoRoute<Options>, Options> {
+export class VideoModel<Options extends VideoOptions = VideoOptions> extends MediaModel<VideoRoute, Options> {
  declare protected readonly _VideoModel: void

-  static make<Options extends VideoOptions = VideoOptions>(input: MediaModel.Input<VideoRoute<Options>>) {
-    return new VideoModel<Options>(input)
-  }
-
-  /** Compose a queued video protocol with its canonical start path into a model for one deployment. */
-  static fromRoute<Options extends VideoOptions = VideoOptions, Token = unknown>(
-    route: VideoModel.RouteInput<Options, Token>,
+  /** The number of type arguments selects the kind: `<Options>`, `<Options, Frame, State>`, or `<Options, Token>`. */
+  static fromRoute<Options extends VideoOptions>(
+    route: MediaModel.InlineRouteInput<VideoRequestFor<Options>, VideoResponse>,
+    input: MediaRoute.ModelInput,
+  ): VideoModel<Options>
+  static fromRoute<Options extends VideoOptions, Frame, State>(
+    route: MediaModel.StreamRouteInput<VideoRequestFor<Options>, VideoEvent, Frame, State>,
+    input: MediaRoute.ModelInput,
+  ): VideoModel<Options>
+  static fromRoute<Options extends VideoOptions, Token>(
+    route: MediaModel.QueuedRouteInput<VideoRequestFor<Options>, VideoResponse, Token>,
+    input: MediaRoute.ModelInput,
+  ): VideoModel<Options>
+  static fromRoute<Options extends VideoOptions, Frame, State, Token>(
+    route: MediaModel.AnyRouteInput<VideoRequestFor<Options>, VideoEvent, VideoResponse, Frame, State, Token>,
    input: MediaRoute.ModelInput,
  ) {
    return new VideoModel<Options>({
      id: input.id,
      provider: route.protocol.provider,
      http: input.http,
-      route: composeRoute(MediaRoute.queued, route, input),
+      route: composeRoute(route, input, collectResponse) as VideoRoute,
    })
  }
 }

-export namespace VideoModel {
-  export type RouteInput<Options extends VideoOptions = VideoOptions, Token = unknown> = MediaModel.RouteInput<
-    VideoRequestFor<Options>,
-    MediaProtocol.Queued<VideoRequestFor<Options>, VideoResponse, Token>
-  >
-}
-
 export const VideoModelSchema = Schema.declare((value): value is VideoModel => value instanceof VideoModel, {
  expected: "Video.Model",
 })
@@ -149,15 +146,19 @@ export const VideoEvent = Object.assign(videoEventTagged, {
 })
 export type VideoEvent = Schema.Schema.Type<typeof videoEventTagged>

-/** A completed response expanded into the streaming event shape. */
-export const responseEvents = (response: VideoResponse): ReadonlyArray<VideoEvent> => [
-  ...response.videos.map((video, index) => VideoOutputEvent.make({ index, video })),
-  VideoFinishEvent.make({
-    usage: response.usage,
-    notices: response.notices,
-    providerMetadata: response.providerMetadata,
-  }),
-]
+const collectResponse = (events: ReadonlyArray<VideoEvent>): Effect.Effect<VideoResponse> => {
+  const finish = events.find(VideoEvent.is.finish)
+  // A streaming video protocol's `finish` emits the terminal event or fails, so a completed stream always has one.
+  if (finish === undefined) return Effect.die(new Error("The video stream completed without a finish event"))
+  return Effect.succeed(
+    new VideoResponse({
+      videos: events.filter(VideoEvent.is.video).map((event) => event.video),
+      usage: finish.usage,
+      notices: finish.notices,
+      providerMetadata: finish.providerMetadata,
+    }),
+  )
+}

 // ---------------------------------------------------------------------------
 // Request-shaped call API
@@ -178,33 +179,28 @@ export function request(input: VideoRequest | VideoRequestInput) {
 const requestEffect = (input: VideoRequest | VideoRequestInput) => tryRequest(() => request(input))

 export function start<const Model extends VideoModel>(
-  input: VideoRequestInput<Model>,
+  input: VideoRequest | VideoRequestInput<Model>,
 ): Effect.Effect<Generation<VideoResponse>, AIError, Service>
-export function start(input: VideoRequest): Effect.Effect<Generation<VideoResponse>, AIError, Service>
 export function start(input: VideoRequest | VideoRequestInput) {
  return requestEffect(input).pipe(Effect.flatMap((request) => VideoClient.start(request)))
 }

 export function generate<const Model extends VideoModel>(
-  input: VideoRequestInput<Model>,
+  input: VideoRequest | VideoRequestInput<Model>,
  options?: AwaitOptions,
 ): Effect.Effect<VideoResponse, AIError, Service>
-export function generate(input: VideoRequest, options?: AwaitOptions): Effect.Effect<VideoResponse, AIError, Service>
 export function generate(input: VideoRequest | VideoRequestInput, options?: AwaitOptions) {
  return requestEffect(input).pipe(Effect.flatMap((request) => VideoClient.generate(request, options)))
 }

 /** Rebuild a generation handle from a persisted `Generation.token`, refreshing its status once. */
-export const resume = <Options extends VideoOptions>(
-  model: VideoModel<Options>,
-  token: unknown,
-): Effect.Effect<Generation<VideoResponse>, AIError, Service> => VideoClient.resume(model, token)
+export const resume = (model: VideoModel, token: unknown): Effect.Effect<Generation<VideoResponse>, AIError, Service> =>
+  VideoClient.resume(model, token)

 export function stream<const Model extends VideoModel>(
-  input: VideoRequestInput<Model>,
+  input: VideoRequest | VideoRequestInput<Model>,
  options?: AwaitOptions,
 ): Stream.Stream<VideoEvent, AIError, Service>
-export function stream(input: VideoRequest, options?: AwaitOptions): Stream.Stream<VideoEvent, AIError, Service>
 export function stream(input: VideoRequest | VideoRequestInput, options?: AwaitOptions) {
  return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => VideoClient.stream(request, options))))
 }
@@ -351,10 +351,34 @@ describe("OpenAI Responses effort updates", () => {
    }),
  )

+  it.effect("strips markers when the body overlay selects pro reasoning mode", () =>
+    Effect.gen(function* () {
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model: OpenAI.configure({ apiKey: "fixture", http: { body: { reasoning: { mode: "pro" } } } }).responses(
+            "gpt-6-sol",
+          ),
+          messages: conversation,
+          providerOptions: { reasoningEffort: "low" },
+        }),
+      )
+
+      expect(updates(prepared.body)).toEqual([])
+      expect(prepared.body.reasoning).toEqual({ effort: "low" })
+    }),
+  )
+
  for (const [id, supported] of [
    ["gpt-6-astra", true],
    ["openai/gpt-6-astra", true],
+    ["gpt-6-sol", true],
+    ["openai/gpt-6-sol", true],
+    ["gpt-6-luna", true],
+    ["openai/gpt-6-luna", true],
    ["gpt-6-astra-2026-09-01", false],
+    ["gpt-6-sol-pro", false],
+    ["gpt-6-luna-pro", false],
+    ["gpt-6-sol-fast", false],
    ["gpt-5.6-sol", false],
  ] as const) {
    it.effect(`${supported ? "lowers" : "strips"} markers for ${id}`, () =>
@@ -23,6 +23,7 @@ import { Provider as ProviderSubpath } from "@opencode/ai/provider"
 import {
  AssemblyAI,
  Baseten,
+  BlackForestLabs,
  Cartesia,
  CloudflareAIGateway,
  CloudflareWorkersAI,
@@ -32,14 +33,18 @@ import {
  Fal,
  Fireworks,
  Google,
+  Meta,
  OpenCodeZen,
  OpenAI,
  OpenAICompatible,
  OpenRouter,
+  Replicate,
  Runway,
+  Stability,
  TypeSafeAI,
  VercelAIGateway,
  XAI,
+  ZAI,
 } from "@opencode/ai/providers"
 import {
  OpenAIChat,
@@ -54,6 +59,19 @@ import { TestLLM } from "@opencode/ai/testing"
 import { Evaluation, EvaluationClient } from "@opencode/ai/experimental"

 describe("public exports", () => {
+  test("modality, provider, and protocol entrypoints load first in a fresh process", async () => {
+    const results = await Promise.all(
+      ["image", "video", "speech", "transcription", "providers", "protocols"].map(async (entry) => {
+        const child = Bun.spawn(
+          [process.execPath, "-e", `await import(${JSON.stringify(`${import.meta.dir}/../src/${entry}.ts`)})`],
+          { stderr: "pipe" },
+        )
+        return { entry, exitCode: await child.exited, stderr: await new Response(child.stderr).text() }
+      }),
+    )
+    expect(results.filter((result) => result.exitCode !== 0)).toEqual([])
+  })
+
  test("root exposes app-facing runtime APIs", () => {
    expect(LLM.request).toBeFunction()
    expect(LLMClient.Service).toBeFunction()
@@ -138,8 +156,34 @@ describe("public exports", () => {
    expect(XAI.provider.chat).toBe(XAI.chat)
    expect(XAI.configure({ apiKey: "fixture" }).responses("grok-4.3").route.id).toBe("openai-responses")
    expect(XAI.configure({ apiKey: "fixture" }).chat("grok-4.3").route.id).toBe("openai-compatible-chat")
+    expect(OpenAI.configure({ apiKey: "fixture" }).image("gpt-image-2").route.id).toBe("openai-images")
+    expect(OpenAI.provider.image).toBe(OpenAI.image)
+    expect(Google.configure({ apiKey: "fixture" }).image("imagen-4.0-generate-001").route.id).toBe("google-images")
+    expect(Google.provider.image).toBe(Google.image)
+    expect(XAI.configure({ apiKey: "fixture" }).image("grok-imagine-image").route.id).toBe("xai-images")
+    expect(XAI.provider.image).toBe(XAI.image)
+    expect(Fal.configure({ apiKey: "fixture" }).image("fal-ai/flux/dev").route.id).toBe("fal-images")
+    expect(Fal.provider.image).toBe(Fal.image)
+    expect(BlackForestLabs.configure({ apiKey: "fixture" }).image("flux-2-pro").route.id).toBe("bfl-images")
+    expect(BlackForestLabs.provider.image).toBe(BlackForestLabs.image)
+    expect(Replicate.configure({ apiKey: "fixture" }).image("black-forest-labs/flux-schnell").route.id).toBe(
+      "replicate-images",
+    )
+    expect(Replicate.provider.image).toBe(Replicate.image)
+    expect(Stability.configure({ apiKey: "fixture" }).image("sd3.5-large").route.id).toBe("stability-images")
+    expect(Stability.provider.image).toBe(Stability.image)
+    expect(Stability.configure({ apiKey: "fixture" }).upscale().route.id).toBe("stability-upscale")
+    expect(Stability.provider.upscale).toBe(Stability.upscale)
+    expect(Meta.configure({ apiKey: "fixture" }).image("muse-image").route.id).toBe("meta-images")
+    expect(Meta.provider.image).toBe(Meta.image)
+    expect(ZAI.configure({ apiKey: "fixture" }).image("glm-image").route.id).toBe("zai-images")
+    expect(ZAI.provider.image).toBe(ZAI.image)
    expect(XAI.configure({ apiKey: "fixture" }).video("grok-imagine-video-1.5").route.id).toBe("xai-video")
+    expect(XAI.provider.video).toBe(XAI.video)
+    expect(Google.configure({ apiKey: "fixture" }).video("veo-3.1-generate-preview").route.id).toBe("google-video")
+    expect(Google.provider.video).toBe(Google.video)
    expect(Fal.configure({ apiKey: "fixture" }).video("fal-ai/veo3.1").route.id).toBe("fal-video")
+    expect(Fal.provider.video).toBe(Fal.video)
    expect(Runway.configure({ apiKey: "fixture" }).video("gen4.5").route.id).toBe("runway-video")
    expect(Runway.provider.video).toBe(Runway.video)
    expect(OpenAI.configure({ apiKey: "fixture" }).speech("gpt-4o-mini-tts").route.id).toBe("openai-speech")
@@ -30,7 +30,7 @@
        {
          "direction": "client",
          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]}],\"instructions\":\"Call get_weather once, then reply exactly: Paris is 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,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":50}"
+          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]}],\"instructions\":\"Call get_weather once, then reply exactly: Paris is 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,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"max_output_tokens\":50}"
        },
        {
          "direction": "server",
@@ -525,7 +525,7 @@
        {
          "direction": "client",
          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"function_call_output\",\"call_id\":\"call_hejtTYDa1IfLyNIzb3fq9gJs\",\"output\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"instructions\":\"Call get_weather once, then reply exactly: Paris is 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,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":50,\"previous_response_id\":\"resp_0d9a44b6df400533016aa8c8e36de887d1be260913d131b2ca\"}"
+          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"function_call_output\",\"call_id\":\"call_hejtTYDa1IfLyNIzb3fq9gJs\",\"output\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"instructions\":\"Call get_weather once, then reply exactly: Paris is 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,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"max_output_tokens\":50,\"previous_response_id\":\"resp_0d9a44b6df400533016aa8c8e36de887d1be260913d131b2ca\"}"
        },
        {
          "direction": "server",
@@ -30,7 +30,7 @@
        {
          "direction": "client",
          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Alpha.\"}]}],\"instructions\":\"Follow the user's exact reply instruction.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":30}"
+          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Alpha.\"}]}],\"instructions\":\"Follow the user's exact reply instruction.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"max_output_tokens\":30}"
        },
        {
          "direction": "server",
@@ -109,7 +109,7 @@
        {
          "direction": "client",
          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Alpha.\"}]},{\"type\":\"reasoning\",\"id\":\"rs_0a6277dd90b94da1016aa8c946e33487d1b725d8e9dc874d82\",\"summary\":[],\"encrypted_content\":\"gAAAAABqqMlHtG6yltzgW_UjUcYxvl2hoMkk7cSEH5SJMe9CR5gKIaCwCh4peUo8XZrd-EU-tPCXthv7JzHxYXGVG1fIgTJ7BjBoOh-jgd_oGlyCHj2jVPj7nVoB763tZHdyw_ovL3V7GpJ6VeLGIsRGqNTnBz47ZuKikTKrbTDupn6fT2wOM_69zwdg4-UVnoF2J9E_jIS0E5XRtRwOidqANl61HCwo7LV-Ut1aqCbXb-59vkrVGWPxD_8n4smf7Qjywc0FCH9zwuEDX4cPdqj3MmjvYPrn0jand9LKkAy9rblaKFJSQfVuritbHrdQrnF7hLxu7QCpehOzNXOkpNEqTmXnAZjfMc53hq-ahH6_KoyYlZpompwyGPngFeI2fKRqP8rlpDilD1BHBsh-bl7kXzI8HQ_jameXwPZ1La6gjtFkThXp53BD6BOx11SB9Nypqolu2at5rR32UYcGrYeGtTu-HmYGp0oHVFkHumTNuHKmGXV14dI9swgryfygLhX8EAJrWrjm3e8rvAkHKpAZ0IkmlCcp15UCFDKNeS560fQVRaKXWnQ7m0Ih3C1xG0ifJ89j27c8GHo1kAhEJk-lSB1-FZr9Ls_w7N772kmZ2a7LLswu3kNW78kPas_CtcOnBOHwE1DhcVh5YpxwNftOHZnK1v8NPNF8EWqio4ArZy1thMCzH5zXBNcFzgd8tePMFukBblSP8QGQoVYRqTne2sFoOZXjslXnDvEe-Ycj8X38zWgRiwAk7guOloFC7Se36KCDP357773Vah86gWCt55mSEyhVW_GF1oTuHvJ18GZsXcyN21scF1PSr8YaCM_jR7ZkU1GYXbQK2Y4oTAV9XDptQA5YzEREnn7muC_6v5ZTAglZF1lhn9Q0NwmylZEAXJdSGHaqXt1Hv-vQlprA_9m22vrreBOTLPnVK946J8absKrwfe-jK_1n_9YQR43uwH8XwFBFND0c4lICCQGbxwM8pX4ACWR0c19aORCYm-M5FrJsxmG29_aDVNhcvkoQ3mlP7ITQeqzkrjfytSwLb2BYpXYZKjEHNfV9j3JoxJobUkK5hrxXBhTvZzbVBnE0LSXQNwR-JAcOliP_jXBEeQ-28B-aGW8TI1vEP2i260QKgzOzPC-pOoFp0-vCvxojNO0kE16ECVTLfDNLNGSMZs9vekdLJP2akBp6PsUXsQUTbWO_wr1E2oNU7ctfMRxoh-yP0ZW2_xz_NjE72O5LF_6zuDVV7Q==\"},{\"type\":\"message\",\"id\":\"msg_0a6277dd90b94da1016aa8c947253887d184c150fcbcbcd8da\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Alpha.\"}],\"phase\":\"final_answer\",\"status\":\"completed\"},{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Beta.\"}]}],\"instructions\":\"Follow the user's exact reply instruction.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":30}"
+          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Alpha.\"}]},{\"type\":\"reasoning\",\"id\":\"rs_0a6277dd90b94da1016aa8c946e33487d1b725d8e9dc874d82\",\"summary\":[],\"encrypted_content\":\"gAAAAABqqMlHtG6yltzgW_UjUcYxvl2hoMkk7cSEH5SJMe9CR5gKIaCwCh4peUo8XZrd-EU-tPCXthv7JzHxYXGVG1fIgTJ7BjBoOh-jgd_oGlyCHj2jVPj7nVoB763tZHdyw_ovL3V7GpJ6VeLGIsRGqNTnBz47ZuKikTKrbTDupn6fT2wOM_69zwdg4-UVnoF2J9E_jIS0E5XRtRwOidqANl61HCwo7LV-Ut1aqCbXb-59vkrVGWPxD_8n4smf7Qjywc0FCH9zwuEDX4cPdqj3MmjvYPrn0jand9LKkAy9rblaKFJSQfVuritbHrdQrnF7hLxu7QCpehOzNXOkpNEqTmXnAZjfMc53hq-ahH6_KoyYlZpompwyGPngFeI2fKRqP8rlpDilD1BHBsh-bl7kXzI8HQ_jameXwPZ1La6gjtFkThXp53BD6BOx11SB9Nypqolu2at5rR32UYcGrYeGtTu-HmYGp0oHVFkHumTNuHKmGXV14dI9swgryfygLhX8EAJrWrjm3e8rvAkHKpAZ0IkmlCcp15UCFDKNeS560fQVRaKXWnQ7m0Ih3C1xG0ifJ89j27c8GHo1kAhEJk-lSB1-FZr9Ls_w7N772kmZ2a7LLswu3kNW78kPas_CtcOnBOHwE1DhcVh5YpxwNftOHZnK1v8NPNF8EWqio4ArZy1thMCzH5zXBNcFzgd8tePMFukBblSP8QGQoVYRqTne2sFoOZXjslXnDvEe-Ycj8X38zWgRiwAk7guOloFC7Se36KCDP357773Vah86gWCt55mSEyhVW_GF1oTuHvJ18GZsXcyN21scF1PSr8YaCM_jR7ZkU1GYXbQK2Y4oTAV9XDptQA5YzEREnn7muC_6v5ZTAglZF1lhn9Q0NwmylZEAXJdSGHaqXt1Hv-vQlprA_9m22vrreBOTLPnVK946J8absKrwfe-jK_1n_9YQR43uwH8XwFBFND0c4lICCQGbxwM8pX4ACWR0c19aORCYm-M5FrJsxmG29_aDVNhcvkoQ3mlP7ITQeqzkrjfytSwLb2BYpXYZKjEHNfV9j3JoxJobUkK5hrxXBhTvZzbVBnE0LSXQNwR-JAcOliP_jXBEeQ-28B-aGW8TI1vEP2i260QKgzOzPC-pOoFp0-vCvxojNO0kE16ECVTLfDNLNGSMZs9vekdLJP2akBp6PsUXsQUTbWO_wr1E2oNU7ctfMRxoh-yP0ZW2_xz_NjE72O5LF_6zuDVV7Q==\"},{\"type\":\"message\",\"id\":\"msg_0a6277dd90b94da1016aa8c947253887d184c150fcbcbcd8da\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Alpha.\"}],\"phase\":\"final_answer\",\"status\":\"completed\"},{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Beta.\"}]}],\"instructions\":\"Follow the user's exact reply instruction.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"max_output_tokens\":30}"
        },
        {
          "direction": "server",
@@ -30,7 +30,7 @@
        {
          "direction": "client",
          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Ready.\"}]}],\"instructions\":\"Follow the user's exact reply instruction.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":30}"
+          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Ready.\"}]}],\"instructions\":\"Follow the user's exact reply instruction.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"max_output_tokens\":30}"
        },
        {
          "direction": "server",
@@ -109,7 +109,7 @@
        {
          "direction": "client",
          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Recovered.\"}]}],\"instructions\":\"Follow the user's exact reply instruction.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":30,\"previous_response_id\":\"resp_01cc0cda24c36acf016aa8ca3c1d3c87d1853283f43675e411\"}"
+          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Recovered.\"}]}],\"instructions\":\"Follow the user's exact reply instruction.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"max_output_tokens\":30,\"previous_response_id\":\"resp_01cc0cda24c36acf016aa8ca3c1d3c87d1853283f43675e411\"}"
        },
        {
          "direction": "server",
@@ -119,7 +119,7 @@
        {
          "direction": "client",
          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Ready.\"}]},{\"type\":\"reasoning\",\"id\":\"rs_01cc0cda24c36acf016aa8ca3ced8c87d1a14c5c6a2ced8544\",\"summary\":[],\"encrypted_content\":\"gAAAAABqqMo9M9B15LsV1CLsXpNJpI08GiwCAK97hTheQ2s1lAkKgARMs1HIIXVeAr-tbUq88yN51fiQE8HvGwdF9ZcNI6bZle8D2PS7m8O7UE7C1Z_HX_fz2f0pRHyRfWpVAT2gYQWIDeZu6UdgxbKPBW0lXWzlk_relHG5x6nXkYzZoEeVasqavWoyMMSX7cexe-IYJh6e_3DgRpOchueS8Z-70P0w5R83Ea7UXZQNhMA0yDEYu_td2PmE2Pd2PUTOB3mxF2pb1z7-2t6S0UryhHx0az7Gh2eT60GGUqz9CIZzNE_FX--tszeuO0eI92Cen5tirOUHBTyyDqE0eG26DRl_p_U-xDZwaQONbtYbvkvrj-G7FA2oZXxjJPHuQZsNgBslXS-H0KT1lx3Y8XJ9QMVjFLFaucFG64wCmXPfCH8dYtX_YqfYQR4lwNfiSbyJEX2oDvTVVD_aCJ9NRo7c0aCTtmKBvr6fvvAy3MAFxAp_Sm2nMx4P5GYO4qAmJDByywKw-VK1vHlv3NRmVsAgbArIFgm-axoCs2PLpvZjDqeQGPavaq8zKWTyZYqBsEzKZUtGOZfYjD4mud0Z08I4i2H4K-L00ccVauode3548ZipOIuslbhJxonQXsF6TFdW2Hj8E5JjoEr5IbmwHyI0PBcDWW5AmkjHLwr9v08mFppRoD-2wzPAd5igROAuUbvJhiQd2A-uOaohwMjdpFxrjyUqgGTlI5g7tmI1ceeQWms0bKm8Pd0wIqVM3Nq6YvV7XfEyeogfRMVUQezr_lES42ZMVAoKBSFzMysDwCFkhVNVclcTUpcUUbVp21FChG7Ag-xuq8Cl6OGLA8nWX1C0aCf2HNa-n3dkYr1DtUziurh1MD-UIs5jdGiq3ptrc0VaVZwNdD4jVfAoHB_Ws7GiISXuclfpqsG3DTJEfzlbukI1vxXrt3FArsHiQvQjW5UM7gGel32M6p8AlXRxnez9PgIuU1WrtBUJetk7m39AZwp_aqbqC-AJ-MF70xP1VJZwFN-GeNL3VZsRHePFG4h7Pj---CCZRGlmzuE1-b-sIE7Bn_gbue_qHFMZJhAY55MO25vfZbSoLWHZCGmLMjJVHOYCPoy6l7zyxNmoIcC58QILNWal31KLCDmCsASmZC-xQRjyFwt-kvLbvk38Dc02IKcP3ujhf6WRRr1A0hh1K-gXmv_XI_MUFDcOVIjjhB-rXgjWSCoKfaKI9GCIsb9mnNaBq65BWg==\"},{\"type\":\"message\",\"id\":\"msg_01cc0cda24c36acf016aa8ca3d4a0087d1950121aed4802434\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Ready.\"}],\"phase\":\"final_answer\",\"status\":\"completed\"},{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Recovered.\"}]}],\"instructions\":\"Follow the user's exact reply instruction.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":30}"
+          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Ready.\"}]},{\"type\":\"reasoning\",\"id\":\"rs_01cc0cda24c36acf016aa8ca3ced8c87d1a14c5c6a2ced8544\",\"summary\":[],\"encrypted_content\":\"gAAAAABqqMo9M9B15LsV1CLsXpNJpI08GiwCAK97hTheQ2s1lAkKgARMs1HIIXVeAr-tbUq88yN51fiQE8HvGwdF9ZcNI6bZle8D2PS7m8O7UE7C1Z_HX_fz2f0pRHyRfWpVAT2gYQWIDeZu6UdgxbKPBW0lXWzlk_relHG5x6nXkYzZoEeVasqavWoyMMSX7cexe-IYJh6e_3DgRpOchueS8Z-70P0w5R83Ea7UXZQNhMA0yDEYu_td2PmE2Pd2PUTOB3mxF2pb1z7-2t6S0UryhHx0az7Gh2eT60GGUqz9CIZzNE_FX--tszeuO0eI92Cen5tirOUHBTyyDqE0eG26DRl_p_U-xDZwaQONbtYbvkvrj-G7FA2oZXxjJPHuQZsNgBslXS-H0KT1lx3Y8XJ9QMVjFLFaucFG64wCmXPfCH8dYtX_YqfYQR4lwNfiSbyJEX2oDvTVVD_aCJ9NRo7c0aCTtmKBvr6fvvAy3MAFxAp_Sm2nMx4P5GYO4qAmJDByywKw-VK1vHlv3NRmVsAgbArIFgm-axoCs2PLpvZjDqeQGPavaq8zKWTyZYqBsEzKZUtGOZfYjD4mud0Z08I4i2H4K-L00ccVauode3548ZipOIuslbhJxonQXsF6TFdW2Hj8E5JjoEr5IbmwHyI0PBcDWW5AmkjHLwr9v08mFppRoD-2wzPAd5igROAuUbvJhiQd2A-uOaohwMjdpFxrjyUqgGTlI5g7tmI1ceeQWms0bKm8Pd0wIqVM3Nq6YvV7XfEyeogfRMVUQezr_lES42ZMVAoKBSFzMysDwCFkhVNVclcTUpcUUbVp21FChG7Ag-xuq8Cl6OGLA8nWX1C0aCf2HNa-n3dkYr1DtUziurh1MD-UIs5jdGiq3ptrc0VaVZwNdD4jVfAoHB_Ws7GiISXuclfpqsG3DTJEfzlbukI1vxXrt3FArsHiQvQjW5UM7gGel32M6p8AlXRxnez9PgIuU1WrtBUJetk7m39AZwp_aqbqC-AJ-MF70xP1VJZwFN-GeNL3VZsRHePFG4h7Pj---CCZRGlmzuE1-b-sIE7Bn_gbue_qHFMZJhAY55MO25vfZbSoLWHZCGmLMjJVHOYCPoy6l7zyxNmoIcC58QILNWal31KLCDmCsASmZC-xQRjyFwt-kvLbvk38Dc02IKcP3ujhf6WRRr1A0hh1K-gXmv_XI_MUFDcOVIjjhB-rXgjWSCoKfaKI9GCIsb9mnNaBq65BWg==\"},{\"type\":\"message\",\"id\":\"msg_01cc0cda24c36acf016aa8ca3d4a0087d1950121aed4802434\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Ready.\"}],\"phase\":\"final_answer\",\"status\":\"completed\"},{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Recovered.\"}]}],\"instructions\":\"Follow the user's exact reply instruction.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"max_output_tokens\":30}"
        },
        {
          "direction": "server",
@@ -26,7 +26,7 @@
        "headers": {
          "content-type": "application/json"
        },
-        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]}],\"instructions\":\"Show concise reasoning when the provider supports visible reasoning summaries.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":120,\"stream\":true}"
+        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]}],\"instructions\":\"Show concise reasoning when the provider supports visible reasoning summaries.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"max_output_tokens\":120,\"stream\":true}"
      },
      "response": {
        "status": 200,
@@ -44,7 +44,7 @@
        "headers": {
          "content-type": "application/json"
        },
-        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]},{\"type\":\"reasoning\",\"id\":\"rs_052e7ec551f55289016aa8c8d63eac87d19d6b921611f123e7\",\"summary\":[],\"encrypted_content\":\"gAAAAABqqMjWZ2Eei8_Gf-5FeEFAYp-gSzFL4D4lQBKL_fyyTYXv5iJ-2jql1mOq0wZpqHL8O9MWxebQGW56Ahd-p21qrDD52CyUBqKKlF87eC1d-cTgjXQlFMsPxvwyQeuU6A2l8tanTtJ48sKtzZtHrDuBXZ35u-lONnovjFGMX3Q83xoqG_um_w5rT420TA_SyU4fGt7oiQvOPS1q4PNo97O824oRnI7n_BC1jPYCaJhl2I1rPJg4afuOpjG-u7JcXRD4JPwZdqMa5o2d0uDKHuUYwP25qiPKKDqTTqFka5cDJjZNPF3ZkVHR-cagjZGvMnizXXxgUpPJ9j83gqY4QJLKCkzcaBj9H7mAL-v9yl4I5kn_9_DhpMILs2SZkC8AvIYNgmel3sDV_BG4XZ2JXciZz86ukQ6DwXgQqS4HOB91g-sGHOWMU1ohsZlEvvJBjGkJ_rAdXVMqAbvi2zvE3_NI4sTAGUrIugGJePrQYTe8gqL8f9NsYac6pzHNQL1e_jQNUvp49bu7EsPzCP3KPYVvZCFohDdwe7sMd6wrztrCJwM4CLdAQK61A7sYzU0HyglLtPidmS5QkSmV6U_xgih7JbKnY0oAeCyYw4ADYqdNTi0axmBErh-lbh-XKNG_TnoMa-2IS3X041N8OsDfSdQp3QsAm53fF8seQuLFa27Iaq2etMj3yGeqWVjA-Mae3K34mt2YPGjQ-HbIOMVmYXBLzNr-s2fT35Sp6SDEsFyvzXb0Vij58s1wW5zkuKgaJiroGgkY86NImuaa3_-wpMK3_9O_wwAbRwV4uBCVzT_rY6rDQHR9-VkM0MbGK8drbdtjXwy3KtAzkux4N4g2nadYU0IIIEUNj_JChUFSHC7VRg7L7LpZMgAFGwHmaUyzQt31LyiVix9WFtcKfBgzehoRV6vstln-oBRd-vFjUW-7WLm7R_lFNHQZ0CKUvKCSpQxdIevczpYT0_lQiDU7Rfp1UBBnicndpq4YQwgRppdZX-QHG5IZxxHNWYdIBtn3eO3ooDXmI-rYryyVcFG6VY5xqssf8GgXqgNy84X_SgYfhGmNiPPQTl5wIBa49f1sxAI-7ri1xLr6FJhQMasOoxm_VuZYNkq6NrAXprtKa70cBRpm1wWBNcPdMul4GNMDQatQZRDENcNLe45iMX-HB1YYSvyc-y5rfSJkP4EgKXC-OqcrzxAlRfB3Bm4jOQL_PSsNBbh26CWAdAYSftM88fbnuqZX2w==\"},{\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Hello!\"}],\"status\":\"completed\"},{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Now reply exactly with: Done.\"}]}],\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":40,\"stream\":true}"
+        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]},{\"type\":\"reasoning\",\"id\":\"rs_052e7ec551f55289016aa8c8d63eac87d19d6b921611f123e7\",\"summary\":[],\"encrypted_content\":\"gAAAAABqqMjWZ2Eei8_Gf-5FeEFAYp-gSzFL4D4lQBKL_fyyTYXv5iJ-2jql1mOq0wZpqHL8O9MWxebQGW56Ahd-p21qrDD52CyUBqKKlF87eC1d-cTgjXQlFMsPxvwyQeuU6A2l8tanTtJ48sKtzZtHrDuBXZ35u-lONnovjFGMX3Q83xoqG_um_w5rT420TA_SyU4fGt7oiQvOPS1q4PNo97O824oRnI7n_BC1jPYCaJhl2I1rPJg4afuOpjG-u7JcXRD4JPwZdqMa5o2d0uDKHuUYwP25qiPKKDqTTqFka5cDJjZNPF3ZkVHR-cagjZGvMnizXXxgUpPJ9j83gqY4QJLKCkzcaBj9H7mAL-v9yl4I5kn_9_DhpMILs2SZkC8AvIYNgmel3sDV_BG4XZ2JXciZz86ukQ6DwXgQqS4HOB91g-sGHOWMU1ohsZlEvvJBjGkJ_rAdXVMqAbvi2zvE3_NI4sTAGUrIugGJePrQYTe8gqL8f9NsYac6pzHNQL1e_jQNUvp49bu7EsPzCP3KPYVvZCFohDdwe7sMd6wrztrCJwM4CLdAQK61A7sYzU0HyglLtPidmS5QkSmV6U_xgih7JbKnY0oAeCyYw4ADYqdNTi0axmBErh-lbh-XKNG_TnoMa-2IS3X041N8OsDfSdQp3QsAm53fF8seQuLFa27Iaq2etMj3yGeqWVjA-Mae3K34mt2YPGjQ-HbIOMVmYXBLzNr-s2fT35Sp6SDEsFyvzXb0Vij58s1wW5zkuKgaJiroGgkY86NImuaa3_-wpMK3_9O_wwAbRwV4uBCVzT_rY6rDQHR9-VkM0MbGK8drbdtjXwy3KtAzkux4N4g2nadYU0IIIEUNj_JChUFSHC7VRg7L7LpZMgAFGwHmaUyzQt31LyiVix9WFtcKfBgzehoRV6vstln-oBRd-vFjUW-7WLm7R_lFNHQZ0CKUvKCSpQxdIevczpYT0_lQiDU7Rfp1UBBnicndpq4YQwgRppdZX-QHG5IZxxHNWYdIBtn3eO3ooDXmI-rYryyVcFG6VY5xqssf8GgXqgNy84X_SgYfhGmNiPPQTl5wIBa49f1sxAI-7ri1xLr6FJhQMasOoxm_VuZYNkq6NrAXprtKa70cBRpm1wWBNcPdMul4GNMDQatQZRDENcNLe45iMX-HB1YYSvyc-y5rfSJkP4EgKXC-OqcrzxAlRfB3Bm4jOQL_PSsNBbh26CWAdAYSftM88fbnuqZX2w==\"},{\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Hello!\"}],\"status\":\"completed\"},{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Now reply exactly with: Done.\"}]}],\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"max_output_tokens\":40,\"stream\":true}"
      },
      "response": {
        "status": 200,
@@ -24,7 +24,7 @@
        "headers": {
          "content-type": "application/json"
        },
-        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]}],\"instructions\":\"Show concise reasoning when the provider supports visible reasoning summaries.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":120,\"stream\":true}"
+        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]}],\"instructions\":\"Show concise reasoning when the provider supports visible reasoning summaries.\",\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"max_output_tokens\":120,\"stream\":true}"
      },
      "response": {
        "status": 200,
@@ -25,7 +25,7 @@
        "headers": {
          "content-type": "application/json"
        },
-        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]}],\"instructions\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is 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,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":80,\"stream\":true}"
+        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]}],\"instructions\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is 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,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"max_output_tokens\":80,\"stream\":true}"
      },
      "response": {
        "status": 200,
@@ -43,7 +43,7 @@
        "headers": {
          "content-type": "application/json"
        },
-        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]},{\"type\":\"function_call\",\"id\":\"fc_09525c04931d1487016aa8c8d8e12887d193bd327a0f313bd7\",\"call_id\":\"call_p57PJbKe0bX44nj908fpHdRn\",\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"},{\"type\":\"function_call_output\",\"call_id\":\"call_p57PJbKe0bX44nj908fpHdRn\",\"output\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"instructions\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is 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,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":80,\"stream\":true}"
+        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"message\",\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]},{\"type\":\"function_call\",\"id\":\"fc_09525c04931d1487016aa8c8d8e12887d193bd327a0f313bd7\",\"call_id\":\"call_p57PJbKe0bX44nj908fpHdRn\",\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"},{\"type\":\"function_call_output\",\"call_id\":\"call_p57PJbKe0bX44nj908fpHdRn\",\"output\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"instructions\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is 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,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"max_output_tokens\":80,\"stream\":true}"
      },
      "response": {
        "status": 200,
@@ -97,6 +97,26 @@ describe("Generation", () => {
    }),
  )

+  it.effect("fails an event stream at the deadline when the poll interval is longer than the timeout", () =>
+    Effect.gen(function* () {
+      const scripted = yield* scriptedRoute(["running"], "never")
+      const generation = new Generation(scripted.route, "t", { id: "gen_1", status: "queued" })
+
+      const fiber = yield* Effect.forkChild(
+        generation
+          .events({ poll: { interval: "30 seconds", timeout: "10 seconds" } })
+          .pipe(Stream.runCollect, Effect.flip),
+      )
+      yield* TestClock.adjust("9 seconds")
+      expect(fiber.pollUnsafe()).toBeUndefined()
+      yield* TestClock.adjust("1 second")
+      const error = yield* Fiber.join(fiber)
+
+      expect(error.reason._tag).toBe("Timeout")
+      expect(yield* Ref.get(scripted.polls)).toBe(1)
+    }),
+  )
+
  it.effect("surfaces the route failure body for failed generations", () =>
    Effect.gen(function* () {
      const scripted = yield* scriptedRoute(["running", "failed"], "unused")
@@ -78,8 +78,11 @@ describe("Image", () => {
        mediaType: "image/webp",
      })
      expect(yield* response.image.bytes()).toEqual(Uint8Array.from([1, 2, 3]))
-      expect(response.image.providerMetadata).toEqual({ openai: { revisedPrompt: "A precise robot" } })
+      expect(response.image.info).toEqual({ format: "webp", width: 2048, height: 2048 })
      expect(response.usage).toMatchObject({ type: "tokens", total: 12 })
+      expect(response.providerMetadata).toEqual({
+        openai: { outputFormat: "webp", size: "2048x2048", quality: "high", background: "opaque" },
+      })
    }).pipe(
      Effect.provide(
        ImageClient.layer.pipe(
@@ -107,8 +110,11 @@ describe("Image", () => {
                })
                return input.respond(
                  JSON.stringify({
-                    data: [{ b64_json: "AQID", revised_prompt: "A precise robot" }, { b64_json: "BAUG" }],
+                    data: [{ b64_json: "AQID" }, { b64_json: "BAUG" }],
                    output_format: "webp",
+                    size: "2048x2048",
+                    quality: "high",
+                    background: "opaque",
                    usage: { input_tokens: 4, output_tokens: 8, total_tokens: 12 },
                  }),
                  { headers: { "content-type": "application/json" } },
@@ -144,6 +150,7 @@ describe("Image", () => {
        ),
      )
      expect(response.image.source).toEqual({ type: "bytes", data: Uint8Array.from([1, 2, 3]), mediaType: "image/png" })
+      expect(response.image.info).toEqual({ format: "png" })
    }),
  )

@@ -725,6 +732,7 @@ describe("Image", () => {
      const errors = yield* Effect.all(
        [
          Image.start({ model: Google.configure({ apiKey: "test" }).image("gemini-3.1-flash-image"), prompt }),
+          Image.generate({ model: Google.configure({ apiKey: "test" }).image("gemini-3.1-flash-image"), prompt, n: 2 }),
          Image.start({
            model: BlackForestLabs.configure({ apiKey: "test" }).image("flux-2-pro"),
            prompt,
@@ -735,7 +743,6 @@ describe("Image", () => {
            prompt,
            size: "512x512",
          }),
-          Stream.runCollect(Image.stream({ model: openai.image("dall-e-3"), prompt })),
          Stream.runCollect(Image.stream({ model: openai.image("gpt-image-2"), prompt, n: 2 })),
          Image.start({ model: replicate, prompt, seed: 7 }),
          Image.start({
@@ -749,9 +756,9 @@ describe("Image", () => {
      expect(errors.map((error) => [error.reason._tag, "operation" in error.reason && error.reason.operation])).toEqual(
        [
          ["UnsupportedOperation", "image.start"],
+          ["UnsupportedOperation", "media.n"],
          ["UnsupportedOperation", "media.aspectRatio"],
          ["UnsupportedOperation", "media.size"],
-          ["UnsupportedOperation", "media.stream"],
          ["UnsupportedOperation", "media.n"],
          ["UnsupportedOperation", "media.seed"],
          ["InvalidRequest", false],
@@ -761,6 +768,80 @@ describe("Image", () => {
    }).pipe(Effect.provide(layer(() => Effect.die("an unsupported request reached the network")))),
  )

+  const falToken = {
+    requestID: "r1",
+    statusURL: "https://queue.fal.test/fal-ai/flux/requests/r1/status",
+    responseURL: "https://queue.fal.test/fal-ai/flux/requests/r1",
+    cancelURL: "https://queue.fal.test/fal-ai/flux/requests/r1/cancel",
+  }
+  const falSubmitted = {
+    request_id: falToken.requestID,
+    status_url: falToken.statusURL,
+    response_url: falToken.responseURL,
+    cancel_url: falToken.cancelURL,
+  }
+  const bodies: Array<unknown> = []
+  it.effect("sizes fal Kontext by aspect ratio and sends several images to /multi", () =>
+    Effect.gen(function* () {
+      const fal = Fal.configure({ apiKey: "test", baseURL: "https://queue.fal.test" })
+      const images = [Media.url("https://example.test/a.png"), Media.url("https://example.test/b.png")]
+      const rejected = yield* Image.start({
+        model: fal.image("fal-ai/flux-pro/kontext"),
+        prompt: "A lighthouse",
+        size: "512x512",
+      }).pipe(Effect.flip)
+      yield* Image.start({
+        model: fal.image("fal-ai/flux-pro/kontext"),
+        prompt: "A lighthouse",
+        images: images.slice(0, 1),
+        aspectRatio: "16:9",
+      })
+      yield* Image.start({ model: fal.image("fal-ai/flux-pro/kontext/max/multi"), prompt: "A lighthouse", images })
+
+      expect(rejected.reason).toMatchObject({ _tag: "UnsupportedOperation", operation: "media.size" })
+      expect(bodies).toEqual([
+        { prompt: "A lighthouse", aspect_ratio: "16:9", image_url: "https://example.test/a.png" },
+        { prompt: "A lighthouse", image_urls: ["https://example.test/a.png", "https://example.test/b.png"] },
+      ])
+    }).pipe(
+      Effect.provide(
+        layer((input) => {
+          bodies.push(JSON.parse(input.text))
+          return Effect.succeed(json(input, falSubmitted))
+        }),
+      ),
+    ),
+  )
+
+  it.effect("decodes fal sync_mode data URIs as inline images", () =>
+    Effect.gen(function* () {
+      const generation = yield* Image.resume(Fal.configure({ apiKey: "test" }).image("fal-ai/flux/schnell"), falToken)
+      const response = yield* generation.await()
+
+      expect(response.images.map((image) => image.source)).toEqual([
+        { type: "base64", data: "AQID", mediaType: "image/png" },
+        { type: "url", url: "https://v3.fal.media/out.jpg", mediaType: "image/jpeg" },
+      ])
+      expect(response.image.info).toEqual({ width: 512, height: 512 })
+      expect(yield* response.image.bytes()).toEqual(Uint8Array.from([1, 2, 3]))
+    }).pipe(
+      Effect.provide(
+        layer((input) =>
+          Effect.succeed(
+            input.request.url === falToken.statusURL
+              ? json(input, { status: "COMPLETED" })
+              : json(input, {
+                  images: [
+                    { url: "data:image/png;base64,AQID", width: 512, height: 512, content_type: "image/png" },
+                    { url: "https://v3.fal.media/out.jpg", width: 512, height: 512, content_type: "image/jpeg" },
+                  ],
+                }),
+          ),
+        ),
+      ),
+    ),
+  )
+
  const moderated = { id: "req_1", status: "Content Moderated" }
  const prediction = {
    id: "p_1",
@@ -768,6 +849,56 @@ describe("Image", () => {
    output: { text: "not an image" },
    urls: { get: "https://replicate.test/p_1", cancel: "https://replicate.test/p_1/cancel" },
  }
+  for (const pending of [
+    {
+      model: BlackForestLabs.configure({ apiKey: "test" }).image("flux-2-pro"),
+      token: { id: "req_1", pollingURL: "https://bfl.test/v1/get_result?id=req_1" },
+      status: 200,
+      body: { id: "req_1", status: "Pending" },
+      message: "Black Forest Labs generation req_1",
+    },
+    {
+      model: Replicate.configure({ apiKey: "test" }).image("owner/model"),
+      token: { id: "p_1", getURL: "https://replicate.test/p_1", cancelURL: "https://replicate.test/p_1/cancel" },
+      status: 200,
+      body: {
+        id: "p_1",
+        status: "processing",
+        urls: { get: "https://replicate.test/p_1", cancel: "https://replicate.test/p_1/cancel" },
+      },
+      message: "Replicate generation p_1",
+    },
+    {
+      model: Stability.configure({ apiKey: "test", baseURL: "https://stability.test" }).upscale(),
+      token: { id: "up_1" },
+      status: 202,
+      body: { id: "up_1", status: "in-progress" },
+      message: "Stability AI generation up_1",
+    },
+  ]) {
+    it.effect(`rejects reading a ${pending.model.provider} result before the generation finishes`, () =>
+      Effect.gen(function* () {
+        const generation = yield* Image.resume(pending.model, pending.token)
+        const error = yield* generation.result().pipe(Effect.flip)
+        expect(error.reason._tag).toBe("InvalidRequest")
+        expect(error.message).toBe(`${pending.message} has not finished; await it before reading the result`)
+        expect(error.reason.body).toBe(JSON.stringify(pending.body))
+        expect(error.reason.http?.status).toBe(pending.status)
+      }).pipe(
+        Effect.provide(
+          layer((input) =>
+            Effect.succeed(
+              input.respond(JSON.stringify(pending.body), {
+                status: pending.status,
+                headers: { "content-type": "application/json" },
+              }),
+            ),
+          ),
+        ),
+      ),
+    )
+  }
+
  it.effect("classifies terminal outcomes the recordings never saw", () =>
    Effect.gen(function* () {
      const bfl = yield* Image.resume(BlackForestLabs.configure({ apiKey: "test" }).image("flux-2-pro"), {
@@ -7,7 +7,6 @@ import {
  type ImageModelOptions,
  type ImageOptions,
  type ImageRequestFor,
-  type ImageRoute,
 } from "../src/index.js"
 import type { Service } from "../src/image-client.js"
 import { Anthropic, BlackForestLabs, Google, OpenAI, Stability, XAI, ZAI } from "../src/providers.js"
@@ -21,8 +20,7 @@ type GoogleLikeOptions = {
  readonly thinkingLevel?: "LOW" | "HIGH"
 } & Record<string, unknown>

-declare const route: ImageRoute<GoogleLikeOptions>
-const google = ImageModel.make<GoogleLikeOptions>({ id: "gemini-image", provider: "google", route })
+declare const google: ImageModel<GoogleLikeOptions>
 // @ts-expect-error Extracted model options retain known provider fields.
 const invalidGoogleOptions: ImageModelOptions<typeof google> = { imageSize: "8K" }
 void invalidGoogleOptions
@@ -152,6 +150,8 @@ Image.generate({ model: zai, prompt: "A lighthouse", providerOptions: { quality:
 Image.generate({ model: zai, prompt: "A lighthouse", providerOptions: { userID: 1 } })

 declare const generic: ImageModel<ImageOptions>
+const widenImage = <Options extends ImageOptions>(model: ImageModel<Options>): ImageModel => model
+void widenImage
 Image.generate({ model: generic, prompt: "A lighthouse", providerOptions: { arbitrary: true } })
 const explicitAsset: Media.Asset = Media.url("https://example.com/image.png")
 void explicitAsset
@@ -6,6 +6,7 @@ import {
  type LanguageModelProviderOptions,
  type ProviderOptions,
 } from "../src/index.js"
+import { ai } from "../src/promise.js"
 import { OpenAIChat } from "../src/protocols.js"

 interface ExampleOptions {
@@ -31,6 +32,10 @@ const generated = LLM.generate(LLM.request({ model, prompt: "Hello" }))
 type GenerateRequirements = Assert<Equal<Requirements<typeof generated>, LLMClientService>>
 const streamed = LLM.stream(LLM.request({ model, prompt: "Hello" }))
 type StreamClientRequirements = Assert<Equal<StreamRequirements<typeof streamed>, LLMClientService>>
+const generatedFromInput = LLM.generate({ model, prompt: "Hello", providerOptions: { mode: "fast" } })
+type InputGenerateRequirements = Assert<Equal<Requirements<typeof generatedFromInput>, LLMClientService>>
+const streamedFromInput = LLM.stream({ model, prompt: "Hello", providerOptions: { mode: "thorough" } })
+type InputStreamRequirements = Assert<Equal<StreamRequirements<typeof streamedFromInput>, LLMClientService>>

 LLM.request({
  model,
@@ -39,6 +44,11 @@ LLM.request({
  providerOptions: { mode: "slow" },
 })

+// @ts-expect-error Direct input keeps the selected model's provider option types.
+LLM.generate({ model, prompt: "Hello", providerOptions: { mode: "slow" } })
+// @ts-expect-error Stream input keeps the selected model's provider option types.
+LLM.stream({ model, prompt: "Hello", providerOptions: { mode: "slow" } })
+
 const generatedObject = LLM.generateObject({
  model,
  prompt: "Hello",
@@ -69,5 +79,16 @@ const options: LanguageModelProviderOptions<typeof model> = { mode: "fast" }
 void (options satisfies LanguageModelProviderOptions<typeof model>)
 void (true satisfies GenerateRequirements)
 void (true satisfies StreamClientRequirements)
+void (true satisfies InputGenerateRequirements)
+void (true satisfies InputStreamRequirements)
 void (true satisfies GenerateObjectRequirements)
 void (true satisfies GenerateDynamicObjectRequirements)
+
+void ai.llm.generate({ model, prompt: "Hello", providerOptions: { mode: "fast" } })
+void ai.llm.stream({ model, prompt: "Hello", providerOptions: { mode: "thorough" } })
+void ai.llm.generate(ai.llm.request({ model, prompt: "Hello" }))
+void ai.llm.stream(ai.llm.request({ model, prompt: "Hello" }))
+// @ts-expect-error Promise direct input keeps the selected model's provider option types.
+void ai.llm.generate({ model, prompt: "Hello", providerOptions: { mode: "slow" } })
+// @ts-expect-error Promise stream input keeps the selected model's provider option types.
+void ai.llm.stream({ model, prompt: "Hello", providerOptions: { mode: "slow" } })
@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { CacheHint, LLM, LLMResponse, ToolEntry, ToolNamespace } from "../src/index.js"
+import { Effect, Schema, Stream } from "effect"
+import { CacheHint, LLM, LLMEvent, LLMResponse, ToolEntry, ToolNamespace } from "../src/index.js"
+import { OpenAI } from "../src/providers.js"
 import * as OpenAIChat from "../src/protocols/openai-chat.js"
 import * as OpenAIResponses from "../src/protocols/openai-responses.js"
 import {
@@ -13,6 +14,8 @@ import {
  ToolDefinition,
  ToolResultPart,
 } from "../src/schema/index.js"
+import { fixedResponse } from "./lib/http.js"
+import { sseEvents } from "./lib/sse.js"

 const chatRoute = OpenAIChat.route
 const responsesRoute = OpenAIResponses.route
@@ -240,6 +243,26 @@ describe("llm constructors", () => {
    expect(request.messages.map((message) => message.role)).toEqual(["user", "system"])
  })

+  test("generates and streams from input or a prebuilt request", async () => {
+    const model = OpenAI.configure({ apiKey: "test", baseURL: "https://openai.test/v1" }).chat("gpt-4o-mini")
+    const layer = fixedResponse(
+      sseEvents({ choices: [{ delta: { content: "Hello" } }] }, { choices: [{ delta: {}, finish_reason: "stop" }] }),
+    )
+    const input = { model, prompt: "Say hello." }
+    const request = LLM.request(input)
+    const generated = await Effect.runPromise(LLM.generate(input).pipe(Effect.provide(layer)))
+    const generatedFromRequest = await Effect.runPromise(LLM.generate(request).pipe(Effect.provide(layer)))
+    expect(generated.text).toBe("Hello")
+    expect(generatedFromRequest.text).toBe(generated.text)
+
+    const streamed = await Effect.runPromise(LLM.stream(input).pipe(Stream.runCollect, Effect.provide(layer)))
+    const streamedFromRequest = await Effect.runPromise(
+      LLM.stream(request).pipe(Stream.runCollect, Effect.provide(layer)),
+    )
+    expect(Array.from(streamed).some(LLMEvent.is.textDelta)).toBe(true)
+    expect(streamedFromRequest).toEqual(streamed)
+  })
+
  test("extracts output text from response events", () => {
    expect(
      LLMResponse.text({
@@ -3,7 +3,7 @@ import { NodeFileSystem } from "@effect/platform-node"
 import { Effect, Ref, Schema } from "effect"
 import { FileSystem } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
-import { Media, Message } from "../src/index.js"
+import { AIError, Media, Message } from "../src/index.js"
 import { it } from "./lib/effect.js"
 import { dynamicResponse, scriptedResponses } from "./lib/http.js"

@@ -161,6 +161,56 @@ describe("Media", () => {
    }),
  )

+  it.effect("keeps transient url download headers out of toJSON and AssetSchema encoding", () =>
+    Effect.sync(() => {
+      const asset = Media.url("https://cdn.example.test/video.mp4", {
+        mediaType: "video/mp4",
+        expiresAt: 42,
+        headers: { "x-goog-api-key": "secret" },
+      })
+      expect(asset.headers).toEqual({ "x-goog-api-key": "secret" })
+      const source = { type: "url", url: "https://cdn.example.test/video.mp4", mediaType: "video/mp4", expiresAt: 42 }
+
+      expect(asset.toJSON()).not.toHaveProperty("headers")
+      expect(JSON.stringify(asset)).not.toContain("secret")
+      expect(asset.toJSON().source).toEqual(source)
+
+      const encoded = Schema.encodeSync(Media.AssetSchema)(asset)
+      expect(encoded).not.toHaveProperty("headers")
+      expect(encoded.source).toEqual(source)
+
+      const codec = Schema.fromJsonString(Media.AssetSchema)
+      const json = Schema.encodeSync(codec)(asset)
+      expect(json).not.toContain("secret")
+      const restored = Schema.decodeSync(codec)(json)
+      expect(restored).toBeInstanceOf(Media.Asset)
+      expect(restored.source).toEqual(source)
+      expect(restored.expiresAt).toBe(42)
+      expect(restored.headers).toBeUndefined()
+    }),
+  )
+
+  it.effect("fails url downloads with non-2xx status as a typed AIError keeping http and body", () =>
+    Effect.gen(function* () {
+      const body = JSON.stringify({ error: { message: "file expired" } })
+      const error = yield* Media.url("https://cdn.example.test/expired.png")
+        .bytes()
+        .pipe(
+          Effect.flip,
+          Effect.provide(
+            dynamicResponse((input) =>
+              Effect.succeed(input.respond(body, { status: 404, headers: { "content-type": "application/json" } })),
+            ),
+          ),
+        )
+      expect(error).toBeInstanceOf(AIError)
+      expect(error.message).toContain("file expired")
+      expect(error.reason.http?.status).toBe(404)
+      expect(error.reason.http?.url).toBe("https://cdn.example.test/expired.png")
+      expect(error.reason.body).toBe(body)
+    }),
+  )
+
  it.effect("reads files with sniffed media types and writes materialized assets", () =>
    Effect.gen(function* () {
      const fs = yield* FileSystem.FileSystem
@@ -116,19 +116,32 @@ describe("AI promise client", () => {
    const seen: Array<string> = []
    const ai = AI.make({ layer: executor(seen) })

-    const text = await ai.llm.generate({ model: openai.chat("gpt-4o-mini"), prompt: "Say hello." })
+    const request = ai.llm.request({ model: openai.chat("gpt-4o-mini"), prompt: "Say hello." })
+    const text = await ai.llm.generate(request)
    expect(text.text).toBe("Hello world")
+    expect((await ai.llm.generate({ model: openai.chat("gpt-4o-mini"), prompt: "Say hello." })).text).toBe(
+      "Hello world",
+    )

    const image = await ai.image.generate({ model: openai.image("gpt-image-2"), prompt: "A lighthouse" })
    expect(image.image).toBeInstanceOf(Media.Asset)
    expect(image.image.mediaType).toBe("image/png")
    expect(await ai.run(image.image.bytes())).toEqual(Uint8Array.from([1, 2, 3]))
+    const requested = await ai.image.generate(
+      ai.image.request({ model: openai.image("gpt-image-2"), prompt: "A lighthouse" }),
+    )
+    expect(requested.image.mediaType).toBe("image/png")

    const deltas: Array<string> = []
-    for await (const event of ai.llm.stream({ model: openai.chat("gpt-4o-mini"), prompt: "Say hello." })) {
+    for await (const event of ai.llm.stream(request)) {
      if (LLMEvent.is.textDelta(event)) deltas.push(event.text)
    }
    expect(deltas).toEqual(["Hello", " world"])
+    const directDeltas: Array<string> = []
+    for await (const event of ai.llm.stream({ model: openai.chat("gpt-4o-mini"), prompt: "Say hello." })) {
+      if (LLMEvent.is.textDelta(event)) directDeltas.push(event.text)
+    }
+    expect(directDeltas).toEqual(deltas)

    const imageEvents: Array<string> = []
    for await (const event of ai.image.stream({ model: openai.image("gpt-image-2"), prompt: "A lighthouse" })) {
@@ -137,8 +150,11 @@ describe("AI promise client", () => {
    expect(imageEvents).toEqual(["image-partial", "image", "finish"])

    expect(seen).toEqual([
+      "https://openai.test/v1/chat/completions",
      "https://openai.test/v1/chat/completions",
      "https://openai.test/v1/images/generations",
+      "https://openai.test/v1/images/generations",
+      "https://openai.test/v1/chat/completions",
      "https://openai.test/v1/chat/completions",
      "https://openai.test/v1/images/generations",
    ])
@@ -260,22 +276,27 @@ describe("AI promise client", () => {
    const ai = AI.make({ layer: executor([]) })

    const failure = await ai.llm
-      .generate({ model: openai.responses("gpt-5"), prompt: "Hello" })
+      .generate(ai.llm.request({ model: openai.responses("gpt-5"), prompt: "Hello" }))
      .then(() => undefined)
      .catch((error: unknown) => error)
    expect(failure).toBeInstanceOf(AIError)
    expect(failure instanceof AIError && failure.reason.http?.status).toBe(404)

-    const invalid = await ai.llm
-      // @ts-expect-error Invalid input must reject with AIError, not throw synchronously.
+    const invalidLLM = await ai.llm
+      // @ts-expect-error Invalid input must reject with AIError instead of throwing synchronously.
      .generate({ model: openai.responses("gpt-5"), messages: [{ role: "bogus" }] })
      .catch((error: unknown) => error)
+    expect(invalidLLM instanceof AIError && invalidLLM.reason._tag).toBe("InvalidRequest")
+
+    const invalid = await ai.image
+      .generate({ model: openai.image("gpt-image-2"), prompt: "A lighthouse", n: 1.5 })
+      .catch((error: unknown) => error)
    expect(invalid instanceof AIError && invalid.reason._tag).toBe("InvalidRequest")

    const controller = new AbortController()
    controller.abort()
    const aborted = await ai.llm
-      .generate({ model: openai.chat("gpt-4o-mini"), prompt: "Hello" }, { signal: controller.signal })
+      .generate(ai.llm.request({ model: openai.chat("gpt-4o-mini"), prompt: "Hello" }), { signal: controller.signal })
      .then(() => "completed")
      .catch(() => "aborted")
    expect(aborted).toBe("aborted")
@@ -216,6 +216,33 @@ it.effect("Alibaba keeps native reasoning controls and future efforts on their s
  }),
 )

+it.effect("Alibaba fits explicit thinking budgets to half the output limit", () =>
+  Effect.gen(function* () {
+    const provider = Alibaba.configure({ region: "ap-southeast-1", apiKey: "fixture" })
+    const chat = (maxTokens?: number) =>
+      compileRequest(
+        LLM.request({
+          model: provider.chat("qwen3.7-plus"),
+          prompt: "hi",
+          ...(maxTokens === undefined ? {} : { generation: { maxTokens } }),
+          providerOptions: { enableThinking: true, thinkingBudget: 131_071 },
+        }),
+      ).pipe(Effect.map((prepared) => prepared.body.thinking_budget))
+    const messages = yield* compileRequest(
+      LLM.request({
+        model: provider.messages("qwen3.7-plus"),
+        prompt: "hi",
+        generation: { maxTokens: 32_000 },
+        providerOptions: { thinking: { type: "enabled", budgetTokens: 131_071 } },
+      }),
+    )
+
+    expect(yield* chat(32_000)).toBe(16_000)
+    expect(yield* chat()).toBe(131_071)
+    expect(messages.body.thinking).toEqual({ type: "enabled", budget_tokens: 16_000 })
+  }),
+)
+
 it.effect("Alibaba validates malformed options before execution", () =>
  Effect.gen(function* () {
    const provider = Alibaba.configure({ region: "ap-southeast-1", apiKey: "fixture" })
@@ -148,11 +148,13 @@ describe("Anthropic Messages route", () => {
    Effect.gen(function* () {
      const enabled = yield* compileRequest(
        LLMRequest.update(request, {
+          generation: { maxTokens: 4_096 },
          providerOptions: { thinking: { type: "enabled", budgetTokens: 1_024 } },
        }),
      )
      const legacy = yield* compileRequest(
        LLMRequest.update(request, {
+          generation: { maxTokens: 4_096 },
          providerOptions: { thinking: { type: "enabled", budget_tokens: 2_048 } },
        }),
      )
@@ -168,6 +170,22 @@ describe("Anthropic Messages route", () => {
    }),
  )

+  it.effect("fits the thinking budget to half the output limit", () =>
+    Effect.gen(function* () {
+      const thinking = (maxTokens: number) =>
+        compileRequest(
+          LLMRequest.update(request, {
+            generation: { maxTokens },
+            providerOptions: { thinking: { type: "enabled", budgetTokens: 31_999 } },
+          }),
+        ).pipe(Effect.map((prepared) => prepared.body.thinking))
+
+      expect(yield* thinking(64_000)).toEqual({ type: "enabled", budget_tokens: 31_999 })
+      expect(yield* thinking(20_000)).toEqual({ type: "enabled", budget_tokens: 10_000 })
+      expect(yield* thinking(1_500)).toEqual({ type: "enabled", budget_tokens: 1_024 })
+    }),
+  )
+
  it.effect("rejects enabled thinking without a budget", () =>
    Effect.gen(function* () {
      const error = yield* compileRequest(
@@ -244,6 +244,29 @@ describe("Bedrock Converse route", () => {
    }),
  )

+  it.effect("fits a Claude thinking budget below maxTokens", () =>
+    Effect.gen(function* () {
+      const fields = (maxTokens: number, budgetTokens: number, topK?: number) =>
+        compileRequest(
+          LLMRequest.update(baseRequest, {
+            model: AmazonBedrock.model("us.anthropic.claude-haiku-4-5-20251001-v1:0", {
+              baseURL: "https://bedrock-runtime.test",
+              apiKey: "test-bearer",
+              thinking: { type: "enabled", budgetTokens },
+            }),
+            generation: GenerationOptions.make({ maxTokens, topK }),
+          }),
+        ).pipe(Effect.map((prepared) => prepared.body.additionalModelRequestFields))
+
+      expect(yield* fields(64_000, 31_999)).toEqual({ thinking: { type: "enabled", budget_tokens: 31_999 } })
+      expect(yield* fields(20_000, 31_999, 40)).toEqual({
+        top_k: 40,
+        thinking: { type: "enabled", budget_tokens: 10_000 },
+      })
+      expect(yield* fields(1_500, 31_999)).toEqual({ thinking: { type: "enabled", budget_tokens: 1_024 } })
+    }),
+  )
+
  it.effect("omits additionalModelRequestFields when topK is unset", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(baseRequest)
@@ -33,6 +33,8 @@ describe("Black Forest Labs Images recorded", () => {

        expect(response.image.source.type).toBe("bytes")
        expect(dimensions(yield* response.image.bytes())).toEqual({ width: 512, height: 512 })
+        // BFL reports cost on submit only; the Ready result omits it.
+        expect(response.usage).toEqual({ type: "credits", credits: 1.4000000000000001 })
      }),
    { timeout: 15 * 60 * 1000 },
  )
@@ -22,21 +22,22 @@ testEffect(
      expect(body).toMatchObject({
        model: "fixture",
        stream: true,
-        store: false,
+        store: true,
        instructions: "Keep the context",
-        parallel_tool_calls: true,
+        parallel_tool_calls: false,
        prompt_cache_key: "session-key",
        service_tier: "priority",
        reasoning: { effort: "high", summary: "auto" },
+        context_management: [{ type: "compaction" }],
+        max_tool_calls: 1,
+        tool_choice: "required",
+        text: { verbosity: "high", format: { type: "json_object" } },
        prompt_cache_retention: "24h",
        prompt_cache_options: { mode: "session", ttl: "1h" },
        input: [{ role: "user", content: [{ type: "input_text", text: "hello" }] }, { type: "compaction_trigger" }],
      })
      expect(body.tools).toHaveLength(1)
      expect(body.tools[0].name).toBe("lookup")
-      expect(body.tool_choice).toBeUndefined()
-      expect(body.context_management).toBeUndefined()
-      expect(body.text).toBeUndefined()
      expect(body.max_output_tokens).toBeUndefined()
      expect(body.previous_response_id).toBeUndefined()
      return respond(
@@ -57,7 +58,7 @@ testEffect(
      )
    }),
  ),
-).effect("trigger uses normal request preparation, configured deployment, and supplied subscription headers", () =>
+).effect("trigger keeps request controls, configured deployment, and supplied subscription headers", () =>
  Effect.gen(function* () {
    const calls: string[] = []
    const input = LLM.request({
@@ -67,12 +68,14 @@ testEffect(
      promptCacheKey: "session-key",
      tools: [{ name: "lookup", description: "Lookup", inputSchema: { type: "object", properties: {} } }],
      toolChoice: { type: "tool", name: "lookup" },
-      generation: { maxTokens: 1 },
      providerOptions: {
        store: true,
        reasoningEffort: "high",
        reasoningSummary: "auto",
        contextManagement: [{ type: "compaction" }],
+        parallelToolCalls: false,
+        maxToolCalls: 1,
+        textVerbosity: "low",
      },
      http: {
        headers: { "chatgpt-account-id": "fixture-account", "x-codex-beta-features": "remote_compaction_v2" },
@@ -82,8 +85,7 @@ testEffect(
          prompt_cache_retention: "24h",
          prompt_cache_options: { mode: "session", ttl: "1h" },
          store: true,
-          stream: false,
-          text: { format: { type: "json_object" } },
+          text: { verbosity: "high", format: { type: "json_object" } },
          tool_choice: "required",
        },
      },
@@ -114,6 +116,75 @@ testEffect(
  }),
 )

+testEffect(
+  dynamicResponse(({ text, respond }) =>
+    Effect.sync(() => {
+      expect(JSON.parse(text).text).toEqual({ verbosity: "low", format: { type: "json_object" } })
+      return respond(sseEvents({ type: "response.completed", response: { id: "resp_1", output: [checkpoint] } }), {
+        headers: { "content-type": "text/event-stream" },
+      })
+    }),
+  ),
+).effect("keeps explicit verbosity on a trigger checkpoint for prompt cache reuse", () =>
+  LLMClient.compact(
+    LLM.request({
+      model: OpenAI.configure({ apiKey: "fixture" }).responses("gpt-5.5"),
+      prompt: "Hello.",
+      providerOptions: { textVerbosity: "low" },
+      http: { body: { text: { format: { type: "json_object" } } } },
+    }),
+    trigger,
+  ),
+)
+
+testEffect(
+  dynamicResponse(({ text, respond }) =>
+    Effect.sync(() => {
+      const body = JSON.parse(text)
+      expect(body.text).toEqual({ verbosity: "high", format: { type: "json_object" } })
+      expect(body.max_output_tokens).toBe(20_000)
+      return respond(sseEvents({ type: "response.completed", response: { id: "resp_1", output: [checkpoint] } }), {
+        headers: { "content-type": "text/event-stream" },
+      })
+    }),
+  ),
+).effect("keeps the effective body-overlay verbosity and text formatting", () =>
+  LLMClient.compact(
+    LLM.request({
+      model: OpenAI.configure({ apiKey: "fixture" }).responses("gpt-5.5"),
+      prompt: "Hello.",
+      generation: { maxTokens: 20_000 },
+      providerOptions: { textVerbosity: "low" },
+      http: { body: { text: { verbosity: "high", format: { type: "json_object" } } } },
+    }),
+    trigger,
+  ),
+)
+
+testEffect(
+  dynamicResponse(({ text, respond }) =>
+    Effect.sync(() => {
+      expect(JSON.parse(text).max_output_tokens).toBe(128)
+      return respond(JSON.stringify({ error: { message: "max_output_tokens must be at least 20000" } }), {
+        status: 400,
+        headers: { "content-type": "application/json" },
+      })
+    }),
+  ),
+).effect("passes configured output limits through and leaves rejection to the provider", () =>
+  Effect.gen(function* () {
+    const error = yield* LLMClient.compact(
+      LLM.request({
+        model: OpenAI.configure({ apiKey: "fixture" }).responses("gpt-5.5"),
+        prompt: "Hello.",
+        generation: { maxTokens: 128 },
+      }),
+      trigger,
+    ).pipe(Effect.flip)
+    expect(error.message).toContain("at least 20000")
+  }),
+)
+
 const idless = { type: "compaction", encrypted_content: "opaque" }
 testEffect(
  fixedResponse(
@@ -184,7 +255,7 @@ testEffect(fixedResponse(sseEvents({ type: "response.output_item.done", item: ch
      expect(error.reason._tag).toBe("InvalidProviderOutput")
    }),
 )
-for (const body of [{ input: [] }, { previous_response_id: "stale" }]) {
+for (const body of [{ input: [] }, { previous_response_id: "stale" }, { stream: false }]) {
  testEffect(dynamicResponse(() => Effect.die("Must reject before sending"))).effect(
    `rejects caller-supplied ${Object.keys(body)[0]} before sending trigger`,
    () =>
@@ -110,11 +110,16 @@ for (const model of [
    dynamicResponse(({ request, text, respond }) =>
      Effect.sync(() => {
        expect(new URL(request.url).pathname).toEndWith("/responses/compact")
-        expect(JSON.parse(text)).toEqual({ model: "fixture", input: [item], instructions: "Keep the context" })
+        expect(JSON.parse(text)).toEqual({
+          model: "fixture",
+          input: [item],
+          instructions: "Keep the context",
+          include: ["reasoning.encrypted_content"],
+        })
        return respond(JSON.stringify({ object: "response.compaction", output: [checkpoint] }))
      }),
    ),
-  ).effect(`${model.provider} compacts provider-specific history without lowering generation settings`, () =>
+  ).effect(`${model.provider} validates tools but ignores unrelated unsupported generation settings`, () =>
    Effect.gen(function* () {
      const request = LLM.request({
        model,
@@ -151,6 +156,11 @@ for (const model of [
      ] as const) {
        const error = yield* LLMClient.generate(candidate).pipe(Effect.flip)
        expect(error.reason._tag).toBe(tag)
+        if (candidate.tools.length > 0) {
+          const compactError = yield* LLMClient.compact(candidate).pipe(Effect.flip)
+          expect(compactError.reason._tag).toBe("InvalidRequest")
+          continue
+        }
        const response = yield* LLMClient.compact(candidate)
        expect(response.replacement[0]?.content[0]?.type).toBe("compaction")
      }
@@ -255,6 +265,13 @@ for (const overlay of [undefined, { service_tier: "priority", prompt_cache_key:
          model: "fixture",
          input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "hello" }] }],
          service_tier: overlay?.service_tier ?? "flex",
+          reasoning: { effort: "low" },
+          text: { verbosity: "low", format: { type: "json_object" } },
+          include: ["reasoning.encrypted_content"],
+          parallel_tool_calls: false,
+          tools: [
+            { type: "function", name: "lookup", description: "Lookup", parameters: { type: "object" }, strict: false },
+          ],
          prompt_cache_key: overlay?.prompt_cache_key ?? "affinity",
          prompt_cache_retention: "24h",
          prompt_cache_options: { mode: "explicit", ttl: "30m" },
@@ -268,12 +285,20 @@ for (const overlay of [undefined, { service_tier: "priority", prompt_cache_key:
        model: OpenAI.configure({ apiKey: "test" }).responses("fixture"),
        prompt: "hello",
        promptCacheKey: "affinity",
-        providerOptions: { serviceTier: "flex" },
+        providerOptions: {
+          serviceTier: "flex",
+          reasoningEffort: "low",
+          textVerbosity: "low",
+          include: ["reasoning.encrypted_content"],
+          parallelToolCalls: false,
+        },
        generation: { maxTokens: 100 },
+        tools: [{ name: "lookup", description: "Lookup", inputSchema: {} }],
        http: {
          body: {
            stream: true,
            store: false,
+            text: { format: { type: "json_object" } },
            prompt_cache_retention: "24h",
            prompt_cache_options: { mode: "explicit", ttl: "30m" },
            ...overlay,
@@ -396,6 +421,8 @@ for (const model of [
            model: model.id,
            input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "original" }] }],
            instructions: "system",
+            include: ["reasoning.encrypted_content"],
+            ...(model.id === "gpt-5.3-codex" ? { reasoning: { effort: "medium", summary: "auto" } } : {}),
          })
          return respond(
            JSON.stringify({
@@ -407,7 +434,10 @@ for (const model of [
          )
        }
        expect(new URL(request.url).pathname.endsWith("/responses")).toBe(true)
-        expect(body.input).toEqual([...output, { type: "message", role: "user", content: [{ type: "input_text", text: "continue" }] }])
+        expect(body.input).toEqual([
+          ...output,
+          { type: "message", role: "user", content: [{ type: "input_text", text: "continue" }] },
+        ])
        return respond(sseEvents({ type: "response.completed", response: { id: "resp_1", output: [] } }), {
          headers: { "content-type": "text/event-stream" },
        })
@@ -90,6 +90,23 @@ describe("Gemini route", () => {
    }),
  )

+  it.effect("fits the thinking budget to half the output limit", () =>
+    Effect.gen(function* () {
+      const thinkingBudget = (budget: number, maxTokens = 32_000) =>
+        compileRequest(
+          LLMRequest.update(request, {
+            generation: { maxTokens },
+            providerOptions: { thinkingConfig: { thinkingBudget: budget } },
+          }),
+        ).pipe(Effect.map((prepared) => prepared.body.generationConfig?.thinkingConfig?.thinkingBudget))
+
+      expect(yield* thinkingBudget(32_768)).toBe(16_000)
+      expect(yield* thinkingBudget(8_000)).toBe(8_000)
+      expect(yield* thinkingBudget(-1)).toBe(-1)
+      expect(yield* thinkingBudget(8_192, 1_000)).toBe(512)
+    }),
+  )
+
  it.effect("forwards standard Gemini generation options", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(
@@ -29,7 +29,11 @@ describe("OpenAI Images recorded", () => {

      expect(response.images).toHaveLength(1)
      expect(response.image.mediaType).toBe("image/jpeg")
+      expect(response.image.info).toEqual({ format: "jpeg", width: 1024, height: 1024 })
      expect((yield* response.image.bytes()).length).toBeGreaterThan(0)
+      expect(response.providerMetadata).toEqual({
+        openai: { outputFormat: "jpeg", size: "1024x1024", quality: "low", background: "opaque" },
+      })
    }),
  )

@@ -76,8 +80,13 @@ describe("OpenAI Images recorded", () => {
      expect(events.map((event) => event.type)).toEqual(["image-partial", "image", "finish"])
      const image = events.find(ImageEvent.is.image)
      expect(image?.image.mediaType).toBe("image/jpeg")
+      expect(image?.image.info).toEqual({ format: "jpeg", width: 1024, height: 1024 })
      expect(dimensions(yield* image!.image.bytes())).toEqual({ width: 1024, height: 1024 })
-      expect(events.find(ImageEvent.is.finish)?.usage).toMatchObject({ type: "tokens" })
+      const finish = events.find(ImageEvent.is.finish)
+      expect(finish?.usage).toMatchObject({ type: "tokens" })
+      expect(finish?.providerMetadata).toEqual({
+        openai: { outputFormat: "jpeg", size: "1024x1024", quality: "low", background: "opaque" },
+      })
    }),
  )
 })
@@ -1945,7 +1945,7 @@ describe("OpenAI Responses route", () => {
      expect(prepared.body.prompt_cache_key).toBe("session_123")
      expect(prepared.body.include).toEqual(["reasoning.encrypted_content"])
      expect(prepared.body.reasoning).toEqual({ effort: "high", summary: "auto" })
-      expect(prepared.body.text).toEqual({ verbosity: "low" })
+      expect(prepared.body.text).toBeUndefined()
      expect(prepared.body.metadata).toEqual({ environment: "test", tenant: "acme" })
      expect(prepared.body.safety_identifier).toBe("user_123")
      expect(prepared.body.stream_options).toEqual({ include_obfuscation: false })
@@ -44,7 +44,12 @@ describe("OpenAI Transcription recorded", () => {
      expect(deltas.length).toBeGreaterThan(1)
      expect(deltas.join("")).toBe(finish.text)
      expect(finish.text).toMatch(TRANSCRIPT)
-      expect(finish.usage).toMatchObject({ type: "tokens", input: expect.any(Number), output: expect.any(Number) })
+      expect(finish.usage).toMatchObject({
+        type: "tokens",
+        input: expect.any(Number),
+        output: expect.any(Number),
+        details: { openai: { input_token_details: { audio_tokens: expect.any(Number) } } },
+      })
    }),
  )

@@ -152,6 +152,27 @@ describe("OpenRouter", () => {
    }),
  )

+  it.effect("fits the reasoning budget to half the output limit", () =>
+    Effect.gen(function* () {
+      const reasoning = (maxTokens: number | undefined, value: Record<string, unknown>) =>
+        compileRequest(
+          LLM.request({
+            model: OpenRouter.configure({ apiKey: "test-key" }).model("qwen/qwen3.8-flash"),
+            cache: "none",
+            prompt: "Hello",
+            ...(maxTokens === undefined ? {} : { generation: { maxTokens } }),
+            providerOptions: { reasoning: value },
+          }),
+        ).pipe(Effect.map((prepared) => prepared.body.reasoning))
+
+      expect(yield* reasoning(32_000, { max_tokens: 131_071 })).toEqual({ max_tokens: 16_000 })
+      expect(yield* reasoning(131_072, { max_tokens: 65_536 })).toEqual({ max_tokens: 65_536 })
+      expect(yield* reasoning(1_500, { max_tokens: 65_536 })).toEqual({ max_tokens: 1_024 })
+      expect(yield* reasoning(undefined, { max_tokens: 131_071 })).toEqual({ max_tokens: 131_071 })
+      expect(yield* reasoning(32_000, { effort: "high" })).toEqual({ effort: "high" })
+    }),
+  )
+
  it.effect("applies OpenRouter payload options from the model helper", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(
@@ -32,7 +32,12 @@ describe("Z.ai Images", () => {

      expect(response.images).toHaveLength(1)
      expect(response.image.mediaType).toBe("application/octet-stream")
-      expect(response.image.source).toEqual({ type: "url", url: "https://cdn.z.ai/generated.png" })
+      // Z.ai documents that output URLs expire 30 days after generation; the test clock starts at 0.
+      expect(response.image.source).toEqual({
+        type: "url",
+        url: "https://cdn.z.ai/generated.png",
+        expiresAt: 30 * 24 * 60 * 60 * 1000,
+      })
      expect(response.notices).toEqual([
        {
          type: "moderated",
@@ -28,10 +28,49 @@ const cartesia = Cartesia.configure({ apiKey: "test", baseURL: "https://cartesia
 const google = Google.configure({ apiKey: "test", baseURL: "https://google.test/v1beta" }).speech(
  "gemini-2.5-flash-preview-tts",
 )
+const google38 = Google.configure({ apiKey: "test", baseURL: "https://google.test/v1beta" }).speech(
+  "gemini-3.8-flash-tts",
+)
+const google38Lite = Google.configure({ apiKey: "test", baseURL: "https://google.test/v1beta" }).speech(
+  "gemini-3.8-flash-lite-tts",
+)
 const deepgram = Deepgram.configure({ apiKey: "test", baseURL: "https://deepgram.test" }).speech("aura-2-thalia-en")
 const voice = "JBFqnCBsd6RMkjVDRZzb"

 describe("Speech", () => {
+  it.effect("preserves Google's WAV output instead of describing it as raw PCM", () =>
+    Effect.gen(function* () {
+      const bytes = new TextEncoder().encode("RIFF....WAVEfmt ")
+      const response = yield* Speech.generate({ model: google38, text: "Hi" }).pipe(
+        Effect.provide(
+          respond(
+            JSON.stringify({
+              candidates: [
+                { content: { parts: [{ inlineData: { mimeType: "audio/wav", data: Encoding.encodeBase64(bytes) } }] } },
+              ],
+            }),
+            "application/json",
+          ),
+        ),
+      )
+      expect(response.audio.mediaType).toBe("audio/wav")
+      expect(response.audio.info?.format).toBe("wav")
+      expect(response.audio.info?.encoding).toBeUndefined()
+      expect(yield* response.audio.bytes()).toEqual(bytes)
+    }),
+  )
+
+  it.effect("rejects raw PCM for Gemini 3.8 unary requests before sending", () =>
+    Effect.gen(function* () {
+      const errors = yield* Effect.all(
+        [google38, google38Lite].map((model) =>
+          Speech.generate({ model, text: "Hi", format: "pcm" }).pipe(Effect.flip),
+        ),
+      ).pipe(Effect.provide(layer(() => Effect.die("An unsupported request reached the network"))))
+      expect(errors.map((error) => error.reason._tag)).toEqual(["UnsupportedOperation", "UnsupportedOperation"])
+    }),
+  )
+
  it.effect("rejects what a provider cannot produce before sending anything", () =>
    Effect.gen(function* () {
      const errors = yield* Effect.all(
@@ -58,6 +97,42 @@ describe("Speech", () => {
    }).pipe(Effect.provide(layer(() => Effect.die("an unsupported request reached the network")))),
  )

+  it.effect("treats timestamps: false as not asking for timestamps on routes that cannot return them", () =>
+    Effect.gen(function* () {
+      const bytes = Uint8Array.from([1, 2, 3])
+      const gemini = JSON.stringify({
+        candidates: [
+          { content: { parts: [{ inlineData: { mimeType: "audio/L16;codec=pcm;rate=24000", data: "AQID" } }] } },
+        ],
+      })
+      const responses = yield* Effect.all([
+        Speech.generate({ model: openai, text: "Hi", timestamps: false }).pipe(
+          Effect.provide(respond(new Blob([bytes]).stream(), "audio/mpeg")),
+        ),
+        Speech.generate({ model: google, text: "Hi", timestamps: false }).pipe(
+          Effect.provide(respond(gemini, "application/json")),
+        ),
+        Speech.generate({ model: deepgram, text: "Hi", timestamps: false }).pipe(
+          Effect.provide(respond(new Blob([bytes]).stream(), "audio/mpeg")),
+        ),
+      ])
+      for (const response of responses) expect(yield* response.audio.bytes()).toEqual(bytes)
+
+      const errors = yield* Effect.all(
+        [openai, google, deepgram].map((model) =>
+          Speech.generate({ model, text: "Hi", timestamps: true }).pipe(Effect.flip),
+        ),
+      ).pipe(Effect.provide(layer(() => Effect.die("an unsupported request reached the network"))))
+      expect(errors.map((error) => [error.reason._tag, "operation" in error.reason && error.reason.operation])).toEqual(
+        [
+          ["UnsupportedOperation", "media.timestamps"],
+          ["UnsupportedOperation", "media.timestamps"],
+          ["UnsupportedOperation", "media.timestamps"],
+        ],
+      )
+    }),
+  )
+
  it.effect("classifies stream failures and keeps the provider payload and HTTP context", () =>
    Effect.gen(function* () {
      const badFrame = JSON.stringify({ type: "speech.audio.delta", audio: "not base64!" })
@@ -1,5 +1,5 @@
 import type { Stream } from "effect"
-import { Speech, type SpeechEvent } from "../src/index.js"
+import { Speech, SpeechModel, type SpeechEvent, type SpeechOptions } from "../src/index.js"
 import { ElevenLabs, OpenAI, Runway } from "../src/providers.js"

 type StreamItem<T> = T extends Stream.Stream<infer A, infer _E, infer _R> ? A : never
@@ -7,6 +7,8 @@ type Equal<A, B> = [A, B] extends [B, A] ? true : false
 type Assert<T extends true> = T

 const elevenlabs = ElevenLabs.configure({ apiKey: "test" }).speech("eleven_flash_v2_5")
+const widenSpeech = <Options extends SpeechOptions>(model: SpeechModel<Options>): SpeechModel => model
+void widenSpeech

 Speech.generate({
  model: elevenlabs,
@@ -5,7 +5,7 @@ import { HttpClientRequest } from "effect/unstable/http"
 import { Media, Transcription, TranscriptionClient } from "../src/index.js"
 import { AssemblyAI, Deepgram, Google, OpenAI } from "../src/providers.js"
 import { it } from "./lib/effect.js"
-import { dynamicResponse } from "./lib/http.js"
+import { dynamicResponse, json, observe, type Call } from "./lib/http.js"

 const layer = (handler: Parameters<typeof dynamicResponse>[0]) =>
  TranscriptionClient.layer.pipe(Layer.provideMerge(dynamicResponse(handler)))
@@ -25,7 +25,6 @@ describe("Transcription", () => {
    Effect.gen(function* () {
      const errors = yield* Effect.all(
        [
-          Stream.runCollect(Transcription.stream({ model: openai.transcription("whisper-1"), audio })),
          Transcription.generate({ model: openai.transcription("gpt-4o-mini-transcribe"), audio, diarize: true }),
          Transcription.generate({ model: openai.transcription("gpt-4o-mini-transcribe"), audio, timestamps: "word" }),
          Transcription.generate({ model: openai.transcription("gpt-4o-transcribe-diarize"), audio, prompt: "Names" }),
@@ -53,7 +52,6 @@ describe("Transcription", () => {
      )
      expect(errors.map((error) => [error.reason._tag, "operation" in error.reason && error.reason.operation])).toEqual(
        [
-          ["UnsupportedOperation", "media.stream"],
          ["UnsupportedOperation", "media.diarize"],
          ["UnsupportedOperation", "media.timestamps"],
          ["UnsupportedOperation", "media.prompt"],
@@ -70,6 +68,67 @@ describe("Transcription", () => {
    }).pipe(Effect.provide(layer(() => Effect.die("an unsupported request reached the network")))),
  )

+  it.effect("ignores unknown OpenAI stream events and fails on an error event with the frame", () =>
+    Effect.gen(function* () {
+      const sse = (...frames: ReadonlyArray<string>) => frames.map((frame) => `data: ${frame}\n\n`).join("")
+      const failure = `{"type":"error","error":{"type":"server_error","code":"server_error","message":"The server had an error"}}`
+      const bodies = [
+        sse(
+          `{"type":"transcript.text.delta","delta":"Hi"}`,
+          `{"type":"transcript.text.future","payload":1}`,
+          `{"type":"transcript.text.done","text":"Hi"}`,
+          "[DONE]",
+        ),
+        sse(`{"type":"transcript.text.delta","delta":"Hi"}`, failure),
+      ]
+      const model = openai.transcription("gpt-4o-mini-transcribe")
+      const program = Effect.gen(function* () {
+        const events = Array.from(yield* Stream.runCollect(Transcription.stream({ model, audio })))
+        const error = yield* Stream.runCollect(Transcription.stream({ model, audio })).pipe(Effect.flip)
+        return { events, error }
+      })
+      const { events, error } = yield* program.pipe(
+        Effect.provide(
+          layer((input) =>
+            Effect.sync(() =>
+              input.respond(bodies.shift() ?? "", { headers: { "content-type": "text/event-stream" } }),
+            ),
+          ),
+        ),
+      )
+
+      expect(events.map((event) => event.type)).toEqual(["text-delta", "finish"])
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", body: failure })
+      expect(error.message).toContain("The server had an error")
+    }),
+  )
+
+  it.effect("streams whisper-1 as a single finish from a plain request", () =>
+    Effect.gen(function* () {
+      const bodies: Array<string> = []
+      const events = Array.from(
+        yield* Stream.runCollect(Transcription.stream({ model: openai.transcription("whisper-1"), audio })).pipe(
+          Effect.provide(
+            layer((input) =>
+              Effect.sync(() => {
+                bodies.push(input.text)
+                return input.respond(
+                  JSON.stringify({ text: "Hello there.", usage: { type: "duration", seconds: 2 } }),
+                  { headers: { "content-type": "application/json" } },
+                )
+              }),
+            ),
+          ),
+        ),
+      )
+
+      expect(bodies[0]).not.toContain('name="stream"')
+      expect(events).toEqual([
+        expect.objectContaining({ type: "finish", text: "Hello there.", usage: { type: "seconds", seconds: 2 } }),
+      ])
+    }),
+  )
+
  it.effect(
    "uploads inline audio to AssemblyAI, resumes polling from a persisted token, and surfaces failed transcripts",
    () =>
@@ -171,4 +230,45 @@ describe("Transcription", () => {
        expect(failure.reason).toMatchObject({ _tag: "ProviderInternal", body: failed })
      }),
  )
+
+  it.effect("enables AssemblyAI speaker labels when only an expected speaker count is given", () =>
+    Effect.gen(function* () {
+      const calls: Array<Call> = []
+      yield* Transcription.start({ model: assemblyai, audio: Media.url("https://a.test/call.mp3"), speakers: 2 }).pipe(
+        Effect.provide(
+          layer((input) => observe(calls, input).pipe(Effect.as(json(input, { id: "tr_1", status: "queued" })))),
+        ),
+      )
+      expect(calls.map((call) => JSON.parse(call.body))).toEqual([
+        {
+          audio_url: "https://a.test/call.mp3",
+          speech_models: ["universal-3-5-pro"],
+          language_detection: true,
+          speaker_labels: true,
+          speakers_expected: 2,
+        },
+      ])
+    }),
+  )
+
+  it.effect("rejects reading an AssemblyAI result before the transcript finishes", () =>
+    Effect.gen(function* () {
+      const generation = yield* Transcription.resume(assemblyai, { transcriptID: "tr_1" })
+      const error = yield* generation.result().pipe(Effect.flip)
+      expect(error.reason._tag).toBe("InvalidRequest")
+      expect(error.message).toBe("AssemblyAI generation tr_1 has not finished; await it before reading the result")
+      expect(error.reason.body).toBe(JSON.stringify({ id: "tr_1", status: "processing" }))
+      expect(error.reason.http?.status).toBe(200)
+    }).pipe(
+      Effect.provide(
+        layer((input) =>
+          Effect.succeed(
+            input.respond(JSON.stringify({ id: "tr_1", status: "processing" }), {
+              headers: { "content-type": "application/json" },
+            }),
+          ),
+        ),
+      ),
+    ),
+  )
 })
@@ -1,5 +1,11 @@
 import type { Stream } from "effect"
-import { Media, Transcription, type TranscriptionEvent } from "../src/index.js"
+import {
+  Media,
+  Transcription,
+  TranscriptionModel,
+  type TranscriptionEvent,
+  type TranscriptionOptions,
+} from "../src/index.js"
 import { AssemblyAI, Deepgram, OpenAI } from "../src/providers.js"

 type StreamItem<T> = T extends Stream.Stream<infer A, infer _E, infer _R> ? A : never
@@ -8,6 +14,10 @@ type Assert<T extends true> = T

 const audio = Media.url("https://example.com/call.mp3")
 const deepgram = Deepgram.configure({ apiKey: "test" }).transcription("nova-3")
+const widenTranscription = <Options extends TranscriptionOptions>(
+  model: TranscriptionModel<Options>,
+): TranscriptionModel => model
+void widenTranscription

 Transcription.generate({
  model: deepgram,
@@ -576,7 +576,7 @@ describe("Video / Runway", () => {
  const model = runway.video("gen4.5")
  const taskUrl = "https://runway.test/v1/tasks/task_1"

-  it.effect("submits image_to_video with the API version header, polls the task, and reports credits", () =>
+  it.effect("submits image_to_video, polls the task, reports credits, and keeps the finished task on cancel", () =>
    Effect.gen(function* () {
      const calls: Array<Call> = []
      const program = Effect.gen(function* () {
@@ -624,7 +624,7 @@ describe("Video / Runway", () => {
                return json(input, { id: "task_1", estimatedCost: { credits: 25 } })
              }
              expect(call.url).toBe(taskUrl)
-              if (call.method === "DELETE") return input.respond(null, { status: 204 })
+              if (call.method === "DELETE") return yield* Effect.die("cancel deleted a finished Runway task")
              if (nth === 1) return json(input, { id: "task_1", status: "PENDING", estimatedCost: { credits: 25 } })
              if (nth === 2) return json(input, { id: "task_1", status: "THROTTLED", estimatedCost: { credits: 25 } })
              if (nth === 3) return json(input, { id: "task_1", status: "RUNNING", progress: 0.5 })
@@ -653,6 +653,32 @@ describe("Video / Runway", () => {
        `GET ${taskUrl}`,
        `GET ${taskUrl}`,
        `GET ${taskUrl}`,
+        `GET ${taskUrl}`,
+      ])
+    }),
+  )
+
+  it.effect("cancels a task that is still running", () =>
+    Effect.gen(function* () {
+      const calls: Array<Call> = []
+      yield* Effect.gen(function* () {
+        const generation = yield* Video.start({ model, prompt: "x" })
+        yield* generation.cancel()
+      }).pipe(
+        Effect.provide(
+          layer((input) =>
+            Effect.gen(function* () {
+              const { call } = yield* observe(calls, input)
+              if (call.method === "POST") return json(input, { id: "task_1" })
+              if (call.method === "DELETE") return input.respond(null, { status: 204 })
+              return json(input, { id: "task_1", status: "RUNNING", progress: 0.2 })
+            }),
+          ),
+        ),
+      )
+      expect(calls.map((call) => `${call.method} ${call.url}`)).toEqual([
+        "POST https://runway.test/v1/text_to_video",
+        `GET ${taskUrl}`,
        `DELETE ${taskUrl}`,
      ])
    }),
@@ -812,3 +838,55 @@ describe("Video / Runway", () => {
    }),
  )
 })
+
+// ---------------------------------------------------------------------------
+// Shared queued behavior
+// ---------------------------------------------------------------------------
+
+describe("Video / queued result", () => {
+  for (const pending of [
+    {
+      model: Google.configure({ apiKey: "test", baseURL: "https://google.test/v1beta" }).video("veo-3.1"),
+      token: { operation: "models/veo-3.1/operations/op_1" },
+      body: { name: "models/veo-3.1/operations/op_1", done: false },
+      name: "Google Veo",
+    },
+    {
+      model: XAI.configure({ apiKey: "test", baseURL: "https://xai.test/v1" }).video("grok-imagine-video-1.5"),
+      token: { requestID: "req_1" },
+      body: { status: "pending", progress: 40 },
+      name: "xAI Video",
+    },
+    {
+      model: Runway.configure({ apiKey: "test", baseURL: "https://runway.test/v1" }).video("gen4.5"),
+      token: { taskID: "task_1" },
+      body: { status: "RUNNING", progress: 0.5 },
+      name: "Runway",
+    },
+  ]) {
+    it.effect(`rejects reading a ${pending.model.provider} result before the generation finishes`, () =>
+      Effect.gen(function* () {
+        const generation = yield* Video.resume(pending.model, pending.token)
+        const error = yield* generation.result().pipe(Effect.flip)
+        expect(error.reason._tag).toBe("InvalidRequest")
+        expect(error.message).toBe(
+          `${pending.name} generation ${generation.id} has not finished; await it before reading the result`,
+        )
+        expect(error.reason.body).toBe(JSON.stringify(pending.body))
+        expect(error.reason.http?.status).toBe(200)
+      }).pipe(Effect.provide(layer((input) => Effect.succeed(json(input, pending.body))))),
+    )
+  }
+
+  it.effect("rejects a status that only matches an inherited property", () =>
+    Effect.gen(function* () {
+      const error = yield* Video.resume(
+        XAI.configure({ apiKey: "test", baseURL: "https://xai.test/v1" }).video("grok-imagine-video-1.5"),
+        { requestID: "req_1" },
+      ).pipe(Effect.flip)
+      expect(error.reason._tag).toBe("InvalidProviderOutput")
+      expect(error.message).toBe('Unknown generation status "constructor"')
+      expect(error.reason.body).toBe(JSON.stringify({ status: "constructor" }))
+    }).pipe(Effect.provide(layer((input) => Effect.succeed(json(input, { status: "constructor" }))))),
+  )
+})
@@ -9,7 +9,6 @@ import {
  type VideoModelOptions,
  type VideoOptions,
  type VideoRequestFor,
-  type VideoRoute,
 } from "../src/index.js"
 import type { Service } from "../src/video-client.js"
 import { Anthropic, Fal, Google, OpenAI, Runway, XAI } from "../src/providers.js"
@@ -23,8 +22,7 @@ type VeoLikeOptions = {
  readonly personGeneration?: "allow_all" | "allow_adult"
 } & Record<string, unknown>

-declare const route: VideoRoute<VeoLikeOptions>
-const veo = VideoModel.make<VeoLikeOptions>({ id: "veo", provider: "google", route })
+declare const veo: VideoModel<VeoLikeOptions>
 // @ts-expect-error Extracted model options retain known provider fields.
 const invalidVeoOptions: VideoModelOptions<typeof veo> = { personGeneration: "everyone" }
 void invalidVeoOptions
@@ -99,6 +97,8 @@ Video.generate({ model: google, prompt: "A kitten", durationSeconds: "8s" })
 Video.generate({ model: google, prompt: "A kitten", options: { personGeneration: "allow_all" } })

 declare const generic: VideoModel<VideoOptions>
+const widenVideo = <Options extends VideoOptions>(model: VideoModel<Options>): VideoModel => model
+void widenVideo
 Video.generate({ model: generic, prompt: "A kitten", providerOptions: { arbitrary: true } })

 const request = Video.request({ model: veo, prompt: "A kitten", providerOptions: { personGeneration: "allow_all" } })
@@ -2,7 +2,7 @@ import { DialogProvider } from "@opencode/ui/context/dialog"
 import { Browser } from "@opencode/plugin-browser/rpc"
 import { For, Show } from "solid-js"
 import { createStore } from "solid-js/store"
-import { render } from "solid-js/web"
+import { Portal, render } from "solid-js/web"
 import { LanguageProvider, UiI18nBridge } from "../src/runtime/i18n/language"
 import type { BrowserPaneLayout, BrowserPaneRegistration } from "../src/runtime/platform/browser-pane"
 import type { createSessionBrowser } from "../src/session/browser/model"
@@ -27,7 +27,12 @@ export function mountBrowserPane() {
      loadErrors: {} as Record<string, string | undefined>,
      error: undefined as string | undefined,
      layouts: {} as Record<string, BrowserPaneLayout | undefined>,
+      covered: false,
+      captures: 0,
+      holdCapture: false,
    })
+    // Each capture waits until the fixture releases it, so a spec can observe the pending state.
+    const held: (() => void)[] = []
    const tabs = ["Alpha", "Beta"].map((name) => ({
      id: Browser.TabID.make(`tab_${name === "Alpha" ? "11111111" : "22222222"}-1111-1111-1111-111111111111`),
      title: name,
@@ -44,6 +49,17 @@ export function mountBrowserPane() {
        {
          setLayout: (layout) => setStore("layouts", tab.title, layout),
          command: async () => undefined,
+          capture: async () => {
+            setStore("captures", (count) => count + 1)
+            if (store.holdCapture) await new Promise<void>((resolve) => held.push(resolve))
+            const canvas = new OffscreenCanvas(4, 4)
+            const paint = canvas.getContext("2d")
+            if (paint) {
+              paint.fillStyle = "#3b82f6"
+              paint.fillRect(0, 0, 4, 4)
+            }
+            return canvas.convertToBlob()
+          },
          close: () => undefined,
        },
      ]),
@@ -118,12 +134,34 @@ export function mountBrowserPane() {
            Complete navigation
          </button>
          <button onClick={() => setStore("visible", (visible) => !visible)}>Toggle Review tab</button>
+          <button onClick={() => setStore("holdCapture", true)}>Hold capture</button>
+          <button onClick={() => held.splice(0).forEach((resolve) => resolve())}>Release capture</button>
+          <button onClick={() => setStore("covered", (covered) => !covered)}>Toggle popover</button>
        </nav>
-        <div style={{ width: "640px", height: "360px", border: "1px solid #555" }}>
+        <p>Captures: {store.captures}</p>
+        <div style={{ position: "relative", width: "640px", height: "360px", border: "1px solid #555" }}>
          <Show when={store.mounted}>
            <SessionBrowserPane browser={browser} visible={store.visible} />
          </Show>
        </div>
+        <Show when={store.covered}>
+          {/* Floating content portals into <body> like a menu or hover card over the page. */}
+          <Portal mount={document.body}>
+            <div
+              data-popper-positioner
+              data-testid="fixture-popover"
+              style={{
+                position: "fixed",
+                top: "0",
+                left: "0",
+                width: "320px",
+                height: "480px",
+                "z-index": "1001",
+                "pointer-events": "none",
+              }}
+            />
+          </Portal>
+        </Show>
        <h2 style={{ "font-size": "18px", margin: "20px 0 12px" }}>Native layout recorder</h2>
        <p>The desktop boundary keeps each session's page visible until its registration is hidden.</p>
        <For each={tabs}>
@@ -58,6 +58,27 @@ story("hides the native view immediately while the pane stays mounted", async ({
  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
 })

+story("keeps a still of the page under floating content that covers it", async ({ page }, testInfo) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  const still = root.locator("#browser-panel img")
+  await root.getByRole("button", { name: "Hold capture", exact: true }).click()
+  await root.getByRole("button", { name: "Toggle popover", exact: true }).click()
+  await expect(root.getByText("Captures: 1", { exact: true })).toBeVisible()
+  // The native page stays up until its still is ready, so the pane never shows blank.
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(still).toHaveCount(0)
+
+  await root.getByRole("button", { name: "Release capture", exact: true }).click()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+  await expect(still).toBeVisible()
+  await page.screenshot({ path: testInfo.outputPath("covered.png") })
+
+  await root.getByRole("button", { name: "Toggle popover", exact: true }).click()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(still).toHaveCount(0)
+  await expect(root.getByText("Captures: 1", { exact: true })).toBeVisible()
+})
+
 story("shows the empty state over a blank native page and restores navigation", async ({ page }) => {
  const root = page.getByTestId("browser-pane-fixture")
  await root.getByRole("button", { name: "Blank page", exact: true }).click()
@@ -1,5 +1,5 @@
 import { expect, test, type Page } from "@playwright/test"
-import type { OpenCodeEvent, SessionMessageInfo } from "@opencode/client/promise"
+import type { OpenCodeEvent, SessionInboxInfo, SessionMessageInfo } from "@opencode/client/promise"
 import { base64Encode } from "@opencode/util/encode"
 import { mockOpenCodeServer } from "../utils/mock-server"
 import { expectAppVisible } from "../utils/waits"
@@ -14,7 +14,12 @@ type InboxRow = {
  sessionID: string
  time: { created: number }
  type: "user"
-  payload: { text: string; metadata?: Record<string, unknown> }
+  payload: {
+    text: string
+    metadata?: Record<string, unknown>
+    files?: Extract<SessionInboxInfo, { type: "user" }>["payload"]["files"]
+    agents?: Extract<SessionInboxInfo, { type: "user" }>["payload"]["agents"]
+  }
  delivery: "steer" | "queue"
 }

@@ -29,7 +34,7 @@ function createQueueMock(seed: string[], messages: SessionMessageInfo[] = []) {
  }))
  const events: OpenCodeEvent[] = []
  const prompts: Record<string, unknown>[] = []
-  const changes: { inboxID: string; action: "cancel" | "steer" }[] = []
+  const changes: { inboxID: string; action: "cancel" | "steer" | "queue" }[] = []
  const log: string[] = []
  let sequence = 0
  const emit = <Type extends OpenCodeEvent["type"]>(
@@ -234,6 +239,108 @@ test("editing restores the existing draft and replaces only the original queue p
  expect(mock.log[0]).toBe("prompt:queue")
 })

+test("Undo cancels only the selected queued prompt and focuses the restored input", async ({ page }) => {
+  const mock = createQueueMock(["first queued prompt", "second queued prompt", "third queued prompt"])
+  const view = await openSession(page, mock)
+  await expect(view.rows).toHaveCount(3)
+
+  const row = view.rows.filter({ hasText: "second queued prompt" })
+  const actions = row.locator('[data-slot="session-queue-actions"] button')
+  await expect(actions).toHaveCount(3)
+  expect(
+    await actions.evaluateAll((buttons) =>
+      buttons.map((button) => button.getAttribute("aria-label") ?? button.textContent?.trim()),
+    ),
+  ).toEqual(["Steer", "Undo", "Remove"])
+  const undo = row.getByRole("button", { name: "Undo" })
+  await expect(undo).toHaveText("")
+  await expect(undo.locator("svg use")).toHaveAttribute("href", "#opencode-v2-icon-arrow-down-to-line")
+  await undo.hover()
+  await expect(page.getByRole("tooltip")).toHaveText("Undo")
+  await undo.click()
+  await expect(view.rows.locator('[data-action="session-queue-edit"]')).toHaveText([
+    "first queued prompt",
+    "third queued prompt",
+  ])
+  await expect(view.input).toHaveText("second queued prompt")
+  await expect(view.input).toBeFocused()
+  expect(mock.changes).toEqual([{ inboxID: "inb_seed_2", action: "cancel" }])
+  expect(mock.prompts).toEqual([])
+})
+
+test("Undo appends to an existing draft and restores inline attachments", async ({ page }) => {
+  const mock = createQueueMock(["queued with image"])
+  mock.rows[0].payload.files = [
+    {
+      data: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIHWP4z8DwHwAFgAI/ScL/nwAAAABJRU5ErkJggg==",
+      mime: "image/png",
+      source: { type: "inline" },
+      name: "shot.png",
+    },
+  ]
+  const view = await openSession(page, mock)
+  await view.input.fill("my draft")
+  await view.rows.getByRole("button", { name: "Undo" }).click()
+  await expect(view.rows).toHaveCount(0)
+  await expect(view.input).toHaveText("my draft\n\nqueued with image")
+  await expect(view.input).toBeFocused()
+  await expect(view.composer.getByRole("img", { name: "shot.png" })).toBeVisible()
+  expect(mock.changes).toEqual([{ inboxID: "inb_seed_1", action: "cancel" }])
+})
+
+test("Undo stays usable with a long queue on a narrow screen", async ({ page }, testInfo) => {
+  await page.setViewportSize({ width: 390, height: 844 })
+  const text = "Review the detailed error report and check every step of the retry path ".repeat(4)
+  const mock = createQueueMock([text, ...Array.from({ length: 6 }, (_, index) => `queued follow-up ${index + 1}`)])
+  const view = await openSession(page, mock)
+  await expect(view.rows).toHaveCount(7)
+  const row = view.rows.filter({ hasText: text })
+  await row.getByRole("button", { name: "Undo" }).hover()
+  await expect(page.getByRole("tooltip")).toHaveText("Undo")
+  await page.screenshot({ path: testInfo.outputPath("undo-narrow-queue.png") })
+  await row.getByRole("button", { name: "Undo" }).click()
+  await expect(view.rows).toHaveCount(6)
+  await expect(view.input).toHaveText(text)
+  await expect(view.input).toBeFocused()
+  expect(mock.changes).toEqual([{ inboxID: "inb_seed_1", action: "cancel" }])
+})
+
+test("Undo preserves mentioned file and agent references on resubmission", async ({ page }) => {
+  const mock = createQueueMock(["inspect @main.ts with @build"])
+  mock.rows[0].payload.files = [
+    {
+      data: "aGk=",
+      mime: "text/plain",
+      source: { type: "uri", uri: "file:///repo/main.ts" },
+      name: "main.ts",
+      mention: { start: 8, end: 16, text: "@main.ts" },
+    },
+  ]
+  mock.rows[0].payload.agents = [{ name: "build", mention: { start: 22, end: 28, text: "@build" } }]
+  const view = await openSession(page, mock)
+  await view.rows.getByRole("button", { name: "Undo" }).click()
+  await expect(view.input).toHaveText("inspect @main.ts with @build")
+  await view.input.press("Enter")
+  await expect.poll(() => mock.prompts.length).toBe(1)
+  expect(mock.prompts[0].files).toMatchObject([
+    { uri: "data:text/plain;base64,aGk=", mention: { text: "@main.ts", start: 8, end: 16 } },
+  ])
+  expect(mock.prompts[0].agents).toMatchObject([{ name: "build", mention: { text: "@build" } }])
+})
+
+test("Undo does not discard hidden file context", async ({ page }) => {
+  const mock = createQueueMock(["inspect this file"])
+  mock.rows[0].payload.files = [
+    { data: "aGk=", mime: "text/plain", source: { type: "uri", uri: "file:///repo/main.ts" }, name: "main.ts" },
+  ]
+  const view = await openSession(page, mock)
+  await view.rows.getByRole("button", { name: "Undo" }).click()
+  await expect(page.getByText("Edit this prompt in the queue to preserve its file context")).toBeVisible()
+  await expect(view.rows).toHaveCount(1)
+  await expect(view.input).toHaveText("")
+  expect(mock.changes).toEqual([])
+})
+
 for (const delivery of ["steer", "queue"] as const) {
  test(`keeps finished tools above a pending ${delivery === "queue" ? "queue-to-steer" : "steer"} follow-up`, async ({
    page,
@@ -47,6 +47,7 @@ export type ComposerDelivery = "steer" | "queue"
 // is loaded in the editor.
 export type ComposerQueue = {
  count: Accessor<number>
+  undoing: Accessor<boolean>
  // Delivery a plain submit uses right now.
  delivery: Accessor<ComposerDelivery>
  // Delivery offered on Mod+Enter and the toolbar hint button; undefined hides the hint.
@@ -168,6 +168,7 @@ function ComposerStory(props: {
              alternate: () => props.alternate,
              editing: () => undefined,
              confirmEdit() {},
+              undoing: () => false,
              cancelEdit() {},
              editFirst: () => false,
            }
@@ -16,6 +16,7 @@ export function Composer(props: {
  class?: string
  model: ComposerModel
  borderUnderlay?: boolean
+  readOnly?: boolean
  suggestionBoundary?: () => HTMLElement | undefined
 }) {
  const dialog = useDialog()
@@ -27,6 +28,7 @@ export function Composer(props: {
      <ComposerEditor
        controller={props.model}
        borderUnderlay={props.borderUnderlay}
+        readOnly={props.readOnly}
        class={props.class}
        modelControlsVisible={!props.model.model.loading}
        attachKeybind={command.keybindParts("file.attach")}
@@ -371,6 +371,7 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
        onSubmit: (submitOptions) => {
          if (!available()) return
          const queue = options?.queue
+          if (queue?.undoing()) return
          // Confirming an edit re-admits the queued prompt instead of sending
          // the composer value as a new prompt. Enter keeps it queued in
          // place; the alternate action sends it as a steer.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Shoubhit Dash	6585bb7105	fix(ai): keep OpenAI image output settings and Z.ai URL expiry (#51380 )	2026-09-25 22:51:46 +05:30
Shoubhit Dash	f954688fbb	fix(ai): harden OpenAI transcription stream parsing (#51378 )	2026-09-25 22:51:22 +05:30
Shoubhit Dash	1463dabde9	fix(ai): tighten media error consistency (#51374 )	2026-09-25 22:46:04 +05:30
Shoubhit Dash	29ea6ee05b	test(ai): cover media facade selectors and url asset edges (#51376 )	2026-09-25 22:37:20 +05:30
Shoubhit Dash	b170904731	docs(ai): describe transcription speakers as a constraint (#51382 )	2026-09-25 22:36:02 +05:30
Shoubhit Dash	88e1fa9304	fix(ai): accept timestamps: false on speech routes without timestamps (#51375 )	2026-09-25 22:33:59 +05:30
opencode-agent[bot]andvimtor	ff1bf315ed	docs(www): hide Console Usage API documentation (#51358 ) Co-authored-by: vimtor <36263538+vimtor@users.noreply.github.com>	2026-09-25 19:01:48 +02:00
Shoubhit Dash	144ce00e00	fix(ai): bound generation event poll sleep by the deadline (#51372 )	2026-09-25 22:31:35 +05:30
Shoubhit Dash	ad504094f0	fix(ai): never delete a finished Runway task on cancel (#51373 )	2026-09-25 22:24:16 +05:30
Shoubhit Dash	bad6834a3e	fix(ai): size fal Kontext by aspect ratio and decode sync_mode data URIs (#51371 )	2026-09-25 22:23:14 +05:30
Shoubhit Dash	0c4bbc3cd1	feat(ai): keep prompt cache across effort switches on GPT-6 Sol and Luna (#51339 )	2026-09-25 22:15:23 +05:30
Shoubhit Dash	ae7dd82126	fix(ai): report Black Forest Labs submit cost as image usage (#51370 )	2026-09-25 22:13:55 +05:30
Shoubhit Dash	65d5123ead	fix(ai): enable AssemblyAI speaker labels when speakers is set (#51369 )	2026-09-25 22:11:44 +05:30
Shoubhit Dash	4eb46a8885	fix(core): revert always-thinking variants for Claude Opus 5.5 (#51359 )	2026-09-25 22:03:12 +05:30
Jack	1986e92842	docs(go): show permanent DeepSeek $60 allowance (#51363 )	2026-09-26 00:17:08 +08:00
Shoubhit Dash	14fc63ba9e	fix(core): keep thinking on for Claude Opus 5.5 variants (#51338 )	2026-09-25 18:32:41 +05:30
opencode-agent[bot]andnexxeln	c34ffa117e	fix(ai): preserve Gemini 3.8 TTS WAV output (#51300 ) Co-authored-by: nexxeln <95541290+nexxeln@users.noreply.github.com>	2026-09-25 18:11:36 +05:30
opencode-agent[bot]vimtor vimtor	beeb14e910	feat(prompt): undo queued prompts back into the input (#51124 ) Co-authored-by: vimtor <36263538+vimtor@users.noreply.github.com> Co-authored-by: vimtor <vn4varro@gmail.com>	2026-09-25 14:36:29 +02:00
opencode-agent[bot]	aae42e2e75	chore(core): refresh bundled models.dev snapshot	2026-09-25 12:21:04 +00:00
opencode-agent[bot]vimtor vimtor	cc9011c1ae	fix(tui): virtualize large added-file diffs (#51122 ) Co-authored-by: vimtor <36263538+vimtor@users.noreply.github.com> Co-authored-by: vimtor <vn4varro@gmail.com>	2026-09-25 13:51:00 +02:00
Victor Navarro	6cd938e1e9	feat(core): register Console-hosted MCP servers (#51325 )	2026-09-25 13:16:04 +02:00
Jack	7de6b3fc15	docs(console): document Qwen3.8 Max (#51320 )	2026-09-25 19:13:45 +08:00
opencode-agent[bot]	c1c9a13993	chore: update nix node_modules hashes	2026-09-25 08:37:39 +00:00
Simon Klee	917d904f18	tui: update OpenTUI v0.5.12 (#50567 )	2026-09-25 08:17:14 +00:00
opencode-agent[bot]andBrendonovich	ee5b67eb84	fix(app): unify session project icon resolution (#51288 ) Co-authored-by: Brendonovich <14191578+Brendonovich@users.noreply.github.com>	2026-09-25 07:47:12 +00:00
Aiden Cline	048a47e89e	docs: focus compaction page on user-facing behavior (#51270 )	2026-09-25 00:21:17 -05:00
Aiden Cline	5335347e80	feat(codemode): add WeakMap and WeakSet (#51257 )	2026-09-25 00:15:19 -05:00
Aiden Cline	16b18dff13	Revert "fix(core): fit model limits and recover compaction overflow" (#51273 )	2026-09-25 00:12:14 -05:00
Aiden Cline	61c2349cef	fix(core): fit model limits and recover compaction overflow (#51238 )	2026-09-25 00:11:40 -05:00
opencode-agent[bot]andBrendonovich	684721efb8	feat(app): add provider account switching (#51266 ) Co-authored-by: Brendonovich <Brendonovich@users.noreply.github.com>	2026-09-25 05:03:33 +00:00
Aiden Cline	962c14a49c	fix(codemode): honor thisArg, program toString in computed keys, and ToPrimitive in String and Number arguments (#51264 )	2026-09-24 23:46:15 -05:00
opencode-agent[bot]andrekram1-node	85b98e7da4	fix(tui): handle storage watcher errors after startup (#51243 ) Co-authored-by: rekram1-node <rekram1-node@users.noreply.github.com>	2026-09-24 20:25:06 -05:00
Aiden Cline	8061220b08	test(codemode): vendor every eligible test262 directory and bound unsupported globals (#51242 )	2026-09-24 20:19:24 -05:00
Luke Parker	b02cc35f13	fix(desktop): keep browser page visible under floating content (#51240 )	2026-09-25 10:35:17 +10:00
Aiden Cline	e23d89c9a9	fix(codemode): destructure object patterns from primitives and convert Date components through ToPrimitive (#51239 )	2026-09-24 19:32:19 -05:00
ARH Alireza Haghdoost Claude Sonnet 5	e8b3e19e85	fix(tui): don't crash when fs.watch throws (e.g. ENOSPC) (#51210 ) Co-authored-by: Alireza Haghdoost <haghdoost@uber.com> Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>	2026-09-24 19:16:43 -05:00
Aiden Cline	5256f30957	feat(codemode): honor program valueOf and toString in operators and conversions (#50837 )	2026-09-24 18:45:48 -05:00
Aiden Cline	61ecf404b9	fix(core): apply GPT verbosity defaults at request time (#51166 )	2026-09-24 17:13:39 -05:00
Shoubhit Dash	92d2b1700f	refactor(ai): one media client shape and route types erased over options (#51226 )	2026-09-25 03:15:45 +05:30
Aiden Cline	56262121ee	feat(codemode): bind this and arguments in functions, add Function.prototype.call, apply, and bind (#50831 )	2026-09-24 16:34:46 -05:00
Aiden Cline	e3b588e7d2	refactor(ai): apply tool schema rules once per request (#51162 )	2026-09-24 16:27:30 -05:00
opencode-agent[bot]andnexxeln	1de648cb13	feat(ai): restore direct LLM input overloads (#51211 ) Co-authored-by: nexxeln <95541290+nexxeln@users.noreply.github.com>	2026-09-25 02:49:07 +05:30
Aiden Cline	03be7f385b	fix(core): accept 128-character tool names (#51207 )	2026-09-24 14:59:57 -05:00
Aiden Cline	8118690839	fix(core): show line counts when tool output is truncated (#51200 )	2026-09-24 14:50:55 -05:00
Aiden Cline	a16eedfed7	fix(codemode): make derived error constructors inherit from Error (#51045 )	2026-09-24 14:03:10 -05:00
Aiden Cline	e796f2f9a5	fix(core): read provider errors from plain AI SDK stream errors (#51194 )	2026-09-24 13:52:32 -05:00
Aiden Cline	20610e6645	fix(ai): fit Claude thinking budgets on Bedrock Converse (#51190 )	2026-09-24 13:48:39 -05:00
Aiden Cline	7f245b0968	fix(ai): fit OpenRouter reasoning budgets to the output limit (#51189 )	2026-09-24 13:42:10 -05:00
Shoubhit Dash	7013e925f5	refactor(ai): keep LLM calls request-only in the promise client (#51180 )	2026-09-24 23:47:42 +05:30
Aiden Cline	499c2feaa3	fix(core): cap Alibaba thinking budget variants at 64k (#51154 )	2026-09-24 13:14:49 -05:00
Aiden Cline	03af821aa5	fix(core): restore the shell no-output placeholder (#51187 )	2026-09-24 13:12:42 -05:00
Aiden Cline	c903774556	fix(ai): fit thinking budgets to the output limit (#51157 )	2026-09-24 12:58:54 -05:00
James Long	14aaf91e65	fix(tui): mark failed groups with a plain ✗ (#51175 )	2026-09-24 13:52:14 -04:00
James Long	c832432d89	refactor(tui): drop unused yellow alias from opencode theme (#51177 )	2026-09-24 13:17:21 -04:00
opencode-agent[bot]andjlongster	1d431a80df	fix(cli): reuse core declarations during typecheck (#51165 ) Co-authored-by: jlongster <jlongster@users.noreply.github.com>	2026-09-24 13:16:46 -04:00